29cfd47d65
Instead of using `zig test` to build a special version of the compiler that runs all the test-cases, the zig build system is now used as much as possible - all with the basic steps found in the standard library. For incremental compilation tests (the ones that look like foo.0.zig, foo.1.zig, foo.2.zig, etc.), a special version of the compiler is compiled into a utility executable called "check-case" which checks exactly one sequence of incremental updates in an independent subprocess. Previously, all incremental and non-incremental test cases were done in the same test runner process. The compile error checking code is now simpler, but also a bit rudimentary, and so it additionally makes sure that the actual compile errors do not include *extra* messages, and it makes sure that the actual compile errors output in the same order as expected. It is also based on the "ends-with" property of each line rather than the previous logic, which frankly I didn't want to touch with a ten-meter pole. The compile error test cases have been updated to pass in light of these differences. Previously, 'error' mode with 0 compile errors was used to shoehorn in a different kind of test-case - one that only checks if a piece of code compiles without errors. Now there is a 'compile' mode of test-cases, and 'error' must be only used when there are greater than 0 errors. link test cases are updated to omit the target object format argument when calling checkObject since that is no longer needed. The test/stage2 directory is removed; the 2 files within are moved to be directly in the test/ directory.
107 lines
3.1 KiB
Zig
107 lines
3.1 KiB
Zig
const std = @import("std");
|
|
const Cases = @import("src/Cases.zig");
|
|
|
|
pub fn addCases(ctx: *Cases) !void {
|
|
{
|
|
var case = addPtx(ctx, "simple addition and subtraction");
|
|
|
|
case.addCompile(
|
|
\\fn add(a: i32, b: i32) i32 {
|
|
\\ return a + b;
|
|
\\}
|
|
\\
|
|
\\pub export fn add_and_substract(a: i32, out: *i32) callconv(.PtxKernel) void {
|
|
\\ const x = add(a, 7);
|
|
\\ var y = add(2, 0);
|
|
\\ y -= x;
|
|
\\ out.* = y;
|
|
\\}
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = addPtx(ctx, "read special registers");
|
|
|
|
case.addCompile(
|
|
\\fn threadIdX() u32 {
|
|
\\ return asm ("mov.u32 \t%[r], %tid.x;"
|
|
\\ : [r] "=r" (-> u32),
|
|
\\ );
|
|
\\}
|
|
\\
|
|
\\pub export fn special_reg(a: []const i32, out: []i32) callconv(.PtxKernel) void {
|
|
\\ const i = threadIdX();
|
|
\\ out[i] = a[i] + 7;
|
|
\\}
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = addPtx(ctx, "address spaces");
|
|
|
|
case.addCompile(
|
|
\\var x: i32 addrspace(.global) = 0;
|
|
\\
|
|
\\pub export fn increment(out: *i32) callconv(.PtxKernel) void {
|
|
\\ x += 1;
|
|
\\ out.* = x;
|
|
\\}
|
|
);
|
|
}
|
|
|
|
{
|
|
var case = addPtx(ctx, "reduce in shared mem");
|
|
case.addCompile(
|
|
\\fn threadIdX() u32 {
|
|
\\ return asm ("mov.u32 \t%[r], %tid.x;"
|
|
\\ : [r] "=r" (-> u32),
|
|
\\ );
|
|
\\}
|
|
\\
|
|
\\ var _sdata: [1024]f32 addrspace(.shared) = undefined;
|
|
\\ pub export fn reduceSum(d_x: []const f32, out: *f32) callconv(.PtxKernel) void {
|
|
\\ var sdata = @addrSpaceCast(.generic, &_sdata);
|
|
\\ const tid: u32 = threadIdX();
|
|
\\ var sum = d_x[tid];
|
|
\\ sdata[tid] = sum;
|
|
\\ asm volatile ("bar.sync \t0;");
|
|
\\ var s: u32 = 512;
|
|
\\ while (s > 0) : (s = s >> 1) {
|
|
\\ if (tid < s) {
|
|
\\ sum += sdata[tid + s];
|
|
\\ sdata[tid] = sum;
|
|
\\ }
|
|
\\ asm volatile ("bar.sync \t0;");
|
|
\\ }
|
|
\\
|
|
\\ if (tid == 0) {
|
|
\\ out.* = sum;
|
|
\\ }
|
|
\\ }
|
|
);
|
|
}
|
|
}
|
|
|
|
const nvptx_target = std.zig.CrossTarget{
|
|
.cpu_arch = .nvptx64,
|
|
.os_tag = .cuda,
|
|
};
|
|
|
|
pub fn addPtx(
|
|
ctx: *Cases,
|
|
name: []const u8,
|
|
) *Cases.Case {
|
|
ctx.cases.append(.{
|
|
.name = name,
|
|
.target = nvptx_target,
|
|
.updates = std.ArrayList(Cases.Update).init(ctx.cases.allocator),
|
|
.output_mode = .Obj,
|
|
.deps = std.ArrayList(Cases.DepModule).init(ctx.cases.allocator),
|
|
.link_libc = false,
|
|
.backend = .llvm,
|
|
// Bug in Debug mode
|
|
.optimize_mode = .ReleaseSafe,
|
|
}) catch @panic("out of memory");
|
|
return &ctx.cases.items[ctx.cases.items.len - 1];
|
|
}
|