Skip to main content

You Dont Know Jack (or CXL Switch Emulation)

·792 words·4 mins
Grant Mackey

JRL is pleased to announce the first open source CXL fabric manager and orchestration tool!

Jack (Our mascot) doesn’t leave the front page of the blog for much (he likes to keep an eye on us), but for this he’ll make an appearance. We are very excited to announce our first major release of code, which is now live on GitHub! We’ll spend some more time elsewhere on the full capabilities and limitations of this release, but we wanted to share our excitement with everyone as soon as we could.

So What’s New?

Our first release is a big one, don’t expect subsequent RCs to be so daunting1. Most of the repositories are supporting libraries for Jack and our CXL Switch Emulator (CSE). The figure below gives a broad overview of the two applications we’re excited to show you.

A high-level diagram of how the ‘Jack’ CLI application interacts with the ‘CSE (CXL switch emulator)’ application to configure, modify, and orchestrate CXL devices and hosts on a CXL fabric
A high-level overview of how Jack and the CXL Switch Emulator (CSE) interact with each other.

“Jack” in this figure is a command line application that packages user intention (e.g. bind these three logical devices to VCS4) into CXL FMAPI commands and sends them to the CXL fabric orchestrator, in this case our CXL Switch Emulator (CSE). We’ll go over the full functionality and capability of this figure in future blog posts (and videos), but with these two applications you can emulate a CXL2.0 environment with full specification (errata included) compliance, which is pretty neat.

Yeah, but what can I do with this?

With Jack and CSE, you can provision a single CXL switch of as many ports as you like (but more than 32 is stretching the bounds of reality) and then connect both emulated upstream CXL ports (Root complexes of servers) and downstream CXL ports (devices). The emulated CXL devices support Type 1, 2, and 3 devices with Single or Multi-Logical device types. In addition to the gamut of CXL device types, the CXL devices with attached memory can also be stateful devices if desired.

Because Jack and CSE communicate via MCTP, they don’t need to reside within the same machine. So long as you have networking they can run independently anywhere. What this means is you can start to develop applications where the requestor and the resources are separate.

You can provision new CXL devices onto the switch, connect new ‘hosts’ to the switch, create VCS, bind devices to said VCS, tickle device registers for configuration, set QoS of memory regions and VCSs, offline/online devices nicely or abruptly, etc.

How do I get started?

First and foremost, make sure that you have a linux environment at your disposal, we don’t currently support Windows or Mac. Next, head to our GitHub to clone CSE and Jack. In both the CSE and Jack projects, the readme details the dependencies, but for ease of use we’ve included a ‘do everything’ script. Once CSE is built, move over to build Jack, then get started whipping those emulated CXL Fabrics into shape!

After both of these are built, launch CSE via cse -c config.yaml in a terminal session, then hop to another and use Jack to interact with the emulated CXL switch. In a later blog post (or video) we’ll go over the ways to configure and initialize CSE, as well as the full functionality of Jack.

I already love it, but I wish it could do [insert feature]

We love you too, smash that star button, fork us, and please send pull requests. A little tongue-in-cheek but not too much, we’ve released all of this effort as Apache-2.0 license. Contributions, bug fixes, and feature requests are welcome feedback!

What’s next?

There’s quite a lot more to do in CXL space as it relates to fabric management and orchestration, and in a later blog post we’ll outline where we’re going as it relates to that development. However in the meantime we’ve got two immediate releases to focus on. First is the release of CSE code that allows Jack to control and manage CXL qemu devices and switches through the CSE, and second is a qemu image with all of this all set up and ready to play with. We’re almost there, it’s baked but it isn’t that pretty so stay tuned.

How do I do this?

Hi there, we’re Jackrabbit Labs (JRL for short). We build open source CXL things then help you use them. If you’re finding yourself scratching your head on day 2 of your CXL deployment, or on CXL in general, please reach out. We’d love to get to know you.

  1. no promises, we may get a wild hare. But puns aside, we hope to continually contribute code to the org rather than dump in large RCs. We hope others start to contribute as well! ↩︎