Dagger Types

Thunk

Wraps a callable object to be run with Dagger. A Thunk is typically created through a call to delayed or its macro equivalent @par.

Constructors

delayed(f; kwargs...)(args...)
@par [option=value]... f(args...)

Examples

julia> t = delayed(sin)(π)  # creates a Thunk to be computed later
Thunk(sin, (π,))

julia> collect(t)  # computes the result and returns it to the current process
1.2246467991473532e-16

Arguments

• fargs: The function and arguments to be called upon execution of the Thunk.
• kwargs: The properties describing unique behavior of this Thunk. Details

for each property are described in the next section.

• option=value: The same as passing kwargs to delayed.

Options

• options: An Options struct providing the options for the Thunk.

If omitted, options can also be specified by passing key-value pairs as kwargs.

DTask

Returned from Dagger.@spawn/Dagger.spawn calls. Represents a task that is in the scheduler, potentially ready to execute, executing, or finished executing. May be fetch'd or wait'd on at any time. See Dagger.@spawn for more details.

Options

Stores per-task options to be passed to the scheduler.

Arguments

• propagates::Vector{Symbol}: The set of option names that will be propagated by this task to tasks that it spawns.
• processor::Processor: The processor associated with this task's function. Generally ignored by the scheduler.
• compute_scope::AbstractScope: The execution scope of the task, which determines where the task can be scheduled and executed. scope is another name for this option.
• result_scope::AbstractScope: The data scope of the task's result, which determines where the task's result can be accessed from.
• exec_scope::AbstractScope: The execution scope of the task, which determines where the task can be scheduled and executed. Can be set to avoid computing the scope in the scheduler, when known.
• single::Int=0: (Deprecated) Force task onto worker with specified id. 0 disables this option.
• proclist=nothing: (Deprecated) Force task to use one or more processors that are instances/subtypes of a contained type. Alternatively, a function can be supplied, and the function will be called with a processor as the sole argument and should return a Bool result to indicate whether or not to use the given processor. nothing enables all default processors.
• get_result::Bool=false: Whether the worker should store the result directly (true) or as a Chunk (false)
• meta::Bool=false: When true, values are not moved, and are passed directly as Chunk, if they are not immediate values
• syncdeps::Set{Any}: Contains any additional tasks to synchronize with
• time_util::Dict{Type,Any}: Indicates the maximum expected time utilization for this task. Each keypair maps a processor type to the utilization, where the value can be a real (approximately the number of nanoseconds taken), or MaxUtilization() (utilizes all processors of this type). By default, the scheduler assumes that this task only uses one processor.
• alloc_util::Dict{Type,UInt64}: Indicates the maximum expected memory utilization for this task. Each keypair maps a processor type to the utilization, where the value is an integer representing approximately the maximum number of bytes allocated at any one time.
• occupancy::Dict{Type,Real}: Indicates the maximum expected processor occupancy for this task. Each keypair maps a processor type to the utilization, where the value can be a real between 0 and 1 (the occupancy ratio, where 1 is full occupancy). By default, the scheduler assumes that this task has full occupancy.
• checkpoint=nothing: If not nothing, uses the provided function to save the result of the task to persistent storage, for later retrieval by restore.
• restore=nothing: If not nothing, uses the provided function to return the (cached) result of this task, were it to execute. If this returns a Chunk, this task will be skipped, and its result will be set to the Chunk. If nothing is returned, restoring is skipped, and the task will execute as usual. If this function throws an error, restoring will be skipped, and the error will be displayed.
• storage::Union{Chunk,Nothing}=nothing: If not nothing, references a MemPool.StorageDevice which will be passed to MemPool.poolset internally when constructing Chunks (such as when constructing the return value). The device must support MemPool.CPURAMResource. When nothing, uses MemPool.GLOBAL_DEVICE[].
• storage_root_tag::Any=nothing: If not nothing, specifies the MemPool storage leaf tag to associate with the task's result. This tag can be used by MemPool's storage devices to manipulate their behavior, such as the file name used to store data on disk."
• storage_leaf_tag::Union{MemPool.Tag,Nothing}=nothing: If not nothing, specifies the MemPool storage leaf tag to associate with the task's result. This tag can be used by MemPool's storage devices to manipulate their behavior, such as the file name used to store data on disk."
• storage_retain::Union{Bool,Nothing}=nothing: The value of retain to pass to MemPool.poolset when constructing the result Chunk. nothing defaults to false.
• name::Union{String,Nothing}=nothing: If not nothing, annotates the task with a name for logging purposes.
• stream_input_buffer_amount::Union{Int,Nothing}=nothing: (Streaming only) Specifies the amount of slots to allocate for the input buffer of the task. Defaults to 1.
• stream_output_buffer_amount::Union{Int,Nothing}=nothing: (Streaming only) Specifies the amount of slots to allocate for the output buffer of the task. Defaults to 1.
• stream_buffer_type::Union{Type,Nothing}=nothing: (Streaming only) Specifies the type of buffer to use for the input and output buffers of the task. Defaults to Dagger.ProcessRingBuffer.
• stream_max_evals::Union{Int,Nothing}=nothing: (Streaming only) Specifies the maximum number of times the task will be evaluated before returning a result. Defaults to infinite evaluations.

