switchboard-hw 0.3.0__cp314-cp314-macosx_11_0_arm64.whl

switchboard/cpp/pagemap.h

@@ -0,0 +1,91 @@
+// Linux user-space virt-to-phys mapper
+
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef PAGEMAP_H_
+#define PAGEMAP_H_
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+/*
+ * From https://www.kernel.org/doc/Documentation/admin-guide/mm/pagemap.rst
+
+ * ``/proc/pid/pagemap``.  This file lets a userspace process find out which
+   physical frame each virtual page is mapped to.  It contains one 64-bit
+   value for each virtual page, containing the following data (from
+   ``fs/proc/task_mmu.c``, above pagemap_read):
+
+    * Bits 0-54  page frame number (PFN) if present
+    * Bits 0-4   swap type if swapped
+    * Bits 5-54  swap offset if swapped
+    * Bit  55    pte is soft-dirty (see
+      :ref:`Documentation/admin-guide/mm/soft-dirty.rst <soft_dirty>`)
+    * Bit  56    page exclusively mapped (since 4.2)
+    * Bit  57    pte is uffd-wp write-protected (since 5.13) (see
+      :ref:`Documentation/admin-guide/mm/userfaultfd.rst <userfaultfd>`)
+    * Bits 58-60 zero
+    * Bit  61    page is file-page or shared-anon (since 3.5)
+    * Bit  62    page swapped
+    * Bit  63    page present
+*/
+
+#define PAGEMAP_PFN_MASK ((1ULL << 55) - 1)
+#define PAGEMAP_PAGE_PRESENT (1ULL << 63)
+#define PAGEMAP_FAILED (~0ULL)
+
+static inline int pagemap_open_self(void) {
+    int r;
+
+    r = open("/proc/self/pagemap", O_RDONLY);
+    if (r < 0) {
+        perror("open");
+    }
+    return r;
+}
+
+// Translate a given virtual ptr into its physical address.
+static inline uint64_t pagemap_virt_to_phys(void* ptr) {
+    uint64_t va = (uintptr_t)ptr;
+    uint64_t pagemap;
+    uint64_t offset;
+    uint64_t vfn;
+    uint64_t pa;
+    int pagesize;
+    ssize_t r;
+    int fd;
+
+    fd = pagemap_open_self();
+    if (fd < 0) {
+        return PAGEMAP_FAILED;
+    }
+
+    pagesize = getpagesize();
+    offset = va % pagesize;
+    vfn = va / pagesize;
+    r = pread(fd, &pagemap, sizeof pagemap, 8 * vfn);
+    assert(r == sizeof pagemap);
+    close(fd);
+
+    if (!(pagemap & PAGEMAP_PAGE_PRESENT)) {
+        return PAGEMAP_FAILED;
+    }
+
+    pa = (pagemap & PAGEMAP_PFN_MASK) * pagesize;
+    if (!pa) {
+        return PAGEMAP_FAILED;
+    }
+
+    pa |= offset;
+    return pa;
+}
+#endif

switchboard/cpp/pciedev.h

