`tiny.choir.PassManager`

Reference tiny.choir PassManager

Defined in tiny.choir.

API (27)

Public operations.

Public fields and members.

Static calls · unresolved targets: unknown · external targets: unknown.

Source

Source: lib/choir/src/passes/pass/manager.zig:771

1pub const PassManager = struct {2    allocator: std.mem.Allocator,3    root: OpPassManager,4    stats: PassManagerStats,5    instrumentor: ?PassInstrumentor,6    verifier_enabled: bool,7    verifier_options: ir.verify.VerifyOptions,8    last_verifier_failure: ?PassVerifierFailure,9    last_failure_reproducer: ?PassFailureReproducer,1011    pub fn init(allocator: std.mem.Allocator) PassManager {12        return .{13            .allocator = allocator,14            .root = OpPassManager.init(allocator, null),15            .stats = .{},16            .instrumentor = null,17            .verifier_enabled = false,18            .verifier_options = ir.verify.default_options,19            .last_verifier_failure = null,20            .last_failure_reproducer = null,21        };22    }2324    pub fn deinit(self: *PassManager) void {25        self.clearLastFailureReproducer();26        if (self.instrumentor) |*inst| {27            inst.deinit();28        }29        self.root.deinit();30    }3132    pub fn addPass(self: *PassManager, pass: Pass) !void {33        try self.root.addPass(pass);34    }3536    pub fn nest(self: *PassManager, op_name: []const u8) !*OpPassManager {37        return self.root.nest(op_name);38    }3940    pub fn nestAny(self: *PassManager) !*OpPassManager {41        return self.root.nestAny();42    }4344    pub fn resetStats(self: *PassManager) void {45        self.stats.reset();46    }4748    pub fn addInstrumentation(self: *PassManager, inst: PassInstrumentation) !void {49        if (self.instrumentor == null) {50            self.instrumentor = PassInstrumentor.init(self.allocator);51        }52        try self.instrumentor.?.addInstrumentation(inst);53    }5455    pub fn getInstrumentor(self: *PassManager) ?*const PassInstrumentor {56        if (self.instrumentor) |*inst| {57            return inst;58        }59        return null;60    }6162    pub fn enableVerifier(self: *PassManager) void {63        self.enableVerifierWithOptions(ir.verify.default_options);64    }6566    pub fn enableVerifierWithOptions(self: *PassManager, options: ir.verify.VerifyOptions) void {67        self.verifier_enabled = true;68        self.verifier_options = options;69        self.last_verifier_failure = null;70    }7172    pub fn disableVerifier(self: *PassManager) void {73        self.verifier_enabled = false;74        self.last_verifier_failure = null;75    }7677    pub fn verifierEnabled(self: *const PassManager) bool {78        return self.verifier_enabled;79    }8081    pub fn getLastVerifierFailure(self: *const PassManager) ?PassVerifierFailure {82        return self.last_verifier_failure;83    }8485    pub fn getLastFailureReproducer(self: *const PassManager) ?*const PassFailureReproducer {86        if (self.last_failure_reproducer) |*reproducer| return reproducer;87        return null;88    }8990    pub fn run(self: *PassManager, op: *ir.Operation, ir_ctx: *ir.Context) PassResult {91        return self.runWithOptions(op, ir_ctx, .{});92    }9394    pub fn runWithOptions(95        self: *PassManager,96        op: *ir.Operation,97        ir_ctx: *ir.Context,98        options: PassManagerRunOptions,99    ) PassResult {100        var analysis_cache = AnalysisCache.init(self.allocator, null);101        defer analysis_cache.deinit();102103        return self.runWithAnalysisCache(op, ir_ctx, &analysis_cache, options);104    }105106    pub fn runWithAnalysisCache(107        self: *PassManager,108        op: *ir.Operation,109        ir_ctx: *ir.Context,110        analysis_cache: *AnalysisCache,111        options: PassManagerRunOptions,112    ) PassResult {113        if (analysis_cache.accounting) |ledger| {114            if (ledger.view().outcome != .running) return .failure;115        }116        self.clearLastFailureReproducer();117        self.last_verifier_failure = null;118        if (analysis_cache.accounting) |ledger| {119            if (options.max_threads != 1 or options.worker_allocator != null) {120                ledger.missingContract();121                ledger.fail(.rejected);122                self.captureFailureReproducer(op, options, .{123                    .kind = .target,124                    .target_op_name = op.name.name,125                    .target_symbol_name = ir.SymbolTable.getSymbolName(op),126                });127                return .failure;128            }129        }130131        if (self.prepareDependentDialects(ir_ctx) == .failure) {132            self.captureFailureReproducer(op, options, null);133            return .failure;134        }135136        const previous_stats = analysis_cache.stats;137        analysis_cache.stats = &self.stats;138        defer analysis_cache.stats = previous_stats;139140        const inst_ptr: ?*const PassInstrumentor = if (self.instrumentor) |*inst| inst else null;141        var verifier_config = self.beginVerifierRun();142        const verifier_ptr: ?*PassVerifierConfig = if (verifier_config) |*config| config else null;143144        const pass_runs_before = self.stats.pass_runs;145        defer ir_ctx.recordPassRuns(self.stats.pass_runs - pass_runs_before);146        var failure: ?CapturedPassFailure = null;147        const result = self.root.runOnOperation(148            op,149            ir_ctx,150            analysis_cache,151            &self.stats,152            inst_ptr,153            verifier_ptr,154            &failure,155            options,156            self.allocator,157        );158        if (result == .failure) self.captureFailureReproducer(op, options, failure);159        return result;160    }161162    pub fn runToFixedPoint(163        self: *PassManager,164        op: *ir.Operation,165        ir_ctx: *ir.Context,166        max_iterations: usize,167    ) PassManagerFixedPointResult {168        return self.runToFixedPointWithOptions(op, ir_ctx, max_iterations, .{});169    }170171    pub fn runToFixedPointWithOptions(172        self: *PassManager,173        op: *ir.Operation,174        ir_ctx: *ir.Context,175        max_iterations: usize,176        options: PassManagerRunOptions,177    ) PassManagerFixedPointResult {178        var fixed_point: PassManagerFixedPointResult = .{};179        self.clearLastFailureReproducer();180        self.last_verifier_failure = null;181182        if (self.prepareDependentDialects(ir_ctx) == .failure) {183            fixed_point.result = .failure;184            self.captureFailureReproducer(op, options, null);185            return fixed_point;186        }187188        var analysis_cache = AnalysisCache.init(self.allocator, &self.stats);189        defer analysis_cache.deinit();190191        const inst_ptr: ?*const PassInstrumentor = if (self.instrumentor) |*inst| inst else null;192        var verifier_config = self.beginVerifierRun();193        const verifier_ptr: ?*PassVerifierConfig = if (verifier_config) |*config| config else null;194195        const pass_runs_before = self.stats.pass_runs;196        defer ir_ctx.recordPassRuns(self.stats.pass_runs - pass_runs_before);197        for (0..max_iterations) |_| {198            const before_modified = self.stats.passes_modified;199            fixed_point.iterations += 1;200201            var failure: ?CapturedPassFailure = null;202            const result = self.root.runOnOperation(203                op,204                ir_ctx,205                &analysis_cache,206                &self.stats,207                inst_ptr,208                verifier_ptr,209                &failure,210                options,211                self.allocator,212            );213            if (result == .failure) {214                fixed_point.result = .failure;215                self.captureFailureReproducer(op, options, failure);216                return fixed_point;217            }218219            const iteration_changed = self.stats.passes_modified != before_modified;220            fixed_point.changed = fixed_point.changed or iteration_changed;221            if (!iteration_changed) break;222        }223224        return fixed_point;225    }226227    fn clearLastFailureReproducer(self: *PassManager) void {228        if (self.last_failure_reproducer) |*reproducer| {229            reproducer.deinit(self.allocator);230            self.last_failure_reproducer = null;231        }232    }233234    fn captureFailureReproducer(235        self: *PassManager,236        op: *ir.Operation,237        options: PassManagerRunOptions,238        failure: ?CapturedPassFailure,239    ) void {240        self.clearLastFailureReproducer();241242        const pipeline_text = textual_pipeline.formatPassManagerPipelineAlloc(243            self.allocator,244            self,245        ) catch return;246247        const ir_text = ir.dump.operationAlloc(self.allocator, op) catch {248            self.allocator.free(pipeline_text);249            return;250        };251252        var reproducer = PassFailureReproducer{253            .pipeline = pipeline_text,254            .ir = ir_text,255            .max_threads = options.max_threads,256            .worker_count = if (failure) |captured| captured.worker_count else 1,257            .verifier_enabled = self.verifier_enabled,258        };259        var stored = false;260        defer if (!stored) reproducer.deinit(self.allocator);261262        if (failure) |captured| {263            reproducer.failure_kind = captured.kind;264            if (captured.pass_name) |name| {265                reproducer.pass_name = self.allocator.dupe(u8, name) catch return;266            }267            reproducer.target_op_name = self.allocator.dupe(268                u8,269                captured.target_op_name,270            ) catch return;271            if (captured.target_symbol_name) |name| {272                reproducer.target_symbol_name = self.allocator.dupe(u8, name) catch return;273            }274            reproducer.verifier_error = captured.verifier_error;275            if (captured.verifier_error) |err| {276                reproducer.verifier_error_name = self.allocator.dupe(277                    u8,278                    @errorName(err),279                ) catch return;280            }281        }282283        self.last_failure_reproducer = reproducer;284        stored = true;285    }286287    fn beginVerifierRun(self: *PassManager) ?PassVerifierConfig {288        if (!self.verifier_enabled) return null;289        return .{290            .options = self.verifier_options,291            .failure = &self.last_verifier_failure,292        };293    }294295    fn prepareDependentDialects(self: *PassManager, ir_ctx: *ir.Context) PassResult {296        var names: std.ArrayListUnmanaged([]const u8) = .empty;297        defer names.deinit(self.allocator);298299        self.root.collectDependentDialects(self.allocator, &names) catch return .failure;300301        for (names.items) |name| {302            _ = ir_ctx.getOrLoadDialect(name) catch return .failure;303        }304305        return .success;306    }307};

