Plug-in ABI.

#include <hyperfold/plugin/abi.h>
#include <stdint.h>

#define OP_NAME "acme.double"

static hyperfold_operation_id op_id(void) {
  hyperfold_operation_id id = {
      sizeof(hyperfold_operation_id),
      {OP_NAME, sizeof(OP_NAME) - 1}, 1};
  return id;
}

static const hyperfold_backend_operand cpu_operands[] = {
    {sizeof(hyperfold_backend_operand),
     HYPERFOLD_OPERAND_ROLE_INPUT_0, HYPERFOLD_OPERAND_READ,
     HYPERFOLD_OPERAND_VECTOR, HYPERFOLD_LOCATION_PAGEABLE_HOST,
     HYPERFOLD_SCALAR_F32, HYPERFOLD_COMPLEX_NONE,
     HYPERFOLD_MATRIX_LAYOUT_NONE,
     HYPERFOLD_SCALAR_F32},
    {sizeof(hyperfold_backend_operand),
     HYPERFOLD_OPERAND_ROLE_OUTPUT, HYPERFOLD_OPERAND_WRITE,
     HYPERFOLD_OPERAND_VECTOR, HYPERFOLD_LOCATION_PAGEABLE_HOST,
     HYPERFOLD_SCALAR_F32, HYPERFOLD_COMPLEX_NONE,
     HYPERFOLD_MATRIX_LAYOUT_NONE,
     HYPERFOLD_SCALAR_F32}};

static hyperfold_status run(void *state,
    const hyperfold_invocation *call, hyperfold_error_sink *errors) {
  (void)state; (void)errors;
  if (!call || call->struct_size < sizeof(*call) ||
      call->backend != HYPERFOLD_BACKEND_CPU_SCALAR ||
      !call->operands || call->operand_count != 2)
    return HYPERFOLD_STATUS_INVALID_ARGUMENT;

  const hyperfold_operand_view *input = &call->operands[0];
  const hyperfold_operand_view *output = &call->operands[1];
  if (input->struct_size < sizeof(*input) ||
      output->struct_size < sizeof(*output) || !input->buffers ||
      !output->buffers || input->buffer_count != 1 ||
      output->buffer_count != 1 || input->extent0 != output->extent0 ||
      input->extent1 != 1 || output->extent1 != 1)
    return HYPERFOLD_STATUS_INVALID_ARGUMENT;
  const hyperfold_buffer_view *src = input->buffers;
  const hyperfold_buffer_view *dst = output->buffers;
  if (src->struct_size < sizeof(*src) || dst->struct_size < sizeof(*dst) ||
      src->role != HYPERFOLD_BUFFER_DATA ||
      dst->role != HYPERFOLD_BUFFER_DATA ||
      src->element_type != HYPERFOLD_SCALAR_F32 ||
      dst->element_type != HYPERFOLD_SCALAR_F32 ||
      src->element_size != sizeof(float) ||
      dst->element_size != sizeof(float) ||
      src->element_count != input->extent0 ||
      dst->element_count != output->extent0 ||
      (src->element_count && (!src->data || !dst->mutable_data)))
    return HYPERFOLD_STATUS_INVALID_ARGUMENT;

  const float *x = (const float *)src->data;
  float *out = (float *)dst->mutable_data;
  for (uint64_t i = 0; i < src->element_count; ++i) out[i] = 2.0F * x[i];
  return HYPERFOLD_STATUS_OK;
}

HYPERFOLD_PLUGIN_EXPORT hyperfold_status hyperfold_plugin_init(
    const hyperfold_host_api *host, hyperfold_plugin_metadata *metadata,
    hyperfold_error_sink *errors) {
  if (!host || host->struct_size < sizeof(*host) ||
      host->abi_revision != HYPERFOLD_PLUGIN_ABI_REVISION ||
      !host->register_kernel || !metadata)
    return HYPERFOLD_STATUS_INVALID_ARGUMENT;

  hyperfold_kernel_spec kernel = {sizeof(kernel), op_id(),
      HYPERFOLD_BACKEND_CPU_SCALAR, cpu_operands, 2, run, 0};
  hyperfold_status status = host->register_kernel(host->host_context, &kernel, errors);
  if (status != HYPERFOLD_STATUS_OK) return status;

  *metadata = (hyperfold_plugin_metadata){
      sizeof(*metadata), HYPERFOLD_PLUGIN_ABI_REVISION,
      {"acme", 4}, {"1.0.0", 5},
      0, 0, 0, 0};
  return HYPERFOLD_STATUS_OK;
}