@@ -0,0 +1,86 @@
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef PCIEDEV_H__
+#define PCIEDEV_H__
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <sys/mman.h>
+
+#define PCIE_READ_GEN(t, suffix)                                                                   \
+    static inline t pcie_read##suffix(void* p) {                                                   \
+        uintptr_t i = (uintptr_t)p;                                                                \
+        t val;                                                                                     \
+                                                                                                   \
+        /* Enforce alignment. */                                                                   \
+        assert((i % sizeof(val)) == 0);                                                            \
+                                                                                                   \
+        /* Make access.	*/                                                                         \
+        return *(volatile t*)p;                                                                    \
+    }
+
+#define PCIE_WRITE_GEN(t, suffix)                                                                  \
+    static inline void pcie_write##suffix(void* p, t v) {                                          \
+        uintptr_t i = (uintptr_t)p;                                                                \
+        t val;                                                                                     \
+                                                                                                   \
+        /* Enforce alignment. */                                                                   \
+        assert((i % sizeof(val)) == 0);                                                            \
+                                                                                                   \
+        /* Make access.	*/                                                                         \
+        *(volatile t*)p = v;                                                                       \
+    }                                                                                              \
+                                                                                                   \
+    static inline void pcie_write##suffix##_strong(void* p, t v) {                                 \
+        t dummy;                                                                                   \
+        pcie_write##suffix(p, v);                                                                  \
+        /* Enforce PCI ordering by reading back the same reg. */                                   \
+        dummy = pcie_read##suffix(p);                                                              \
+        dummy = dummy;                                                                             \
+    }
+
+PCIE_READ_GEN(uint64_t, 64)
+PCIE_WRITE_GEN(uint64_t, 64)
+PCIE_READ_GEN(uint32_t, 32)
+PCIE_WRITE_GEN(uint32_t, 32)
+PCIE_READ_GEN(uint16_t, 16)
+PCIE_WRITE_GEN(uint16_t, 16)
+PCIE_READ_GEN(uint8_t, 8)
+PCIE_WRITE_GEN(uint8_t, 8)
+
+static inline void* pcie_bar_map(const char* bdf, int bar_num, uint64_t offset, uint64_t size) {
+    char name[] = "/sys/bus/pci/devices/XXXX:XX:XX.X/resourceYY";
+    void* p = MAP_FAILED;
+    int fd = -1;
+
+    snprintf(name, sizeof name, "/sys/bus/pci/devices/%s/resource%d", bdf, bar_num);
+
+    fd = open(name, O_RDWR | O_SYNC);
+    if (fd < 0) {
+        goto done;
+    }
+
+    p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
+
+done:
+    if (fd > 0) {
+        close(fd);
+    }
+    return p;
+}
+
+static inline void pcie_bar_unmap(void* p, uint64_t size) {
+    int r;
+
+    r = munmap(p, size);
+    if (r < 0) {
+        perror("munmap");
+    }
+}
+#endif

switchboard/cpp/router.cc

