switchboard-hw 0.3.0__cp314-cp314-macosx_10_15_x86_64.whl

switchboard/cpp/umilib.h

@@ -0,0 +1,144 @@
+// C-based subset of umilib
+
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef __UMILIB_H__
+#define __UMILIB_H__
+
+#include <assert.h>
+#include <string.h>
+#include <unistd.h>
+
+// ref: umi/rtl/umi_messages.vh
+enum UMI_CMD {
+    UMI_INVALID = 0x00,
+
+    // Requests (host -> device)
+    UMI_REQ_READ = 0x01,
+    UMI_REQ_WRITE = 0x03,
+    UMI_REQ_POSTED = 0x05,
+    UMI_REQ_RDMA = 0x07,
+    UMI_REQ_ATOMIC = 0x09,
+    UMI_REQ_USER0 = 0x0B,
+    UMI_REQ_FUTURE0 = 0x0D,
+    UMI_REQ_ERROR = 0x0F,
+    UMI_REQ_LINK = 0x2F,
+
+    // Response (device -> host)
+    UMI_RESP_READ = 0x02,
+    UMI_RESP_WRITE = 0x04,
+    UMI_RESP_USER0 = 0x06,
+    UMI_RESP_USER1 = 0x08,
+    UMI_RESP_FUTURE0 = 0x0A,
+    UMI_RESP_FUTURE1 = 0x0C,
+    UMI_RESP_LINK = 0x0E
+};
+
+enum UMI_ATOMIC {
+    UMI_REQ_ATOMICADD = 0x00,
+    UMI_REQ_ATOMICAND = 0x01,
+    UMI_REQ_ATOMICOR = 0x02,
+    UMI_REQ_ATOMICXOR = 0x03,
+    UMI_REQ_ATOMICMAX = 0x04,
+    UMI_REQ_ATOMICMIN = 0x05,
+    UMI_REQ_ATOMICMAXU = 0x06,
+    UMI_REQ_ATOMICMINU = 0x07,
+    UMI_REQ_ATOMICSWAP = 0x08
+};
+
+// TODO: make this flexible
+#define UMI_PACKET_DATA_BYTES 32
+
+typedef struct umi_packet {
+    uint32_t cmd;
+    uint64_t dstaddr;
+    uint64_t srcaddr;
+    uint8_t data[UMI_PACKET_DATA_BYTES];
+} __attribute__((packed)) umi_packet;
+
+static inline bool has_umi_resp(uint32_t opcode) {
+    return ((opcode == UMI_REQ_READ) || (opcode == UMI_REQ_WRITE) || (opcode == UMI_REQ_ATOMIC));
+}
+
+static inline bool has_umi_data(uint32_t opcode) {
+    return ((opcode == UMI_REQ_WRITE) || (opcode == UMI_REQ_POSTED) || (opcode == UMI_REQ_ATOMIC) ||
+            (opcode == UMI_REQ_USER0) || (opcode == UMI_REQ_FUTURE0) || (opcode == UMI_RESP_READ) ||
+            (opcode == UMI_RESP_USER1) || (opcode == UMI_RESP_FUTURE1));
+}
+
+static inline bool allows_umi_merge(uint32_t opcode) {
+    return ((opcode == UMI_REQ_READ) || (opcode == UMI_REQ_WRITE) || (opcode == UMI_REQ_POSTED) ||
+            (opcode == UMI_REQ_RDMA) || (opcode == UMI_RESP_READ) || (opcode == UMI_RESP_WRITE));
+}
+
+static inline bool is_umi_invalid(uint32_t opcode) {
+    return opcode == 0;
+}
+
+static inline bool is_umi_req(uint32_t opcode) {
+    return (opcode & 0b1) == 0b1;
+}
+
+static inline bool is_umi_resp(uint32_t opcode) {
+    return (opcode != 0) && ((opcode & 0b1) == 0b0);
+}
+
+static inline bool is_umi_user(uint32_t opcode) {
+    return ((opcode == UMI_REQ_USER0) | (opcode == UMI_RESP_USER0) | (opcode == UMI_RESP_USER1));
+}
+
+static inline bool is_umi_future(uint32_t opcode) {
+    return (
+        (opcode == UMI_REQ_FUTURE0) | (opcode == UMI_RESP_FUTURE0) | (opcode == UMI_RESP_FUTURE1));
+}
+
+static inline uint32_t get_umi_bits(uint32_t cmd, uint32_t offset, uint32_t width) {
+    uint32_t mask = (1 << width) - 1;
+    return ((cmd >> offset) & mask);
+}
+
+static inline void set_umi_bits(uint32_t* cmd, uint32_t bits, uint32_t offset, uint32_t width) {
+
+    uint32_t mask = (1 << width) - 1;
+
+    *cmd = *cmd & (~(mask << offset));
+    *cmd = *cmd | (((bits & mask) << offset));
+}
+
+#define DECL_UMI_GETTER(FIELD, OFFSET, WIDTH)                                                      \
+    static inline uint32_t umi_##FIELD(uint32_t cmd) {                                             \
+        return get_umi_bits(cmd, OFFSET, WIDTH);                                                   \
+    }
+
+#define DECL_UMI_SETTER(FIELD, OFFSET, WIDTH)                                                      \
+    static inline void set_umi_##FIELD(uint32_t* cmd, uint32_t FIELD) {                            \
+        set_umi_bits(cmd, FIELD, OFFSET, WIDTH);                                                   \
+    }
+
+#define DECL_UMI_FIELD(FIELD, OFFSET, WIDTH)                                                       \
+    DECL_UMI_GETTER(FIELD, OFFSET, WIDTH)                                                          \
+    DECL_UMI_SETTER(FIELD, OFFSET, WIDTH)
+
+DECL_UMI_FIELD(opcode, 0, 5)
+DECL_UMI_FIELD(size, 5, 3)
+static inline uint32_t umi_len(uint32_t cmd) {
+    if (umi_opcode(cmd) == UMI_REQ_ATOMIC) {
+        return 0;
+    } else {
+        return get_umi_bits(cmd, 8, 8);
+    }
+}
+DECL_UMI_SETTER(len, 8, 8)
+DECL_UMI_FIELD(atype, 8, 8)
+DECL_UMI_FIELD(qos, 16, 4)
+DECL_UMI_FIELD(prot, 20, 2)
+DECL_UMI_FIELD(eom, 22, 1)
+DECL_UMI_FIELD(eof, 23, 1)
+DECL_UMI_FIELD(ex, 24, 1)
+
+static inline bool umi_packets_match(umi_packet* a, umi_packet* b) {
+    return (memcmp(a, b, 52) == 0);
+}
+
+#endif // __UMILIB_H__

