stelliferous

Search uses release 0.0.2.0 · 2,086 definitions

Releases (2)

def capacityThe capacity as a word, for run-time guards that need no other limit.
def limits

type Context
def windowedA leaf assembles the rows its outputs read into one contiguous window whose first row is a stride multiple, then runs the dense leaf on it: packing a window is packing a shorter image with output rows shifted by first / stride.
def leaf
def parallel
def input_geometry
def parallel_plan
def Parameters
def shared
def shareEach half of a split owns its copy of the read-only weights and bias.
def band
def runEvery core leaf with its halo, through the shared band recursion.
def prepared
def planned
def executeThe weights arrive in the order the kernel reads them.

type MovementImages run one after another, each as its own parallel region (the runtime forks only within an image).
type Plan
def transfer
def leaf_cost
def assemblyBandWindow.assemble reuses the core exactly when both row ranges agree.
def leaf_window
def merge
def merge_imagesA split between images finishes both sides' regions in turn.
def merge_layout
def clone_cost
def reorder_cost
def movement
def parallel_ns
def estimate
def choose
def transfer_layout
def wake_cost
def candidate
def initial_candidate
def candidates
def dense_baseline
def selectGrain bounds the operation's work; the two wake rounds are charged separately.
type LayoutPlan
def retained_parallel
def layout_cost
def evaluated
def prefer
def layout_candidate
def layouts
def replan

type TwinA statically shaped product.
def zip_mapStatic product composition also lifts an operation to any pair of elements.
def finish_pair
def read_second
def read_at
def read_pair

type Configuration
def element_nsOne element's cost.
def region_nsThe official runtime grows fork tasks and queues fork-free tasks for its work round (monk_step, row_grow, cube_run).

type Buffers
type LayoutRow-major output, eight contiguous columns; packed weights are [M/8,K,8].
type Contextinput_base and weight_base address the job's first input group and weight tile; the loop index advances both.
type Job
type LoopOne flat loop state.
def row_unitsA job owns four output rows: one half of an eight-row weight block.
def column_groups
def job_count
def jobInput-major: one input group stays in cache while every row unit passes over it (the BLIS loop order).
def update
def with_input
def with_weights
def stepOne ordered k step: read the weight tile, then the input tile, then MAC.
def store_laneThe last group can contain padding lanes; only real columns are written.
def store_tail
def write_bias
def write_row
def write
def after_write
def finishThe loop's final step stores its accumulators; bias is added once.
def reduce
def executeEvery output folds k in order from +0, then adds its bias once.
def step_job
def result
def run_keepingEvery job in order.
def run_at
def run
def kept_input
def kept_weights
def kept_bias

def runThe live certificate is updated once, outside every output and MAC loop.
type KeptThe tiles, the weights and the bias come back with the output, for a caller that uses them again.
def kept
def run_keeping
def reorder