@@ -0,0 +1,89 @@
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "switchboard.hpp"
+
+// connections to each of the entries in the grid
+std::map<int, int> routing_table;
+std::map<int, std::unique_ptr<SBTX>> txconn;
+std::vector<std::unique_ptr<SBRX>> rxconn;
+
+bool init(int argc, char* argv[]) {
+    // determine number of rows and columns
+
+    int arg_idx = 1;
+
+    enum MODE { RX, TX, ROUTE, UNDEF };
+    MODE mode = UNDEF;
+
+    while (arg_idx < argc) {
+        std::string arg = std::string(argv[arg_idx++]);
+        if (arg == "--rx") {
+            mode = RX;
+        } else if (arg == "--tx") {
+            mode = TX;
+        } else if (arg == "--route") {
+            mode = ROUTE;
+        } else if (mode == RX) {
+            rxconn.push_back(std::unique_ptr<SBRX>(new SBRX()));
+            rxconn.back()->init(std::string("queue-") + arg);
+        } else if (mode == TX) {
+            int queue = atoi(arg.c_str());
+            txconn[queue] = std::unique_ptr<SBTX>(new SBTX());
+            txconn[queue]->init(std::string("queue-") + arg);
+        } else if (mode == ROUTE) {
+            size_t split = arg.find(':');
+            std::string first = arg.substr(0, split);
+            std::string second = arg.substr(split + 1);
+            int dest = atoi(first.c_str());
+            int queue = atoi(second.c_str());
+            routing_table[dest] = queue;
+        } else {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+int main(int argc, char* argv[]) {
+    // set up connections
+    if (!init(argc, argv)) {
+        printf("ERROR: arguments are not formed properly.\n");
+        return 1;
+    }
+
+    sb_packet p;
+    while (true) {
+        // loop over all RX connection
+        for (auto& rx : rxconn) {
+            if (rx->is_active()) {
+                if (rx->recv_peek(p)) {
+                    // make sure that the destination is in the routing table and active
+                    if ((routing_table.count(p.destination) > 0) &&
+                        (txconn.count(routing_table[p.destination]) > 0) &&
+                        (txconn[routing_table[p.destination]]->is_active())) {
+
+                        // try to send the packet, removing it from
+                        // the RX queue if the send is successful
+                        if (txconn[routing_table[p.destination]]->send(p)) {
+                            rx->recv();
+                        }
+                    } else {
+                        printf("ERROR: Cannot route packet.\n");
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}

switchboard/cpp/spsc_queue.h

@@ -0,0 +1,267 @@
+// Single Producer Single Consumer Queue implemented over shared-memory
+
+// Copyright (c) 2024 Zero ASIC Corporation
+// This code is licensed under Apache License 2.0 (see LICENSE for details)
+
+#ifndef SPSC_QUEUE_H__
+#define SPSC_QUEUE_H__
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#ifdef __cplusplus
+#include <atomic>
+using namespace std;
+#else
+#include <stdatomic.h>
+#endif
+
+#ifndef MAP_POPULATE
+// If the implementation lacks MAP_POPULATE, define it to 0 (no-op).
+#define MAP_POPULATE 0
+#endif
+
+#define SPSC_QUEUE_MAX_PACKET_SIZE 64
+#define SPSC_QUEUE_CACHE_LINE_SIZE 64
+
+typedef struct spsc_queue_shared {
+    int32_t head __attribute__((__aligned__(SPSC_QUEUE_CACHE_LINE_SIZE)));
+    int32_t tail __attribute__((__aligned__(SPSC_QUEUE_CACHE_LINE_SIZE)));
+    uint32_t packets[1][SPSC_QUEUE_MAX_PACKET_SIZE / 4]
+        __attribute__((__aligned__(SPSC_QUEUE_CACHE_LINE_SIZE)));
+} spsc_queue_shared;
+
+typedef struct spsc_queue {
+    int32_t cached_tail __attribute__((__aligned__(SPSC_QUEUE_CACHE_LINE_SIZE)));
+    int32_t cached_head __attribute__((__aligned__(SPSC_QUEUE_CACHE_LINE_SIZE)));
+    spsc_queue_shared* shm;
+    char* name;
+    int capacity;
+
+    bool unmap_at_close;
+} spsc_queue;
+
+// Returns the capacity of a queue given a specific mapsize.
+static inline int spsc_capacity(size_t mapsize) {
+    spsc_queue* q = NULL;
+    int capacity;
+
+    if (mapsize < sizeof(*q->shm)) {
+        return 0;
+    }
+
+    // Start with the size of the shared area. This includes the
+    // control members + one packet.
+    mapsize -= sizeof(*q->shm);
+
+    capacity = mapsize / sizeof(q->shm->packets[0]) + 1;
+
+    if (capacity < 2) {
+        // Capacities less than 2 are invalid.
+        return 0;
+    }
+
+    return capacity;
+}
+
+static inline size_t spsc_mapsize(int capacity) {
+    spsc_queue* q = NULL;
+    size_t mapsize;
+
+    assert(capacity >= 2);
+
+    // Start with the size of the shared area. This includes the
+    // control members + one packet.
+    mapsize = sizeof(*q->shm);
+    // Add additional packets.
+    mapsize += sizeof(q->shm->packets[0]) * (capacity - 1);
+
+    return mapsize;
+}
+
+static inline spsc_queue* spsc_open_mem(const char* name, size_t capacity, void* mem) {
+    spsc_queue* q = NULL;
+    size_t mapsize;
+    void* p;
+    int fd = -1;
+    int r;
+
+    // Compute the size of the SHM mapping.
+    mapsize = spsc_mapsize(capacity);
+
+    // Allocate a cache-line aligned spsc-queue.
+    r = posix_memalign(&p, SPSC_QUEUE_CACHE_LINE_SIZE, sizeof(spsc_queue));
+    if (r) {
+        fprintf(stderr, "posix_memalign: %s\n", strerror(r));
+        goto err;
+    }
+    q = (spsc_queue*)p;
+    memset(q, 0, sizeof *q);
+
+    p = mem;
+    if (!mem) {
+        fd = open(name, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+        if (fd < 0) {
+            perror(name);
+            goto err;
+        }
+
+        r = ftruncate(fd, mapsize);
+        if (r < 0) {
+            perror("ftruncate");
+            goto err;
+        }
+
+        // Map a shared file-backed mapping for the SHM area.
+        // This will always be page-aligned.
+        p = mmap(NULL, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, 0);
+
+        if (p == MAP_FAILED) {
+            perror("mmap");
+            goto err;
+        }
+
+        // We can now close the fd without affecting active mmaps.
+        close(fd);
+        q->unmap_at_close = true;
+    }
+
+    q->shm = (spsc_queue_shared*)p;
+    q->name = strdup(name);
+    q->capacity = capacity;
+
+    /* In case we're opening a pre-existing queue, pick up where we left off. */
+    __atomic_load(&q->shm->tail, &q->cached_tail, __ATOMIC_RELAXED);
+    __atomic_load(&q->shm->head, &q->cached_head, __ATOMIC_RELAXED);
+    return q;
+
+err:
+    if (fd > 0) {
+        close(fd);
+    }
+    free(q);
+    return NULL;
+}
+
+static inline int spsc_mlock(spsc_queue* q) {
+    size_t mapsize = spsc_mapsize(q->capacity);
+
+    return mlock(q->shm, mapsize);
+}
+
+static inline spsc_queue* spsc_open(const char* name, size_t capacity) {
+    return spsc_open_mem(name, capacity, NULL);
+}
+
+static inline void spsc_remove_shmfile(const char* name) {
+    remove(name);
+}
+
+static inline void spsc_close(spsc_queue* q) {
+    size_t mapsize;
+
+    if (!q) {
+        return;
+    }
+
+    mapsize = spsc_mapsize(q->capacity);
+
+    // We've already closed the file-descriptor. We now need to munmap the mmap.
+    if (q->unmap_at_close) {
+        munmap(q->shm, mapsize);
+    }
+
+    free(q->name);
+    free(q);
+}
+
+static inline int spsc_size(spsc_queue* q) {
+    int head, tail;
+    int size;
+
+    __atomic_load(&q->shm->head, &head, __ATOMIC_ACQUIRE);
+    __atomic_load(&q->shm->tail, &tail, __ATOMIC_ACQUIRE);
+
+    size = head - tail;
+    if (size < 0) {
+        size += q->capacity;
+    }
+    return size;
+}
+
+static inline bool spsc_send(spsc_queue* q, void* buf, size_t size) {
+    // get pointer to head
+    int head;
+
+    __atomic_load(&q->shm->head, &head, __ATOMIC_RELAXED);
+
+    assert(size <= sizeof q->shm->packets[0]);
+
+    // compute the head pointer
+    int next_head = head + 1;
+    if (next_head == q->capacity) {
+        next_head = 0;
+    }
+
+    // if the queue is full, bail out
+    if (next_head == q->cached_tail) {
+        __atomic_load(&q->shm->tail, &q->cached_tail, __ATOMIC_ACQUIRE);
+        if (next_head == q->cached_tail) {
+            return false;
+        }
+    }
+
+    // otherwise write in the packet
+    memcpy(q->shm->packets[head], buf, size);
+
+    // and update the head pointer
+    __atomic_store(&q->shm->head, &next_head, __ATOMIC_RELEASE);
+
+    return true;
+}
+
+static inline bool spsc_recv_base(spsc_queue* q, void* buf, size_t size, bool pop) {
+    // get the read pointer
+    int tail;
+    __atomic_load(&q->shm->tail, &tail, __ATOMIC_RELAXED);
+
+    assert(size <= sizeof q->shm->packets[0]);
+
+    // if the queue is empty, bail out
+    if (tail == q->cached_head) {
+        __atomic_load(&q->shm->head, &q->cached_head, __ATOMIC_ACQUIRE);
+        if (tail == q->cached_head) {
+            return false;
+        }
+    }
+
+    // otherwise read out the packet
+    memcpy(buf, q->shm->packets[tail], size);
+
+    if (pop) {
+        // and update the read pointer
+        tail++;
+        if (tail == q->capacity) {
+            tail = 0;
+        }
+        __atomic_store(&q->shm->tail, &tail, __ATOMIC_RELEASE);
+    }
+
+    return true;
+}
+
+static inline bool spsc_recv(spsc_queue* q, void* buf, size_t size) {
+    return spsc_recv_base(q, buf, size, true);
+}
+
+static inline bool spsc_recv_peek(spsc_queue* q, void* buf, size_t size) {
+    return spsc_recv_base(q, buf, size, false);
+}
+#endif // _SPSC_QUEUE