switchboard/cpp/umilib.hpp

@@ -0,0 +1,113 @@
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef __UMILIB_HPP__
+#define __UMILIB_HPP__
+
+#include "umilib.h"
+#include <string>
+
+static inline uint32_t umi_pack(uint32_t opcode, uint32_t atype, uint32_t size, uint32_t len,
+    uint32_t eom, uint32_t eof, uint32_t qos = 0, uint32_t prot = 0, uint32_t ex = 0) {
+
+    uint32_t cmd = 0;
+
+    set_umi_opcode(&cmd, opcode);
+    set_umi_size(&cmd, size);
+    if (opcode != UMI_REQ_ATOMIC) {
+        set_umi_len(&cmd, len);
+    } else {
+        set_umi_atype(&cmd, atype);
+    }
+    set_umi_qos(&cmd, qos);
+    set_umi_prot(&cmd, prot);
+    set_umi_eom(&cmd, eom);
+    set_umi_eof(&cmd, eof);
+    set_umi_ex(&cmd, ex);
+
+    return cmd;
+}
+
+static inline void umi_unpack(uint32_t cmd, uint32_t& opcode, uint32_t& atype, uint32_t& size,
+    uint32_t& len, uint32_t& eom, uint32_t& eof, uint32_t& qos, uint32_t& prot, uint32_t& ex) {
+
+    opcode = umi_opcode(cmd);
+    size = umi_size(cmd);
+    len = umi_len(cmd);
+    atype = umi_atype(cmd);
+    qos = umi_qos(cmd);
+    prot = umi_prot(cmd);
+    eom = umi_eom(cmd);
+    eof = umi_eof(cmd);
+    ex = umi_ex(cmd);
+}
+
+static inline void umi_unpack(uint32_t cmd, uint32_t& opcode, uint32_t& atype, uint32_t& size,
+    uint32_t& len, uint32_t& eom, uint32_t& eof) {
+    uint32_t qos, prot, ex;
+    umi_unpack(cmd, opcode, atype, size, len, eom, eof, qos, prot, ex);
+}
+
+static inline void umi_unpack(uint32_t cmd, uint32_t& opcode, uint32_t& atype, uint32_t& size,
+    uint32_t& len, uint32_t& eom, uint32_t& eof, uint32_t& qos) {
+    uint32_t prot, ex;
+    umi_unpack(cmd, opcode, atype, size, len, eom, eof, qos, prot, ex);
+}
+
+static inline void umi_unpack(uint32_t cmd, uint32_t& opcode, uint32_t& atype, uint32_t& size,
+    uint32_t& len, uint32_t& eom, uint32_t& eof, uint32_t& qos, uint32_t& prot) {
+    uint32_t ex;
+    umi_unpack(cmd, opcode, atype, size, len, eom, eof, qos, prot, ex);
+}
+
+static inline std::string umi_opcode_to_str(uint32_t cmd) {
+    uint32_t opcode = umi_opcode(cmd);
+    if (opcode == UMI_INVALID) {
+        return "UMI_INVALID";
+    } else if (opcode == UMI_REQ_READ) {
+        return "UMI_REQ_READ";
+    } else if (opcode == UMI_REQ_RDMA) {
+        return "UMI_REQ_RDMA";
+    } else if (opcode == UMI_REQ_WRITE) {
+        return "UMI_REQ_WRITE";
+    } else if (opcode == UMI_REQ_POSTED) {
+        return "UMI_REQ_POSTED";
+    } else if (opcode == UMI_REQ_ATOMIC) {
+        return "UMI_REQ_ATOMIC";
+    } else if (opcode == UMI_RESP_READ) {
+        return "UMI_RESP_READ";
+    } else if (opcode == UMI_RESP_WRITE) {
+        return "UMI_RESP_WRITE";
+    } else if (opcode == UMI_REQ_ATOMIC) {
+        uint32_t atomic = umi_atype(cmd);
+        if (atomic == UMI_REQ_ATOMICADD) {
+            return "UMI_REQ_ATOMICADD";
+        } else if (atomic == UMI_REQ_ATOMICAND) {
+            return "UMI_REQ_ATOMICAND";
+        } else if (atomic == UMI_REQ_ATOMICOR) {
+            return "UMI_REQ_ATOMICOR";
+        } else if (atomic == UMI_REQ_ATOMICXOR) {
+            return "UMI_REQ_ATOMICXOR";
+        } else if (atomic == UMI_REQ_ATOMICMAX) {
+            return "UMI_REQ_ATOMICMAX";
+        } else if (atomic == UMI_REQ_ATOMICMIN) {
+            return "UMI_REQ_ATOMICMIN";
+        } else if (atomic == UMI_REQ_ATOMICMAXU) {
+            return "UMI_REQ_ATOMICMAXU";
+        } else if (atomic == UMI_REQ_ATOMICMINU) {
+            return "UMI_REQ_ATOMICMINU";
+        } else if (atomic == UMI_REQ_ATOMICSWAP) {
+            return "UMI_REQ_ATOMICSWAP";
+        } else {
+            return "UMI_REQ_ATOMIC";
+        }
+    } else if (is_umi_user(opcode)) {
+        return "UMI_USER";
+    } else if (is_umi_future(opcode)) {
+        return "UMI_FUTURE";
+    } else {
+        return "UMI_UNKNOWN";
+    }
+}
+
+#endif // __UMILIB_HPP__

