PerfChecker.jl

Appearance

Julia API ​

The public API exported by PerfChecker. For an executable introduction, start with Quickstart.

  • Existing tests: discover_testitems, run_testitems.

  • Inline experiment: @check.

  • Custom workloads and version matrices: SoftwareSuite, plan_suite, run_suite.

  • Shared scenarios: run_scenarios, diagnose, compare_scenarios.

Interface packages ​

Some entry points are implemented by an interface package. Install and load the owner to get its method.

  • PerfCheckerWeb — serve_suite, register_oxygen_routes!, register_testitem_routes!, studio_token_authenticator, run_studio_agent.

  • PerfCheckerPluto — prepare_pluto_dashboard, launch_pluto_dashboard, write_suite_notebook, write_investigation_notebook.

  • PerfCheckerMakie — performance_figure, suite_dashboard, checkres_to_boxplots, checkres_to_scatterlines, checkres_to_pie.

  • PerfCheckerMakie + WGLMakie — performance_plot_html.

Index ​

Docstrings ​

PerfChecker.PerfChecker Module

Performance measurement, comparison and qualification for Julia workloads. Start with discover_testitems for existing tests or plan_suite for explicit feature workloads. Interface packages consume the same plans and saved evidence; measurement and diagnostic processes run in separately prepared environments.

source
PerfChecker.AdvisorConfig Type

Optional evidence writer configuration. Local endpoints are the default; no model is bundled.

source
PerfChecker.BundleComparison Type

A definition-aware comparison between two portable run bundles.

source
PerfChecker.CancellationToken Type

Thread-safe cancellation request, checked while an isolated child is running.

source
PerfChecker.CheckConfig Type
julia
CheckConfig

Validated internal configuration used by PerfChecker after merging backend defaults with the public Dict passed to @check.

Users can keep passing dictionaries; CheckConfig exists to make required fields and cache identity explicit before workers are launched.

source
PerfChecker.CheckerResult Type
julia
CheckerResult

Result returned by @check.

Fields:

  • tables: one TypedTables.Table per package version or target.

  • hwinfo: hardware information collected by the orchestrating process.

  • tags: tags attached to the run.

  • pkgs: package specs corresponding to tables.

  • qualifications: probe and correctness evidence corresponding to tables.

  • resource_envelopes: optional process/external-memory evidence corresponding to tables. This remains separate from Julia allocation columns.

source
PerfChecker.ComparisonPolicy Type

An exact or grouped reference used to compare several candidate targets.

source
PerfChecker.CompatibilityReport Type

Structured dependency-resolution evidence produced before measurement.

source
PerfChecker.ExternalCommandSpec Type

A command provider that emits perfchecker-provider-result/1 JSON.

source
PerfChecker.ExternalMemorySnapshot Type

A versioned workload-owned view of native or otherwise external memory.

source
PerfChecker.FeatureRun Type

Result of one planned feature execution. planned identifies the target; status distinguishes :pass, :unavailable, :blocked, :invalid and :error. elapsed_seconds is orchestration time, not a replacement for measured samples. result holds backend data when available; qualification retains probe, correctness and provenance evidence even when execution fails.

source
PerfChecker.FeatureSpec Type

A feature-level performance contract.

source
PerfChecker.FeatureVariant Type

One workload implementation over a package-version interval.

source
PerfChecker.InvestigationJob Type

An asynchronous investigation shared by the web interface and notebook interfaces.

source
PerfChecker.InvestigationView Type

A presentation of saved investigation evidence for the REPL, Pluto and HTML reports.

source
PerfChecker.IsolatedNetworkCommandResult Type

Result of an external command executed in a requested network namespace. Carries the command outcome, captured output, provider and network sample. Inspect isolated_network_result_dict before attributing traffic to the target; unavailable isolation is not a zero-traffic measurement.

source
PerfChecker.JuliaRegressionInvestigation Type

Ranked source evidence for differences between two Julia runtime runs.

source
PerfChecker.JuliaRuntimeCampaign Type

A completed suite campaign over an explicit Julia runtime axis.

source
PerfChecker.JuliaRuntimeSpec Type

One explicit Julia runtime axis, independent from package-version targets.

source
PerfChecker.NativeDependencyEvidence Type

Declared, resolved, and observed dependency evidence captured at one phase.

source
PerfChecker.NetworkInterfaceSnapshot Type

Monotonic counters observed on one operating-system network interface.

source
PerfChecker.NetworkIsolationSpec Type

A process-tree network-isolation request for native Linux or Linux through WSL2.

source
PerfChecker.OracleSpec Type

A deterministic correctness oracle executed outside the measured region.

source
PerfChecker.PackageSuite Type

All feature measurements owned by one package.

source
PerfChecker.PackageVersionSpec Type
julia
PackageVersionSpec(name, selector, versions, prefer_latest)
PackageVersionSpec(pkgconf::Tuple)

Normalized representation of the :pkgs option accepted by @check.

The tuple form is (name::String, selector::Symbol, versions::Vector{VersionNumber}, prefer_latest::Bool). Supported selectors are :custom, :patches, :minor, :major, and :breaking.

source
PerfChecker.PerfConfig Type
julia
PerfConfig(backend::Symbol; path=pwd(), kwargs...)
PerfConfig(backend::Symbol, options)

Julia-native public configuration object for @check.

PerfConfig keeps the existing dictionary-based API available while giving REPL, scripts, and Pluto notebooks a clearer object to pass around. Keyword arguments are stored with symbolic keys and validated by normalize_config just before a check runs.

Example:

julia
config = PerfConfig(:benchmark; path=pwd(), tags=[:local], samples=10)
result = @check config begin
    nothing
end begin
    sum(1:100)
end
source
PerfChecker.PerformanceDocumentBlock Type

A documentation-system-neutral block backed by one bundle query.

source
PerfChecker.PerformancePlot Type

Backend-neutral plot description consumed by Makie, Oxygen, notebooks and CI exporters.

source
PerfChecker.PerformanceQuery Type

A presentation-neutral selection over a PerfChecker run bundle.

source
PerfChecker.PlannedFeatureRun Type

One resolved package, feature variant and target in a suite plan. Created by plan_suite; inspect planned_status and reason before execution. Planning an unavailable target preserves it for reports rather than executing it.

source
PerfChecker.ProbeSpec Type

A functional capability probe executed inside the prepared target worker.

source
PerfChecker.ProcessMemorySnapshot Type

A point-in-time operating-system view of one process' memory usage.

source
PerfChecker.QualificationFailure Type

Structured qualification evidence carried when a run is blocked or invalid.

source
PerfChecker.QueryPredicate Type

A portable predicate over a result field, an attribute, or a manifest field.

