Commit afa66fa392f5a32d16da7f4705c59dad369f6d48 | zig

author	Jacob Young <jacobly@ziglang.org> 2024-07-10 14:33:46-04:00
committer	Jacob Young <jacobly@ziglang.org> 2024-07-10 14:42:50-04:00
log	afa66fa392f5a32d16da7f4705c59dad369f6d48
tree	4872284bc454b34c14f25559ea46ea9bd6bf2deb
parent	f290b54f891a67af456529da0f4f824a1e27b4ef

InternPool: make `tracked_insts` thread-safe

5 files changed, 382 insertions(+), 216 deletions(-)

src/Compilation.zig+22-53

 @@ -2675,7 +2675,10 @@ fn reportMultiModuleErrors(pt: Zcu.PerThread) !void {
                     .import => |import| try Zcu.ErrorMsg.init(
                         gpa,
                         .{
-                            .base_node_inst = try ip.trackZir(gpa, import.file, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                                .file = import.file,
+                                .inst = .main_struct_inst,
+                            }),
                             .offset = .{ .token_abs = import.token },
                         },
                         "imported from module {s}",
 @@ -2684,7 +2687,10 @@ fn reportMultiModuleErrors(pt: Zcu.PerThread) !void {
                     .root => |pkg| try Zcu.ErrorMsg.init(
                         gpa,
                         .{
-                            .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                                .file = file_index,
+                                .inst = .main_struct_inst,
+                            }),
                             .offset = .entire_file,
                         },
                         "root of module {s}",
 @@ -2698,7 +2704,10 @@ fn reportMultiModuleErrors(pt: Zcu.PerThread) !void {
                 notes[num_notes] = try Zcu.ErrorMsg.init(
                     gpa,
                     .{
-                        .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                        .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                            .file = file_index,
+                            .inst = .main_struct_inst,
+                        }),
                         .offset = .entire_file,
                     },
                     "{} more references omitted",
 @@ -2710,7 +2719,10 @@ fn reportMultiModuleErrors(pt: Zcu.PerThread) !void {
             const err = try Zcu.ErrorMsg.create(
                 gpa,
                 .{
-                    .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                    .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                        .file = file_index,
+                        .inst = .main_struct_inst,
+                    }),
                     .offset = .entire_file,
                 },
                 "file exists in multiple modules",
 @@ -2776,7 +2788,7 @@ const Header = extern struct {
         //extra_len: u32,
         //limbs_len: u32,
         //string_bytes_len: u32,
-        tracked_insts_len: u32,
+        //tracked_insts_len: u32,
         src_hash_deps_len: u32,
         decl_val_deps_len: u32,
         namespace_deps_len: u32,
 @@ -2805,7 +2817,7 @@ pub fn saveState(comp: *Compilation) !void {
                 //.extra_len = @intCast(ip.extra.items.len),
                 //.limbs_len = @intCast(ip.limbs.items.len),
                 //.string_bytes_len = @intCast(ip.string_bytes.items.len),
-                .tracked_insts_len = @intCast(ip.tracked_insts.count()),
+                //.tracked_insts_len = @intCast(ip.tracked_insts.count()),
                 .src_hash_deps_len = @intCast(ip.src_hash_deps.count()),
                 .decl_val_deps_len = @intCast(ip.decl_val_deps.count()),
                 .namespace_deps_len = @intCast(ip.namespace_deps.count()),
 @@ -2822,7 +2834,7 @@ pub fn saveState(comp: *Compilation) !void {
         //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.items.items(.data)));
         //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.items.items(.tag)));
         //addBuf(&bufs_list, &bufs_len, ip.string_bytes.items);
-        addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.tracked_insts.keys()));
+        //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.tracked_insts.keys()));
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.src_hash_deps.keys()));
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.src_hash_deps.values()));
 @@ -4134,14 +4146,6 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anye
     };
 }