#include <hyperfold/plugin/sdk.h>
#include <stdexcept>
using namespace Hyperfold::Plugin;

static const hyperfold_backend_operand cpu[] = {{
    sizeof(hyperfold_backend_operand),
    HYPERFOLD_OPERAND_ROLE_OUTPUT, HYPERFOLD_OPERAND_READ_WRITE,
    HYPERFOLD_OPERAND_SCALAR, HYPERFOLD_LOCATION_PAGEABLE_HOST,
    HYPERFOLD_SCALAR_I32, HYPERFOLD_COMPLEX_NONE,
    HYPERFOLD_MATRIX_LAYOUT_NONE,
    HYPERFOLD_SCALAR_I32}};

static hyperfold_status run(void *, const hyperfold_invocation *call,
                               hyperfold_error_sink *errors) {
  return translate_exceptions(errors, [&] {
    if (!call || call->struct_size < sizeof(*call) ||
        call->backend != HYPERFOLD_BACKEND_CPU_SCALAR ||
        call->operand_count != 1 || !call->operands)
      throw std::runtime_error("invalid toggle invocation");
    const auto &operand = call->operands[0];
    if (operand.struct_size < sizeof(operand) || operand.buffer_count != 1 ||
        !operand.buffers || operand.extent0 != 1 || operand.extent1 != 1) throw std::runtime_error("invalid toggle operand");
    const auto &buffer = operand.buffers[0];
    if (buffer.struct_size < sizeof(buffer) || !buffer.mutable_data ||
        buffer.role != HYPERFOLD_BUFFER_DATA ||
        buffer.element_type != HYPERFOLD_SCALAR_I32 ||
        buffer.element_count != 1 || buffer.element_size != sizeof(int32_t))
      throw std::runtime_error("invalid toggle storage");
    auto *value = static_cast<int32_t *>(buffer.mutable_data);
    *value = *value == 1 ? 0 : 1;
  });
}

HYPERFOLD_PLUGIN_ENTRY(const hyperfold_host_api *host,
                          hyperfold_plugin_metadata *metadata,
                          hyperfold_error_sink *errors) {
  if (!host || host->struct_size < sizeof(*host) ||
      host->abi_revision != HYPERFOLD_PLUGIN_ABI_REVISION ||
      !host->register_kernel || !metadata)
    return HYPERFOLD_STATUS_INVALID_ARGUMENT;

  const auto id = operation_id("acme.toggle", 1);
  const hyperfold_kernel_spec kernel{
      sizeof(hyperfold_kernel_spec), id, HYPERFOLD_BACKEND_CPU_SCALAR,
      cpu, 1, run, nullptr};
  hyperfold_status status = host->register_kernel(host->host_context, &kernel, errors);
  if (status != HYPERFOLD_STATUS_OK) return status;

  *metadata = hyperfold_plugin_metadata{
      sizeof(hyperfold_plugin_metadata), HYPERFOLD_PLUGIN_ABI_REVISION,
      string("acme"), string("1.0.0"),
      0, 0, nullptr, nullptr};
  return HYPERFOLD_STATUS_OK;
}

cmake_minimum_required(VERSION 3.18)
project(acme_plugin C)
find_package(Python COMPONENTS Interpreter REQUIRED)
execute_process(
  COMMAND "${Python_EXECUTABLE}" -c
          "import hyperfold; print(hyperfold.get_include())"
  OUTPUT_VARIABLE HYPERFOLD_INCLUDE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
add_library(acme_plugin MODULE acme_plugin.c)
target_include_directories(acme_plugin PRIVATE "${HYPERFOLD_INCLUDE_DIR}")
set_target_properties(acme_plugin PROPERTIES C_STANDARD 11 C_STANDARD_REQUIRED YES)
set_target_properties(acme_plugin PROPERTIES PREFIX "")

from pathlib import Path
import hyperfold

context = (hyperfold.ContextBuilder()
           .load_plugin(Path("build/acme_plugin.so"))
           .build())
print(context.describe("acme.double"))