source
PerfChecker.ResourceEnvelope Type

One resource envelope around a backend collection in an isolated worker.

source
PerfChecker.RunBundle Type

A self-contained, language-neutral performance result bundle.

source
PerfChecker.RunMetadata Type
julia
RunMetadata

Structured metadata written next to cached performance outputs. It records the backend, package version, tags, normalized config hash, result UUID, Julia version, thread count, timestamp, and hardware identity used for cache lookup.

source
PerfChecker.RunTarget Type
julia
RunTarget(spec, label, is_dev)

Internal description of one package target to run in an isolated worker. Released versions use is_dev == false; local development targets created from :devops use is_dev == true.

source
PerfChecker.ScenarioCatalog Type

The explicit catalog used by both local execution and CI. Inferred candidates are never members.

source
PerfChecker.ScenarioSpec Type

A shared, dependency-free Julia factory, identified independently of its measurement collector.

source
PerfChecker.SoftwareSuite Type

The measurable surface of one software, composed from package suites.

source
PerfChecker.SoftwareSuiteResult Type

Completed suite evidence: the original plan, UTC start/finish timestamps and a vector of FeatureRun records. Use suite_verdict for qualification and write_suite_reports to export it without repeating measurements.

source
PerfChecker.SuiteCandidate Type

A named Git branch, tag, or commit evaluated beside releases and the working tree.

source
PerfChecker.SuiteJob Type

Handle returned by launch_suite for asynchronous controller execution. Use suite_job_status, suite_job_progress, cancel_suite! and wait_suite instead of mutating its task and reference fields.

source
PerfChecker.SuitePlan Type

Resolved suite, profile, feature runs and comparison policies. Obtain a plan with plan_suite, inspect or filter it, then pass it to run_suite or launch_suite. Holding a plan does not start workers.

source
PerfChecker.VersionComparison Type

A release-by-release comparison and its plottable version series.

source
PerfChecker.VersionWindow Type

A closed package-version interval with explicit exclusions.

source
PerfChecker.@check Macro
julia
@check backend config begin
    # preparation code
end begin
    # measured code
end

Run a performance check using backend and return a CheckerResult.

The public config argument is usually a Dict. PerfChecker merges it with backend defaults, validates it with normalize_config, copies the environment at config[:path], launches isolated Julia workers, installs the requested package versions, runs the two code blocks, and stores result tables plus metadata.

Example:

julia
using PerfChecker, BenchmarkTools

config = Dict(:path => @__DIR__, :samples => 10, :evals => 1)

result = @check :benchmark config begin
    using Random
end begin
    sum(rand(Random.MersenneTwister(1), 1_000))
end
source
PerfChecker.@check Macro
julia
@check config begin
    # preparation code
end begin
    # measured code
end

Run a performance check from a PerfConfig.

This is equivalent to @check config.backend Dict(config) ..., but keeps the backend and options bundled in one Julia object for scripts, REPL sessions, and Pluto notebooks.

source
PerfChecker._advisor_draft Method

Validate a setup draft, optionally before an MCP advice tool has been selected.

source
PerfChecker._copy_check_environment Method

Copy a worker environment, excluding only explicitly named top-level entries.

source
PerfChecker._git_provenance Method

Capture reproducible source identity without recording remotes or file contents.

source
PerfChecker._json_parse Method

Parse JSON into ordinary dictionaries on every supported JSON.jl major.

source
PerfChecker._json_parsefile Method

Read JSON without retaining a memory-mapped handle to the source file.

source
PerfChecker._prepare_check_environment Method

Prepare one immutable package target environment for reuse by fresh workers.

source
PerfChecker._suite_environment_key Method

Identity of the package graph prepared for one feature worker.

source
PerfChecker._terminate_process_tree Method

Terminate a controller process and, where supported, its complete child tree.

source
PerfChecker._validate_narrative Method

Validate references and shape, without claiming that generated prose is semantically true.

source
PerfChecker.advise Method

Produce deterministic, evidence-linked advice. This function never executes target code.

source
PerfChecker.advisor_setup Method
julia
advisor_setup(configuration; action=:probe, model="", confirmed=false, project, cancellation)

Check a connection or discover available models/MCP tools without sending project evidence. Ollama :pull, :delete, and :unload require explicit confirmation and a loopback endpoint. Operations run in a cancellable worker. Model files are managed by the existing Ollama server, never bundled with PerfChecker.

source
PerfChecker.advisor_setup_transport Method

Extension point for optional connection checks and local model management.

source
PerfChecker.advisor_transport Method

Provider extension point: return a Chat Completions-shaped response, preserving usage when known.

source
PerfChecker.agent_evidence Function

Create a bounded machine-readable evidence envelope for CI and AI workflows.

source
PerfChecker.agent_evidence Method

Expose diagnostics and deterministic advice to agents without running or modifying target code.

source
PerfChecker.arrange_breaking Method
julia
arrange_breaking(version, versions, prefer_latest)

Return the first or last compatible breaking-version group. For 0.x packages, minor versions are treated as breaking; otherwise major versions are used.

source
PerfChecker.arrange_major Method
julia
arrange_major(version, versions, prefer_latest)

Return the first or last version with the same major version.

source
PerfChecker.arrange_patches Method
julia
arrange_patches(version, versions, prefer_latest)

Return all versions with the same major and minor version.

source
PerfChecker.bundle_dict Method

Return the dictionary representation of a RunBundle manifest and, with include_records=true (default), its definitions, observations, diagnostics and artifacts. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.bundle_passed Method
julia
bundle_passed(bundle::RunBundle) -> Bool

Return whether the manifest is complete and no diagnostic has error severity. This is an execution check, not a comparison against a performance budget. Use compare_bundles and comparison_verdict for a regression decision.

source
PerfChecker.cancel! Method

Request cancellation of scenario measurements or diagnostics.

source
PerfChecker.cancel! Method

Request cancellation of a web or notebook investigation and its isolated worker.

source
PerfChecker.cancel_suite! Method
julia
cancel_suite!(job::SuiteJob) -> Bool

Request interruption of an active suite task and mark it as cancelling. Return false if the task already finished. A true return acknowledges the request; use wait_suite or the job status to observe completed cancellation and cleanup.

source
PerfChecker.check Method
julia
check(config::Dict, block::Expr, ::Val{backend}) -> Expr

Backend hook returning code that performs the measurement. Its result is stored as config[:check_result] before post is called.

source
PerfChecker.check_to_metadata_csv Method
julia
check_to_metadata_csv(backend, pkg, version, tags; metadata="")

Compatibility wrapper for the legacy metadata format. New runs use structured metadata with result UUIDs and config hashes.

