Skip to content

Execution information

Every ProgramOutput has execution: ExecutionInfo, defaulting to an empty ExecutionInfo(). Individual fields may be unknown; explicit execution=None is invalid. Passing ExecutionInfo() or execution={} means output.execution.wall_time returns None without requiring a check for the execution object itself.

host_cpu counts logical CPUs; host_mem_gib accepts fractional values. The former hostcpus and hostmem names are no longer accepted.

wall_time is measured in seconds and host_mem_gib in GiB. host_cpu and host_mem_gib describe host capacity, not the resources allocated to the job. Each frame or scan point records its own execution information, including its working directory.

identities says which code made the results (each program's numerics identity, set by the runner), and store_run names the stored run an output is ("<key>/<run>"): set on every output a store returns and on one a runner has just stored, None on an output no store holds.

qcdata.ExecutionInfo

Runtime information about a program execution.

All fields may be unknown. Pass ExecutionInfo() when no details are available.

Attributes:

Name Type Description
scratch_dir Path | None

The working directory used by the program.

wall_time float | None

Elapsed execution time in seconds.

hostname str | None

The hostname of the machine where the program ran.

host_cpu int | None

The number of logical CPUs on the host, not the allocated CPU count.

host_mem_gib float | None

The host's total memory in GiB, not the allocated memory.

cpu_model str | None

The CPU's model name, as the operating system reports it.

devices list[str]

The names of the GPUs the calculation ran on, in device order.

libc str | None

The C library and its version (glibc 2.39). With the CPU and the devices it is the run's environment: results agree across environments to the program's stated round-off, and bitwise only within one.

timings dict[str, float]

Wall-clock seconds per phase of the calculation. The keys are the program's; total is the whole call, and a program with subprograms reports subprograms (time inside them) beside its own phases. An output of a batch also has batch, the whole batch's wall time, set by the runner.

threads int | None

CPU threads the calculation ran with. Some programs' results depend on it at round-off, so it is recorded with every result.

peak_memory_gib float | None

Peak host memory the calculation used (GiB), as measured.

peak_device_memory_gib float | None

Peak GPU memory the calculation used (GiB), as measured; schedulers compare it with the plan's estimate.

identities dict[str, str]

Which code produced the results: {program: numerics}, each program's numerics identity for the input's program and every subprogram it names, as the runner saw them when it ran. A program named with several specs has its sorted, distinct identities joined with ;. The runner sets it on every output it returns, and a store keeps it with the run, so an output read back says which code made it. A result carried forward to new code keeps the identities that made it. Empty for an output no runner made.

store_run str | None

Where the output is filed in a store, as "<key>/<run>" (its calculation key and run id): set by the store on the outputs it returns and by the runner on an output it has just stored; never stored itself. None for an output no store holds.

extras FreeDict

Additional execution information.