Analog CIM SDK and Compiler: From Model to Running Code

candidate = {
  implementation: analog | digital | host,
  layout: {tiles, groups, buffers, sharding},
  numerics: {weight_digits, activation_bits, adc_grade, accumulator},
  physical: {arrays, phases, spares, calibration_class},
  estimates: {latency_ns, energy_pj, error_distribution, confidence},
  boundaries: {copies, conversions, synchronization},
  fallback: {trigger, implementation, recovery_cost}
}

minimize latency_weight * latency_p99
       + energy_weight  * energy
       + risk_weight    * accuracy_risk
       + boundary_weight * transfer_and_conversion
       + wear_weight    * programming_and_refresh

subject to error_budget, SRAM, current, ADC range, capacity,
           firmware ABI, calibration class, and service policy.

#ifndef ACIM_SDK_H_
#define ACIM_SDK_H_

#include <stddef.h>
#include <stdint.h>

#if defined(_WIN32)
#  if defined(ACIM_SDK_EXPORTS)
#    define ACIM_API __declspec(dllexport)
#  else
#    define ACIM_API __declspec(dllimport)
#  endif
#elif defined(__GNUC__)
#  define ACIM_API __attribute__((visibility("default")))
#else
#  define ACIM_API
#endif

#define ACIM_API_VERSION 1u
#define ACIM_MAX_RANK 8u

#ifdef __cplusplus
extern "C" {
#endif

typedef struct acim_context acim_context_t;
typedef struct acim_device acim_device_t;
typedef struct acim_executable acim_executable_t;
typedef struct acim_session acim_session_t;
typedef struct acim_queue acim_queue_t;
typedef struct acim_buffer acim_buffer_t;
typedef struct acim_event acim_event_t;

typedef enum acim_status {
  ACIM_STATUS_OK = 0,
  ACIM_STATUS_INVALID_ARGUMENT,
  ACIM_STATUS_UNSUPPORTED,
  ACIM_STATUS_INCOMPATIBLE_ARTIFACT,
  ACIM_STATUS_STALE_CALIBRATION,
  ACIM_STATUS_RESOURCE_EXHAUSTED,
  ACIM_STATUS_BUSY,
  ACIM_STATUS_TIMEOUT,
  ACIM_STATUS_CANCELED,
  ACIM_STATUS_DEVICE_FAULT,
  ACIM_STATUS_INTERNAL
} acim_status_t;

typedef enum acim_io_kind {
  ACIM_IO_INPUT = 0,
  ACIM_IO_OUTPUT = 1
} acim_io_kind_t;

typedef enum acim_element_type {
  ACIM_ELEMENT_I8 = 0,
  ACIM_ELEMENT_I32,
  ACIM_ELEMENT_F16,
  ACIM_ELEMENT_F32
} acim_element_type_t;

typedef enum acim_memory_flags {
  ACIM_MEMORY_HOST_VISIBLE = 1u << 0,
  ACIM_MEMORY_HOST_PINNED  = 1u << 1,
  ACIM_MEMORY_DEVICE_LOCAL = 1u << 2
} acim_memory_flags_t;

typedef struct acim_context_options {
  uint32_t struct_size;
  uint32_t api_version;
  const char* backend_name;      /* functional, analog, cycle, device */
  const char* backend_options;   /* validated JSON or key/value text */
} acim_context_options_t;

typedef struct acim_tensor_desc {
  uint32_t struct_size;
  uint32_t api_version;
  const char* name;              /* executable-owned; valid until release */
  acim_element_type_t element_type;
  uint32_t rank;
  int64_t dimensions[ACIM_MAX_RANK];
  size_t byte_size;
} acim_tensor_desc_t;

typedef struct acim_buffer_binding {
  uint32_t struct_size;
  uint32_t api_version;
  uint32_t tensor_index;
  acim_buffer_t* buffer;
  size_t offset;
  size_t size;
} acim_buffer_binding_t;

typedef struct acim_error_info {
  uint32_t struct_size;
  uint32_t api_version;
  acim_status_t status;
  uint32_t subsystem;
  int64_t device_code;
  uint64_t trace_id;
  char message[256];
} acim_error_info_t;

ACIM_API uint32_t acim_api_version(void);
ACIM_API acim_status_t acim_context_create(
    const acim_context_options_t*, acim_context_t**);
ACIM_API acim_status_t acim_context_get_last_error(
    acim_context_t*, acim_error_info_t*);
ACIM_API acim_status_t acim_device_count(acim_context_t*, uint32_t*);
ACIM_API acim_status_t acim_device_open(acim_context_t*, uint32_t, acim_device_t**);
ACIM_API acim_status_t acim_device_get_capabilities(
    acim_device_t*, char* json, size_t* inout_size);
ACIM_API acim_status_t acim_device_bind_state(
    acim_device_t*, const void* bytes, size_t size);
ACIM_API acim_status_t acim_executable_load(
    acim_device_t*, const void* bytes, size_t size, acim_executable_t**);
ACIM_API acim_status_t acim_executable_get_tensor_desc(
    acim_executable_t*, acim_io_kind_t, uint32_t index, acim_tensor_desc_t*);
ACIM_API acim_status_t acim_session_create(
    acim_device_t*, acim_executable_t*, acim_session_t**);
ACIM_API acim_status_t acim_queue_create(
    acim_session_t*, uint32_t queue_flags, acim_queue_t**);
ACIM_API acim_status_t acim_buffer_allocate(
    acim_device_t*, size_t bytes, uint32_t memory_flags, acim_buffer_t**);
ACIM_API acim_status_t acim_buffer_write(
    acim_buffer_t*, size_t offset, const void* source, size_t size);
ACIM_API acim_status_t acim_buffer_read(
    acim_buffer_t*, size_t offset, void* destination, size_t size);
ACIM_API acim_status_t acim_queue_submit(
    acim_queue_t*, const acim_buffer_binding_t* inputs, size_t input_count,
    const acim_buffer_binding_t* outputs, size_t output_count, acim_event_t**);
ACIM_API acim_status_t acim_event_wait(acim_event_t*, uint64_t timeout_ns);
ACIM_API acim_status_t acim_event_cancel(acim_event_t*);
ACIM_API acim_status_t acim_event_get_result(acim_event_t*, acim_error_info_t*);

ACIM_API void acim_event_release(acim_event_t*);
ACIM_API void acim_buffer_release(acim_buffer_t*);
ACIM_API void acim_queue_release(acim_queue_t*);
ACIM_API void acim_session_release(acim_session_t*);
ACIM_API void acim_executable_release(acim_executable_t*);
ACIM_API void acim_device_release(acim_device_t*);
ACIM_API void acim_context_release(acim_context_t*);

#ifdef __cplusplus
}  /* extern "C" */
#endif
#endif  /* ACIM_SDK_H_ */