source
PerfChecker.checkres_to_boxplots Function
julia
checkres_to_boxplots(result::CheckerResult, ::Val{backend}; kwarg=:times)

Create boxplots from a CheckerResult for the selected metric column.

source
PerfChecker.checkres_to_pie Function
julia
checkres_to_pie(result::CheckerResult, ::Val{backend}; kwargs...)

Create pie charts from a CheckerResult. For allocation checks this returns pairs mapping version labels to Makie figures. Forwards min_percentage and top to table_to_pie.

source
PerfChecker.checkres_to_scatterlines Function
julia
checkres_to_scatterlines(result::CheckerResult, ::Val{backend}; kwargs...)

Create an evolution plot from a CheckerResult. Plotting dispatch is explicit: use Val(:benchmark), Val(:chairmark), or Val(:alloc).

source
PerfChecker.cleanup Method
julia
cleanup(config::Dict, ::Val{backend})

Backend hook run after workers have stopped. Backends that create process-exit artifacts can use it to remove files that are flushed only when a worker exits.

source
PerfChecker.compare_bundles Method

Compare exact measurement definitions; no cross-unit conversion is implicit.

source
PerfChecker.compare_scenarios Method

Compare each scenario/implementation/collector separately, retaining configurations not tested.

source
PerfChecker.compare_suite_versions Method

Compare adjacent releases, then compare a development checkout to the latest release.

source
PerfChecker.comparison_dict Method

Return the dictionary representation of a BundleComparison, including input validity, environment status, verdict and per-metric records. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.comparison_passed Method

Return true only when comparison_verdict(comparison) is :qualified.

source
PerfChecker.comparison_policy_dict Method

Return the dictionary representation of a ComparisonPolicy, including its baseline/candidate selection and metric limits. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.comparison_verdict Method
julia
comparison_verdict(comparison::BundleComparison) -> Symbol

Return :invalid_inputs, :incomparable, :regressed, :qualified or :inconclusive. Qualification requires valid inputs, comparable environments, at least one comparison record and a passing status for every record.

source
PerfChecker.compatibility_report_dict Method

Return the dictionary representation of a CompatibilityReport, including diagnostic counts and the preflight pass predicate. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.configure_suite_repl Method
julia
configure_suite_repl(suite; profile=:historical, input=stdin, output=stdout)

Prompt for package, workload, collector, version bounds, search and sort order, then print the selected plan. Read positive sample, duration and worker-thread settings and return (plan, overrides) after confirmation. This prepares a run; it does not execute workloads or write reports. Pass the returned values to run_suite_repl.

Empty selectors include all matching runs; an empty numeric answer uses the displayed default. Reject an empty selection or invalid settings with ArgumentError; declining confirmation throws InterruptException. input and output may be redirected for a reproducible scripted dialogue.

source
PerfChecker.csv_to_table Method
julia
csv_to_table(path::String) -> Table

Read a CSV file written by PerfChecker into a TypedTables.Table.

source
PerfChecker.default_options Method
julia
default_options(::Val{backend}) -> Dict

Backend hook returning default configuration values. These defaults are merged with the user dictionary before normalize_config validates shared options.

source
PerfChecker.dependency_evidence Method

Capture the dependency closure visible from the current Julia process.

source
PerfChecker.dependency_evidence_dict Method

Return the dictionary representation of NativeDependencyEvidence with dependency identity, origin and availability details. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.diagnose Method

Run optional analyzers in separate bounded processes. Reports never install missing packages.

source
PerfChecker.diagnostic_capabilities Method

Describe executable diagnostic tools without loading packages or executing target code.

source
PerfChecker.discover Function

Discover test-derived proposals and explicit catalogs without executing target code or CI commands.

source
PerfChecker.discover_testitems Function
julia
discover_testitems(root=pwd(); mode=:performance, tags=[], exclude_tags=[])

List existing @testitem declarations without executing their bodies, setup modules, or surrounding source code. Load TestItemRunner to enable this method.

mode=:performance includes ordinary items and :perf_only, but excludes :test_only. mode=:test does the converse; :all keeps both categories. tags matches any requested tag; exclude_tags always removes matching items. An item carrying both reserved tags is rejected.

Return a dictionary with schema perfchecker-testitems/1, normalized root, selection mode, executed=false, and an items array. Each item contains its stable ID, name, relative file, tags and source SHA-256. IDs identify the file/name pair; renaming either changes the ID. Duplicate names in one file are rejected.

Discovery writes no report and launches no measured workload. Missing directories, invalid declarations and ambiguous identities raise an error rather than silently producing a partial listing. See run_testitems to execute a selection.

source
PerfChecker.documenter_makedocs Function
julia
documenter_makedocs(bundle; root=pwd(), source="src", build="build",
                    page="performance.md", sitename="Performance", kwargs...)

Load Documenter. Generate a performance page from saved evidence and invoke Documenter.makedocs, forwarding additional options. This writes documentation outputs but does not deploy them. For VitePress, use the corresponding extension.

source
PerfChecker.documenter_page Function
julia
documenter_page(bundle_or_result, destination; title="Performance",
                blocks=PerformanceDocumentBlock[], config=nothing)

Load Documenter and write a Markdown report page from existing evidence. config selects blocks from a configuration file; without blocks, include the version comparison summary. Create parent directories, replace the destination and return its absolute path. This renders saved data without running workloads.

source
PerfChecker.documenter_vitepress_makedocs Function
julia
documenter_vitepress_makedocs(bundle; repo, devbranch="main",
                              devurl="dev", deploy_url=nothing, kwargs...)

Load Documenter and DocumenterVitepress. Configure the VitePress formatter and build a report site through documenter_makedocs. repo is required. This is a report-publishing integration for user projects, separate from PerfChecker's own website and its collection qualification gate.

source
PerfChecker.drwatson_parameters Function

Load DrWatson, then convert a suite plan (or a suite with profile=:quick) into parameter dictionaries for each planned run. No measurement is started.

source
PerfChecker.drwatson_produce_or_load Function
julia
drwatson_produce_or_load(producer, parameters; directory="",
                        force=false, tag=true, kwargs...)

Load DrWatson to enable its disk-cache workflow. Delegate cache lookup and writing to DrWatson.produce_or_load; wrap a non-dictionary producer result under "result". Return DrWatson's result. The producer executes only when its cache policy requires it; cached data is not fresh measurement evidence.

source
PerfChecker.drwatson_run_suite Function
julia
drwatson_run_suite(suite; profile=:quick, directory="", force=false,
                  tag=true, kwargs...)

Load DrWatson. Plan a suite, use its plan revision as a cache parameter and run it with reports when production is required. Return the DrWatson cache result. Existing artifacts may be reused: request force=true when fresh execution is required, and inspect the saved provenance before comparison.

