switchboard-hw 0.3.0__cp314-cp314-macosx_11_0_arm64.whl

switchboard_hw-0.3.0.dist-info/METADATA

@@ -0,0 +1,303 @@
+Metadata-Version: 2.4
+Name: switchboard-hw
+Version: 0.3.0
+Summary: A low-latency communication library for RTL simulation and emulation.
+Home-page: https://github.com/zeroasiccorp/switchboard
+Author: Zero ASIC
+License: Apache License 2.0
+Project-URL: Documentation, https://zeroasiccorp.github.io/switchboard/
+Project-URL: Bug Tracker, https://github.com/zeroasiccorp/switchboard/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Requires-Dist: siliconcompiler<0.36.0,>=0.35.3
+Provides-Extra: test
+Requires-Dist: pytest<10,>=8; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: autodocsumm; extra == "docs"
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Switchboard
+
+[![Actions Status](https://github.com/zeroasiccorp/switchboard/actions/workflows/regression.yml/badge.svg?branch=main)](https://github.com/zeroasiccorp/switchboard/actions)
+[![Documentation Status](https://github.com/zeroasiccorp/switchboard/actions/workflows/documentation.yml/badge.svg?branch=main)](https://zeroasiccorp.github.io/switchboard/)
+[![PyPI version](https://badge.fury.io/py/switchboard-hw.svg)](https://badge.fury.io/py/switchboard-hw)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Introduction
+
+Switchboard (SB) is a framework for communication between distinct hardware models, such as RTL simulations, RTL implemented on FPGAs, and fast SW models.  This makes it possible to simulate large hardware systems in a distributed fashion, using whatever models are available for the different components.
+
+In such a simulation, each hardware model has one or more SB ports.  Each is unidirectional: it may act as an input or an output, but not both.  In addition, each SB connection is single-producer, single-consumer (SPSC): an output port may not drive more than one input port, and an input port may not be driven by more than one output port.
+
+Here's an example of what a switchboard connection topology might look like:
+
+<img width="318" alt="image" src="https://user-images.githubusercontent.com/19254098/225485548-ff127b2e-d959-46c0-af1d-2c4bbe3f119d.png">
+
+The method for adding a switchboard port depends on the language that a HW model is implemented in.  For RTL-based models, SB ports are instantiated as Verilog models, whereas for C++ and Python-based models, these ports are instantiated as objects.  We provide both a low-level interface for moving data directly between SB ports, as well as a higher-level interface for running [UMI](https://github.com/zeroasiccorp/umi) transactions over SB connections.
+
+Under the hood, communication happens through shared-memory queues, where an SB output port is driving packets into the queue, and an SB input port is reading from that queue.  This standardization is what allows any two kinds of models to talk to each other.  A shared-memory SPSC queue is an appealing common interface because it is one of the fastest interprocess communication techniques, with latencies on the order of hundreds of nanoseconds; no system calls are required to transmit and receive data.  At the same time, this type of queue is straightforward to implement for FPGA platforms, with queue read and write operations only requiring a handful of memory transactions.
+
+For an in depth explanation of the theory and philosophy behind Switchboard, we recommend reading the paper [*Switchboard: an Open-Source Framework for Modular Simulation of Large Hardware Systems"*](https://arxiv.org/abs/2407.20537).
+
+If used for research, please cite Switchboard by the following publication:
+
+```
+@misc{herbst2024switchboardopensourceframeworkmodular,
+      title={Switchboard: An Open-Source Framework for Modular Simulation of Large Hardware Systems},
+      author={Steven Herbst and Noah Moroze and Edgar Iglesias and Andreas Olofsson},
+      year={2024},
+      eprint={2407.20537},
+      archivePrefix={arXiv},
+      primaryClass={cs.DC},
+      url={https://arxiv.org/abs/2407.20537},
+}
+```
+
+## Installation
+
+The fastest way to install this package is from PyPI:
+
+```console
+pip install switchboard-hw
+```
+
+However, if you want to run the examples below (or if you're a switchboard developer), clone this repository and install the Python package in-place:
+
+```console
+git clone https://github.com/zeroasiccorp/switchboard.git
+```
+
+```console
+cd switchboard
+```
+
+```console
+git submodule update --init
+```
+
+```console
+pip install --upgrade pip
+```
+
+```console
+pip install -e .
+```
+
+## Examples
+
+Various examples demonstrating the features of switchboard are in the [examples](examples) folder.  If you'd like to run them yourself, please run this command first:
+
+```console
+pip install -r examples/requirements.txt
+```
+
+This clones some additional repositories that are needed by the examples.
+
+A good starting point is the [python](examples/python) example, where a Python script sends packets to and receives packets from a Verilator RTL simulation.  The configuration is simple: there is a small RTL simulation that accepts an SB packet, increments the data payload, and transmits the result on its SB output port.  On the other side, a Python script sends an SB packet to the simulation, and checks that the packet it gets back has been incremented.
+
+<img width="311" alt="image" src="https://user-images.githubusercontent.com/19254098/225485672-1793521d-a9db-4c18-ad61-c22a605f8720.png">
+
+To run this example, you'll need `verilator` (`sudo apt install verilator` for Ubuntu, `brew install verilator` for macOS).  You can then run the example by changing directory to [examples/python](examples/python) and then typing `make`.  That should produce output similar to the following:
+
+```text
+*** TX packet ***
+dest: 123456789
+last: 1
+data: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
+ 24 25 26 27 28 29 30 31]
+
+*** RX packet ***
+dest: 123456789
+last: 1
+data: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
+ 25 26 27 28 29 30 31 32]
+
+- ../verilog/testbench.sv:72: Verilog $finish
+PASS!
+```
+
+To get a sense of how this works, open the Python script [examples/python/test.py](examples/python/test.py).  The core logic is essentially:
+
+```python
+from switchboard import PySbPacket, PySbTx, PySbRx
+
+...
+
+tx = PySbTx("to_rtl.q", fresh=True)
+rx = PySbRx("from_rtl.q", fresh=True)
+
+...
+
+txp = PySbPacket(...)
+tx.send(txp)
+
+...
+
+rxp = rx.recv()
+```
+
+In other words, we create an SB output port (`tx`) and an SB input port (`rx`).  An SB packet is then created (`txp`) and sent via the output port.  Finally, a new SB packet is received from the input port.
+
+To get a sense of how switchboard is used in RTL, have a look at the Verilog part of this example in [examples/python/testbench.sv](examples/python/testbench.sv).  The core logic is the instantiation of `queue_to_sb_sim` (SB input port) and `sb_to_queue_sim` (SB output port), along with the initialization step to define the name of each SB connection.  Notice that the Python output port is matched to the Verilog input port (`to_rtl.q`) and similarly the Python input port is matched to the Verilog output port (`from_rtl.q`).
+
+```verilog
+`include "switchboard.vh"
+
+...
+
+`SB_WIRES(to_rtl, DW);
+`QUEUE_TO_SB_SIM(to_rtl, DW, "to_rtl.q");
+
+...
+
+`SB_WIRES(from_rtl, DW);
+`SB_TO_QUEUE_SIM(from_rtl, DW, "from_rtl.q");
+```
+
+Using the same name for two ports is what establishes a connection between them.  You can use any name that you like for a SB connection, as long as it is a valid file name.  The reason is that SB connections are visible as files on your file system.  After this example runs, it will leave behind files called `to_rtl.q` and `from_rtl.q`.  It's convenient to name SB connections in a way that is amenable to pattern matching, so that you can do things like `rm *.q` to clean up old connections.
+
+We encourage you to explore the other examples, which demonstrate simulation with Icarus Verilog and switchboard's C++ library ([minimal](examples/minimal)), bridging SB connections via TCP ([tcp](examples/tcp)), and switchboard's UMI abstraction ([umiram](examples/umiram)).
+
+
+## Build automation
+
+We also provide build automation powered by [SiliconCompiler](https://github.com/siliconcompiler/siliconcompiler) that makes it easy to build RTL simulations with switchboard infrastructure (`queue_to_sb_sim`, `sb_to_queue_sim`, etc.).  This is mainly important because Verilog DPI and VPI are used under the hood, requiring certain flags to be passed to the RTL simulator during the build.  Using our build automation lets you focus on specifying RTL sources, without having to deal with these details.
+
+As an example, we return to [examples/python](examples/python).  The basic logic for a Verilator build is:
+
+```python
+from switchboard import SbDut
+
+dut = SbDut('name-of-top-level-module')
+
+dut.input('path/to/file/1')
+dut.input('path/to/file/2')
+...
+
+dut.build()
+
+dut.simulate()
+```
+
+In other words, create an `SbDut` object, `input()` files, `build()` it to compile the Verilator simulator, and use `simulate()` to start the simulator.  `SbDut` is a subclass of `siliconcompiler.Chip`, which allows you to invoke a range of features to control the simulator build, such as specifying include paths and `` `define `` macros.  More information about `siliconcompiler.Chip` can be found [here](https://docs.siliconcompiler.com/en/stable/reference_manual/core_api.html#siliconcompiler.core.Chip).
+
+
+## Packet format
+
+An SB packet is a simple data structure with three parts, defined in [switchboard/cpp/switchboard.hpp](switchboard/cpp/switchboard.hpp).
+1. A 32-bit `destination`.
+2. A 32-bit `flags` bit vector.  Currently only bit "0" is used, providing the `last` flag.
+3. A 416-bit data payload.  This width was chosen to accommodate a UMI packet with a 256 bit payload, 64-bit source and destination addresses, and a 32-bit command.  In the future, we may support parameterizable data widths for switchboard connections.
+
+`destination` and `flags` control how the packet is routed.  `destination` indicates the intended recipient of the packet as a flat, unsigned 32-bit integer.  This provides a mechanism where a packet can be routed through multiple hops before reaching its final destination.
+
+For example, consider using switchboard to build a simple topology in which packets can be sent from one HW block to one of two other blocks.  One could indicate which block should receive the packet using the `destination` field, with a router transmitting the packet to the right one.
+
+<img width="291" alt="image" src="https://user-images.githubusercontent.com/19254098/225485726-60ce5539-f282-4ceb-8e33-6cb2b7220ffd.png">
+
+The `last` indicator (part of the `flags` bit vector) indicates whether there is more to come as part of a transaction.  The rule is that a transmission cannot be interrupted as long as as `last` is zero.  As an example, consider the system below, where Block A and Block B are both sending SB packets to the same port on Block C, using a router to multiplex between the two.  Following the rule of unbroken transmissions, if the router starts sending a sequence of packets from Block A to Block C, it cannot switch to sending packets from Block B to Block C until it gets a packet from Block A that has `last` set to one.  It is legal to have `last=1` set in all packets, meaning that packets can be interspersed at any time.
+
+<img width="253" alt="image" src="https://user-images.githubusercontent.com/19254098/225485752-59cd02f3-6877-4cbd-960c-823276d8a815.png">
+
+The purpose of `last` is two-fold.  For one, it simplifies the process of transmitting "burstable" protocols such as UMI through switchboard.  It also provides opportunities for performance optimization.  For example, if a long sequence of SB packets is being sent over TCP, the TCP bridge knows it can wait to fill up its transmission buffer as long as `last=0`.  Without the `last` bit, the bridge would have to send each packet one at a time (or speculatively wait for more packets), since any given packet may be the last one.
+
+
+## UMI interface
+
+In addition to supporting data movement directly through SB packets, we provide a higher-level interface for running [UMI](https://github.com/zeroasiccorp/umi) transactions over switchboard connections.  The mechanisms for this can be seen in the `examples/umi*` examples.  Here's a sketch of what UMI transactions look like, adapted from the definition of `python_intf()` in [examples/umiram/test.py](examples/umiram/test.py):
+
+```python
+from switchboard import UmiTxRx
+
+umi = UmiTxRx(from_client, to_client, fresh=True)
+
+wrbuf = np.array([elem1, elem2, ...], dtype)
+umi.write(wraddr, wrbuf)
+
+rdbuf = umi.read(rdaddr, num, dtype)  # also a numpy array
+```
+
+We are no longer creating `PySbTx` and `PySbRx` objects, but rather a single `UmiTxRx` object with two SB ports: `from_client`, and `to_client`.  Transactions are sent by the Python script through the `from_client` port, and responses are received back through the `to_client` port.
+
+UMI write transactions are generated with the `umi.write()` method, which accepts an address and numpy array or scalar as arguments.  This sends out one or more [SUMI](https://github.com/zeroasiccorp/umi#4-signal-umi-layer-sumi) packets to implement the write request, packing the data, source address, destination address, and command into SB packets.  Since an SB packet is 416 bits, and the two addresses + command take up 160 bits, each SB packet contains up to 256b data.  Switchboard automatically splits up larger transactions into multiple SUMI packets as needed, incrementing the source and destination addresses automatically.  Optional arguments to `write()` control where a ack'd or non-ack'd (posted) write is used and the maximum amount of data to send in a single SUMI packet.  If an ack'd write is used, `write()` blocks until the response is received.
+
+In a similar fashion, `umi.read()` reads a certain number of words from a given address.  For example, `umi.read(0x1234, 4, np.uint16)` will send out a UMI read request with `dstaddr=0x1234`, `LEN=3`, `SIZE=1` from the SB port `from_client`.  When it gets the response to that query on `to_client`, it will return an array of 4 `np.uint16` words to the Python script.  A `umi.atomic()` method is also provided to generate UMI atomic transactions.
+
+Sometimes it is convenient to work directly with SUMI packets, for example when testing a UMI FIFO or UMI router.  For that situation, we provide `send()` and `recv()` methods for `UmiTxRx`, highlighted in [examples/umi_fifo/test.py](examples/umi_fifo/test.py).  In that exampe, we are sending SUMI packets into a UMI FIFO, and want to make sure that the sequence of packets read out of the FIFO is the same as the sequence of packets written in.
+
+The main `while` loop is essentially:
+
+```python
+txq = []
+
+while ...:
+    txp = random_umi_packet()
+    if umi.send(txp, blocking=False):
+        txq.append(txp)
+
+    rxp = umi.recv(blocking=False)
+    if rxp is not None:
+        assert rxp == txq[0]
+        txq.pop(0)
+```
+
+In other words, first try to write a random packet into the FIFO.  If successful, add it to the back of a list of outstanding packets.  Then, try to read a packet from the FIFO.  If successful, make sure that the packet is equal to the oldest outstanding packet (since this is a first-in, first-out queue) and remove that outstanding packet from our records.  Continue in a loop until a sufficient number of transactions have been checked.
+
+This code example demonstrates several features:
+1. `send()` and `recv()` for working with SUMI packets, represented using `PyUmiPacket` objects.
+2. `blocking=False` for non-blocking transactions.  `send()` returns `True` if successful and `False` otherwise; `recv()` returns a `PyUmiPacket` if successful, and `None` otherwise.  A transaction might be unsuccessful if the underlying UMI FIFO is full or empty.  For example, if we don't call `umi.recv()`, eventually the FIFO will fill, and subsequent `send()` invocations will fail (returning `False`).  Similarly, if we keep calling `umi.recv()` without calling `umi.send()`, eventually the FIFO will be empty, and `umi.recv()` will fail (returning `None`).
+3. The ability to generate random SUMI packets with `random_umi_packet()`.  Various optional arguments can constrain the opcodes, addresses, and data.
+4. `PyUmiPacket` objects can be compared using Python `==` and `!=` operators.  This checks if two packets have equal commands, addresses, and data.
+
+
+## Queue format
+
+Under the hood, SB ports are implemented using shared memory queues.  The data structure used is made simple enough that RTL running on FPGAs can directly read and write to these queues, without the need for bridge programs.  In fact, if two FPGAs have access to the same memory space, they can communicate through a shared memory queue without any involvement from the host operating system, after the initial setup.
+
+The layout of the queue is:
+* Bytes 0-3: head (int32)
+* Bytes 64-67: tail (int32)
+* Bytes 128-179: SB packet
+* Bytes 256-307: SB packet
+* Bytes 320-371: SB packet
+* ...
+* Bytes 4,032-4,095: SB packet
+
+To write an SB packet to the queue, compute `next_head = head + 1`.  If `next_head` equals `62` (the end of the queue), then set `next_head` to `0`.  If `next_head` equals `tail`, then the write fails - the queue is full.  Otherwise, write the SB packet to address `128 + (64 * head)`, and then set `head` to `next_head`.
+
+Reading an SB packet works in a similar fashion.  If `tail` equals `head`, the read fails - the queue is empty.  Otherwise, read the SB packet from address `128 + (64 * tail)`, and then increment `tail`.  If `tail` equals `62` (the end of the queue), then set `tail` to `0`.
+
+The queue implementation in C is in [switchboard/cpp/spsc_queue.h](switchboard/cpp/spsc_queue.h), with care taken to avoid memory ordering hazards, and various cache-oriented optimizations.  The queue implementation in Verilog (intended for FPGA-based emulation) can be found in [switchboard/verilog/fpga/sb_rx_fpga.sv](switchboard/verilog/fpga/sb_rx_fpga.sv) and [switchboard/verilog/fpga/sb_tx_fpga.sv](switchboard/verilog/fpga/sb_tx_fpga.sv).
+
+
+## License
+
+[Apache 2.0](LICENSE)
+
+
+## Contributing
+
+switchboard is an open-source project and welcomes contributions. To find out how to contribute to the project, see our
+[Contributing Guidelines](CONTRIBUTING.md).
+
+
+## Issues / Bugs
+
+We use [GitHub Issues](https://github.com/zeroasiccorp/switchboard/issues) for tracking requests and bugs.

switchboard_hw-0.3.0.dist-info/RECORD

@@ -0,0 +1,99 @@
+_switchboard.cpython-314-darwin.so,sha256=A04qMp5NMwVxl7GiP-ridfdLfpT8Zmu-mrT0XCkawCY,649744
+switchboard_hw-0.3.0.dist-info/RECORD,,
+switchboard_hw-0.3.0.dist-info/WHEEL,sha256=2Id6qreet5t4wZv58bZfijJ58qrc2xkw6OVvWfeqxV0,136
+switchboard_hw-0.3.0.dist-info/entry_points.txt,sha256=mghLHSk1FjnHpCIO-u3RigFOE7amAUhG5oscF7wWe18,144
+switchboard_hw-0.3.0.dist-info/top_level.txt,sha256=hDPbMY9dCMf4f2ObR5n7sLpXJwKaln0h0IvIDd_ufK8,25
+switchboard_hw-0.3.0.dist-info/METADATA,sha256=cXiJ7TQxEFG3O_eKo5Ys3-sSdyUmbRRlZqlda_g94SI,18984
+switchboard_hw-0.3.0.dist-info/licenses/LICENSE,sha256=2dqsbMlc1IxGnBJVsoUb3HtT1N0kAJnAGF9MBTqSjkw,10766
+switchboard/bitvector.py,sha256=esbnyNloyXp42x9-0pOKjE-08GAtfxIqnUWXN5ot4eU,3305
+switchboard/uart_xactor.py,sha256=5LEA0lVYo4483wOcSwyCIO26LkHJwloA5LkldrpJwjU,1701
+switchboard/util.py,sha256=Up8kV1EQ-zfZoNtjtVOtO6JOAwq0fIGaUvZu_MBvhVM,4014
+switchboard/axi.py,sha256=Nrujg5VWB-UrBSrgwTWF0Pv4NzlmVS1LK_ZlbP4nFiA,19787
+switchboard/sbdut.py,sha256=c58z1H-Qa08ci7ROmG0Tp65lrGMxNTbFVDK9LIP0ULQ,24335
+switchboard/cmdline.py,sha256=oQPL3Zo8RZteQSr5kmYlb_kSd4wOwnFjWQMPEdhW-Sc,5598
+switchboard/__init__.py,sha256=QRcRTlcsziU73yHH2IiwV8rx-nJtQ3jflPoGzh-6g78,1005
+switchboard/loopback.py,sha256=Zx1wBDrXYpUdoV04ru4QG5LfDMy59n91PTeE2eoST88,5246
+switchboard/umi.py,sha256=DB9coLwBK925yiYNboiwcSmTX0ZqTSXk2GBR7sAj7SI,26717
+switchboard/warn.py,sha256=YLI6T_WrB3mPcASvSqrSa6Nkj5X84HofPm0TOZDS4s8,311
+switchboard/verilator_run.py,sha256=apmqm_a49mSqvBN08lRHrDjmxl-ChU3rgYElq5alzTo,1012
+switchboard/test_util.py,sha256=hIC3p4v6sjanwDSUKEt-IjA2OuAkMf7_sxk6Rsp9aVw,1333
+switchboard/ams.py,sha256=6nLQZ2qha5gvaeLHiCxDQCIn2P3lFswnOrYh_HTIOTs,18067
+switchboard/autowrap.py,sha256=Tkuwj3IuneQZPCAEqq1UeWaFaKSsvLU6ZJJD3-ABOA8,28843
+switchboard/switchboard.py,sha256=DZI1pao3WQEAlPyQxSZPcH57NwM4epPfeuch48vsSLI,1506
+switchboard/gpio.py,sha256=HReAzzVoiN3MM1Xr7SstkIIr3gdV6n-BZNrdxwdfGrc,2706
+switchboard/network.py,sha256=uCCvWTnKKokXG_Ml7YLhPcHFCVTiXdLl6Bu2mzvURW4,22699
+switchboard/xyce.py,sha256=sZ02vJn0PujzuIbxZ4lKaoggmQVrBdQjMzZWUNfayuo,547
+switchboard/icarus.py,sha256=jcxwNUN0Kb3OblY_kw_I41wDRcrPA26zACJWT0-CEYo,2088
+switchboard/sbdesign.py,sha256=0_DhkQgE6TEgPicOelGbbJ4z5ANiN282hKE74X1w518,1590
+switchboard/axil.py,sha256=pD_Lo1qdxh-Zr73d9bWkLzK7G5lEQvv95XmYD4QCO1Y,12858
+switchboard/sbtcp.py,sha256=VcVJiK1wQK9V2GK7xopwUmfI2CVOyGjikez8eiIMdr8,10256
+switchboard/pytest_plugin.py,sha256=4OvYou16YhikOluwUMYt2bBg1Q5aUEkIUNtBp-GQ6U8,200
+switchboard/apb.py,sha256=oINH2AHDpIa05BL7d11ZIpAGclOmD4avcbX-tmgVOHQ,9191
+switchboard/sc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/sc/standalone_netlist_flow.py,sha256=ukouKDe3akGT-DUMpqsqKxod0wxihuTEm-nC8nIalI8,777
+switchboard/sc/sed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/sc/sed/sed_remove.py,sha256=CkyMDUURP2wVLZHRABeYQ4C96uebPCUqnxIFRU1mwlg,1074
+switchboard/sc/morty/uniquify.py,sha256=2b9ww-t-oazwebQFZifBlOcXY5S78-4KE8zGfKAbsmg,1588
+switchboard/sc/morty/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/vpi/xyce_vpi.cc,sha256=VyAFGyUztbllLnXYhhmr2PAkUwGE124XZ9haSRWONKg,4954
+switchboard/vpi/switchboard_vpi.cc,sha256=rZeZ9N-KuT97KG7jvtKOUMipY5JgPesMhtsz-lhDXIs,11038
+switchboard/dpi/switchboard_dpi.py,sha256=zwfMQaVEo4MznXCH8sVhbRUYWjQSUxeA43C6xop6EcA,317
+switchboard/dpi/xyce_dpi.cc,sha256=czJOYoBvAHXBYWLn88Ua9M6oPX1-7a56Gjf0W0skWeo,1103
+switchboard/dpi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/dpi/switchboard_dpi.cc,sha256=dWl2s6_G3orzDaYIWFsBWbtgHYfcH5cVicu0hoqHnnQ,3469
+switchboard/verilog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilog/common/uart_xactor.sv,sha256=3bx5EfE_YIXJh8N71oa9hyCbX7hj1S99p9FmfwO6tLg,7442
+switchboard/verilog/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilog/common/common.py,sha256=HnoMbzbwe6EMQByX2HWxGIXeWqycYm6oKEOYFmBRty0,599
+switchboard/verilog/common/switchboard.vh,sha256=EOvvco_Fx173LQTdRtX9dBTpiV7Lc2T4z6AEgUgAoi0,36964
+switchboard/verilog/common/umi_gpio.v,sha256=CGdrTZ8Uik7q8qI3lA6AHtdWL0UbOHojWGSzFmWtOoA,7590
+switchboard/verilog/fpga/axi_writer.sv,sha256=47DH1wXOs-OErNpvBpQ0qYuodBgeS75SwZf8KQyrZ5I,3171
+switchboard/verilog/fpga/axi_reader.sv,sha256=BvKRDDss7rhXbd9QRCioXzTSVWhbIWbw1gIGYavVfck,2061
+switchboard/verilog/fpga/sb_rx_fpga.sv,sha256=Ophq7CC_fxkgqIPs0gSQyOiVY1toC28Do4AD0HGcqRk,7821
+switchboard/verilog/fpga/fpga.py,sha256=FgaFq5gtcCWpiX8lzRX5qdL-dyqxeE-lMYrf66WH268,481
+switchboard/verilog/fpga/sb_tx_fpga.sv,sha256=fE94Vrdgbom_8sXonBh9hDcJtxitMA-AwIwLokxmMrI,7608
+switchboard/verilog/fpga/config_registers.sv,sha256=Nec_5D30NgIVekjdqhIVbkeUUREdduzTsetj68WiOyY,8478
+switchboard/verilog/fpga/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilog/fpga/memory_fault.sv,sha256=Hs0M3P-pxHuavDB2WVWnh0vY2CIuC7ZRIqJFvdU3K9c,1005
+switchboard/verilog/fpga/umi_fpga_queues.sv,sha256=DeZ_0ibOvJ7JRMr7QoiTZ_wRpwkbsWKgCzlXlQQROOw,4341
+switchboard/verilog/fpga/sb_fpga_queues.sv,sha256=MSEjp52no5YpKXnYjVK5YEi_n7fMj41XfNcW04GqnPA,13623
+switchboard/verilog/fpga/include/spsc_queue.vh,sha256=Ae640uy8p9r8mdojX1jrfb2c3iKayTMf_2tPj31i8lU,272
+switchboard/verilog/fpga/include/sb_queue_regmap.vh,sha256=_HUvT4wceII4hi_m2f46y32FDjczWq4Z5mablfDr3OE,789
+switchboard/verilog/sim/umi_to_queue_sim.sv,sha256=sjd6nYMaqO9Kpb_RQkCY-eEL8Pnt49z1hRQz2zP0Hcc,1575
+switchboard/verilog/sim/sb_axi_m.sv,sha256=a2t-O5ttWIV-Y6-ZpG5ptHOXFpZRPqOBldwnj5Xrekg,5807
+switchboard/verilog/sim/sb_axil_s.sv,sha256=007LPeLzXVhcI-rhas7JJksGydSe5pn9w_F98Z2cwIw,4714
+switchboard/verilog/sim/sb_clk_gen.sv,sha256=fwTCvi1Z6ZjpIbVvtdKqJBCaA4JIkxcrDPMv2jl_Zr4,2207
+switchboard/verilog/sim/auto_stop_sim.sv,sha256=DqWknItCjgUdLS04FknzGMdU3q3H04CmKlzA5Go39EY,468
+switchboard/verilog/sim/xyce_intf.sv,sha256=PVC5BDCWjn3-nzHvkJ_GwonqWMsf3pI0XXscPgSFPwA,1902
+switchboard/verilog/sim/sb_jtag_rbb_sim.sv,sha256=fC64xh3sd7HwPhB95cvKubNHp1WwhtgempRbNqcwnsU,4556
+switchboard/verilog/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilog/sim/umi_rx_sim.sv,sha256=rqlO4l9nDQLelacmU2mnk9D0L3qfTlnmFOgE9FBslbk,1423
+switchboard/verilog/sim/sb_tx_sim.sv,sha256=57cvx6pEUbwH5e1pZJezNoGdRU_VcfNYGhUO_4zt6Hk,1283
+switchboard/verilog/sim/switchboard_sim.py,sha256=GDKRqCrUAJuk2RT8UmCH_txKJ28ONBAJ8UZMIiQEwWU,1473
+switchboard/verilog/sim/queue_to_sb_sim.sv,sha256=it-EEo8m555YZ-CsNEp1Up4xIP5Hq80vIqmT5ElCVF0,5883
+switchboard/verilog/sim/queue_to_umi_sim.sv,sha256=djjx6jXxnb42n75jAQaTNrVy45Ok4NHt46w9MsUoFS8,1546
+switchboard/verilog/sim/sb_to_queue_sim.sv,sha256=jYSbL-N-HSxOJ7YCMSiveo9-vFm-0bPPKZVDZCbwdUM,6921
+switchboard/verilog/sim/sb_apb_m.sv,sha256=yF5hyDGwU9A6m4MXXGr3GAEp6uJ9epztqEsL_y682u4,4027
+switchboard/verilog/sim/sb_axil_m.sv,sha256=NIeyPnRV5h2c0Py2r7izVH3nGu1vdsw756rMQpBdwVo,4714
+switchboard/verilog/sim/sb_rx_sim.sv,sha256=_lZNoC2ltrH7VepawVPmu1Yz5-lALnB0tfq7llmbNzg,1286
+switchboard/verilog/sim/umi_tx_sim.sv,sha256=oYEtgVWaouKLC69IP7FpQS0ru4tYBGL0IVsHDPKMAO8,1419
+switchboard/verilog/sim/perf_meas_sim.sv,sha256=l40bL8V5A_ofiYm03RfWarcka_7WTSjj_3uROpFkbHY,3310
+switchboard/cpp/router.cc,sha256=VcNZ49M00iZFsftcC-YadQH22kR0B7Kcof_jF2H8Pj0,2786
+switchboard/cpp/umisb.hpp,sha256=zfxFK1LhUv5_z9l0HZF4KGUQQ-yTcR9ZTCt0US3adxs,9987
+switchboard/cpp/pagemap.h,sha256=AfydFiJNa6buIfOc24bMMhxd_JKL74zwSa8SsY9JIgQ,2376
+switchboard/cpp/switchboard_pcie.hpp,sha256=-p00WsgH3y-Hhxjb-ixXKwZYRsuuR4AjR2pMPcgVVIM,6188
+switchboard/cpp/Makefile,sha256=-xItDPwG4HxKLoxqUix9jWLXK5oRN44erXFG99HCPKo,291
+switchboard/cpp/xyce.hpp,sha256=pBJ8gEArUoUSL-KoQWYuxCV7y2MrJqozAWxV5g5h2RE,2351
+switchboard/cpp/umilib.h,sha256=O0jjh_CtRCLRFuWyQL3B5LkpHdaStwg5VGJGaV2QZQ0,4477
+switchboard/cpp/switchboard_tlm.hpp,sha256=jUA1Ixb6SnuRz_auH0QzBZn26ATeR-H3a9vCuaKZhCc,2514
+switchboard/cpp/switchboard.hpp,sha256=Y1fUV7cjRIPgenOe_PWlGLsKGSb4Mr1BZ9-cUKwutKg,6064
+switchboard/cpp/umilib.hpp,sha256=ktxWbbj0Lx6xAPJFryF121Sh2_v6PL6W_zqq0e9AJug,3809
+switchboard/cpp/pciedev.h,sha256=wyLaeCYBjvn8FZi-2JTNqOG2Ko5VR7zBUEmQHJ2_Mrg,4047
+switchboard/cpp/spsc_queue.h,sha256=OUtgmtV9k8Fk-1xYZwIimw5MGyCsHZcT4WXlRH6ZKag,6699
+switchboard/cpp/bitutil.h,sha256=kTj81I2lVfN1QFXgX_plMH8zeBpERqcFJ8pmwivPoBs,979
+switchboard/deps/verilog_axi.py,sha256=uRxcf7QauSQyGc-h1o4qxdEy5TX-grtiN6-7eJPBjd4,533
+switchboard/deps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilator/config.vlt,sha256=3M7kr2VAnIBS8zEJUFKiJtq-aZrinXHk9itZOn3MlTs,526
+switchboard/verilator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+switchboard/verilator/testbench.cc,sha256=bGAcj82luYYm9Gapd4VQQiTJSAE6J__cEiJboEDwENQ,4571
+switchboard/verilator/verilator.py,sha256=pk_yqqYwneg7mn3sP5lE_vqFDy93WXpNxBnb16VkwFg,312

switchboard_hw-0.3.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_11_0_arm64
+Generator: delocate 0.13.0
+

switchboard_hw-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+sbtcp = switchboard.sbtcp:main
+switchboard = switchboard.switchboard:main
+
+[pytest11]
+switchboard = switchboard.pytest_plugin

switchboard_hw-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 Zero ASIC Corporation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

switchboard_hw-0.3.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_switchboard
+switchboard