Source: lib/choir/src/root.zig:57

1pub const PassManager = passes.PassManager;

Static calls · unresolved targets: 0 · external targets: 0.

Static calls · unresolved targets: 0 · external targets: 1.

Static calls · unresolved targets: 0 · external targets: 0.

Static calls · unresolved targets: 0 · external targets: 1.

Static calls · unresolved targets: 0 · external targets: 5.

Static calls · unresolved targets: 0 · external targets: 0.

Also reachable as

passes.PassManager, passes.pass.PassManager.

Complete caller list for `PassManager.addInstrumentation`

7 direct callers.

Complete caller list for `PassManager.addPass`

30 direct callers.

Complete caller list for `PassManager.deinit`

52 direct callers.

Complete caller list for `PassManager.getLastFailureReproducer`

8 direct callers.

Complete caller list for `PassManager.init`

52 direct callers.

Complete caller list for `PassManager.nest`

21 direct callers.

Complete caller list for `PassManager.run`

23 direct callers.

Complete call list for `PassManager.runToFixedPointWithOptions`

7 direct calls.

Complete caller list for `PassManager.runWithAnalysisCache`

10 direct callers.

Complete caller list for `PassManager.runWithOptions`

15 direct callers.

Audit

Definitions	20
Public names	60
Members	8
Version	`26.7.0`
Revision	`daab053ee433`

tiny.choir.PassManager

API (27)

Actions

Fields and members

Source

Also reachable as

Complete caller list for PassManager.addInstrumentation

Complete caller list for PassManager.addPass

Complete caller list for PassManager.deinit

Complete caller list for PassManager.getLastFailureReproducer

Complete caller list for PassManager.init

Complete caller list for PassManager.nest

Complete caller list for PassManager.run

Complete call list for PassManager.runToFixedPointWithOptions

Complete caller list for PassManager.runWithAnalysisCache

Complete caller list for PassManager.runWithOptions

Audit

`tiny.choir.PassManager`

Complete caller list for `PassManager.addInstrumentation`

Complete caller list for `PassManager.addPass`

Complete caller list for `PassManager.deinit`

Complete caller list for `PassManager.getLastFailureReproducer`

Complete caller list for `PassManager.init`

Complete caller list for `PassManager.nest`

Complete caller list for `PassManager.run`

Complete call list for `PassManager.runToFixedPointWithOptions`

Complete caller list for `PassManager.runWithAnalysisCache`

Complete caller list for `PassManager.runWithOptions`