source
PerfChecker.drwatson_savename Function

Load DrWatson, then derive a filename from a planned run's suite, package, feature and target version; suffix="jld2" selects the default extension. This does not write a file.

source
PerfChecker.estimate_performance Method
julia
estimate_performance(target, references, workload; neighbours=3,
                     min_calibrations=3, max_log_error=0.25)

Experimental calibrated nearest-neighbour transfer. Each record contains machine, context, calibration (workload => positive seconds) and measurements. Context must explicitly identify suite_revision, environment, measurement, unit, and resource_policy; only equal contexts and OS/architecture are compared. Fit a log time ratio on shared calibration workloads. Leave-one-workload-out error rejects unstable transfers. Return a donor spread/error envelope, NOT a confidence interval or a measured result. At least two independent machine labels are required. Use only to prioritize actual measurements, never to qualify a CI performance gate.

source
PerfChecker.evaluate_advisors Method

Evaluate evidence selection separately from prose truth; supplied expected rule IDs are the oracle.

source
PerfChecker.evaluate_resource_envelope Method

Evaluate absolute memory bounds and ownership balance for one resource envelope.

source
PerfChecker.external_command_dict Method

Return the dictionary representation of an ExternalCommandSpec describing a command without executing it. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.external_memory_snapshot Method

Normalize a dictionary or named tuple implementing perfchecker-external-memory/1.

source
PerfChecker.external_memory_snapshot_dict Method

Return the portable perfchecker-external-memory/1 representation of a snapshot.

source
PerfChecker.filter_suite_plan Method

Filter and deterministically order a suite plan without starting workers.

source
PerfChecker.find_by_tags Method
julia
find_by_tags(tags::Vector{Symbol}, results; exact_match=true)

Find results whose tags match tags.

With exact_match=true, tags must match exactly. With exact_match=false, any overlap is accepted.

source
PerfChecker.freeze_propcheck_corpus Function
julia
freeze_propcheck_corpus(path, generator; count=100, seed=0,
                        encode=identity, metadata=Dict(), force=false)

Load PropCheck to enable this extension. Generate cases with a seeded Xoshiro RNG, extract tree roots, apply encode and save a frozen JSON corpus. Return its absolute path. count must be positive; overwriting requires force=true. Generation happens now, outside later measurement workers.

source
PerfChecker.freeze_supposition_corpus Function
julia
freeze_supposition_corpus(path, possibility; count=100, tries=100_000,
                          encode=identity, metadata=Dict(), force=false)

Load Supposition to enable this extension. Sample the possibility, encode the cases as JSON-compatible values and persist them for later reproducible replay. Return the corpus path; a positive count is required and existing files need force=true. Replay uses saved inputs rather than resampling the generator.

source
PerfChecker.get_pkg_versions Function
julia
get_pkg_versions(name::String, regname=nothing) -> Vector{VersionNumber}

Find all registered versions of name in the installed registries.

Example:

julia
julia> get_pkg_versions("ConstraintLearning")
7-element Vector{VersionNumber}:
 v"0.1.4"
 v"0.1.5"
 v"0.1.0"
 v"0.1.6"
 v"0.1.1"
 v"0.1.3"
 v"0.1.2"

The optional regname argument restricts the lookup to registry names.

source
PerfChecker.get_versions Function

Select registered versions using the legacy version-selection configuration. The configuration supplies package name, grouping mode, requested versions and whether to prefer the latest representative. Registry lookup reads installed registry metadata; it does not measure or install the selected versions.

source
PerfChecker.initpkgs Method
julia
initpkgs(::Val{backend}) -> Expr

Backend hook returning code that loads backend-specific packages inside each worker. Extensions normally define methods such as PerfChecker.initpkgs(::Val{:benchmark}).

source
PerfChecker.investigate Method

Run only declared scenario/collector/analyzer experiments within explicit count and wall-time limits.

source
PerfChecker.investigate_julia_regressions Method

Rank source lines that gained sampled CPU/allocation weight across Julia runtimes.

source
PerfChecker.investigation_status Method

Read a consistent job snapshot without waiting or rerunning code.

source
PerfChecker.investigation_view Method

Display an investigation without executing the target program.

source
PerfChecker.isolated_network_result_dict Method

Return the dictionary representation of an IsolatedNetworkCommandResult with command, output, status and network attribution evidence. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.julia_investigation_dict Method

Return the dictionary representation of a JuliaRegressionInvestigation with its classification, evidence and recommended follow-up. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.julia_runtime_campaign_dict Method

Return the dictionary representation of a JuliaRuntimeCampaign with runtime specifications, execution results and comparisons. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.julia_runtime_command Method

Build a hermetic-by-default Julia command prefix for a runtime spec.

source
PerfChecker.julia_runtime_matrix Method

Create the usual stable/candidate/nightly runtime axis without installing channels.

source
PerfChecker.julia_runtime_spec_dict Method

Return the dictionary representation of a JuliaRuntimeSpec with its identifier, command and runtime role. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.julia_runtime_suite_command Method

Build a child-controller command that runs one suite under the selected Julia runtime.

source
PerfChecker.launch_advisor_setup Method

Start a cancellable setup task for web/Pluto clients. Opening a view never calls this.

source
PerfChecker.launch_investigation Method

Launch one bounded investigation; callbacks execute only after this explicit call.

source
PerfChecker.launch_pluto_dashboard Function
julia
launch_pluto_dashboard(path; kwargs...)

Load PerfCheckerPluto and open an existing generated notebook with Pluto.run. Reject a missing file and forward server options to Pluto. This starts a notebook server; generating a notebook alone uses prepare_pluto_dashboard instead.

source
PerfChecker.launch_suite Method
julia
launch_suite(plan::SuitePlan; executor, overrides=Dict()) -> SuiteJob
launch_suite(suite::SoftwareSuite; profile=:quick, kwargs...) -> SuiteJob

Start an asynchronous controller task which executes the selected plan. The normal executor prepares isolated environments and starts measurement workers. Return immediately with a job handle. Poll suite_job_progress for progress, use cancel_suite! to request interruption and wait_suite to obtain the result or surface a failure. Supplying an executor changes how measurements are run.

source
PerfChecker.list_run_bundles Method
julia
list_run_bundles(root; recursive=false)

Read manifests in child bundle directories and return them with bundle_path. A missing root returns an empty vector. Unreadable or foreign manifests are ignored. This is discovery only: call read_run_bundle to verify bundle integrity before using its observations.

source
PerfChecker.load_advisor_config Method

Load an explicit provider configuration. Secrets are referenced by environment variable name.

source
PerfChecker.load_scenario_catalog Method