switchboard/cpp/umisb.hpp

@@ -0,0 +1,364 @@
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef __UMISB_HPP__
+#define __UMISB_HPP__
+
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+
+#include "switchboard.hpp"
+#include "umilib.h"
+#include "umilib.hpp"
+
+// generic formatting methods
+
+template <typename T> std::string umi_data_as_str(T& x) {
+    // get the data representation
+    uint8_t* ptr = x.ptr();
+    size_t nbytes = x.nbytes();
+
+    uint32_t opcode = umi_opcode(x.cmd);
+
+    // create a formatted representation
+    std::stringstream stream;
+    stream << "[";
+    if (has_umi_data(opcode)) {
+
+        uint32_t size = umi_size(x.cmd);
+        uint32_t len = umi_len(x.cmd) + 1;
+
+        for (size_t i = 0; i < len; i++) {
+            if ((i + 1) * (1 << size) <= nbytes) {
+                if (size == 0) {
+                    // uint8_t needs to be cast to an integer to print correctly
+                    // with std::hex: https://stackoverflow.com/a/23575509
+                    stream << "0x" << std::hex << static_cast<int>(ptr[i]);
+                } else if (size == 1) {
+                    stream << "0x" << std::hex << ((uint16_t*)ptr)[i];
+                } else if (size == 2) {
+                    stream << "0x" << std::hex << ((uint32_t*)ptr)[i];
+                } else if (size == 3) {
+                    stream << "0x" << std::hex << ((uint64_t*)ptr)[i];
+                } else {
+                    stream << "X";
+                }
+            } else {
+                stream << "X";
+            }
+            if (i != (len - 1)) {
+                stream << ", ";
+            }
+        }
+    }
+
+    stream << "]";
+
+    // return the result
+    return stream.str();
+}
+
+template <typename T> std::string umi_transaction_as_str(T& x) {
+    std::stringstream stream;
+
+    uint32_t opcode = umi_opcode(x.cmd);
+
+    stream << "opcode: " << umi_opcode_to_str(opcode);
+
+    stream << std::endl << "dstaddr: 0x" << std::hex << x.dstaddr;
+
+    // print out the source address if this is a request, as long
+    // as it isn't a posted write, since that doesn't have a source
+    // address.
+    if (is_umi_req(opcode) && (opcode != UMI_REQ_POSTED)) {
+        stream << std::endl << "srcaddr: 0x" << std::hex << x.srcaddr;
+    }
+
+    stream << std::endl << "size: " << umi_size(x.cmd);
+    stream << std::endl << "len: " << umi_len(x.cmd);
+    stream << std::endl << "eom: " << umi_eom(x.cmd);
+    stream << std::endl << "eof: " << umi_eof(x.cmd);
+
+    // print out the data as long as this isn't a read request, since
+    // that doesn't have data
+    if (!((opcode == UMI_REQ_READ) || (opcode == UMI_REQ_RDMA))) {
+        stream << std::endl << "data: " << umi_data_as_str<T>(x);
+    }
+
+    // return the result, noting that it does not contain a final newline
+    return stream.str();
+}
+
+// function to print a warning or throw an error
+
+static inline void umisb_error_or_warn(std::string const& msg, bool error = true) {
+    if (error) {
+        throw std::runtime_error(msg);
+    } else {
+        std::cerr << "Warning: " << msg << std::endl;
+    }
+}
+
+// function for checking if requests and replies match up as expected
+
+template <typename T>
+void umisb_check_resp(T& resp, uint32_t opcode, uint32_t size, uint32_t to_ack,
+    uint64_t expected_addr, bool error = true) {
+
+    uint32_t resp_opcode = umi_opcode(resp.cmd);
+    uint32_t resp_size = umi_size(resp.cmd);
+    uint32_t resp_len = umi_len(resp.cmd);
+
+    // check that the response makes sense
+
+    if (resp_opcode != opcode) {
+        std::ostringstream oss;
+        oss << "Got " << umi_opcode_to_str(resp_opcode) << " (expected "
+            << umi_opcode_to_str(opcode) << ")";
+        umisb_error_or_warn(oss.str(), error);
+    }
+
+    if (resp_size != size) {
+        std::ostringstream oss;
+        oss << umi_opcode_to_str(resp_opcode) << " response SIZE is " << std::to_string(resp_size)
+            << " (expected " << std::to_string(size) << ")";
+        umisb_error_or_warn(oss.str(), error);
+    }
+
+    if ((resp_len + 1) > to_ack) {
+        std::ostringstream oss;
+        oss << umi_opcode_to_str(resp_opcode) << " response LEN is " << std::to_string(resp_len)
+            << " (expected no more than " << std::to_string(to_ack - 1) << ")";
+        umisb_error_or_warn(oss.str(), error);
+    }
+
+    if (resp.dstaddr != expected_addr) {
+        std::ostringstream oss;
+        oss << "dstaddr in " << umi_opcode_to_str(resp_opcode) << " response is "
+            << std::to_string(resp.dstaddr) << " (expected " << std::to_string(expected_addr)
+            << ")";
+        umisb_error_or_warn(oss.str(), error);
+    }
+}
+
+// basic class for representing a UMI transaction, which may span
+// multiple packets.
+
+struct UmiTransaction {
+    UmiTransaction(uint32_t cmd = 0, uint64_t dstaddr = 0, uint64_t srcaddr = 0,
+        uint8_t* data = NULL, size_t nbytes = 0)
+        : cmd(cmd), dstaddr(dstaddr), srcaddr(srcaddr) {
+
+        m_storage = false;
+        m_allocated = false;
+        m_nbytes = 0;
+
+        if (data != NULL) {
+            this->data = data;
+            m_storage = true;
+            m_nbytes = nbytes;
+        } else if (nbytes > 0) {
+            allocate(0, nbytes - 1);
+        } else {
+            this->data = NULL;
+        }
+    }
+
+    ~UmiTransaction() {
+        if (m_allocated) {
+            delete[] data;
+        }
+    }
+
+    std::string toString() {
+        return umi_transaction_as_str<UmiTransaction>(*this);
+    }
+
+    void allocate(size_t size, size_t len) {
+        // check that we can perform this operation
+
+        if (m_storage) {
+            throw std::runtime_error(
+                "There is already storage for this UMI transaction, no need to allocate.");
+        }
+
+        if (m_allocated) {
+            throw std::runtime_error("Memory has already been allocated for this UMI transaction.");
+        }
+
+        // allocate the memory
+
+        size_t nbytes = (len + 1) << size;
+        data = new uint8_t[nbytes];
+
+        // indicate that storage is now available for this transaction,
+        // and that we allocated memory to make it available
+
+        m_storage = true;
+        m_allocated = true;
+        m_nbytes = nbytes;
+    }
+
+    bool storage() {
+        return m_storage;
+    }
+
+    size_t nbytes() {
+        return m_nbytes;
+    }
+
+    uint8_t* ptr() {
+        return data;
+    }
+
+    uint32_t cmd;
+    uint64_t dstaddr;
+    uint64_t srcaddr;
+    uint8_t* data;
+
+  private:
+    size_t m_nbytes;
+    bool m_allocated;
+    bool m_storage;
+};
+
+// higher-level functions for UMI transactions
+
+template <typename T>
+static inline bool umisb_send(T& x, SBTX& tx, bool blocking = true, void (*loop)(void) = NULL) {
+
+    // sends (or tries to send, if blocking=false) a single UMI transaction
+
+    if (!tx.is_active()) {
+        return false;
+    }
+
+    // load fields into an SB packet
+
+    sb_packet p;
+    umi_packet* up = (umi_packet*)p.data;
+
+    up->cmd = x.cmd;
+    up->dstaddr = x.dstaddr;
+    up->srcaddr = x.srcaddr;
+
+    uint32_t opcode = umi_opcode(x.cmd);
+
+    if ((opcode == UMI_REQ_READ) || (opcode == UMI_REQ_RDMA) || (opcode == UMI_RESP_WRITE)) {
+        // do nothing, since there isn't data to copy
+    } else {
+        uint32_t size = umi_size(x.cmd);
+        uint32_t len = umi_len(x.cmd);
+
+        size_t nbytes = (len + 1) << size;
+
+        if (nbytes > sizeof(up->data)) {
+            throw std::runtime_error(
+                "umisb_send: (len+1)<<size cannot exceed the data size of a umi_packet.");
+        }
+
+        if (nbytes > x.nbytes()) {
+            throw std::runtime_error(
+                "umisb_send: (len+1)<<size cannot exceed the data size of a UmiTransaction.");
+        }
+
+        memcpy(up->data, x.ptr(), nbytes);
+    }
+
+    bool header_sent = tx.send(p);
+    if ((!blocking) && (!header_sent)) {
+        return false;
+    }
+
+    // if we reach this point, we're committed to send out the whole UMI
+    // transaction, which may span multiple packets
+
+    // finish sending the header packet
+    if (!header_sent) {
+        bool success = false;
+
+        while (!success) {
+            success = tx.send(p);
+
+            if (loop) {
+                loop();
+            }
+        }
+    }
+
+    // if we reach this point, we succeeded in sending the packet
+    return true;
+}
+
+template <typename T>
+static inline bool umisb_recv(T& x, SBRX& rx, bool blocking = true, void (*loop)(void) = NULL) {
+
+    // if the receive side isn't active, there is nothing to receive
+    if (!rx.is_active()) {
+        return false;
+    }
+
+    // get a response
+
+    sb_packet p;
+
+    if (!blocking) {
+        if (!rx.recv(p)) {
+            return false;
+        }
+    } else {
+        bool success = false;
+
+        while (!success) {
+            success = rx.recv(p);
+
+            if (loop) {
+                loop();
+            }
+        }
+    }
+
+    // if we get to this point, there is valid data in "p"
+
+    umi_packet* up = (umi_packet*)p.data;
+
+    // read information from the packet
+
+    x.cmd = up->cmd;
+    x.dstaddr = up->dstaddr;
+    x.srcaddr = up->srcaddr;
+
+    uint32_t opcode = umi_opcode(up->cmd);
+
+    if ((opcode == UMI_REQ_READ) || (opcode == UMI_REQ_RDMA) || (opcode == UMI_RESP_WRITE)) {
+        // do nothing, since there isn't data to copy
+    } else {
+        uint32_t size = umi_size(x.cmd);
+        uint32_t len = umi_len(x.cmd);
+
+        if (!x.storage()) {
+            x.allocate(size, len);
+        }
+
+        size_t nbytes = (len + 1) << size;
+
+        if (nbytes > sizeof(up->data)) {
+            throw std::runtime_error(
+                "umisb_recv: (len+1)<<size cannot exceed the data size of a umi_packet.");
+        }
+
+        if (nbytes > x.nbytes()) {
+            throw std::runtime_error(
+                "umisb_recv: (len+1)<<size cannot exceed the data size of a UmiTransaction.");
+        }
+
+        memcpy(x.ptr(), up->data, nbytes);
+    }
+
+    return true;
+}
+
+#endif // __UMISB_HPP__

