Compile and run Cerebras SDK programs on a Wafer-Scale Cluster using the Appliance API — covers SdkCompiler, SdkLauncher, job submission, and appliance mode execution.
If True, ignore version differences between appliance client and server.
Example:In the following example, an SdkCompiler object is instantiated
via a context manager.
The SdkCompiler.compile() function takes four arguments:
the directory containing the CSL code files,
the name of the top level CSL code file that contains the layout block,
the compiler arguments,
and the output directory or output file for the compile artifacts.
import jsonfrom cerebras.sdk.client import SdkCompiler# Instantiate compiler using a context managerwith SdkCompiler(disable_version_check=True) as compiler: # Launch compile job artifact_path = compiler.compile( ".", "layout.csl", "--fabric-dims=8,3 --fabric-offsets=4,1 --memcpy --channels=1 -o out", "." ) # Write the artifact_path to a JSON file with open("artifact_path.json", "w", encoding="utf8") as f: json.dump({"artifact_path": artifact_path,}, f)
class cerebras.sdk.client.SdkLauncher(artifact_path: str, **kwargs)
Bases: object
The SdkLauncher API can be used to upload artifacts, run custom commands in
the appliance, and use custom scripts written as if the system was not in
appliance mode and the user were running directly from a worker node.The user must use the %CMADDR% template string to pass the system address
to a run script.
If True, ignore version differences between appliance client and server.
Example:In the following example, an SdkLauncher object is instantiated via a
context manager, with path to compile artifacts given by artifact_path.
launcher.stage transfers an additional file additional_artifact.txt
to the appliance. Next, launcher.run runs a command on the appliance
worker node which writes the contents of that file to stdout.
We then use launcher.run to run a host Python script run.py.
Notice that we specify the system’s CM address passed to this script via
the template string %CMADDR, which will be evaluated at runtime based
on the system allocated to this job. We then use download_artifact
to transfer a file back from the appliance.
import jsonimport osfrom cerebras.sdk.client import SdkLauncher# read the compile artifact_path from the json filewith open("artifact_path.json", "r", encoding="utf8") as f: data = json.load(f) artifact_path = data["artifact_path"]# artifact_path contains the path to the compiled artifact.# It will be transferred and extracted in the appliance.# The extracted directory will be the working directory.# Set simulator=False if running on CS system within appliance.with SdkLauncher(artifact_path, simulator=False, disable_version_check=True) as launcher: # Transfer an additional file to the appliance, # then write contents to stdout on appliance launcher.stage("additional_artifact.txt") response = launcher.run( "echo \"ABOUT TO RUN IN THE APPLIANCE\"", "cat additional_artifact.txt", ) print("Test response: ", response) # Run the original host code as-is on the appliance, # using the same cmd as when using the Singularity container response = launcher.run("cs_python run.py --name out --cmaddr %CMADDR%") print("Host code execution response: ", response) # Fetch files from the appliance launcher.download_artifact("out.txt", "./output_dir/out.txt")
One or more command strings. Use the special placeholder
%CMADDR% wherever a CS system address should be substituted.
All positional arguments must be strings.
class cerebras.sdk.client.SdkRuntime(artifact_path: str, **kwargs)
Bases: object
Manages the execution of SDK programs on the Cerebras Wafer-Scale Cluster
appliance. The constructor analyzes the WSE ELFs in the bindir
and prepares the WSE or simfabric for a run.SdkRuntime must be used via a context manager.
Path to ELF files compiled by SdkCompiler.
The runtime collects the I/O and fabric parameters
automatically, including height, width, number of
channels, width of buffers, etc.
If True, ignore version differences between appliance client and server.
Example:In the following example, an SdkRuntime runner object is instantiated
via a context manager, with path to compile artifacts given by
artifact_path. The compiled kernel code has exported symbols
my_fn, which names a function defined on all PEs in the program, and
A, which points to an array on all PEs. The context manager loads and
starts the program. Then, the function my_fn is launched. After this
function is launched, A on the device is copied back into data
on the host.
import jsonimport osfrom cerebras.sdk.client import SdkRuntime# Read the artifact_path from the JSON filewith open("artifact_path.json", "r", encoding="utf8") as f: data = json.load(f) artifact_path = data["artifact_path"]# Instantiate a runner object using a context manager.# Set simulator=False if running on CS system within appliance.with SdkRuntime(artifact_path, simulator=False, disable_version_check=True) as runner: # Launch my_fn on device runner.launch('my_fn', nonblock=False) # Copy A back from device symbol_A = runner.get_id("A") runner.memcpy_d2h(data, symbol_A, px, py, w, h, l, streaming=False, data_type=memcpy_dtype, order=memcpy_order, nonblock=False)
Like launch, but without type checking on the arguments. The caller passes a list of integer-castable arguments which are packed as uint32 before transfer.
Downloads an artifact from the appliance worker node to the local host. If the artifact is a directory, a tarball of that directory will be created and transferred.
Start program execution on the CS system or simulator. This step also encompasses loading the program. May be called at most once per SdkRuntime object.When using the context-manager form (with SdkRuntime(...) as runner:), start() is invoked implicitly on entry and explicit calls are unnecessary.
Stop program execution. Must follow start(). Pending nonblocking operations are flushed before this call returns, so D2H destination buffers are guaranteed populated after stop() returns.When using the context-manager form, stop() is invoked implicitly on exit; calling it again afterwards is an error.
