Execution Cores

The Signaloid Cloud Compute Engine provides you access to cloud instances of the Signaloid C0 processor cores. We refer to these instances as Execution Cores. Your Signaloid Cloud account gives you access to default Execution Cores with varying performance and accuracy characteristics. Most cores are implementations of Signaloid's patented distribution-extended architectures. Cores with the Bypass microarchitecture and cores of the r7i class run your application without distribution arithmetic. See the core types section for more information on the different core types.

Use these Cores to run your programs and leverage Signaloid distribution arithmetic. Create your own custom cores with your own custom configurations optimized for the performance and accuracy requirements of your applications. See the Create new Core section for more information on creating custom cores.

Access to the Compute Engine API is linked to your Signaloid Cloud account. You can view the Cores you have access to and create your own custom cores with custom configurations from the Developer Platform. See the Developer Platform Documentation for information on how to interact with Execution Cores using the Signaloid Cloud Developer Platform.

C0 processor Cores

Each Signaloid C0 Core has the following configurable parameters:

Class
Microarchitecture
Representation Precision
Dependency Tracking

The Signaloid Cloud Compute Engine sets each core's memory size from its class.

Core classes

C0Pro: Cloud cores with a double-precision underlying representation.
C0-microSD, C0-microSD-plus, C0-SD: Cores whose builds run on the matching Signaloid Compute Module. Their builds cannot run as tasks in the cloud. Download the build binary and run it on the module instead.
r7i: Native cores. They build your application with a stock host toolchain and run it without distribution arithmetic. Their builds cannot discover or trace variables, and their tasks produce no Ux values.

The retired C0 class is no longer accepted when you create or update a core. Cores that still have it can be read and used for builds. To keep editing such a core, update it with a new Class, for example C0Pro.

Each core has a unique identifier (CoreID) and a name. The CoreID uniquely identifies the core when making API calls. The name visually identifies the core when using the Signaloid Cloud Developer Platform. The core name is mutable in custom Cores.

Core microarchitectures

The Core's microarchitecture affects how the core performs distribution arithmetic, along with its performance and accuracy characteristics. Currently the Signaloid Cloud Compute Engine supports execution cores with the following C0 processor microarchitecture variants:

Athens: Basic distribution arithmetic.
Rome: Basic distribution arithmetic.
Jupiter: Advanced distribution arithmetic. The C0Pro-Jupiter-S default core uses this microarchitecture.
Mercury: Advanced distribution arithmetic, configured like Jupiter. The C0Pro-Mercury-S default core uses this microarchitecture.
Europa: Advanced distribution arithmetic, configured like Jupiter. The C0Pro-Europa-S default core uses this microarchitecture.
Bypass: Bypasses distribution arithmetic.
Reference: Higher execution time but providing distribution arithmetic that is on-par with performing a brute-force Monte Carlo simulation.
Native: No distribution arithmetic. Valid only with the r7i class.

Not every microarchitecture is available for every core class:

Class	Microarchitectures
`C0Pro`	`Athens`, `Rome`, `Jupiter`, `Mercury`, `Europa`, `Bypass`, `Reference`
`C0-microSD`, `C0-microSD-plus`, `C0-SD`	`Athens`, `Rome`, `Bypass`
`r7i`	`Native`

Requesting an unsupported combination returns 400 Bad Request. Which classes and microarchitectures your account may use depends on your subscription tier. The Free tier does not include Mercury or Europa, so creating, building with, or connecting a repository to a core that uses either returns 403 Forbidden on that tier.

Athens microarchitecture

The Athens microarchitecture provides enhanced distribution arithmetic underneath a standard RISC-V instruction set architecture. Athens uses an improved distribution representation that is able to adapt to low-probability events and distributions with long tails.

Bypass microarchitecture

The Bypass microarchitecture allows you to test basic usage of an application without distribution arithmetic. Use this microarchitecture when initially getting your application ported to the Signaloid Cloud Compute Engine to ensure the application compiles correctly and behaves as expected (without distribution arithmetic). Afterwards we recommend looking at the microarchitectures that perform distribution arithmetic to understand how input distributions affect your application.

Reference microarchitecture