switchboard/cpp/xyce.hpp

@@ -0,0 +1,90 @@
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <N_CIR_XyceCInterface.h>
+
+class XyceIntf {
+  public:
+    XyceIntf() {}
+
+    ~XyceIntf() {
+        if (m_opened) {
+            xyce_close(m_xyceObj);
+        }
+
+        if (m_xyceObj) {
+            free(m_xyceObj);
+        }
+    }
+
+    void init(std::string file) {
+        // pointer to N_CIR_Xyce object
+        m_xyceObj = (void**)malloc(sizeof(void* [1]));
+
+        // xyce command
+        char* argList[] = {(char*)("Xyce"), (char*)("-quiet"), (char*)file.c_str()};
+        int argc = sizeof(argList) / sizeof(argList[0]);
+        char** argv = argList;
+
+        // Open N_CIR_Xyce object
+        xyce_open(m_xyceObj);
+        m_opened = true;
+
+        // Initialize N_CIR_Xyce object
+        xyce_initialize(m_xyceObj, argc, argv);
+        m_initialized = true;
+
+        // Simulate for a small amount of time
+        xyce_simulateUntil(m_xyceObj, 1e-10, &m_simTime);
+    }
+
+    void put(std::string name, double time, double value) {
+        if (!m_time.count(name)) {
+            m_time[name] = std::vector<double>();
+        }
+
+        m_time[name].push_back(time);
+
+        if (!m_value.count(name)) {
+            m_value[name] = std::vector<double>();
+        }
+
+        m_value[name].push_back(value);
+
+        // TODO: prune old values for higher performance?
+
+        if (m_initialized) {
+            std::string fullName = "YDAC!" + name;
+
+            xyce_updateTimeVoltagePairs(m_xyceObj, (char*)fullName.c_str(), m_time[name].size(),
+                m_time[name].data(), m_value[name].data());
+        }
+    }
+
+    void get(std::string name, double time, double* value) {
+        if (m_initialized) {
+            // advance simulation if necessary
+            if (time > m_simTime) {
+                int status = xyce_simulateUntil(m_xyceObj, time, &m_simTime);
+            }
+
+            // read out the value
+            xyce_obtainResponse(m_xyceObj, (char*)name.c_str(), value);
+        }
+    }
+
+  private:
+    void** m_xyceObj;
+    double m_simTime;
+    bool m_opened;
+    bool m_initialized;
+    std::map<std::string, std::vector<double>> m_time;
+    std::map<std::string, std::vector<double>> m_value;
+};