lib/accy/src/kernel/library/catalog/artifact/specialized/indexing.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const std = @import("std");
 2 
 3 const kernel = @import("../../../../root.zig");
 4 const entry = @import("../../../root.zig").entry;
 5 const histogram_mod = @import("../../../root.zig").histogram;
 6 const indexing = @import("../../../root.zig").indexing;
 7 
 8 pub fn create(
 9     allocator: std.mem.Allocator,
10     handle: kernel.BackendHandle,
11     metadata: entry.Metadata,
12     options: entry.ArtifactOptions,
13 ) !kernel.OwnedKernelCallArtifact {
14     return switch (metadata.specialization.operation orelse return error.UnknownKernelLibraryEntry) {
15         .indexing => |indexing_operation| switch (indexing_operation) {
16             .gather => createGather(allocator, handle, metadata, options),
17             .scatter => createScatter(allocator, handle, metadata, options),
18             .scatter_add => createScatterAdd(allocator, handle, metadata, options),
19             .histogram => createHistogram(allocator, handle, metadata, options),
20         },
21         else => error.UnknownKernelLibraryEntry,
22     };
23 }
24 
25 fn createHistogram(
26     allocator: std.mem.Allocator,
27     handle: kernel.BackendHandle,
28     metadata: entry.Metadata,
29     options: entry.ArtifactOptions,
30 ) !kernel.OwnedKernelCallArtifact {
31     if (metadata.version != histogram_mod.histogram_family_version) return error.UnknownKernelLibraryEntry;
32     const instance = histogram_mod.histogramInstanceFromSpecialization(metadata.specialization) orelse {
33         return error.UnknownKernelLibraryEntry;
34     };
35     const target = try histogram_mod.histogramFamilyTarget(allocator, instance);
36     defer allocator.free(target);
37     if (!std.mem.eql(u8, metadata.target, target)) return error.UnknownKernelLibraryEntry;
38     return try histogram_mod.createHistogramFamilyArtifact(allocator, handle, instance, options);
39 }
40 
41 fn createGather(
42     allocator: std.mem.Allocator,
43     handle: kernel.BackendHandle,
44     metadata: entry.Metadata,
45     options: entry.ArtifactOptions,
46 ) !kernel.OwnedKernelCallArtifact {
47     if (metadata.version != indexing.gather_family_version) return error.UnknownKernelLibraryEntry;
48     const instance = indexing.gatherInstanceFromSpecialization(metadata.specialization) orelse {
49         return error.UnknownKernelLibraryEntry;
50     };
51     const target = try indexing.gatherFamilyTarget(allocator, instance);
52     defer allocator.free(target);
53     if (!std.mem.eql(u8, metadata.target, target)) return error.UnknownKernelLibraryEntry;
54     return try indexing.createGatherFamilyArtifact(allocator, handle, instance, options);
55 }
56 
57 fn createScatter(
58     allocator: std.mem.Allocator,
59     handle: kernel.BackendHandle,
60     metadata: entry.Metadata,
61     options: entry.ArtifactOptions,
62 ) !kernel.OwnedKernelCallArtifact {
63     if (metadata.version != indexing.scatter_family_version) return error.UnknownKernelLibraryEntry;
64     const instance = indexing.scatterInstanceFromSpecialization(metadata.specialization) orelse {
65         return error.UnknownKernelLibraryEntry;
66     };
67     const target = try indexing.scatterFamilyTarget(allocator, instance);
68     defer allocator.free(target);
69     if (!std.mem.eql(u8, metadata.target, target)) return error.UnknownKernelLibraryEntry;
70     return try indexing.createScatterFamilyArtifact(allocator, handle, instance, options);
71 }
72 
73 fn createScatterAdd(
74     allocator: std.mem.Allocator,
75     handle: kernel.BackendHandle,
76     metadata: entry.Metadata,
77     options: entry.ArtifactOptions,
78 ) !kernel.OwnedKernelCallArtifact {
79     if (metadata.version != indexing.scatter_add_family_version) return error.UnknownKernelLibraryEntry;
80     const instance = indexing.scatterAddInstanceFromSpecialization(metadata.specialization) orelse {
81         return error.UnknownKernelLibraryEntry;
82     };
83     const target = try indexing.scatterAddFamilyTarget(allocator, instance);
84     defer allocator.free(target);
85     if (!std.mem.eql(u8, metadata.target, target)) return error.UnknownKernelLibraryEntry;
86     return try indexing.createScatterAddFamilyArtifact(allocator, handle, instance, options);
87 }