from acim_sdk import Compiler, CompileOptions, Context, TargetProfile

target = TargetProfile.load("targets/rev_b.atarget", "targets/rev_b.achar")
compiler = Compiler(target)

artifact, report = compiler.compile_onnx(
    "models/linear.onnx",
    model_calibration="build/linear.qcal",
    options=CompileOptions(
        accuracy_budget=0.005,
        latency_target_us=100,
        allow_digital_fallback=True,
        save_intermediate_ir="build/ir",
    ),
)
artifact.save("build/linear.acx")
report.save("build/linear.compile.json")

with Context(backend="functional") as context:
    device = context.open_device(0)
    session = device.load("build/linear.acx")
    output = session.run({"input": input_tensor})

with Context(backend="device") as context:
    device = context.open_device(0)
    session = device.load("build/linear.acx")
    event = session.submit({"input": input_tensor})
    output = event.result(timeout=1.0)
    event.trace().save("build/linear.atrace")

class Device {
 public:
  virtual ~Device() = default;
  virtual StatusOr<Capabilities> QueryCapabilities() = 0;
  virtual Status BindDeviceState(const DeviceState&) = 0;
  virtual StatusOr<ExecutableHandle> Load(const Artifact&) = 0;
  virtual StatusOr<BufferHandle> Allocate(const BufferDesc&) = 0;
  virtual StatusOr<EventHandle> Submit(
      QueueId, ExecutableHandle, Span<BufferBinding>, const RunPolicy&) = 0;
  virtual Status Wait(EventHandle, Duration timeout) = 0;
  virtual StatusOr<Trace> ReadTrace(EventHandle) = 0;
  virtual Status Recover(const RecoveryRequest&) = 0;
};

class Backend {
 public:
  virtual ~Backend() = default;
  virtual StatusOr<std::vector<DeviceInfo>> Enumerate() = 0;
  virtual StatusOr<std::unique_ptr<Device>> Open(DeviceId) = 0;
};

namespace acim.artifact;

table Version {
  major:ushort (id: 0);
  minor:ushort (id: 1);
  patch:uint   (id: 2);
}

table TargetRequirements {
  device_family:string        (id: 0);
  revision_min:uint           (id: 1);
  revision_max:uint           (id: 2);
  firmware_abi:Version        (id: 3);
  calibration_schema:Version (id: 4);
  characterization_hash:[ubyte] (id: 5);
  required_features:[string]  (id: 6);
}

table Executable {
  schema:Version                    (id: 0);
  build_id:string                   (id: 1);
  model_hash:[ubyte]                (id: 2);
  target:TargetRequirements         (id: 3);
  graph:[ubyte]                     (id: 4);
  constants:[ubyte]                 (id: 5);
  weight_program:[ubyte]            (id: 6);
  command_streams:[ubyte]           (id: 7);
  digital_kernels:[ubyte]           (id: 8);
  memory_plan:[ubyte]               (id: 9);
  numerical_contract:[ubyte]        (id: 10);
  recovery_policy:[ubyte]           (id: 11);
  debug_map:[ubyte]                 (id: 12);
  compile_report:[ubyte]            (id: 13);
  signature:[ubyte]                 (id: 14);
}

root_type Executable;
file_identifier "ACIX";