The Reference microarchitecture provides reference-quality distribution arithmetic underneath a standard RISC-V instruction set architecture. Reference yields results with identical quality to manually creating a Monte Carlo simulation of your application. The Reference microarchitecture allows you to get these benefits without making any code changes to your application.

Representation precision

For Athens, Rome, Jupiter, Mercury, and Europa cores, the representation precision determines the performance and accuracy characteristics of the core. The higher the precision, the more accurate the distribution arithmetic of the core will be, but with potentially slower application execution. The cores can be configured to have a representation precision that is a power of two between 4 and 8,192.

For Reference cores, the precision determines Reference Quality Level. This is equivalent to the number of Monte Carlo re-executions of your application that the microarchitecture will run for distribution arithmetic. The Signaloid Cloud Compute Engine currently supports Reference Cores with a Reference Quality Level between 4 and 1,000,000. As with Monte Carlo simulation, the higher the Reference Quality Level, the more accurate the distribution arithmetic of the core will be and slower the application execution will be.

Bypass cores ignore this parameter, and cores of the r7i class do not perform distribution arithmetic, so both always have a precision of 0. Leave Precision out when you create or update such a core, or set it to 0. Any other value returns 400 Bad Request. The Microarchitectures list returned by the user endpoint reports this fixed value as FixedPrecision.

Your subscription tier sets the upper limits that apply to your account. The Allowance object returned by the user endpoint reports them as MaxPrecisionBits and MaxReferenceQuality. A value above your tier's limit that a higher tier supports returns 403 Forbidden.

Single-precision and double-precision representations

Separately from the representation precision above, which sets how many Dirac deltas a representation stores, each core stores distributions in either a single-precision or a double-precision floating-point underlying data type. Cores in the C0Pro class use a double-precision underlying representation. Cores in the C0-microSD, C0-microSD-plus, and C0-SD classes use a single-precision one. This changes the size of the Ux data that a task returns. See Single-Precision and Double-Precision Representations.

Memory size

The MemorySize of a core is the amount of memory, in bytes, allocated to the core at runtime. The Signaloid Cloud Compute Engine sets it according to the core class, and ignores any MemorySize you send when you create or update a core.

Dependency tracking

The dependency tracking parameter specifies how the core tracks dependencies between distributional values. Depending on the application, this affects the accuracy of distribution arithmetic. The Signaloid Cloud Compute Engine supports three modes:

None: No dependency tracking. The core treats all distributional variables as independent.
Basic: Tracks dependencies using a runtime heuristic. This is the setting of the plus (+) default Cores (for example, C0Pro-S+, C0Pro-M+, and C0Pro-L+).
Advanced: Tracks all dependencies at runtime.

Each microarchitecture accepts only some modes:

Microarchitecture	Dependency tracking
`Athens`, `Rome`	`None` or `Basic`
`Jupiter`, `Mercury`, `Europa`	`Advanced`
`Bypass`, `Reference`, `Native`	`None`

Any other pairing returns 400 Bad Request. Bypass cores and cores of the r7i class may leave DependencyTracking out, and the API sets it to None. Choosing Basic yields better distribution arithmetic accuracy for applications with highly correlated random variables. In most cases, it also increases the speed of the application.

DependencyTracking replaces the older CorrelationTracking parameter, and the API refuses CorrelationTracking in requests. Basic was formerly Autocorrelation, and None was formerly Disable. Cores created before the rename may still report only CorrelationTracking until you update them with a DependencyTracking mode.

The `Core` API object

The Core object represents the properties of a configured Execution Core. The code snippet below shows the structure of the Core object:

TypeScript

type Core = {
  Object: "Core";
  CoreID: string;
  Owner: string;
  Name: string;
  Class: "C0Pro" | "r7i" | "C0-microSD" | "C0-microSD-plus" | "C0-SD" | "C0";
  Precision: number;
  MemorySize: number;
  Microarchitecture: "Athens" | "Rome" | "Jupiter" | "Mercury" | "Europa" | "Bypass" | "Reference" | "Native";
  DependencyTracking?: "None" | "Basic" | "Advanced";
  /** Only on cores created before DependencyTracking replaced it. */
  CorrelationTracking?: "Disable" | "Autocorrelation";
  CreatedAt: number;
  UpdatedAt: number;
}

