tiny.simd.ProcessorTopology

1pub const Topology = struct {2    phase: alloc_phase.capacity.Phase = .initialization,3    capacity: TopologyCapacity = .{},4    allocation: ?[]align(storage_alignment.toByteUnits()) u8 = null,5    packages: []const Package = &.{},6    lps: []const LP = &.{},78    pub const Limits: type = TopologyLimits;9    pub const Capacity: type = TopologyCapacity;1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "simd.topology_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "one_exact_topology_array_region_and_borrowed_views",20                        .lifetime = .steady,21                        .detail = "one exact topology array region and borrowed views",22                    },23                },24                .excluded = &.{25                    "caller-owned processor discovery records",26                    "operating-system queries and temporary relationship buffers",27                },28            },29            .capacity = .{30                .inputs = &.{},31                .type_selectors = &.{},32                .nodes = &.{33                    .{ .constant = 0 },34                },35                .assertions = &.{.{36                    .scope = .closure_total,37                    .measure = .retained,38                    .relation = .exact,39                    .expression = 0,40                }},41            },42            .overload = .{43                .kind = .reject_before_seal,44                .detail = "empty oversize package and SMT bounds reject before allocation",45            },46            .risks = .{47                .transitive = .{48                    .status = .witnessed,49                    .detail = "remapping placement and allocation cleanup are checked together",50                },51                .foreign = .{52                    .status = .excluded,53                    .detail = "native discovery completes before immutable topology storage is sealed",54                },55            },56            .obligations = &.{57                .{ .key = "simd_topology_capacity_capacity_model", .role = .capacity_model },58                .{ .key = "simd_topology_capacity_overload", .role = .overload },59                .{ .key = "simd_topology_remap", .role = .transitive_risk },60                .{ .key = "simd_topology_oom", .role = .transitive_risk },61                .{ .key = "simd_topology_native", .role = .foreign_risk },62            },63        },64        .bindings = .{65            .owner = @This(),66            .seal = .{67                .family = alloc_phase.capacity.selector(@This().activate),68                .premise = .{69                    .class = .checked_semantic_fact,70                    .authority = .checker,71                },72            },73            .teardown = .{74                .family = alloc_phase.capacity.selector(@This().deinit),75                .premise = .{76                    .class = .checked_semantic_fact,77                    .authority = .checker,78                },79            },80        },81    };8283    pub fn init(84        allocator: std.mem.Allocator,85        limits: Limits,86    ) Error!Topology {87        const records = limits.records;88        var mapped_lps: [max_logical_processors]LP = @splat(.{});89        var package_sizes: [max_packages]PackageSize = @splat(.{});90        const capacity_value = try inspectRecords(records, &mapped_lps, &package_sizes);91        const allocation = try allocator.alignedAlloc(92            u8,93            storage_alignment,94            capacity_value.storage_bytes,95        );96        errdefer allocator.free(allocation);97        @memset(allocation, 0);9899        var offset: usize = 0;100        const packages = take(Package, allocation, &offset, capacity_value.packages);101        const clusters = take(Cluster, allocation, &offset, capacity_value.clusters);102        const cores = take(Core, allocation, &offset, capacity_value.cores);103        const lps = take(LP, allocation, &offset, capacity_value.logical_processors);104        std.debug.assert(offset == capacity_value.storage_bytes);105        @memcpy(lps, mapped_lps[0..records.len]);106        placePackageSlices(packages, clusters, cores, &package_sizes);107        populateSets(packages, lps, records);108        return .{109            .phase = .initialization,110            .capacity = capacity_value,111            .allocation = allocation,112            .packages = packages,113            .lps = lps,114        };115    }116117    pub fn initFromRecords(118        allocator: std.mem.Allocator,119        records: []const ProcessorRecord,120    ) Error!Topology {121        var topology = try init(allocator, .{ .records = records });122        topology.activate();123        return topology;124    }125126    pub fn activate(self: *Topology) void {127        std.debug.assert(self.phase == .initialization);128        std.debug.assert(self.capacity.logical_processors == self.lps.len);129        self.phase = .steady;130    }131132    pub fn deinit(self: *Topology, allocator: std.mem.Allocator) void {133        std.debug.assert(self.phase != .teardown);134        self.phase = .teardown;135        if (self.allocation) |allocation| allocator.free(allocation);136        self.allocation = null;137        self.packages = &.{};138        self.lps = &.{};139    }140141    pub fn allocatedBytes(self: *const Topology) usize {142        std.debug.assert(self.phase != .teardown);143        return if (self.allocation) |allocation| allocation.len else 0;144    }145};

1pub const ProcessorTopology = topology.Topology;