Read a TOML catalog without evaluating package or test code. Paths are relative to the catalog.

source
PerfChecker.load_software_suite Method
julia
load_software_suite(path; factory=:build_suite) -> SoftwareSuite

Load an ordinary Julia suite definition in an isolated controller module. The file must define the selected zero-argument factory or bind suite to a SoftwareSuite. Only the controller evaluates this file; measured Malt workers still load just their backend, package, and feature entrypoint.

source
PerfChecker.loaded_library_inventory Method

List shared libraries loaded in the current process. File hashing is opt-in.

source
PerfChecker.machine_profile Method
julia
machine_profile(; label="", limits=Dict())

Capture a specification fingerprint, independent of host name and transient CPU load. This identifies a specification class, not a unique physical machine. Declare CI CPU quotas, affinity and memory limits in limits; unknown limits remain unknown.

source
PerfChecker.measure_isolated_network_command Method

Run one command tree in an isolated network namespace and capture its counters.

source
PerfChecker.measure_network_interface Method

Measure interface counters around a workload. Isolation is required for package attribution.

source
PerfChecker.measure_network_isolated Method

Measure an in-process workload only when launched by PerfChecker's netns wrapper.

source
PerfChecker.migrate_run_bundle Method

Rewrite a legacy/unverified bundle into a new digest-protected destination.

source
PerfChecker.narrate_advice Method

Write optional prose from bounded evidence in a cancellable worker. Verdicts remain deterministic.

source
PerfChecker.native_tool_plan Method
julia
native_tool_plan(tool, script; project=dirname(Base.active_project()),
                 output="native-profile", julia=first(Base.julia_cmd().exec),
                 suppressions=nothing)

Prepare shell-free arguments for optional native profilers. No process is started and no software is installed. Linux tools can be planned on Windows for execution inside Linux/WSL with Linux paths. The plan reports local availability separately from qualification. Capture the workload's oracle and dependency inventory alongside the resulting artifact; a profiler exit code does not prove workload correctness.

source
PerfChecker.network_interface_capabilities Method
julia
network_interface_capabilities()

Describe platform support and available interfaces for network-counter sampling. This reports collection capability; interface counters include other traffic using the same interface. Use network isolation for process-tree attribution.

source
PerfChecker.network_interface_delta Method

Compute counter deltas for two snapshots of the same interface.

source
PerfChecker.network_interface_snapshot Function

Take a network-interface snapshot. auto selects the busiest non-loopback interface.

source
PerfChecker.network_isolation_capabilities Function

Describe whether a process-tree network namespace can be launched on this host.

source
PerfChecker.network_isolation_spec_dict Method

Return the dictionary representation of a NetworkIsolationSpec with provider, distribution, interface and connectivity requirements. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.normalize_config Method
julia
normalize_config(backend::Symbol, config::Dict) -> CheckConfig

Merge backend defaults with a user configuration dictionary, validate shared PerfChecker options, and return a CheckConfig.

Required shared option:

  • :path: environment directory copied for each worker.

Common optional options include :tags, :threads, :track, :pkgs, :devops, :extra_pkgs, :targets, and :repeat.

source
PerfChecker.oracle_spec_dict Method

Return the dictionary representation of an OracleSpec with its function name and required flag. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.package_dependency_inventory Method

Inventory the active Pkg dependency graph without loading dependency modules.

source
PerfChecker.perf_plot Function
julia
perf_plot(...)

Reserved extension point for backend-specific plots.

source
PerfChecker.perf_setup Method
julia
perf_setup(; dir="perf", kinds=(:benchmark, :chairmark, :alloc, :pluto), force=false)

Create a small Julia-native performance workspace.

This writes benchmark, chairmark, allocation, and Pluto dashboard starter files by default. It intentionally does not create a Perf.toml; options stay in Julia code through PerfConfig. The Pluto dashboard activates the surrounding Julia project so it can be used as a controlled project-local view over stored or newly run checks.

source
PerfChecker.perf_table Function
julia
perf_table(...)

Reserved extension point for backend-specific tabular summaries.

source
PerfChecker.perfchecker_main Function

Implementation of the unified perfchecker CLI. Returns a process exit code.

source
PerfChecker.performance_document_block Method

Parse one documentation block from the shared JSON-compatible grammar.

source
PerfChecker.performance_figure Function

Extension point implemented by MakieExt.

source
PerfChecker.performance_plot Method
julia
performance_plot(bundle, [id]; reference_version=nothing, version=nothing, top=40, min_percentage=5)

Build a backend-neutral plot. With no identifier, prefer overlaid BenchmarkTools or Chairmarks metrics. By default, use each version's minimum sample, divided by the minimum across the compared versions separately for each metric (best = 1). Pass statistic=:median to compare medians instead. Release targets use semantic version order; Git labels follow the series order. Use reference_version=:latest or a version label to select a target instead of the minimum. Raw measurements and units remain in every record. Equal zeros appear at 1 (unchanged), by convention; a nonzero value over a zero reference, or a missing reference, has no finite ratio. Separate absolute plots remain available through plot_catalog. Allocation pies combine sites contributing strictly less than min_percentage percent of the selected version's allocated bytes into "Other allocation sites". The default is 5%; exactly 5% remains separate. Set min_percentage=0 to disable this threshold. top still caps legend entries, including the combined remainder.

source
PerfChecker.performance_plot_dict Method

Return the dictionary representation of a performance plot view model for interface transport. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.performance_plot_html Function

Extension point implemented by WGLMakieExt.

source
PerfChecker.performance_query Method

Parse and validate the language-neutral dictionary form of a report query.

source
PerfChecker.performance_query_dict Method

Return the dictionary representation of a PerformanceQuery with its filters and requested evidence selections. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.plan_suite Method
julia
plan_suite(suite; profile=:quick, candidates=Dict(), comparisons=[])

Resolve package releases, development sources, Git candidates, feature variants, and comparison policies into an immutable SuitePlan without running workloads.

source
PerfChecker.planned_run_id Method

Return the deterministic identifier of a planned feature/target selection used by plan filters, progress events and interfaces. This identifies the selection, not a completed measurement.

source
PerfChecker.plot_catalog Method

List every plot supported by the evidence contained in a run bundle.

source
PerfChecker.post Method
julia
post(config::Dict, ::Val{backend})

Backend hook that selects or transforms the worker result before it is converted to a TypedTables.Table by to_table.

source
PerfChecker.preflight_passed Method

Return whether a CompatibilityReport contains no blocking diagnostic. This checks preparation evidence and does not execute or qualify a workload.

source
PerfChecker.preflight_suite Method

Resolve every ready feature/version environment without running a workload.