See below the C0Pro-L+ core (one of the default cores) as JSON. The Compute Engine API returns * as the owner as this core is accessible (read-only) to all Signaloid Cloud accounts.

{
  "Object": "Core",
  "CoreID": "cor_ede121cb700a5dee8adacbdd5ae492b3",
  "Name": "C0Pro-L+",
  "Class": "C0Pro",
  "Owner": "*",
  "Precision": 256,
  "MemorySize": 8192000000,
  "Microarchitecture": "Athens",
  "DependencyTracking": "Basic",
  "CreatedAt": 1683643245,
  "UpdatedAt": 1683643245
}

Default Cores

All Signaloid Cloud accounts have access to default execution cores with pre-specified performance and accuracy characteristics. In addition, you can create custom cores in the C0Pro, r7i, C0-microSD, C0-microSD-plus and C0-SD classes to match your application's needs. The default cores are listed below:

Name	Class	Microarchitecture	Precision	MemorySize	DependencyTracking
C0Pro-XS	C0Pro	Athens	32	8192000000	None
C0Pro-XS+	C0Pro	Athens	32	8192000000	Basic
C0Pro-S	C0Pro	Athens	64	8192000000	None
C0Pro-S+	C0Pro	Athens	64	8192000000	Basic
C0Pro-M	C0Pro	Athens	128	8192000000	None
C0Pro-M+	C0Pro	Athens	128	8192000000	Basic
C0Pro-L	C0Pro	Athens	256	8192000000	None
C0Pro-L+	C0Pro	Athens	256	8192000000	Basic
C0Pro-XL	C0Pro	Athens	512	8192000000	None
C0Pro-XL+	C0Pro	Athens	512	8192000000	Basic
C0Pro-Bypass	C0Pro	Bypass	0	8192000000	None
C0Pro-Reference	C0Pro	Reference	32	8192000000	None
C0Pro-Jupiter-S	C0Pro	Jupiter	64	8192000000	Advanced
C0Pro-Mercury-S	C0Pro	Mercury	64	8192000000	Advanced
C0Pro-Europa-S	C0Pro	Europa	64	8192000000	Advanced
C0-microSD-N	C0-microSD	Athens	8	131072	None
C0-microSD-N+	C0-microSD	Athens	8	131072	Basic
C0-microSD-XS	C0-microSD	Athens	32	131072	None
C0-microSD-XS+	C0-microSD	Athens	32	131072	Basic

Default Core Objects

