Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42808 0 0 Zig
Normal View History Raw
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const std = @import("../std.zig");
const builtin = @import("builtin");
std.atomic: use spinlocks the lock-free data structures all had ABA problems and std.atomic.Stack had a possibility to load an unmapped memory address.
2018-07-11 19:38:01 -04:00
const assert = std.debug.assert;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
const expect = std.testing.expect;
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
std.atomic: use spinlocks the lock-free data structures all had ABA problems and std.atomic.Stack had a possibility to load an unmapped memory address.
2018-07-11 19:38:01 -04:00
/// Many reader, many writer, non-allocating, thread-safe
/// Uses a spinlock to protect push() and pop()
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
/// When building in single threaded mode, this is a simple linked list.
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
pub fn Stack(comptime T: type) type {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return struct {
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
root: ?*Node,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 21:56:19 +01:00
lock: @TypeOf(lock_init),
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
const lock_init = if (builtin.single_threaded) {} else false;
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
remove `this`. add `@This()`. closes #1283
2018-09-13 16:34:33 -04:00
pub const Self = @This();
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
pub const Node = struct {
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
next: ?*Node,
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
data: T,
};
pub fn init() Self {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return Self{
std.atomic: use spinlocks the lock-free data structures all had ABA problems and std.atomic.Stack had a possibility to load an unmapped memory address.
2018-07-11 19:38:01 -04:00
.root = null,
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
.lock = lock_init,
std.atomic: use spinlocks the lock-free data structures all had ABA problems and std.atomic.Stack had a possibility to load an unmapped memory address.
2018-07-11 19:38:01 -04:00
};
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
}
/// push operation, but only if you are the first item in the stack. if you did not succeed in
/// being the first item in the stack, returns the other item that was there.
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn pushFirst(self: *Self, node: *Node) ?*Node {
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
node.next = null;
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
return @cmpxchgStrong(?*Node, &self.root, null, node, .SeqCst, .SeqCst);
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn push(self: *Self, node: *Node) void {
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
if (builtin.single_threaded) {
node.next = self.root;
self.root = node;
} else {
add note to disabled tests, improve comptime cmpxchg
2020-03-12 22:42:01 +02:00
while (@atomicRmw(bool, &self.lock, .Xchg, true, .SeqCst)) {}
defer assert(@atomicRmw(bool, &self.lock, .Xchg, false, .SeqCst));
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
node.next = self.root;
self.root = node;
}
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn pop(self: *Self) ?*Node {
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
if (builtin.single_threaded) {
const root = self.root orelse return null;
self.root = root.next;
return root;
} else {
add note to disabled tests, improve comptime cmpxchg
2020-03-12 22:42:01 +02:00
while (@atomicRmw(bool, &self.lock, .Xchg, true, .SeqCst)) {}
defer assert(@atomicRmw(bool, &self.lock, .Xchg, false, .SeqCst));
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
const root = self.root orelse return null;
self.root = root.next;
return root;
}
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn isEmpty(self: *Self) bool {
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
return @atomicLoad(?*Node, &self.root, .SeqCst) == null;
add std.atomic.Stack and std.atomic.Queue
2018-04-27 19:27:58 -04:00
}
};
}
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
const Context = struct {
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: std.mem.Allocator,
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
stack: *Stack(i32),
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
put_sum: isize,
get_sum: isize,
add tests for std.atomic Queue and Stack
2018-04-28 18:00:51 -04:00
get_count: usize,
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
puts_done: bool,
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
};
fix compiler-rt tests accidentally running std tests also reduce the aggressiveness of std.atomic.stack and std.atomic.queue fuzz testing. appveyor has 1 core and 10,000 iterations is too much for 6 threads to thrash over
2018-05-02 21:34:34 -04:00
// TODO add lazy evaluated build options and then put puts_per_thread behind
// some option such as: "AggressiveMultithreadedFuzzTest". In the AppVeyor
// CI we would use a less aggressive setting since at 1 core, while we still
// want this test to pass, we need a smaller value since there is so much thrashing
// we would also use a less aggressive setting when running in valgrind
const puts_per_thread = 500;
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
const put_thread_count = 3;
test "std.atomic.stack" {
rename std.heap.direct_allocator to std.heap.page_allocator std.heap.direct_allocator is still available for now but it is marked deprecated.
2019-11-25 17:25:06 -05:00
var plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024);
defer std.heap.page_allocator.free(plenty_of_memory);
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
var fixed_buffer_allocator = std.heap.FixedBufferAllocator.init(plenty_of_memory);
allocgate: renamed getAllocator function to allocator
2021-10-29 02:08:41 +01:00
var a = fixed_buffer_allocator.threadSafeAllocator();
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
var stack = Stack(i32).init();
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
var context = Context{
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
.allocator = a,
.stack = &stack,
.put_sum = 0,
.get_sum = 0,
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
.puts_done = false,
add tests for std.atomic Queue and Stack
2018-04-28 18:00:51 -04:00
.get_count = 0,
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
};
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
if (builtin.single_threaded) {
{
var i: usize = 0;
while (i < put_thread_count) : (i += 1) {
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try expect(startPuts(&context) == 0);
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
}
}
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
context.puts_done = true;
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
{
var i: usize = 0;
while (i < put_thread_count) : (i += 1) {
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try expect(startGets(&context) == 0);
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
}
}
} else {
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
var putters: [put_thread_count]std.Thread = undefined;
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
for (putters) |*t| {
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
t.* = try std.Thread.spawn(.{}, startPuts, .{&context});
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
}
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
var getters: [put_thread_count]std.Thread = undefined;
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
for (getters) |*t| {
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
t.* = try std.Thread.spawn(.{}, startGets, .{&context});
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
}
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
for (putters) |t|
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
t.join();
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
@atomicStore(bool, &context.puts_done, true, .SeqCst);
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
for (getters) |t|
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
t.join();
introduce --single-threaded build option closes #1764 This adds another boolean to the test matrix; hopefully it does not inflate the time too much. std.event.Loop does not work with this option yet. See #1908
2019-02-01 17:49:29 -05:00
}
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
better debugging for CI failures of std.atomic
2018-06-12 15:14:32 -04:00
if (context.put_sum != context.get_sum) {
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
std.debug.panic("failure\nput_sum:{} != get_sum:{}", .{ context.put_sum, context.get_sum });
better debugging for CI failures of std.atomic
2018-06-12 15:14:32 -04:00
}
if (context.get_count != puts_per_thread * put_thread_count) {
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
std.debug.panic("failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}", .{
better debugging for CI failures of std.atomic
2018-06-12 15:14:32 -04:00
context.get_count,
update the codebase to use `@as`
2019-11-06 23:25:57 -05:00
@as(u32, puts_per_thread),
@as(u32, put_thread_count),
std.fmt.format: tuple parameter instead of var args
2019-12-08 22:53:51 -05:00
});
better debugging for CI failures of std.atomic
2018-06-12 15:14:32 -04:00
}
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn startPuts(ctx: *Context) u8 {
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
var put_count: usize = puts_per_thread;
std.rand: Refactor `Random` interface These changes have been made to resolve issue #10037. The `Random` interface was implemented in such a way that causes significant slowdown when calling the `fill` function of the rng used. The `Random` interface is no longer stored in a field of the rng, and is instead returned by the child function `random()` of the rng. This avoids the performance issues caused by the interface.
2021-10-27 15:53:29 +01:00
var prng = std.rand.DefaultPrng.init(0xdeadbeef);
const random = prng.random();
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
while (put_count != 0) : (put_count -= 1) {
starting to fix the regressions
2019-05-24 22:52:07 -04:00
std.time.sleep(1); // let the os scheduler be our fuzz
std.rand: Refactor `Random` interface These changes have been made to resolve issue #10037. The `Random` interface was implemented in such a way that causes significant slowdown when calling the `fill` function of the rng used. The `Random` interface is no longer stored in a field of the rng, and is instead returned by the child function `random()` of the rng. This avoids the performance issues caused by the interface.
2021-10-27 15:53:29 +01:00
const x = @bitCast(i32, random.int(u32));
`std.mem.Allocator.create` replaced with better API `std.mem.Allocator.createOne` is renamed to `std.mem.Allocator.create`. The problem with the previous API is that even after copy elision, the initalization value passed as a parameter would always be a copy. With the new API, once copy elision is done, initialization functions can directly initialize allocated memory in place. Related: * #1872 * #1873
2019-02-03 16:13:28 -05:00
const node = ctx.allocator.create(Stack(i32).Node) catch unreachable;
node.* = Stack(i32).Node{
remove std.mem.Allocator.construct and other fixups
2018-06-20 17:33:29 -04:00
.next = undefined,
zig fmt
2018-06-20 17:16:27 -04:00
.data = x,
`std.mem.Allocator.create` replaced with better API `std.mem.Allocator.createOne` is renamed to `std.mem.Allocator.create`. The problem with the previous API is that even after copy elision, the initalization value passed as a parameter would always be a copy. With the new API, once copy elision is done, initialization functions can directly initialize allocated memory in place. Related: * #1872 * #1873
2019-02-03 16:13:28 -05:00
};
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
ctx.stack.push(node);
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
_ = @atomicRmw(isize, &ctx.put_sum, .Add, x, .SeqCst);
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
}
return 0;
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn startGets(ctx: *Context) u8 {
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
while (true) {
add note to disabled tests, improve comptime cmpxchg
2020-03-12 22:42:01 +02:00
const last = @atomicLoad(bool, &ctx.puts_done, .SeqCst);
fix race condition bug in test harness of std.atomic
2018-06-13 11:57:57 -04:00
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
while (ctx.stack.pop()) |node| {
starting to fix the regressions
2019-05-24 22:52:07 -04:00
std.time.sleep(1); // let the os scheduler be our fuzz
use atomic bools in std lib
2020-03-10 22:46:19 +02:00
_ = @atomicRmw(isize, &ctx.get_sum, .Add, node.data, .SeqCst);
_ = @atomicRmw(usize, &ctx.get_count, .Add, 1, .SeqCst);
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
}
fix race condition bug in test harness of std.atomic
2018-06-13 11:57:57 -04:00
if (last) return 0;
add fuzz tests for std.atomic.Stack
2018-04-28 17:53:06 -04:00
}
}
Reference in New Issue Copy Permalink