source
PerfChecker.prep Method
julia
prep(config::Dict, block::Expr, ::Val{backend}) -> Expr

Backend hook returning code run before the measured block. Its result is stored as config[:prep_result] before post is called.

source
PerfChecker.prepare_pluto_dashboard Function
julia
prepare_pluto_dashboard(path; suite_path=nothing, factory=:build_suite, kwargs...)

Load PerfCheckerPluto. Write a suite dashboard notebook and return its absolute path without starting Pluto or a workload. suite_path selects the Julia suite definition and factory its constructor; the notebook uses explicit run controls. Other keywords, including project, reports_root and force, are forwarded to write_suite_notebook.

source
PerfChecker.print_suite_plan Method
julia
print_suite_plan([io=stdout], plan::SuitePlan; limit=typemax(Int))

Print a readable plan, including target labels and availability status, without starting workers. limit must be positive and bounds displayed rows.

source
PerfChecker.probe_julia_runtime Method

Resolve a Julia selector to the exact runtime identity observed in a fresh process.

source
PerfChecker.probe_spec_dict Method

Return the dictionary representation of a ProbeSpec with its identifier, function name, blocking flag and category. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.process_memory_capabilities Method

Report which process-memory counters PerfChecker can observe on this platform.

source
PerfChecker.process_memory_snapshot Function

Take a non-throwing memory snapshot for pid; unsupported counters remain nothing.

source
PerfChecker.process_memory_snapshot_dict Method

Return the portable perfchecker-process-memory/1 representation of a snapshot.

source
PerfChecker.query_bundle Method

Execute a report query without invoking a measurement worker or mutating the bundle.

source
PerfChecker.query_result_dict Method

Return the dictionary representation of a query result for transport to a report, UI or agent. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.read_advice Method

Read saved deterministic advice without executing the target.

source
PerfChecker.read_document_blocks Method

Read a shared UI/documentation configuration and return its document blocks.

source
PerfChecker.read_property_corpus Method
julia
read_property_corpus(path)

Read a frozen property corpus and return its JSON dictionary, including cases and generation metadata. Reject missing files, unsupported schemas and a count that disagrees with the stored cases. No generator or shrinking code is run.

source
PerfChecker.read_provider_result Method

Read and validate a language-neutral provider result.

source
PerfChecker.read_run_bundle Method
julia
read_run_bundle(directory; verify_integrity=true, require_integrity=false)

Read and validate a perfchecker-run-bundle/1 directory. Integrity metadata is verified by default when present and can be made mandatory with require_integrity=true.

source
PerfChecker.read_scenario_runs Method

Read shared-scenario bundles from one measurement directory without modifying them.

source
PerfChecker.read_ui_configuration Method

Read and minimally validate a shared interface configuration.

source
PerfChecker.register_oxygen_routes! Function
julia
register_oxygen_routes!(source; prefix="/perfchecker/v1", kwargs...)

Load PerfCheckerWeb. Register routes on Oxygen's current router for a result, bundle, result provider or interactive suite. Read-only evidence routes do not run measurements; suite/studio control routes may launch work. This registers routes without starting the HTTP server. See serve_suite for hosting.

source
PerfChecker.register_testitem_routes! Function

Register an Oxygen UI for existing TestItemRunner items. Load PerfCheckerWeb; bind the server to loopback or supply external authentication.

source
PerfChecker.resource_envelope_dict Method

Return the portable perfchecker-resource-envelope/1 representation.

source
PerfChecker.resource_envelope_metrics Method

Flatten an envelope into explicitly named, non-conflated resource metrics.

source
PerfChecker.resource_policy_passed Method

Return whether an evaluate_resource_envelope result has status="passed". Missing status is treated as failure.

source
PerfChecker.run_external_command Method

Run a non-Julia provider in its own process and ingest its result grammar.

source
PerfChecker.run_julia_runtime_campaign Method

Run one package suite under baseline and candidate Julia runtimes.

source
PerfChecker.run_perfitem Method
julia
run_perfitem(catalog, id; implementation="default", kwargs...)

Run exactly one declared performance item with the shared isolated lifecycle. Keywords are forwarded to run_scenarios; unknown identities fail before execution.

source
PerfChecker.run_scenarios Method

Measure explicit shared scenarios in fresh Julia processes; no package installation is performed.

source
PerfChecker.run_studio_agent Function
julia
run_studio_agent(suite; server, token, agent_id, poll_seconds=2,
                 heartbeat_seconds=30, max_jobs=typemax(Int), once=false)

Load PerfCheckerWeb. Register an agent with the specified controller, poll for jobs, execute accepted suite plans locally and upload progress/results. This performs network requests and runs workload processes; keep the server and suite under the caller's control. Use once=true for a bounded polling iteration or max_jobs to bound completed jobs.

source
PerfChecker.run_suite Method
julia
run_suite(plan; executor=_default_suite_executor, strict=true,
          progress_callback=identity)

Execute the runnable leaves of a resolved suite plan and return their isolated worker results. When strict is false, individual failures are retained in the result instead of aborting the complete suite.

source
PerfChecker.run_suite_file Method
julia
run_suite_file(path; profile=:quick, reports=nothing,
               factory=:build_suite, kwargs...)

Load and execute a suite definition. When reports is a path, write the JSON, Markdown, and JUnit representations consumed by CI and user interfaces.

source
PerfChecker.run_suite_repl Method

Run a selected plan with a terminal progress bar and optional report output.

source
PerfChecker.run_testitems Function
julia
run_testitems(root=pwd(); ids=nothing, tags=[], exclude_tags=[],
              project=dirname(Base.active_project()), samples=1,
              timeout=120, threads=1, reports=nothing,
              cancellation=CancellationToken())

Execute a selection from discover_testitems with the official TestItemRunner lifecycle. Load TestItemRunner before calling. Prepare project with the target's test dependencies first; running does not install packages.

ids=nothing selects every item admitted by the performance/tag filters. Explicit IDs must be unique and known. Empty selections and nonpositive sample counts are errors. Each sample runs in a fresh process with the requested Julia threads and timeout. There is no implicit warmup or repetition.

The measured scope includes item setup, imports, assertions and module cleanup. It is suitable for checking the cost of an existing test; it does not isolate an inner operation. Use a feature workload when that narrower scope is required.

Return a perfchecker-testitem-run/1 dictionary with item/sample records and a functional passed flag. performance=not_compared means no regression budget was evaluated; functional success is not a performance verdict. Source or environment changes during a sample invalidate its evidence. Failures, timeouts and cancellation remain visible in the result.

If reports is supplied, write the report into that directory without replacing an existing testitems.json. Cancellation stops the current worker and prevents further selected items from running. See testitem_filter for reserved tags.