SchedulerOptions

Stores DAG-global options to be passed to the Dagger.Sch scheduler.

Arguments

• single::Int=0: (Deprecated) Force all work onto worker with specified id. 0 disables this option.
• proclist=nothing: (Deprecated) Force scheduler to use one or more processors that are instances/subtypes of a contained type. Alternatively, a function can be supplied, and the function will be called with a processor as the sole argument and should return a Bool result to indicate whether or not to use the given processor. nothing enables all default processors.
• allow_errors::Bool=false: Allow thunks to error without affecting non-dependent thunks.
• checkpoint=nothing: If not nothing, uses the provided function to save the final result of the current scheduler invocation to persistent storage, for later retrieval by restore.
• restore=nothing: If not nothing, uses the provided function to return the (cached) final result of the current scheduler invocation, were it to execute. If this returns a Chunk, all thunks will be skipped, and the Chunk will be returned. If nothing is returned, restoring is skipped, and the scheduler will execute as usual. If this function throws an error, restoring will be skipped, and the error will be displayed.

Chunk

A reference to a piece of data located on a remote worker. Chunks are typically created with Dagger.tochunk(data), and the data can then be accessed from any worker with collect(::Chunk). Chunks are serialization-safe, and use distributed refcounting (provided by MemPool.DRef) to ensure that the data referenced by a Chunk won't be GC'd, as long as a reference exists on some worker.

Each Chunk is associated with a given Dagger.Processor, which is (in a sense) the processor that "owns" or contains the data. Calling collect(::Chunk) will perform data movement and conversions defined by that processor to safely serialize the data to the calling worker.

Constructors

See tochunk.

Maps a value to one of multiple distributed "mirror" values automatically when used as a thunk argument. Construct using @shard or shard.

Specifies a read-only dependency.

Specifies a write-only dependency.

Specifies a read-write dependency.

Specifies one or more dependencies.

Processor

An abstract type representing a processing device and associated memory, where data can be stored and operated on. Subtypes should be immutable, and instances should compare equal if they represent the same logical processing device/memory. Subtype instances should be serializable between different nodes. Subtype instances may contain a "parent" Processor to make it easy to transfer data to/from other types of Processor at runtime.

OSProc <: Processor

Julia CPU (OS) process, identified by Distributed pid. The logical parent of all processors on a given node, but otherwise does not participate in computations.

ThreadProc <: Processor

Julia CPU (OS) thread, identified by Julia thread ID.

Widest scope that contains all processors.

Scoped to the same physical node.

Scoped to the same OS process.

Scoped to any processor with a given supertype.

Taints a scope for later evaluation.

Union of two or more scopes.

Scoped to a specific processor.

Context(xs::Vector{OSProc}) -> Context
Context(xs::Vector{Int}) -> Context

Create a Context, by default adding each available worker.

It is also possible to create a Context from a vector of OSProc, or equivalently the underlying process ids can also be passed directly as a Vector{Int}.

Special fields include:

• 'log_sink': A log sink object to use, if any.
• profile::Bool: Whether or not to perform profiling with Profile stdlib.

DArray{T,N,F}(domain, subdomains, chunks, concat)
DArray(T, domain, subdomains, chunks, [concat=cat])

An N-dimensional distributed array of element type T, with a concatenation function of type F.

Arguments

• T: element type
• domain::ArrayDomain{N}: the whole ArrayDomain of the array
• subdomains::AbstractArray{ArrayDomain{N}, N}: a DomainBlocks of the same dimensions as the array
• chunks::AbstractArray{Union{Chunk,Thunk}, N}: an array of chunks of dimension N
• concat::F: a function of type F. concat(x, y; dims=d) takes two chunks x and y and concatenates them along dimension d. cat is used by default.

Blocks(xs...)

Indicates the size of an array operation, specified as xs, whose length indicates the number of dimensions in the resulting array.

ArrayDomain{N}

An N-dimensional domain over an array.

UnitDomain

Default domain – has no information about the value

BytesAllocd

Tracks memory allocated for Chunks.

ProcessorSaturation

Tracks the compute saturation (running tasks) per-processor.

WorkerSaturation

Tracks the compute saturation (running tasks).