{
  "Cores": [
    {
      "Object": "Core",
      "Name": "C0Pro-XS",
      "CoreID": "cor_f7644f0976495958afd3926f5d91fa0b",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 32,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-XS+",
      "CoreID": "cor_3107e0d7e3b65455ae90b7b2976235ea",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 32,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-S",
      "CoreID": "cor_748bc0ffd0855ada8bc2da70014dd749",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 64,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-S+",
      "CoreID": "cor_e7eec4dce06f5a03a1b5418e0c5cbd7e",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 64,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-M",
      "CoreID": "cor_9864a3b49f17503094e04b418af40ef0",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 128,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-M+",
      "CoreID": "cor_b852539c8ffd5a40a2688a0b29e344b5",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 128,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-L",
      "CoreID": "cor_5a7849305bdb5be5a8f34e1aa45f8bc5",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 256,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-L+",
      "CoreID": "cor_ede121cb700a5dee8adacbdd5ae492b3",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 256,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-XL",
      "CoreID": "cor_6ba7d14f76635a85bfd757e084433afc",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 512,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-XL+",
      "CoreID": "cor_7354fce65c415e639bd3bb60f48fd9a5",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 512,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-Bypass",
      "CoreID": "cor_27e6f27f74215d4b887400adc9d4f7bd",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Bypass",
      "DependencyTracking": "None",
      "Precision": 0,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-Reference",
      "CoreID": "cor_f8e4d85980b458bda1542f7a1067ebcc",
      "UpdatedAt": 1683643245,
      "CreatedAt": 1683643245,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Reference",
      "DependencyTracking": "None",
      "Precision": 32,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0Pro-Jupiter-S",
      "CoreID": "cor_3594398692215796bd14a61b49c0380c",
      "UpdatedAt": 1703273407,
      "CreatedAt": 1703273407,
      "Owner": "*",
      "Class": "C0Pro",
      "Microarchitecture": "Jupiter",
      "DependencyTracking": "Advanced",
      "Precision": 64,
      "MemorySize": 8192000000
    },
    {
      "Object": "Core",
      "Name": "C0-microSD-N",
      "CoreID": "cor_271d544c73a8544d9026252652342972",
      "UpdatedAt": 1704988800,
      "CreatedAt": 1704988800,
      "Owner": "*",
      "Class": "C0-microSD",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 8,
      "MemorySize": 131072
    },
    {
      "Object": "Core",
      "Name": "C0-microSD-N+",
      "CoreID": "cor_c1cde893b0d75bb6a8941e9caf90f2a6",
      "UpdatedAt": 1704988800,
      "CreatedAt": 1704988800,
      "Owner": "*",
      "Class": "C0-microSD",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 8,
      "MemorySize": 131072
    },
    {
      "Object": "Core",
      "Name": "C0-microSD-XS",
      "CoreID": "cor_808bbbb9932c5d29a58370a1ec9a859f",
      "UpdatedAt": 1704988800,
      "CreatedAt": 1704988800,
      "Owner": "*",
      "Class": "C0-microSD",
      "Microarchitecture": "Athens",
      "DependencyTracking": "None",
      "Precision": 32,
      "MemorySize": 131072
    },
    {
      "Object": "Core",
      "Name": "C0-microSD-XS+",
      "CoreID": "cor_3d8dfc5d4f305e16b867716fe6aba1e9",
      "UpdatedAt": 1704988800,
      "CreatedAt": 1704988800,
      "Owner": "*",
      "Class": "C0-microSD",
      "Microarchitecture": "Athens",
      "DependencyTracking": "Basic",
      "Precision": 32,
      "MemorySize": 131072
    }
  ]
}

The Cores API endpoints

The Cores API endpoints allow you to programmatically manage the Execution Cores available to your Signaloid Cloud account. The endpoint supports the following operations:

List available Cores
Get a Core by ID
Create a new custom Core
Modify a Core
Delete a Core

See the Cores API Reference for more details on the Cores API endpoints.

List Cores

You can list the custom cores associated with your Signaloid Cloud account by sending a HTTP GET request to /cores. The JSON response contains the Core objects for your custom Cores. Below are code snippets showing how to list the cores using different programming languages:

TypeScript
cURL

// API token generated from signaloid.io/settings/api
const apiToken = process.env.SIGNALOID_KEY || "scce_yourSignaloidCloudApiKey";
const baseUrl = process.env.SIGNALOID_URL || "https://api.signaloid.io";

// Setup HTTP client
const axios = require("axios");
const signaloidClient = axios.create({
  baseURL: baseUrl,
});

// Setup request headers
signaloidClient.defaults.headers["Authorization"] = `${apiToken}`;
signaloidClient.defaults.headers["Content-Type"] = "application/json";

console.log("Submitting the List cores request to the API...");
let getCoresListResponse;
try {
  getCoresListResponse = await signaloidClient.get("/cores");

  if (getCoresListResponse?.data) {
    console.log(`... fetched details of ${getCoresListResponse.data?.Cores?.length} cores`);
    console.log(JSON.stringify(getCoresListResponse.data, null, 2));
  }
} catch (error) {
  console.log("Error :>> ", error);
}

If the request is successful, response.data will contain the list of cores.

# API key generated from signaloid.io/settings/api
# signaloidAPIKey="scce_yourSignaloidCloudApiKey"

# The following call to the Signaloid API lists the custom cores of your account.
curl -sS --request GET --location 'https://api.signaloid.io/cores' \
  --header "Authorization: $signaloidAPIKey"

The code snippet below shows an example response from the API:

{
  "UserID": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Cores": [
    {
      "Object": "Core",
      "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
      "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
      "Name": "Example Core",
      "Class": "C0Pro",
      "Precision": 4,
      "Microarchitecture": "Athens",
      "MemorySize": 256000000,
      "DependencyTracking": "Basic",
      "CreatedAt": 0,
      "UpdatedAt": 0
    }
  ],
  "Count": 1,
  "Pagination": {
    "Limit": 100,
    "Links": {
      "First": { "Href": "https://api.signaloid.io/cores?limit=100" }
    }
  }
}

If you do not have any Cores, the Cores key of the response will be an empty array. The Count key will contain the number of cores in the response.

Note

The GET /cores request returns custom execution cores. To retrieve the default Cores available to all accounts you need to add the default query parameter: GET /cores?default.

The list is paginated, with 100 Cores per page by default. Follow Pagination.Links.Next until it is absent, as the Pagination section of the API Reference describes.

Get Core by ID

Note

For brevity, this and the following code examples do not include the setup of the Axios client (for TypeScript) or of the signaloidAPIKey shell variable holding the API key (for cURL). See above for an example.

If you require details of a specific core, you can use the /cores/{coreID} endpoint to get the details of a core by its ID. The response will be a JSON object containing the details of the core if it exists and your account has permission to access its details. Below are code snippets showing how to list the cores using different programming languages:

Note

As with /cores, if you require the details of a default core, you need to pass in default as a query parameter, i.e., /cores/<coreID>?default.

TypeScript
cURL

console.log(`Fetching details of core ${coreId} from the API...`);
let getCoreByIDResponse;
try {
  getCoreByIDResponse = await signaloidClient.get(`/cores/${coreId}`);

  if (getCoreByIDResponse?.data) {
    console.log(`... fetched details of the core ${getCoreByIDResponse.data.CoreID}`);
    console.log(JSON.stringify(getCoreByIDResponse.data, null, 2));
  }
} catch (error) {
  console.log("Error :>> ", error);
}

If the request is successful, response.data will contain the core details.

# Unique identifier of the core to fetch
# coreID="cor_58c1fb8a09a5b603c2afb21e4de99271"

# The following call to the Signaloid API gets back the details of the core with ID coreID.
curl -sS --request GET --location "https://api.signaloid.io/cores/$coreID" \
  --header "Authorization: $signaloidAPIKey"

The code snippet below shows an example response from the API:

{
  "Object": "Core",
  "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
  "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Name": "Example Core",
  "Class": "C0Pro",
  "Precision": 4,
  "Microarchitecture": "Athens",
  "MemorySize": 256000000,
  "DependencyTracking": "Basic",
  "CreatedAt": 0,
  "UpdatedAt": 0
}

Create new Core

To create a custom core, you should send a POST request to /cores with the details of the core in the request body. If the request was successful, the response will contain a JSON object containing the details of the newly created core.

TypeScript
cURL

const coreConfig = {
  Name: "My Athens core",
  Class: "C0Pro",
  Precision: 64,
  Microarchitecture: "Athens",
  DependencyTracking: "Basic",
};

console.log(`Creating a new core with the API...`);
let createCoreResponse;
try {
  createCoreResponse = await signaloidClient.post(`/cores/`, coreConfig);

  if (createCoreResponse?.data?.CoreID) {
    console.log(`... created a new core with ID ${createCoreResponse.data.CoreID}`);
    console.log(JSON.stringify(createCoreResponse.data, null, 2));
  }
} catch (error) {
  console.log("Error :>> ", error);
}

# Configuration of the new core
coreConfig='{
  "Name": "My Athens core",
  "Class": "C0Pro",
  "Precision": 64,
  "Microarchitecture": "Athens",
  "DependencyTracking": "Basic"
}'

# The following call to the Signaloid API creates a new core with details specified by coreConfig.
createCoreResponse=$(curl -s --request POST --location 'https://api.signaloid.io/cores' \
  --header "Content-Type: application/json" \
  --header "Authorization: $signaloidAPIKey" \
  --data "$coreConfig")

# Unique identifier of the newly created core
coreID=$(echo $createCoreResponse | jq -r '.CoreID')
if [ ! "$coreID" == "null" ]
then
  echo "Created a new core with ID: "$coreID