source
PerfChecker.runtime_campaign_passed Method

Return whether every runtime run has status "passed" and every recorded comparison passed. This predicate summarizes the supplied campaign; it does not schedule missing runtimes.

source
PerfChecker.saveplot Function
julia
saveplot(...)

Reserved extension point for saving backend-specific plots.

source
PerfChecker.scenario_catalog_dict Method

Return the portable representation of an explicit scenario catalog.

source
PerfChecker.scenario_sync Function

Relate declared scenarios, test proposals and literal CI configurations without executing them.

source
PerfChecker.select_scenarios Method

Select exact scenario/implementation pairs; inferred or unknown identities are rejected.

source
PerfChecker.select_suite_plan Method

Apply the ordered selection from a shared UI configuration.

source
PerfChecker.select_suite_plan Method

Return a validated, explicitly ordered subset of a server-produced plan.

source
PerfChecker.serve_suite Function
julia
serve_suite(source; host="127.0.0.1", port=8080, kwargs...)

Load PerfCheckerWeb to serve a suite, saved reports, bundle or scenario catalog in Oxygen. Available routes depend on the source type. The default host is loopback; remote control requires an authenticator and explicit allow_remote_control=true. Server startup and lifetime options are forwarded to Oxygen. Loading a report view does not itself rerun its measurements.

source
PerfChecker.similar_machines Method

Rank specification neighbours; a small distance is not performance equivalence.

source
PerfChecker.stop_before_post Method
julia
stop_before_post(::Val{backend}) -> Bool

Backend hook for measurements whose artifacts are flushed when the worker process exits.

source
PerfChecker.studio_token_authenticator Function
julia
studio_token_authenticator(users_or_path) -> Function

Load PerfCheckerWeb. Build a bearer-token verifier from a digest-to-identity dictionary or a TOML file with [[users]], id, token_sha256 and roles. The returned function hashes a supplied token and returns its identity or nothing. It does not create credentials, start a server or grant new roles.

source
PerfChecker.suite_dashboard Function
julia
suite_dashboard(result::SoftwareSuiteResult; view=:normalized)
suite_dashboard(job::SuiteJob; strict=true, view=:normalized)
suite_dashboard(suite::SoftwareSuite; profile=:quick, strict=true, view=:normalized, kwargs...)

Load PerfCheckerMakie to overlay the first available benchmark workload's measurements, each divided by its minimum across versions. Use plot_catalog and performance_figure to select another workload. With view=:absolute, show minimum benchmark times for every run; this is also the fallback when no overlay is available. The result overload only renders saved measurements. The job overload waits for completion; the suite overload launches and waits for new measurements. Return a Makie figure.

source
PerfChecker.suite_dict Method

Return the dictionary representation of a SoftwareSuiteResult with schema, execution verdict and per-run summaries and qualification. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.suite_job_dict Method

Return the dictionary representation of a SuiteJob snapshot, including a completed result or failure message when available. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.suite_job_progress Method

Return a shallow copy of the current progress dictionary without waiting. It includes completed/total counts, per-status counts and the current run when available.

source
PerfChecker.suite_job_status Method

Return the current job state, such as :running, :cancelling, :complete, :cancelled or :failed, without waiting.

source
PerfChecker.suite_passed Method

Return whether no run has status :error, :blocked or :invalid. Unavailable runs do not fail this execution predicate. Use suite_verdict to distinguish partial execution from validated results.

source
PerfChecker.suite_plan_dict Method

Return the dictionary representation of a SuitePlan with its revision and resolved selections for UI and execution contracts. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.suite_summary Method

Return a TypedTables table with one row per feature run: suite, package, feature, target version, comparison key, status, elapsed orchestration seconds and message.

source
PerfChecker.suite_verdict Method
julia
suite_verdict(result::SoftwareSuiteResult) -> Symbol

Summarize execution and qualification in priority order: execution failure, blocked capability, invalid result, partial execution, no execution, validated, execution with warnings, or executed. Ordinary successful execution without a correctness oracle remains :executed.

source
PerfChecker.suite_version_series Method

Aggregate raw observations into plottable statistics for every package feature/version.

source
PerfChecker.summary_table Method
julia
summary_table(result::CheckerResult) -> Table

Build a compact table for REPL display or Pluto notebooks.

The summary uses a common schema across benchmark-like and allocation-like tables. Missing metrics are reported as missing rather than inferred.

source
PerfChecker.table_to_csv Method
julia
table_to_csv(table::Table, path::String)

Write a TypedTables.Table to path, creating the parent directory if needed.

source
PerfChecker.table_to_pie Function
julia
table_to_pie(table, ::Val{backend}; kwargs...)

Create a pie chart from a backend table. Currently implemented by the Makie package for allocation tables with Val(:alloc). Sites below 5% of allocated bytes are combined by default. Use min_percentage=0 to show smaller sites; top=40 caps legend entries, including the combined remainder.

source
PerfChecker.terminal_plot Function

Load UnicodePlots to render a performance plot model or a selected bundle plot in the terminal. This consumes existing observations without rerunning their workload.

source
PerfChecker.testitem_filter Function
julia
testitem_filter(mode=:performance; tags=[], exclude_tags=[])

Build a TestItemRunner filter. Untagged items are shared. :test_only excludes performance execution; :perf_only excludes functional execution. Contradictory tags are rejected. A nonempty tag selection matches any requested tag. Use @run_package_tests filter=testitem_filter(:test) in functional CI. Loading PerfChecker never changes TestItemRunner's default behavior.

source
PerfChecker.to_dict Method
julia
to_dict(config::PerfConfig) -> Dict{Symbol, Any}

Return a copy of the public options stored in config.

source
PerfChecker.to_table Function
julia
to_table(raw_result) -> TypedTables.Table

Convert a backend-specific raw result into a table stored by PerfChecker. Backends should extend this method for their raw result types.

source
PerfChecker.tool_catalog Method

Inventory of implemented integrations and candidates; listing is never qualification.

source
PerfChecker.verify_run_bundle Method

Verify the immutable protocol documents of a run bundle.

source
PerfChecker.version_comparison_dict Method

Return the dictionary representation of a VersionComparison with availability, series, comparisons and verdict. This is an in-memory conversion; it does not write a report or run a workload.

source
PerfChecker.version_comparison_passed Method

Return true only when the within-bundle version comparison is :qualified.

source
PerfChecker.version_comparison_verdict Method

Return :invalid_input, :regressed, :qualified or :inconclusive for a VersionComparison. Empty records and incomplete evidence are inconclusive; a successful input bundle alone does not qualify a version comparison.

source
PerfChecker.wait_investigation Method

Wait for a launched investigation and retain incomplete or cancelled outcomes.

