solprop.calibration.grain#

Operation-grain candidates from the work sizes the calibration problems run (SEP 46).

operations() reads a workspace’s execution_sizing into Operation rows (class, work, width), and width() is the width a native execution record (Record) gives one. proposals() makes each class’s Candidate moves past the nearest work sizes the problems actually run, at most four a class; affected() says whether a candidate changes any of a problem’s operations, and best() keeps each setting’s admitted candidate with the lowest score. TIMED and SHAPE_MOVES name the classes and the shape settings moved. Every function here is pure. The candidate rule is in docs/dev/backends.md (section 3.4a).

Module Attributes

Record

A native execution record (ExecutionRecord.native()).

TIMED

The classes whose thresholds the grain moves, in the order their candidates go.

SHAPE_MOVES

The transforms' shape settings the grain halves and doubles.

Functions

affected(record, base, found, capacity)

Return whether record gives any of found another width than base does.

best(candidates, verdicts)

Return each setting's admitted candidate with the lowest score.

operations(sizing)

Return the operations a workspace's execution_sizing records.

proposals(record, problems, capacity[, ...])

Return the grain candidates for problems running problems' operations.

width(record, operation, capacity)

Return the width record gives operation on a pool of capacity threads.

Classes

Candidate(setting, name, changes)

One grain candidate: a setting's group and the record's changed fields.

Operation(pool, kind, elements[, samples])

One operation a problem runs, as its workspace's sizing records it.

class solprop.calibration.grain.Candidate(setting, name, changes)[source]#

Bases: object

One grain candidate: a setting’s group and the record’s changed fields.

Attributes:
settingstr

What it moves: an operation class, "medium" or "compact".

namestr

A short description, such as "stage threshold 2048".

changesMapping[str, int]

The fields it sets over the base record.

changes: Mapping[str, int]#
name: str#
record(base)[source]#

Return base with this candidate’s changes.

Parameters:
baseMapping[str, int or bool]

A native execution record.

Returns:
dict

The candidate’s record.

setting: str#
class solprop.calibration.grain.Operation(pool, kind, elements, samples=0)[source]#

Bases: object

One operation a problem runs, as its workspace’s sizing records it.

Attributes:
poolstr

"kernels", "fft", "raman_fft" or "raman_tail_fft".

kindstr

Its class: "stage", "response", "dense", "fft", "raman", "copy", "flow", "modal" or "adams".

elementsint

Its work.

samplesint

A response’s fine samples per column, a transform batch’s row length; zero otherwise.

elements: int#
kind: str#
pool: str#
samples: int = 0#
type solprop.calibration.grain.Record = Mapping[str, int | bool]#

A native execution record (ExecutionRecord.native()).

solprop.calibration.grain.SHAPE_MOVES = ('fft_thread_elements',)#

The transforms’ shape settings the grain halves and doubles.

Not the long row: with its moves too, a thorough calibration of 16 cores of an AMD EPYC 7763 timed 21 grain candidates and ran out of rounds before any verdict, where 17 had concluded.

solprop.calibration.grain.TIMED = ('stage', 'response', 'raman', 'copy', 'dense', 'modal', 'fft')#

The classes whose thresholds the grain moves, in the order their candidates go.

The exponential Adams trial’s passes and a coupled flow’s matrix functions run in no calibration window: their thresholds keep the built-in table’s. The transforms thread by shape (rows and row length, solprop issue #587), so beside their threshold the grain moves their thread grain (SHAPE_MOVES) rather than their full size: by element count alone, a full width from 98304 elements won 0.56 on a line’s many short rows and ran grin_nonlinear’s few long rows 8-10 % slower on AMD EPYC cores (SEP 46 Part II). They go last: a move of theirs changes nearly every problem’s width, so each costs a round’s worth of windows, and a level’s limit drops them first.

solprop.calibration.grain.affected(record, base, found, capacity)[source]#

Return whether record gives any of found another width than base does.

Parameters:
record, baseMapping[str, int or bool]

Two native execution records.

founditerable of Operation

A problem’s operations.

capacityint

The pool’s width.

Returns:
bool

Whether timing the problem can tell the two apart.

solprop.calibration.grain.best(candidates, verdicts)[source]#

Return each setting’s admitted candidate with the lowest score.

Parameters:
candidatesiterable of Candidate

The candidates timed.

verdictsMapping[str, Verdict]

Each one’s verdict, by name.

Returns:
list of Candidate

At most one a setting, in the order the settings first appear.

solprop.calibration.grain.operations(sizing)[source]#

Return the operations a workspace’s execution_sizing records.

Parameters:
sizingMapping[str, object]

The sizing, keyed pool.operation.elements[.samples.N].

Returns:
list of Operation

One per key, in key order; keys of another form are left out.

Examples

>>> found = operations({"kernels.stage.4096": {}, "fft.fft.66.samples.33": {}})
>>> [(operation.kind, operation.elements, operation.samples) for operation in found]
[('fft', 66, 33), ('stage', 4096, 0)]
solprop.calibration.grain.proposals(record, problems, capacity, compact=(), *, limit=None, fulls=True)[source]#

Return the grain candidates for problems running problems’ operations.

Parameters:
recordMapping[str, int or bool]

The base record: the process’s, under which the problems were sized.

problemsMapping[str, list of Operation]

Each problem’s operations.

capacityint

The pool’s width.

compactiterable of str

The problems that run on a compact team.

limitint or None, optional

The most candidates; the medium widths and compact teams come first, then the classes in TIMED order.

fullsbool, optional

Whether to move the classes’ full sizes as well as their thresholds.

Returns:
list of Candidate

The medium widths, the compact teams, then each timed class’s moves; each changes some operation’s width (or a compact problem’s team).

Examples

>>> base = {"stage_threshold": 100, "stage_full": 1000, "medium_threads": 4}
>>> found = proposals(base, {"p": [Operation("kernels", "stage", 500)]}, 18)
>>> [candidate.name for candidate in found]
['medium 2', 'medium 8', 'stage threshold 501', 'stage full 500']
solprop.calibration.grain.width(record, operation, capacity)[source]#

Return the width record gives operation on a pool of capacity threads.

The native rule (operation_threads), without the compact cap, the stable team or an explicit pool: one below the threshold, the full pool for a long or wide response, a thread per fft_thread_elements samples (at most one a row, or the medium width for rows fft_long_row long) for a transform batch of known row length, the medium width below the full size, the full pool from it.

Parameters:
recordMapping[str, int or bool]

A native execution record.

operationOperation

The operation.

capacityint

The pool’s width.

Returns:
int

Threads.

Examples

>>> table = {"stage_threshold": 100, "stage_full": 1000, "medium_threads": 4}
>>> [width(table, Operation("kernels", "stage", n), 18) for n in (50, 500, 5000)]
[1, 4, 18]