else
  message=$(echo $createCoreResponse | jq -r '.message')
  echo "Exiting because core creation failed with message: \""$message"\""
  exit 1
fi

The code snippet below shows an example response from the API:

{
  "Object": "Core",
  "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
  "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Name": "My Athens core",
  "Class": "C0Pro",
  "Precision": 64,
  "Microarchitecture": "Athens",
  "MemorySize": 256000,
  "DependencyTracking": "Basic",
  "CreatedAt": 0,
  "UpdatedAt": 0
}

Modify Core

If you need to change any of the properties of a core, you can send a PATCH request to /cores/{coreID} with the new details of the core in the request body. This method is useful for updating the core of a specific CoreID without having to edit integrations that use this core. The request must change at least one of the editable core properties for the API to accept it. If the request was successful, the API will respond with a HTTP 200 OK response.

TypeScript
cURL

const newCoreConfig = {
  Name: "My updated Athens core",
  Class: "C0Pro",
  Precision: 128, // Changed from 64
  Microarchitecture: "Athens",
  DependencyTracking: "None", // Changed from "Basic"
};

console.log(`Modifying the core with ID ${coreId} through the API...`);
let modifyCoreResponse;
try {
  modifyCoreResponse = await signaloidClient.patch(`/cores/${coreId}`, newCoreConfig);

  if (modifyCoreResponse.status === 200) {
    console.log(`Modified Core with ID ${coreId}`);
    console.log(JSON.stringify(modifyCoreResponse.data, null, 2));
  }
} catch (error) {
  console.log("Error :>> ", error);
}

# Unique identifier of the core to modify
# coreID="cor_58c1fb8a09a5b603c2afb21e4de99271"

newCoreConfig='{
  "Name": "My updated Athens code",
  "Class": "C0Pro",
  "Precision": 128,
  "Microarchitecture": "Athens",
  "DependencyTracking": "None"
}'

# The following call to the Signaloid API modifies the core with ID coreID
# using the details specified by newCoreConfig.
curl -sS --request PATCH --location "https://api.signaloid.io/cores/$coreID" \
  --header "Content-Type: application/json" \
  --header "Authorization: $signaloidAPIKey" \
  --data "$newCoreConfig"

The code snippet below shows an example response from the API:

{
  "message": "OK"
}

Delete Core

Finally, if you need to delete a core you can send a DELETE request to /cores/{coreID}. This method is useful for deleting a core that is no longer needed. If the request was successful, the API will respond with a HTTP 200 OK response.

TypeScript
cURL

console.log(`Deleting the core with ID ${coreId} through the API...`);
let deleteCoreResponse;
try {
  deleteCoreResponse = await signaloidClient.delete(`/cores/${coreId}`);

  if (deleteCoreResponse.status === 200) {
    console.log(`Deleted Core with ID ${coreId}`);
    console.log(JSON.stringify(deleteCoreResponse.data, null, 2));
  }
} catch (error) {
  console.log("Error :>> ", error);
}

# Unique identifier of the core to delete
# coreID="cor_58c1fb8a09a5b603c2afb21e4de99271"

# The following call to the Signaloid API deletes the core with ID coreID.
curl -sS --request DELETE --location "https://api.signaloid.io/cores/$coreID" \
  --header "Authorization: $signaloidAPIKey"

The code snippet below shows an example response from the API:

{
  "message": "OK"
}

C0 processor Cores​

Core classes​

Core microarchitectures​

Athens microarchitecture​

Bypass microarchitecture​

Reference microarchitecture​

Representation precision​

Single-precision and double-precision representations​

Memory size​

Dependency tracking​

The Core API object​

Default Cores​

The Cores API endpoints​

List Cores​

Get Core by ID​

Create new Core​

Modify Core​

Delete Core​

C0 processor Cores

Core classes

Core microarchitectures

Athens microarchitecture

Bypass microarchitecture

Reference microarchitecture

Representation precision

Single-precision and double-precision representations

Memory size

Dependency tracking

The `Core` API object

Default Cores

The Cores API endpoints

List Cores

Get Core by ID

Create new Core

Modify Core

Delete Core