source
PerfChecker.wait_suite Method
julia
wait_suite(job::SuiteJob; strict=true) -> SoftwareSuiteResult

Wait for the controller task to finish. Rethrow orchestration failures and throw InterruptException for cancellation. With strict=true, a failed suite raises an error carrying its result; strict=false returns completed failure records for inspection. It does not suppress orchestration exceptions.

source
PerfChecker.worker_environment Method

Seed environment copied into every isolated measurement worker.

source
PerfChecker.workload_id Method

Stable business-feature identifier shared by plans, reports, and user interfaces.

source
PerfChecker.write_comparison_json Method
julia
write_comparison_json(result::BundleComparison, path)

Write canonical JSON comparison evidence. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_comparison_markdown Method
julia
write_comparison_markdown(result::BundleComparison, path)

Write a Markdown comparison table and verdict. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_compatibility_report Method
julia
write_compatibility_report(result::CompatibilityReport, path)

Write JSON preparation and compatibility evidence. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_folded_profile Method
julia
write_folded_profile(bundle, path; metric="julia.cpu.samples",
                     case_id="", version=nothing)

Write matching saved stacks as folded stack/weight lines for flame-graph tools. Create parent directories, replace the file and return its absolute path. Reject an empty selection. This exports observations; it does not sample a process.

source
PerfChecker.write_investigation_notebook Function

Generate an investigation notebook. Load PerfCheckerPluto before calling.

source
PerfChecker.write_investigation_report Method

Write the same investigation as JSON and human-readable Markdown. Existing output requires force=true.

source
PerfChecker.write_julia_investigation Method
julia
write_julia_investigation(investigation::JuliaRegressionInvestigation, directory)

Write julia-investigation.json and a Markdown attribution report in directory. Create the directory, replace these report files and return both absolute paths. This exports the supplied investigation without rerunning any runtime campaign.

source
PerfChecker.write_julia_runtime_campaign Method
julia
write_julia_runtime_campaign(campaign::JuliaRuntimeCampaign, directory;
                             include_output=false)

Write julia-runtime-campaign.json and a Markdown summary in directory and return both absolute paths. Existing report files are replaced. Captured process output is omitted from JSON unless include_output=true. No measurements run.

source
PerfChecker.write_pprof_profile Function
julia
write_pprof_profile(bundle, path; metric="julia.cpu.samples",
                   case_id="", version=nothing, max_samples=100_000)

Load PProf and FlameGraphs. Convert saved weighted stacks into a PProf file, returning its absolute path. The conversion approximates weights with repeated samples scaled by max_samples; it is not a fresh native-process profile. Reject nonpositive sample limits and profiles without positive weights.

source
PerfChecker.write_property_corpus Method
julia
write_property_corpus(path, cases; producer="manual", metadata=Dict(), force=false)

Persist JSON-compatible property-generated cases before benchmarking them. The result is an immutable input artifact: generation and shrinking do not run in the timed worker.

source
PerfChecker.write_run_bundle Method

Write a run bundle using a temporary sibling and an atomic directory rename.

source
PerfChecker.write_scenario_workflow Method

Write a new CI workflow consuming an explicitly selected catalog; never overwrite a workflow.

source
PerfChecker.write_software_suite_template Function

Create an immediately runnable feature-oriented suite for the current package.

source
PerfChecker.write_speedscope_profile Method
julia
write_speedscope_profile(bundle, path; metric="julia.cpu.samples",
                        case_id="", version=nothing)

Export matching saved stacks as a Speedscope sampled-profile JSON document. Weights use bytes for allocation metrics and unitless samples otherwise. Create parents, replace the file and return its absolute path; reject an empty selection.

source
PerfChecker.write_suite_bundle Method
julia
write_suite_bundle(result, root; run_id=uuid4(), attempt_id=uuid4(),
                   evidence="fresh")

Convert a completed suite result into a portable bundle under root/run-<id>. Return the absolute bundle directory. The atomic writer rejects an existing destination. The evidence label is supplied by the caller; writing a bundle does not establish that previously cached observations were freshly measured.

source
PerfChecker.write_suite_json Method
julia
write_suite_json(result::SoftwareSuiteResult, path)

Write JSON suite evidence including per-run qualification. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_suite_junit Method
julia
write_suite_junit(result::SoftwareSuiteResult, path)

Write JUnit XML, mapping error/blocked/invalid runs to failures and unavailable runs to skipped cases. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_suite_markdown Method
julia
write_suite_markdown(result::SoftwareSuiteResult, path)

Write a Markdown suite summary with verdict and run statuses. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_suite_notebook Function
julia
write_suite_notebook(path; suite_path=nothing, factory=:build_suite,
    profile=:quick, project=dirname(Base.active_project()),
    result_path="results/suite-result.json", reports_root="results/notebook",
    force=false)

Load PerfCheckerPluto and generate an editable Pluto notebook. It selects a package, workload, collector and target, with explicit Launch, Cancel, Refresh and Save controls. Generation does not start Pluto or execute a workload. Without suite_path, the notebook only displays an existing saved result.

project must be a prepared controller environment containing PerfChecker, PlutoUI and the selected collectors. Relative report paths resolve beside the notebook; relative suite and project paths resolve from the caller's directory. Create parent directories and return the absolute notebook path. Reject an existing destination unless force=true explicitly permits replacement.

source
PerfChecker.write_suite_reports Method
julia
write_suite_reports(result, directory; formats, relative_limits=Dict(),
                    min_samples=1, sample_statistics=Dict(),
                    default_sample_statistic=:median)

Export a completed suite and return written paths. Defaults include JSON, Markdown, JUnit, a run bundle, version series and version-comparison reports. The comparison options control evidence reduction and budgets. Ordinary report files are replaced; bundles use new run directories. No workload is rerun.

source
PerfChecker.write_template Method
julia
write_template(kind::Symbol; path=nothing, force=false) -> String

Write a Julia performance-checking template and return its path.

Supported template kinds are :benchmark, :chairmark, :alloc, and :pluto. The generated files use PerfConfig; no external configuration file format is introduced.

source
PerfChecker.write_version_comparison_json Method
julia
write_version_comparison_json(result::VersionComparison, path)

Write canonical JSON version-comparison evidence. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_version_comparison_markdown Method
julia
write_version_comparison_markdown(result::VersionComparison, path)

Write a Markdown version-comparison report. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source
PerfChecker.write_version_series_json Method
julia
write_version_series_json(result::VersionComparison, path)

Write canonical JSON series and target availability. Create parent directories, replace the destination file and return its path. The input is saved evidence; this writer does not execute measurements.

source

Open source · Report an issue · Contributions welcome

© 2026 PerfChecker contributors