Skip to main content

Execution Cores

The Signaloid Cloud Compute Engine provides you access to cloud instances of the Signaloid C0 processor instances. 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. All cores, except two, are implementations of Signaloid's patented uncertainty tracking architectures. Please refer to the core types section for more information on the different core types.

Use these Cores to run your programs and leverage Signaloid uncertainty tracking. Create your own custom cores with your own custom configurations optimised for the performance and accuracy requirements of your applications. Please refer to the Create new Core section for more information on creating custom cores.

tip

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:

  • Microarchitecture
  • Representation Precision
  • Memory Size
  • Correlation Tracking

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 the uncertainty tracking functionality of the core along with its performance and accuracy characteristics. Currently the Signaloid Cloud Compute Engine supports execution cores with the following C0 processor microarchitecture variants:

  • Zurich: Basic uncertainty tracking.
  • Athens: Enhanced uncertainty tracking. (Recommended.)
  • Bypass: No uncertainty tracking; acts as a conventional microarchitecture.
  • Reference: Higher execution time but providing uncertainty tracking that is on-par with performing a brute-force Monte Carlo simulation.

Zurich microarchitecture​

The Zurich microarchitecture provides basic uncertainty tracking underneath a standard RISC-V instruction set architecture.

Athens microarchitecture​

The Athens microarchitecture provides enhanced uncertainty tracking underneath a standard RISC-V instruction set architecture. Athens uses an improved uncertainty 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 uncertainty tracking. 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 uncertainty tracking). Afterwards we recommend looking at the uncertainty-tracking microarchitectures to understand uncertainty affects your application.

Reference microarchitecture​

The Reference microarchitecture provides reference-quality uncertainty tracking 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 and Zurich cores, the representation precision determines the performance and accuracy characteristics of the core: the higher the precision, the more accurate the uncertainty tracking performance of the core will be, but with potentially slower application execution. The cores can be configured to have a representation precision between 4 and 8,000.

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

For Bypass cores this parameter is ignored.

Memory Size​

The memory size parameter determines the amount of memory allocated to the core during runtime. For applications with large data sets, you can increase the memory allocation to allow your applications to run without exhausting the memory available. The cores can be configured to have a memory allocation between 256 KB and 2 GB.

Correlation Tracking​

The correlation tracking parameter specifies the mechanism the core uses to track correlations between application variables. Depending on the application, this affects the accuracy of uncertainty tracking. The Signaloid Cloud Compute Engine supports two (2) types of correlation tracking:

  • Disabled: This disables correlation tracking and treats all distributional variables as independent.
  • Autocorrelation: This enables autocorrelation tracking. This is the default setting for the plus (+) default Cores (e.g., C0-S+, C0-M+, and C0-L+).

Choosing Autocorrelation will yield better uncertainty tracking accuracy for applications with highly-correlated random variables. In most cases, it also increases the speed of the application.

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:

type Core = {
    Object: "Core";
    CoreID: string;
    Owner: string;
    Name: string;
    Class: "C0";
    Precision: number;
    MemorySize: number;
    Microarchitecture: "Athens"| "Zurich" | "disable" | "Reference";
    CorrelationTracking: "Disable"|"Autocorrelation";
    CreatedAt: number;
    UpdatedAt: number;
}

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

    {
        "Object": "Core",
        "CoreID": "cor_0fd46f4b888d548f8cddabb1b04e5c4a",
        "Name": "C0-L+",
        "Class": "C0",
        "Owner": "*",
        "Precision": 256,
        "MemorySize": 512000000,
        "Microarchitecture": "Athens",
        "CorrelationTracking": "Autocorrelation",
        "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 C0 cores to match your application's needs. The default cores are listed below:

NameClassMicroarchitecturePrecisionMemorySizeCorrelationTracking
C0-XSC0Athens3264000000Disable
C0-XS+C0Athens3264000000Autocorrelation
C0-SC0Athens6464000000Disable
C0-S+C0Athens6464000000Autocorrelation
C0-MC0Athens128256000000Disable
C0-M+C0Athens128256000000Autocorrelation
C0-LC0Athens256512000000Disable
C0-L+C0Athens256512000000Autocorrelation
C0-XLC0Athens5121024000000Disable
C0-XL+C0Athens5121024000000Autocorrelation
C0-BypassC0BypassN/A64000000N/A (Disable)
C0-ReferenceC0Reference3264000000N/A (Disable)
Default Core Objects
{
    "Cores": [
        {
            "Object": "Core",
            "Name": "C0-XS",
            "CoreID": "cor_e24163f7762754e1b405fb039b2fda56",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Disable",
            "Precision": 32,
            "MemorySize": 64000000
        },
        {
            "Object": "Core",
            "Name": "C0-XS+",
            "CoreID": "cor_84a2b23fe9f75183853f8dc20c529a92",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Autocorrelation",
            "Precision": 32,
            "MemorySize": 64000000
        },
        {
            "Object": "Core",
            "Name": "C0-S",
            "CoreID": "cor_0d65d1e8f57459079c0a036a3e09ae1d",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Disable",
            "Precision": 64,
            "MemorySize": 64000000
        },
        {
            "Object": "Core",
            "Name": "C0-S+",
            "CoreID": "cor_b21e4de9927158c1a5b603c2affb8a09",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Autocorrelation",
            "Precision": 64,
            "MemorySize": 64000000
        },
        {
            "Object": "Core",
            "Name": "C0-M",
            "CoreID": "cor_d5067addfe3d5794a6f6a5f802fd07c8",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Disable",
            "Precision": 128,
            "MemorySize": 256000000
        },
        {
            "Object": "Core",
            "Name": "C0-M+",
            "CoreID": "cor_1d2f4596735d58118fa52478d2a22465",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Autocorrelation",
            "Precision": 128,
            "MemorySize": 256000000
        },
        {
            "Object": "Core",
            "Name": "C0-L",
            "CoreID": "cor_9e4969d93ba45e318c9fb9738164e772",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Disable",
            "Precision": 256,
            "MemorySize": 512000000
        },
        {
            "Object": "Core",
            "Name": "C0-L+",
            "CoreID": "cor_0fd46f4b888d548f8cddabb1b04e5c4a",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Autocorrelation",
            "Precision": 256,
            "MemorySize": 512000000
        },
        {
            "Object": "Core",
            "Name": "C0-XL",
            "CoreID": "cor_06a895c415eb59acb7cee47904585d51",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Disable",
            "Precision": 512,
            "MemorySize": 1024000000
        },
        {
            "Object": "Core",
            "Name": "C0-XL+",
            "CoreID": "cor_d9e740d047aa5161be576d4d138bcaf7",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Athens",
            "CorrelationTracking": "Autocorrelation",
            "Precision": 512,
            "MemorySize": 1024000000
        },
        {
            "Object": "Core",
            "Name": "C0-Reference",
            "CoreID": "cor_9a3efb0094405df5aeb61cf1f29606a0",
            "UpdatedAt": 1683643245,
            "CreatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Reference",
            "CorrelationTracking": "Disable",
            "Precision": 32,
            "MemorySize": 64000000
        },
        {
            "Object": "Core",
            "Name": "C0-Bypass",
            "CoreID": "cor_18bbadd3f79b5ba1b28821d7c4703711",
            "CreatedAt": 1683643245,
            "UpdatedAt": 1683643245,
            "Owner": "*",
            "Class": "C0",
            "Microarchitecture": "Bypass",
            "CorrelationTracking": "Disable",
            "MemorySize": 64000000
        }
    ]
}

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:

Refer to 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:

  // API token generated from signaloid.io/settings/api
  const apiToken = "scce_yourSignaloidCloudApiKey";

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

  // 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); // [TODO]: handle errors
  }

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

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": "C0",
      "Precision": 4,
      "Microarchitecture": "Zurich",
      "MemorySize": 256000000,
      "CorrelationTracking": "Autocorrelation",
      "CreatedAt": 0,
      "UpdatedAt": 0
    }
  ],
  "Count": 1,
  "ContinuationToken": "cor_58c1fb8a09a5b603c2afb21e4de99271"
}

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.

Get Core by ID​

Note

For brevity, this and the following code examples do not include the setup of the Axios client. 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.

  const coreID = "cor_58c1fb8a09a5b603c2afb21e4de99271";
  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); // [TODO]: handle errors
  }

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

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

{
  "Object": "Core",
  "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
  "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Name": "Example Core",
  "Class": "C0",
  "Precision": 4,
  "Microarchitecture": "Zurich",
  "MemorySize": 256000000,
  "CorrelationTracking": "Autocorrelation",
  "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.

  const coreConfig = {
    Name: "new athens core",
    Class: "C0",
    Precision: 64,
    MemorySize: 256000,
    Microarchitecture: "Athens",
    CorrelationTracking: "autocorrelation",
  };

  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); // [TODO]: handle errors
  }

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

{
  "Object": "Core",
  "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
  "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Name": "new athens core",
  "Class": "C0",
  "Precision": 64,
  "Microarchitecture": "Athens",
  "MemorySize": 256000,
  "CorrelationTracking": "Autocorrelation",
  "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 response will contain a the details modified core.

  const newCoreConfig = {
    Name: "new athens core",
    Class: "C0",
    Precision: 128, // Changed from 64
    MemorySize: 256000,
    Microarchitecture: "Athens",
    CorrelationTracking: "disable", // Changed from "autocorrelation"
  };

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

    if (modifyCoreResponse?.data?.CoreID) {
      console.log(`... modified the core with ID ${modifyCoreResponse.data.CoreID}`);
      console.log(JSON.stringify(modifyCoreResponse.data, null, 2));
    }
  } catch (error) {
    console.log("Error :>> ", error); // [TODO]: handle errors
  }

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

{
  "Object": "Core",
  "CoreID": "cor_58c1fb8a09a5b603c2afb21e4de99271",
  "Owner": "usr_96295c9d6d7051a88e3bb3ac2299994b",
  "Name": "new athens core",
  "Class": "C0",
  "Precision": 128,
  "Microarchitecture": "Athens",
  "MemorySize": 256000,
  "CorrelationTracking": "disable",
  "CreatedAt": 0,
  "UpdatedAt": 0
}

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.

  const coreID = "cor_58c1fb8a09a5b603c2afb21e4de99271";
  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 the core with ID ${deleteCoreResponse.data.CoreID}`);
      console.log(JSON.stringify(deleteCoreResponse.data, null, 2));
    }
  } catch (error) {
    console.log("Error :>> ", error); // [TODO]: handle errors
  }

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

{
  "message": "OK"
}