-const AstGenSrc = union(enum) {
-    root,
-    import: struct {
-        importing_file: Zcu.File.Index,
-        import_tok: std.zig.Ast.TokenIndex,
-    },
-};
 fn workerAstGenFile(
     tid: usize,
     comp: *Compilation,
 @@ -4151,7 +4155,7 @@ fn workerAstGenFile(
     root_decl: Zcu.Decl.OptionalIndex,
     prog_node: std.Progress.Node,
     wg: *WaitGroup,
-    src: AstGenSrc,
+    src: Zcu.AstGenSrc,
 ) void {
     const child_prog_node = prog_node.start(file.sub_file_path, 0);
     defer child_prog_node.end();
 @@ -4161,7 +4165,7 @@ fn workerAstGenFile(
         error.AnalysisFail => return,
         else => {
             file.status = .retryable_failure;
-            comp.reportRetryableAstGenError(src, file_index, err) catch |oom| switch (oom) {
+            pt.reportRetryableAstGenError(src, file_index, err) catch |oom| switch (oom) {
                 // Swallowing this error is OK because it's implied to be OOM when
                 // there is a missing `failed_files` error message.
                 error.OutOfMemory => {},
 @@ -4207,7 +4211,7 @@ fn workerAstGenFile(
                 log.debug("AstGen of {s} has import '{s}'; queuing AstGen of {s}", .{
                     file.sub_file_path, import_path, import_result.file.sub_file_path,
                 });
-                const sub_src: AstGenSrc = .{ .import = .{
+                const sub_src: Zcu.AstGenSrc = .{ .import = .{
                     .importing_file = file_index,
                     .import_tok = item.data.token,
                 } };
 @@ -4560,41 +4564,6 @@ fn reportRetryableWin32ResourceError(
     }
 }
-fn reportRetryableAstGenError(
-    comp: *Compilation,
-    src: AstGenSrc,
-    file_index: Zcu.File.Index,
-    err: anyerror,
-) error{OutOfMemory}!void {
-    const zcu = comp.module.?;
-    const gpa = zcu.gpa;
-    const file = zcu.fileByIndex(file_index);
-    file.status = .retryable_failure;
-    const src_loc: Zcu.LazySrcLoc = switch (src) {
-        .root => .{
-            .base_node_inst = try zcu.intern_pool.trackZir(gpa, file_index, .main_struct_inst),
-            .offset = .entire_file,
-        },
-        .import => |info| .{
-            .base_node_inst = try zcu.intern_pool.trackZir(gpa, info.importing_file, .main_struct_inst),
-            .offset = .{ .token_abs = info.import_tok },
-        },
-    };
-    const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
-        file.mod.root, file.sub_file_path, @errorName(err),
-    });
-    errdefer err_msg.destroy(gpa);
-    {
-        comp.mutex.lock();
-        defer comp.mutex.unlock();
-        try zcu.failed_files.putNoClobber(gpa, file, err_msg);
-    }
-}
 fn reportRetryableEmbedFileError(
     comp: *Compilation,
     embed_file: *Zcu.EmbedFile,

src/InternPool.zig+156-26

 @@ -20,10 +20,6 @@ tid_shift_32: if (single_threaded) u0 else std.math.Log2Int(u32) = if (single_th
 /// These are not serialized; it is computed upon deserialization.
 maps: std.ArrayListUnmanaged(FieldMap) = .{},
-/// An index into `tracked_insts` gives a reference to a single ZIR instruction which
-/// persists across incremental updates.
-tracked_insts: std.AutoArrayHashMapUnmanaged(TrackedInst, void) = .{},
 /// Dependencies on the source code hash associated with a ZIR instruction.
 /// * For a `declaration`, this is the entire declaration body.
 /// * For a `struct_decl`, `union_decl`, etc, this is the source of the fields (but not declarations).
 @@ -76,12 +72,15 @@ pub const TrackedInst = extern struct {
     }
     pub const Index = enum(u32) {
         _,
-        pub fn resolveFull(i: TrackedInst.Index, ip: *const InternPool) TrackedInst {
+        pub fn resolveFull(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) TrackedInst {
-            return ip.tracked_insts.keys()[@intFromEnum(i)];
+            const tracked_inst_unwrapped = tracked_inst_index.unwrap(ip);
+            const tracked_insts = ip.getLocalShared(tracked_inst_unwrapped.tid).tracked_insts.acquire();
+            return tracked_insts.view().items(.@"0")[tracked_inst_unwrapped.index];
         }
         pub fn resolve(i: TrackedInst.Index, ip: *const InternPool) Zir.Inst.Index {
             return i.resolveFull(ip).inst;
         }
         pub fn toOptional(i: TrackedInst.Index) Optional {
             return @enumFromInt(@intFromEnum(i));
         }
 @@ -95,21 +94,124 @@ pub const TrackedInst = extern struct {
                 };
             }
         };
+        pub const Unwrapped = struct {
+            tid: Zcu.PerThread.Id,
+            index: u32,
+            pub fn wrap(unwrapped: Unwrapped, ip: *const InternPool) TrackedInst.Index {
+                assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask());
+                assert(unwrapped.index <= ip.getIndexMask(u32));
+                return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 |
+                    unwrapped.index);
+            }
+        };
+        pub fn unwrap(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) Unwrapped {
+            return .{
+                .tid = @enumFromInt(@intFromEnum(tracked_inst_index) >> ip.tid_shift_32 & ip.getTidMask()),
+                .index = @intFromEnum(tracked_inst_index) & ip.getIndexMask(u32),
+            };
+        }
     };
 };
 pub fn trackZir(
     ip: *InternPool,
     gpa: Allocator,
-    file: FileIndex,
+    tid: Zcu.PerThread.Id,
-    inst: Zir.Inst.Index,
+    key: TrackedInst,
 ) Allocator.Error!TrackedInst.Index {
-    const key: TrackedInst = .{
+    const full_hash = Hash.hash(0, std.mem.asBytes(&key));
-        .file = file,
+    const hash: u32 = @truncate(full_hash >> 32);
-        .inst = inst,
+    const shard = &ip.shards[@intCast(full_hash & (ip.shards.len - 1))];
-    };
+    var map = shard.shared.tracked_inst_map.acquire();
-    const gop = try ip.tracked_insts.getOrPut(gpa, key);
+    const Map = @TypeOf(map);
-    return @enumFromInt(gop.index);
+    var map_mask = map.header().mask();
+    var map_index = hash;
+    while (true) : (map_index += 1) {
+        map_index &= map_mask;
+        const entry = &map.entries[map_index];
+        const index = entry.acquire().unwrap() orelse break;
+        if (entry.hash != hash) continue;
+        if (std.meta.eql(index.resolveFull(ip), key)) return index;
+    }
+    shard.mutate.tracked_inst_map.mutex.lock();
+    defer shard.mutate.tracked_inst_map.mutex.unlock();
+    if (map.entries != shard.shared.tracked_inst_map.entries) {
+        shard.mutate.tracked_inst_map.len += 1;
+        map = shard.shared.tracked_inst_map;
+        map_mask = map.header().mask();
+        map_index = hash;
+    }
+    while (true) : (map_index += 1) {
+        map_index &= map_mask;
+        const entry = &map.entries[map_index];
+        const index = entry.acquire().unwrap() orelse break;
+        if (entry.hash != hash) continue;
+        if (std.meta.eql(index.resolveFull(ip), key)) return index;
+    }
+    defer shard.mutate.tracked_inst_map.len += 1;
+    const local = ip.getLocal(tid);
+    local.mutate.tracked_insts.mutex.lock();
+    defer local.mutate.tracked_insts.mutex.unlock();
+    const list = local.getMutableTrackedInsts(gpa);
+    try list.ensureUnusedCapacity(1);
+    const map_header = map.header().*;
+    if (shard.mutate.tracked_inst_map.len < map_header.capacity * 3 / 5) {
+        const entry = &map.entries[map_index];
+        entry.hash = hash;
+        const index = (TrackedInst.Index.Unwrapped{
+            .tid = tid,
+            .index = list.mutate.len,
+        }).wrap(ip);
+        list.appendAssumeCapacity(.{key});
+        entry.release(index.toOptional());
+        return index;
+    }
+    const arena_state = &local.mutate.arena;
+    var arena = arena_state.promote(gpa);
+    defer arena_state.* = arena.state;
+    const new_map_capacity = map_header.capacity * 2;
+    const new_map_buf = try arena.allocator().alignedAlloc(
+        u8,
+        Map.alignment,
+        Map.entries_offset + new_map_capacity * @sizeOf(Map.Entry),
+    );
+    const new_map: Map = .{ .entries = @ptrCast(new_map_buf[Map.entries_offset..].ptr) };
+    new_map.header().* = .{ .capacity = new_map_capacity };
+    @memset(new_map.entries[0..new_map_capacity], .{ .value = .none, .hash = undefined });
+    const new_map_mask = new_map.header().mask();
+    map_index = 0;
+    while (map_index < map_header.capacity) : (map_index += 1) {
+        const entry = &map.entries[map_index];
+        const index = entry.value.unwrap() orelse continue;
+        const item_hash = entry.hash;
+        var new_map_index = item_hash;
+        while (true) : (new_map_index += 1) {
+            new_map_index &= new_map_mask;
+            const new_entry = &new_map.entries[new_map_index];
+            if (new_entry.value != .none) continue;
+            new_entry.* = .{
+                .value = index.toOptional(),
+                .hash = item_hash,
+            };
+            break;
+        }
+    }
+    map = new_map;
+    map_index = hash;
+    while (true) : (map_index += 1) {
+        map_index &= new_map_mask;
+        if (map.entries[map_index].value == .none) break;
+    }
+    const index = (TrackedInst.Index.Unwrapped{
+        .tid = tid,
+        .index = list.mutate.len,
+    }).wrap(ip);
+    list.appendAssumeCapacity(.{key});
+    map.entries[map_index] = .{ .value = index.toOptional(), .hash = hash };
+    shard.shared.tracked_inst_map.release(new_map);
+    return index;
 }
 /// Analysis Unit. Represents a single entity which undergoes semantic analysis.
 @@ -324,6 +426,7 @@ const Local = struct {
         extra: ListMutate,
         limbs: ListMutate,
         strings: ListMutate,
+        tracked_insts: MutexListMutate,
         files: ListMutate,
         decls: BucketListMutate,
 @@ -335,6 +438,7 @@ const Local = struct {
         extra: Extra,
         limbs: Limbs,
         strings: Strings,
+        tracked_insts: TrackedInsts,
         files: List(File),
         decls: Decls,
 @@ -356,6 +460,7 @@ const Local = struct {
         else => @compileError("unsupported host"),
     };
     const Strings = List(struct { u8 });
+    const TrackedInsts = List(struct { TrackedInst });
     const decls_bucket_width = 8;
     const decls_bucket_mask = (1 << decls_bucket_width) - 1;
 @@ -375,6 +480,16 @@ const Local = struct {
         };
     };
+    const MutexListMutate = struct {
+        mutex: std.Thread.Mutex,
+        list: ListMutate,
+        const empty: MutexListMutate = .{
+            .mutex = .{},
+            .list = ListMutate.empty,
+        };
+    };
     const BucketListMutate = struct {
         last_bucket_len: u32,
         buckets_list: ListMutate,
 @@ -396,7 +511,7 @@ const Local = struct {
             const ListSelf = @This();
             const Mutable = struct {
-                gpa: std.mem.Allocator,
+                gpa: Allocator,
                 arena: *std.heap.ArenaAllocator.State,
                 mutate: *ListMutate,
                 list: *ListSelf,
 @@ -564,7 +679,7 @@ const Local = struct {
                     mutable.list.release(new_list);
                 }
-                fn view(mutable: Mutable) View {
+                pub fn view(mutable: Mutable) View {
                     const capacity = mutable.list.header().capacity;
                     assert(capacity > 0); // optimizes `MultiArrayList.Slice.items`
                     return .{
 @@ -614,7 +729,7 @@ const Local = struct {
         };
     }
-    pub fn getMutableItems(local: *Local, gpa: std.mem.Allocator) List(Item).Mutable {
+    pub fn getMutableItems(local: *Local, gpa: Allocator) List(Item).Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -623,7 +738,7 @@ const Local = struct {
         };
     }
-    pub fn getMutableExtra(local: *Local, gpa: std.mem.Allocator) Extra.Mutable {
+    pub fn getMutableExtra(local: *Local, gpa: Allocator) Extra.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -636,7 +751,7 @@ const Local = struct {
     /// On 64-bit systems, this array is used for big integers and associated metadata.
     /// Use the helper methods instead of accessing this directly in order to not
     /// violate the above mechanism.
-    pub fn getMutableLimbs(local: *Local, gpa: std.mem.Allocator) Limbs.Mutable {
+    pub fn getMutableLimbs(local: *Local, gpa: Allocator) Limbs.Mutable {
         return switch (@sizeOf(Limb)) {
             @sizeOf(u32) => local.getMutableExtra(gpa),
             @sizeOf(u64) => .{
 @@ -654,7 +769,7 @@ const Local = struct {
     /// is referencing the data here whether they want to store both index and length,
     /// thus allowing null bytes, or store only index, and use null-termination. The
     /// `strings` array is agnostic to either usage.
-    pub fn getMutableStrings(local: *Local, gpa: std.mem.Allocator) Strings.Mutable {
+    pub fn getMutableStrings(local: *Local, gpa: Allocator) Strings.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -663,6 +778,17 @@ const Local = struct {
         };
     }
+    /// An index into `tracked_insts` gives a reference to a single ZIR instruction which
+    /// persists across incremental updates.
+    pub fn getMutableTrackedInsts(local: *Local, gpa: Allocator) TrackedInsts.Mutable {
+        return .{
+            .gpa = gpa,
+            .arena = &local.mutate.arena,
+            .mutate = &local.mutate.tracked_insts.list,
+            .list = &local.shared.tracked_insts,
+        };
+    }
     /// Elements are ordered identically to the `import_table` field of `Zcu`.
     ///
     /// Unlike `import_table`, this data is serialized as part of incremental
 @@ -672,7 +798,7 @@ const Local = struct {
     /// `InternPool.TrackedInst`.
     ///
     /// Value is the `Decl` of the struct that represents this `File`.
-    pub fn getMutableFiles(local: *Local, gpa: std.mem.Allocator) List(File).Mutable {
+    pub fn getMutableFiles(local: *Local, gpa: Allocator) List(File).Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -691,7 +817,7 @@ const Local = struct {
     ///    serialization trivial.
     ///  * It provides a unique integer to be used for anonymous symbol names, avoiding
     ///    multi-threaded contention on an atomic counter.
-    pub fn getMutableDecls(local: *Local, gpa: std.mem.Allocator) Decls.Mutable {
+    pub fn getMutableDecls(local: *Local, gpa: Allocator) Decls.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -701,7 +827,7 @@ const Local = struct {
     }
     /// Same pattern as with `getMutableDecls`.
-    pub fn getMutableNamespaces(local: *Local, gpa: std.mem.Allocator) Namespaces.Mutable {
+    pub fn getMutableNamespaces(local: *Local, gpa: Allocator) Namespaces.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -723,11 +849,13 @@ const Shard = struct {
     shared: struct {
         map: Map(Index),
         string_map: Map(OptionalNullTerminatedString),
+        tracked_inst_map: Map(TrackedInst.Index.Optional),
     } align(std.atomic.cache_line),
     mutate: struct {
         // TODO: measure cost of sharing unrelated mutate state
         map: Mutate align(std.atomic.cache_line),
         string_map: Mutate align(std.atomic.cache_line),
+        tracked_inst_map: Mutate align(std.atomic.cache_line),
     },
     const Mutate = struct {
 @@ -5240,6 +5368,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
             .extra = Local.Extra.empty,
             .limbs = Local.Limbs.empty,
             .strings = Local.Strings.empty,
+            .tracked_insts = Local.TrackedInsts.empty,
             .files = Local.List(File).empty,
             .decls = Local.Decls.empty,
 @@ -5252,6 +5381,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
             .extra = Local.ListMutate.empty,
             .limbs = Local.ListMutate.empty,
             .strings = Local.ListMutate.empty,
+            .tracked_insts = Local.MutexListMutate.empty,
             .files = Local.ListMutate.empty,
             .decls = Local.BucketListMutate.empty,
 @@ -5267,10 +5397,12 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
         .shared = .{
             .map = Shard.Map(Index).empty,
             .string_map = Shard.Map(OptionalNullTerminatedString).empty,
+            .tracked_inst_map = Shard.Map(TrackedInst.Index.Optional).empty,
         },
         .mutate = .{
             .map = Shard.Mutate.empty,
             .string_map = Shard.Mutate.empty,
+            .tracked_inst_map = Shard.Mutate.empty,
         },
     });
 @@ -5311,8 +5443,6 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
     for (ip.maps.items) |*map| map.deinit(gpa);
     ip.maps.deinit(gpa);
-    ip.tracked_insts.deinit(gpa);
     ip.src_hash_deps.deinit(gpa);
     ip.decl_val_deps.deinit(gpa);
     ip.func_ies_deps.deinit(gpa);
 @@ -9887,7 +10017,7 @@ pub fn getOrPutTrailingString(
     }
     const key: []const u8 = strings.view().items(.@"0")[start..];
     const value: embedded_nulls.StringType() =
-        @enumFromInt(@as(u32, @intFromEnum(tid)) << ip.tid_shift_32 | start);
+        @enumFromInt(@intFromEnum((String.Unwrapped{ .tid = tid, .index = start }).wrap(ip)));
     const has_embedded_null = std.mem.indexOfScalar(u8, key, 0) != null;
     switch (embedded_nulls) {
         .no_embedded_nulls => assert(!has_embedded_null),

src/Sema.zig+5-6

...	@@ -835,12 +835,11 @@ pub const Block = struct {	...	@@ -835,12 +835,11 @@ pub const Block = struct {
835	}	835	}
836		836
837	fn trackZir(block: *Block, inst: Zir.Inst.Index) Allocator.Error!InternPool.TrackedInst.Index {	837	fn trackZir(block: *Block, inst: Zir.Inst.Index) Allocator.Error!InternPool.TrackedInst.Index {
838	const sema = block.sema;	838	const pt = block.sema.pt;
839	const gpa = sema.gpa;	839	return pt.zcu.intern_pool.trackZir(pt.zcu.gpa, pt.tid, .{
840	const zcu = sema.pt.zcu;	840	.file = block.getFileScopeIndex(pt.zcu),
841	const ip = &zcu.intern_pool;	841	.inst = inst,
842	const file_index = block.getFileScopeIndex(zcu);	842	});
843	return ip.trackZir(gpa, file_index, inst);
844	}	843	}
845	};	844	};
846		845

src/Zcu.zig+8-35

...	@@ -1018,6 +1018,14 @@ pub const ErrorMsg = struct {	...	@@ -1018,6 +1018,14 @@ pub const ErrorMsg = struct {
1018	}	1018	}
1019	};	1019	};
1020		1020
		1021	pub const AstGenSrc = union(enum) {
		1022	root,
		1023	import: struct {
		1024	importing_file: Zcu.File.Index,
		1025	import_tok: std.zig.Ast.TokenIndex,
		1026	},
		1027	};
		1028
1021	/// Canonical reference to a position within a source file.	1029	/// Canonical reference to a position within a source file.
1022	pub const SrcLoc = struct {	1030	pub const SrcLoc = struct {
1023	file_scope: *File,	1031	file_scope: *File,
...	@@ -3186,41 +3194,6 @@ pub fn handleUpdateExports(	...	@@ -3186,41 +3194,6 @@ pub fn handleUpdateExports(
3186	};	3194	};
3187	}	3195	}
3188		3196
3189	pub fn reportRetryableFileError(
3190	zcu: *Zcu,
3191	file_index: File.Index,
3192	comptime format: []const u8,
3193	args: anytype,
3194	) error{OutOfMemory}!void {
3195	const gpa = zcu.gpa;
3196	const ip = &zcu.intern_pool;
3197
3198	const file = zcu.fileByIndex(file_index);
3199	file.status = .retryable_failure;
3200
3201	const err_msg = try ErrorMsg.create(
3202	gpa,
3203	.{
3204	.base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
3205	.offset = .entire_file,
3206	},
3207	format,
3208	args,
3209	);
3210	errdefer err_msg.destroy(gpa);
3211
3212	zcu.comp.mutex.lock();
3213	defer zcu.comp.mutex.unlock();
3214
3215	const gop = try zcu.failed_files.getOrPut(gpa, file);
3216	if (gop.found_existing) {
3217	if (gop.value_ptr.*) \|old_err_msg\| {
3218	old_err_msg.destroy(gpa);
3219	}
3220	}
3221	gop.value_ptr.* = err_msg;
3222	}
3223
3224	pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u8) !void {	3197	pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u8) !void {
3225	const gop = try mod.global_assembly.getOrPut(mod.gpa, decl_index);	3198	const gop = try mod.global_assembly.getOrPut(mod.gpa, decl_index);
3226	if (gop.found_existing) {	3199	if (gop.found_existing) {

src/Zcu/PerThread.zig+191-96

...	@@ -342,6 +342,7 @@ pub fn astGenFile(	...	@@ -342,6 +342,7 @@ pub fn astGenFile(
342	/// the Compilation mutex when acting on shared state.	342	/// the Compilation mutex when acting on shared state.
343	fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index, old_zir: Zir) !void {	343	fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index, old_zir: Zir) !void {
344	const zcu = pt.zcu;	344	const zcu = pt.zcu;
		345	const ip = &zcu.intern_pool;
345	const gpa = zcu.gpa;	346	const gpa = zcu.gpa;
346	const new_zir = file.zir;	347	const new_zir = file.zir;
347		348
...	@@ -355,109 +356,117 @@ fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index,	...	@@ -355,109 +356,117 @@ fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index,
355		356
356	// TODO: this should be done after all AstGen workers complete, to avoid	357	// TODO: this should be done after all AstGen workers complete, to avoid
357	// iterating over this full set for every updated file.	358	// iterating over this full set for every updated file.
358	for (zcu.intern_pool.tracked_insts.keys(), 0..) \|*ti, idx_raw\| {	359	for (ip.locals, 0..) \|*local, tid\| {
359	const ti_idx: InternPool.TrackedInst.Index = @enumFromInt(idx_raw);	360	local.mutate.tracked_insts.mutex.lock();
360	if (ti.file != file_index) continue;	361	defer local.mutate.tracked_insts.mutex.unlock();
361	const old_inst = ti.inst;	362	const tracked_insts_list = local.getMutableTrackedInsts(gpa);
362	ti.inst = inst_map.get(ti.inst) orelse {	363	for (tracked_insts_list.view().items(.@"0"), 0..) \|*tracked_inst, tracked_inst_unwrapped_index\| {
363	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.	364	if (tracked_inst.file != file_index) continue;
364	zcu.comp.mutex.lock();	365	const old_inst = tracked_inst.inst;
365	defer zcu.comp.mutex.unlock();	366	const tracked_inst_index = (InternPool.TrackedInst.Index.Unwrapped{
366	log.debug("tracking failed for %{d}", .{old_inst});	367	.tid = @enumFromInt(tid),
367	try zcu.markDependeeOutdated(.{ .src_hash = ti_idx });	368	.index = @intCast(tracked_inst_unwrapped_index),
368	continue;	369	}).wrap(ip);
369	};	370	tracked_inst.inst = inst_map.get(old_inst) orelse {
		371	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.
		372	zcu.comp.mutex.lock();
		373	defer zcu.comp.mutex.unlock();
		374	log.debug("tracking failed for %{d}", .{old_inst});
		375	try zcu.markDependeeOutdated(.{ .src_hash = tracked_inst_index });
		376	continue;
		377	};
370		378
371	if (old_zir.getAssociatedSrcHash(old_inst)) \|old_hash\| hash_changed: {	379	if (old_zir.getAssociatedSrcHash(old_inst)) \|old_hash\| hash_changed: {
372	if (new_zir.getAssociatedSrcHash(ti.inst)) \|new_hash\| {	380	if (new_zir.getAssociatedSrcHash(tracked_inst.inst)) \|new_hash\| {
373	if (std.zig.srcHashEql(old_hash, new_hash)) {	381	if (std.zig.srcHashEql(old_hash, new_hash)) {
374	break :hash_changed;	382	break :hash_changed;
		383	}
		384	log.debug("hash for (%{d} -> %{d}) changed: {} -> {}", .{
		385	old_inst,
		386	tracked_inst.inst,
		387	std.fmt.fmtSliceHexLower(&old_hash),
		388	std.fmt.fmtSliceHexLower(&new_hash),
		389	});
375	}	390	}
376	log.debug("hash for (%{d} -> %{d}) changed: {} -> {}", .{	391	// The source hash associated with this instruction changed - invalidate relevant dependencies.
377	old_inst,	392	zcu.comp.mutex.lock();
378	ti.inst,	393	defer zcu.comp.mutex.unlock();
379	std.fmt.fmtSliceHexLower(&old_hash),	394	try zcu.markDependeeOutdated(.{ .src_hash = tracked_inst_index });
380	std.fmt.fmtSliceHexLower(&new_hash),
381	});
382	}	395	}
383	// The source hash associated with this instruction changed - invalidate relevant dependencies.
384	zcu.comp.mutex.lock();
385	defer zcu.comp.mutex.unlock();
386	try zcu.markDependeeOutdated(.{ .src_hash = ti_idx });
387	}
388		396
389	// If this is a `struct_decl` etc, we must invalidate any outdated namespace dependencies.	397	// If this is a `struct_decl` etc, we must invalidate any outdated namespace dependencies.
390	const has_namespace = switch (old_tag[@intFromEnum(old_inst)]) {	398	const has_namespace = switch (old_tag[@intFromEnum(old_inst)]) {
391	.extended => switch (old_data[@intFromEnum(old_inst)].extended.opcode) {	399	.extended => switch (old_data[@intFromEnum(old_inst)].extended.opcode) {
392	.struct_decl, .union_decl, .opaque_decl, .enum_decl => true,	400	.struct_decl, .union_decl, .opaque_decl, .enum_decl => true,
		401	else => false,
		402	},
393	else => false,	403	else => false,
394	},	404	};
395	else => false,	405	if (!has_namespace) continue;
396	};	406
397	if (!has_namespace) continue;	407	var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};
398		408	defer old_names.deinit(zcu.gpa);
399	var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};	409	{
400	defer old_names.deinit(zcu.gpa);	410	var it = old_zir.declIterator(old_inst);
401	{	411	while (it.next()) \|decl_inst\| {
402	var it = old_zir.declIterator(old_inst);	412	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;
403	while (it.next()) \|decl_inst\| {	413	switch (decl_name) {
404	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;	414	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,
405	switch (decl_name) {	415	_ => if (decl_name.isNamedTest(old_zir)) continue,
406	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,	416	}
407	_ => if (decl_name.isNamedTest(old_zir)) continue,	417	const name_zir = decl_name.toString(old_zir).?;
		418	const name_ip = try zcu.intern_pool.getOrPutString(
		419	zcu.gpa,
		420	pt.tid,
		421	old_zir.nullTerminatedString(name_zir),
		422	.no_embedded_nulls,
		423	);
		424	try old_names.put(zcu.gpa, name_ip, {});
408	}	425	}
409	const name_zir = decl_name.toString(old_zir).?;
410	const name_ip = try zcu.intern_pool.getOrPutString(
411	zcu.gpa,
412	pt.tid,
413	old_zir.nullTerminatedString(name_zir),
414	.no_embedded_nulls,
415	);
416	try old_names.put(zcu.gpa, name_ip, {});
417	}	426	}
418	}	427	var any_change = false;
419	var any_change = false;	428	{
420	{	429	var it = new_zir.declIterator(tracked_inst.inst);
421	var it = new_zir.declIterator(ti.inst);	430	while (it.next()) \|decl_inst\| {
422	while (it.next()) \|decl_inst\| {	431	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;
423	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;	432	switch (decl_name) {
424	switch (decl_name) {	433	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,
425	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,	434	_ => if (decl_name.isNamedTest(old_zir)) continue,
426	_ => if (decl_name.isNamedTest(old_zir)) continue,	435	}
		436	const name_zir = decl_name.toString(old_zir).?;
		437	const name_ip = try zcu.intern_pool.getOrPutString(
		438	zcu.gpa,
		439	pt.tid,
		440	old_zir.nullTerminatedString(name_zir),
		441	.no_embedded_nulls,
		442	);
		443	if (!old_names.swapRemove(name_ip)) continue;
		444	// Name added
		445	any_change = true;
		446	zcu.comp.mutex.lock();
		447	defer zcu.comp.mutex.unlock();
		448	try zcu.markDependeeOutdated(.{ .namespace_name = .{
		449	.namespace = tracked_inst_index,
		450	.name = name_ip,
		451	} });
427	}	452	}
428	const name_zir = decl_name.toString(old_zir).?;	453	}
429	const name_ip = try zcu.intern_pool.getOrPutString(	454	// The only elements remaining in `old_names` now are any names which were removed.
430	zcu.gpa,	455	for (old_names.keys()) \|name_ip\| {
431	pt.tid,
432	old_zir.nullTerminatedString(name_zir),
433	.no_embedded_nulls,
434	);
435	if (!old_names.swapRemove(name_ip)) continue;
436	// Name added
437	any_change = true;	456	any_change = true;
438	zcu.comp.mutex.lock();	457	zcu.comp.mutex.lock();
439	defer zcu.comp.mutex.unlock();	458	defer zcu.comp.mutex.unlock();
440	try zcu.markDependeeOutdated(.{ .namespace_name = .{	459	try zcu.markDependeeOutdated(.{ .namespace_name = .{
441	.namespace = ti_idx,	460	.namespace = tracked_inst_index,
442	.name = name_ip,	461	.name = name_ip,
443	} });	462	} });
444	}	463	}
445	}
446	// The only elements remaining in `old_names` now are any names which were removed.
447	for (old_names.keys()) \|name_ip\| {
448	any_change = true;
449	zcu.comp.mutex.lock();
450	defer zcu.comp.mutex.unlock();
451	try zcu.markDependeeOutdated(.{ .namespace_name = .{
452	.namespace = ti_idx,
453	.name = name_ip,
454	} });
455	}
456		464
457	if (any_change) {	465	if (any_change) {
458	zcu.comp.mutex.lock();	466	zcu.comp.mutex.lock();
459	defer zcu.comp.mutex.unlock();	467	defer zcu.comp.mutex.unlock();
460	try zcu.markDependeeOutdated(.{ .namespace = ti_idx });	468	try zcu.markDependeeOutdated(.{ .namespace = tracked_inst_index });
		469	}
461	}	470	}
462	}	471	}
463	}	472	}
...	@@ -854,7 +863,10 @@ fn getFileRootStruct(	...	@@ -854,7 +863,10 @@ fn getFileRootStruct(
854	const decls = file.zir.bodySlice(extra_index, decls_len);	863	const decls = file.zir.bodySlice(extra_index, decls_len);
855	extra_index += decls_len;	864	extra_index += decls_len;
856		865
857	const tracked_inst = try ip.trackZir(gpa, file_index, .main_struct_inst);	866	const tracked_inst = try ip.trackZir(gpa, pt.tid, .{
		867	.file = file_index,
		868	.inst = .main_struct_inst,
		869	});
858	const wip_ty = switch (try ip.getStructType(gpa, pt.tid, .{	870	const wip_ty = switch (try ip.getStructType(gpa, pt.tid, .{
859	.layout = .auto,	871	.layout = .auto,
860	.fields_len = fields_len,	872	.fields_len = fields_len,
...	@@ -1015,7 +1027,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {	...	@@ -1015,7 +1027,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
1015	switch (zcu.comp.cache_use) {	1027	switch (zcu.comp.cache_use) {
1016	.whole => \|whole\| if (whole.cache_manifest) \|man\| {	1028	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
1017	const source = file.getSource(gpa) catch \|err\| {	1029	const source = file.getSource(gpa) catch \|err\| {
1018	try Zcu.reportRetryableFileError(zcu, file_index, "unable to load source: {s}", .{@errorName(err)});	1030	try pt.reportRetryableFileError(file_index, "unable to load source: {s}", .{@errorName(err)});
1019	return error.AnalysisFail;	1031	return error.AnalysisFail;
1020	};	1032	};
1021		1033
...	@@ -1024,7 +1036,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {	...	@@ -1024,7 +1036,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
1024	file.mod.root.sub_path,	1036	file.mod.root.sub_path,
1025	file.sub_file_path,	1037	file.sub_file_path,
1026	}) catch \|err\| {	1038	}) catch \|err\| {
1027	try Zcu.reportRetryableFileError(zcu, file_index, "unable to resolve path: {s}", .{@errorName(err)});	1039	try pt.reportRetryableFileError(file_index, "unable to resolve path: {s}", .{@errorName(err)});
1028	return error.AnalysisFail;	1040	return error.AnalysisFail;
1029	};	1041	};
1030	errdefer gpa.free(resolved_path);	1042	errdefer gpa.free(resolved_path);
...	@@ -1148,11 +1160,10 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {	...	@@ -1148,11 +1160,10 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {
1148	defer sema.deinit();	1160	defer sema.deinit();
1149		1161
1150	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.	1162	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.
1151	try sema.declareDependency(.{ .src_hash = try ip.trackZir(	1163	try sema.declareDependency(.{ .src_hash = try ip.trackZir(gpa, pt.tid, .{
1152	gpa,	1164	.file = decl.getFileScopeIndex(zcu),
1153	decl.getFileScopeIndex(zcu),	1165	.inst = decl_inst,
1154	decl_inst,	1166	}) });
1155	) });
1156		1167
1157	var block_scope: Sema.Block = .{	1168	var block_scope: Sema.Block = .{
1158	.parent = null,	1169	.parent = null,
...	@@ -1890,7 +1901,10 @@ const ScanDeclIter = struct {	...	@@ -1890,7 +1901,10 @@ const ScanDeclIter = struct {
1890	}	1901	}
1891		1902
1892	const parent_file_scope_index = iter.parent_decl.getFileScopeIndex(zcu);	1903	const parent_file_scope_index = iter.parent_decl.getFileScopeIndex(zcu);
1893	const tracked_inst = try ip.trackZir(gpa, parent_file_scope_index, decl_inst);	1904	const tracked_inst = try ip.trackZir(gpa, pt.tid, .{
		1905	.file = parent_file_scope_index,
		1906	.inst = decl_inst,
		1907	});
1894		1908
1895	// We create a Decl for it regardless of analysis status.	1909	// We create a Decl for it regardless of analysis status.
1896		1910
...	@@ -2611,6 +2625,87 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {	...	@@ -2611,6 +2625,87 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {
2611	}	2625	}
2612	}	2626	}
2613		2627
		2628	pub fn reportRetryableAstGenError(
		2629	pt: Zcu.PerThread,
		2630	src: Zcu.AstGenSrc,
		2631	file_index: Zcu.File.Index,
		2632	err: anyerror,
		2633	) error{OutOfMemory}!void {
		2634	const zcu = pt.zcu;
		2635	const gpa = zcu.gpa;
		2636	const ip = &zcu.intern_pool;
		2637
		2638	const file = zcu.fileByIndex(file_index);
		2639	file.status = .retryable_failure;
		2640
		2641	const src_loc: Zcu.LazySrcLoc = switch (src) {
		2642	.root => .{
		2643	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2644	.file = file_index,
		2645	.inst = .main_struct_inst,
		2646	}),
		2647	.offset = .entire_file,
		2648	},
		2649	.import => \|info\| .{
		2650	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2651	.file = info.importing_file,
		2652	.inst = .main_struct_inst,
		2653	}),
		2654	.offset = .{ .token_abs = info.import_tok },
		2655	},
		2656	};
		2657
		2658	const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
		2659	file.mod.root, file.sub_file_path, @errorName(err),
		2660	});
		2661	errdefer err_msg.destroy(gpa);
		2662
		2663	{
		2664	zcu.comp.mutex.lock();
		2665	defer zcu.comp.mutex.unlock();
		2666	try zcu.failed_files.putNoClobber(gpa, file, err_msg);
		2667	}
		2668	}
		2669
		2670	pub fn reportRetryableFileError(
		2671	pt: Zcu.PerThread,
		2672	file_index: Zcu.File.Index,
		2673	comptime format: []const u8,
		2674	args: anytype,
		2675	) error{OutOfMemory}!void {
		2676	const zcu = pt.zcu;
		2677	const gpa = zcu.gpa;
		2678	const ip = &zcu.intern_pool;
		2679
		2680	const file = zcu.fileByIndex(file_index);
		2681	file.status = .retryable_failure;
		2682
		2683	const err_msg = try Zcu.ErrorMsg.create(
		2684	gpa,
		2685	.{
		2686	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2687	.file = file_index,
		2688	.inst = .main_struct_inst,
		2689	}),
		2690	.offset = .entire_file,
		2691	},
		2692	format,
		2693	args,
		2694	);
		2695	errdefer err_msg.destroy(gpa);
		2696
		2697	zcu.comp.mutex.lock();
		2698	defer zcu.comp.mutex.unlock();
		2699
		2700	const gop = try zcu.failed_files.getOrPut(gpa, file);
		2701	if (gop.found_existing) {
		2702	if (gop.value_ptr.*) \|old_err_msg\| {
		2703	old_err_msg.destroy(gpa);
		2704	}
		2705	}
		2706	gop.value_ptr.* = err_msg;
		2707	}
		2708
2614	/// Shortcut for calling `intern_pool.get`.	2709	/// Shortcut for calling `intern_pool.get`.
2615	pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index {	2710	pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index {
2616	return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key);	2711	return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key);