Omp: use names and synchronization behaviours for critical sections

This may not fit the standard completely since we need to specify every
time a name and a sync behaviour, but it works. Also the critical
section will come with a huge performance hit compared to the native
counterpart i imagine

Author: sbancuz

src/kmp.zig

@@ -57,7 +57,6 @@ pub const ident_t = extern struct {
     psource: [*:0]const u8,
 };
 
-pub const critical_name_t = [8]c_int;
 pub const kmpc_micro_t = fn (global_tid: *c_int, bound_tid: *c_int, args: *align(@alignOf(usize)) anyopaque) callconv(.C) void;
 
 extern "C" fn __kmpc_fork_call(name: *ident_t, argc: c_int, fun: *const kmpc_micro_t, ...) void;
@@ -136,16 +135,15 @@ pub inline fn push_num_threads(name: *ident_t, global_tid: c_int, num_threads: c
     __kmpc_push_num_threads(@constCast(name), global_tid, num_threads);
 }
 
-// Maybe figure out how to use the clang API, but since this GOMP is supported by clang we can just use it
-// This is "needed" because it's an API that doesn't need to use the name for which i don't know the rules to it
-extern "C" fn GOMP_critical_start() void;
-pub inline fn critical() void {
-    GOMP_critical_start();
+pub const critical_name_t = [8]c_int; // This seems to be just a lock, so I give up on ever using it
+extern "C" fn __kmpc_critical_with_hint(loc: *ident_t, global_tid: c_int, crit: *critical_name_t, hint: c_int) void;
+pub inline fn critical(loc: *ident_t, global_tid: c_int, crit: *critical_name_t, hint: c_int) void {
+    __kmpc_critical_with_hint(loc, global_tid, crit, hint);
 }
 
-extern "C" fn GOMP_critical_end() void;
-pub inline fn critical_end() void {
-    GOMP_critical_end();
+extern "C" fn __kmpc_end_critical(loc: *ident_t, global_tid: c_int, crit: *critical_name_t) void;
+pub inline fn critical_end(loc: *ident_t, global_tid: c_int, crit: *critical_name_t) void {
+    __kmpc_end_critical(loc, global_tid, crit);
 }
 
 // Todo: invert for big endian

src/omp.zig

@@ -103,13 +103,15 @@ pub const ctx = struct {
 
     global_tid: c_int,
     bound_tid: c_int,
+    locks: std.StringHashMap(kmp.critical_name_t),
 
     fn make_outline(comptime T: type, comptime R: type, comptime f: anytype) type {
         return opaque {
             fn outline(gtid: *c_int, btid: *c_int, argss: *T) callconv(.C) void {
                 var this: Self = .{
                     .global_tid = gtid.*,
                     .bound_tid = btid.*,
+                    .locks = std.StringHashMap(kmp.critical_name_t).init(std.heap.page_allocator),
                 };
 
                 const private_type = @TypeOf(argss.args.privates);
@@ -149,6 +151,7 @@ pub const ctx = struct {
                 } else {
                     argss.ret = @call(.auto, f, .{&this} ++ true_args);
                 }
+
                 return;
             }
         };
@@ -304,8 +307,21 @@ pub const ctx = struct {
         kmp.barrier(&id, this.global_tid);
     }
 
-    pub fn critical(this: *Self, f: anytype, args: anytype) copy_ret(f) {
-        kmp.critical();
+    pub fn critical(this: *Self, name: []const u8, sync: sync_hint_t, f: anytype, args: anytype) copy_ret(f) {
+        var id: kmp.ident_t = .{
+            .flags = @intFromEnum(kmp.ident_flags.IDENT_KMPC) | @intFromEnum(kmp.ident_flags.IDENT_WORK_LOOP),
+            .psource = "barrier",
+        };
+
+        var loc: kmp.critical_name_t = this.locks.get(name) orelse l: {
+            var l: kmp.critical_name_t = @bitCast([_]u8{0} ** 32);
+            this.locks.put(name, l) catch {
+                @panic("Failed to allocate memory for lock");
+            };
+            break :l l;
+        };
+
+        kmp.critical(&id, this.global_tid, &loc, @intFromEnum(sync));
 
         const new_args = .{this} ++ args;
 
@@ -317,7 +333,7 @@ pub const ctx = struct {
                 break :ret @call(.auto, f, new_args);
             }
         };
-        kmp.critical_end();
+        kmp.critical_end(&id, this.global_tid, &loc);
 
         return ret;
     }