https://danielmangum.com/ Recent content on Daniel Mangum Hugo -- gohugo.io en Fri, 31 Jul 2026 01:41:34 -0600 https://danielmangum.com/posts/integrated-timing-belt-loopback-fastener/ Fri, 31 Jul 2026 01:41:34 -0600 https://danielmangum.com/posts/integrated-timing-belt-loopback-fastener/ I’ve recently been working on a mechatronics project that involves constructing an X-Y cartesian motion system. I opted to use stepper motors to drive each axis, and timing belts and pulleys for translating the rotational torque of the steppers into linear motion. The timing belts need to be anchored to the component that is being actuated, which in this case is the carriage on the linear rails. Though matching toothed clamps exist, it is common, particularly in DIY projects, for timing belts to be fastened using zip ties or custom clips. https://danielmangum.com/posts/odyssey-leadership-lessons/ Mon, 27 Jul 2026 01:41:34 -0600 https://danielmangum.com/posts/odyssey-leadership-lessons/ Disclaimer: this post contains spoilers for Christopher Nolan’s 2026 depiction of The Odyssey. If you are planning to watch the movie, I would recommend doing so prior to reading, even if you are already familiar with the story. I’ve spent most of my career leading teams, including serving as CTO at Golioth prior to our acquisition by Canonical. Over the years I’ve tried to commit a significant portion of my time to listening to feedback from individuals on those teams, reflecting on my own decisions and motivations, and seeking advice and guidance from those who have been successful leaders. https://danielmangum.com/posts/jlink-jtag-pinecil/ Sat, 30 May 2026 01:41:34 -0600 https://danielmangum.com/posts/jlink-jtag-pinecil/ It has been more than two years since I bought a Pinecil soldering iron and wrote about soldering the breakout board and accessing the UART. I’ve been doing more work with the Pinecil as of late following the addition of upstream support for the Bouffalo Lab BL706 MCU in Zephyr (big shout out to @VynDragon, @will-tm, @josuah, and everyone else who has been contributing to the upstream Bouffalo Lab efforts!). https://danielmangum.com/posts/floating-point-cortex-m/ Thu, 16 Apr 2026 01:41:34 -0600 https://danielmangum.com/posts/floating-point-cortex-m/ In my recent post on the PSA Crypto API, I demonstrated the use of the API on two different MCUs: the nRF52840 and the ESP32-S3. In the case of the former, the ECDSA signature operation was eventually executed in a closed source library that manages communication between the Arm Cortex-M4 processor and the Arm TrustZone CryptoCell 310 security subsytem. Readers that ventured down the rabbit hole of links in the post may have noticed that there are variants of the nrf_cc310_mbedcrypto libraries for hard-float and soft-float. https://danielmangum.com/posts/psa-crypto-portability/ Fri, 10 Apr 2026 01:41:34 -0600 https://danielmangum.com/posts/psa-crypto-portability/ Arm’s Platform Security Architecture (PSA) was released in 2017, but it was two years until the first beta release of the PSA Cryptography API in 2019, and another year until the 1.0 specification in 2020. Aimed at securing connected devices and originally targeting only Arm-based systems, PSA has evolved with the donation of the PSA Certified program to GlobalPlatform in 2025, allowing non-Arm devices, such as popular RISC-V microcontrollers (MCUs), to achieve certification. https://danielmangum.com/posts/fooling-go-x509-certificate-verification/ Sun, 01 Mar 2026 01:41:34 -0600 https://danielmangum.com/posts/fooling-go-x509-certificate-verification/ Below are two X.509 certificates. The first is the Certificate Authority (CA) root certificate, and the second is a leaf certifcate signed by the private key of the CA. ca.crt.pem -----BEGIN CERTIFICATE----- MIIBejCCASGgAwIBAgIUda4UvlFzwQEO/fD0f4hAnj+ydPYwCgYIKoZIzj0EAwIw EjEQMA4GA1UEAxMHUm9vdCBDQTAgFw0yNjAyMjcxOTQ3NDZaGA8yMTI2MDIwMzE5 NDc0NlowEjEQMA4GA1UEAxMHUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEH A0IABKL5BB9aaQ2TtNgUymEsa/+s2ZlTXVll0N22KKWxh0N/JdgHcjrKfzqRlVrt UN2GXdvsdLOq15TxBq97WvE07lKjUzBRMB0GA1UdDgQWBBTAVEw9doSzY1DuPVxP EnwEp/+VJDAfBgNVHSMEGDAWgBTAVEw9doSzY1DuPVxPEnwEp/+VJDAPBgNVHRMB Af8EBTADAQH/MAoGCCqGSM49BAMCA0cAMEQCIHrSTk/KJHAjn3MC/egvfxMM1NpG GEzMB7EH+VXWz7RfAiAyhwy4E9hc8/qsTI+4iKf2o/zMRu5H2GNJOLqOngglbQ== -----END CERTIFICATE----- leaf.crt.pem -----BEGIN CERTIFICATE----- MIIBHjCBxAIULE3hvnYxU91g9c9H3+uGCSqXi4MwCgYIKoZIzj0EAwIwEjEQMA4G A1UEAwwHUm9vdCBDQTAgFw0yNjAyMjcxOTQ3NDZaGA8yMTI2MDIwMzE5NDc0Nlow DzENMAsGA1UEAwwEbGVhZjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABKDZ21Yh +1AQp1TrxrS8FquIVEHrFRSXncX9xl5vVhZFqvblzTp2Tg7TER5x7rHG1TIqQL1z xDX4TB+nZOWkyAcwCgYIKoZIzj0EAwIDSQAwRgIhAMeo5t2d1RWL/SB0E+mvvIZP jFT0wDWX1Bm26MtxRcf9AiEApG96fs70WF1JliFgzkTiNvbG7Gj4SvErZ9nNX/Lr PnA= -----END CERTIFICATE----- If you downloaded these certificates, you could visually see that the latter references the former as its Issuer. https://danielmangum.com/posts/making-ferrite-core-inductors-home/ Sun, 01 Feb 2026 01:41:34 -0600 https://danielmangum.com/posts/making-ferrite-core-inductors-home/ I have recently been working on tuning circuits, which typically consist of an inductor and a capacitor (i.e. an LC circuit). For those not familiar with inductors, they are passive components that store energy in a magnetic field. They oppose changes in current, meaning that they pass direct current (DC) and block alternating current (AC). While there are many types of inductors, ferrite core inductors are useful because the high magnetic permeability of ferrite leads to a significant increase in induction. https://danielmangum.com/posts/3500-miles-2025/ Mon, 19 Jan 2026 01:41:34 -0600 https://danielmangum.com/posts/3500-miles-2025/ A few months ago I wrote Make it Possible, Then Make it Normal, in which I described unceremoniously running my 3,000th mile of 2025 nearly two months before the year concluded. While I didn’t have a total mileage goal for the year, after hitting 3,000 with time to spare I naturally locked on to trying to reach 3,500. I crossed the threshold on December 30th, 2025 and finished with a final tally of 3,507. https://danielmangum.com/posts/fix-system76-laptop-20-min/ Tue, 30 Dec 2025 01:41:34 -0600 https://danielmangum.com/posts/fix-system76-laptop-20-min/ Minutes before a recent video call where I was slated to give a demo, I initiated a reboot on my System76 Oryx Pro laptop, but it did not come back up after seemingly powering off. I attempted to manually power on and found it unresponsive. The machine was connected to power, so I saw the familiar power and battery LEDs illuminated on the front of the machine. Given that the machine appeared to not even be attempting to boot, I suspected that the issue was likely related to power or the battery. https://danielmangum.com/posts/arm-cortex-m-security-state-gdb/ Wed, 24 Dec 2025 01:41:34 -0600 https://danielmangum.com/posts/arm-cortex-m-security-state-gdb/ In my day job and free time I frequently find myself debugging Arm Cortex-M microcontrollers (MCUs). In recent years, it has become more and more common for the cores in these MCUs to implement Armv8-M, with the Arm Cortex-M33 being a very popular variant. Armv8-M includes an optional security extension (Cortex-M Security Extension or “CMSE”), which is more commonly known by its marketing name, TrustZone. The security extension allows for a core, or a Processing Element (PE) if using the official terminology in Arm reference manuals, to divide memory into Secure and Non-Secure regions. https://danielmangum.com/posts/possible-then-normal/ Sun, 09 Nov 2025 01:41:34 -0600 https://danielmangum.com/posts/possible-then-normal/ This past Saturday I went out for a 12 mile run with a few friends. Absent the beautiful fall colors on display this time of year in North Carolina, there was nothing especially notable about this particular run. However, the fact that it was not notable is notable itself. Two years ago I set a goal to run 2,023 miles in 2023. After reaching that goal with time to spare, I revised the goal to 3,000 miles, and just barely reached it. https://danielmangum.com/posts/spi-routing-ice40-fpga/ Fri, 07 Nov 2025 01:41:34 -0600 https://danielmangum.com/posts/spi-routing-ice40-fpga/ A few weeks ago I posted about how much fun I was having with the Fomu FPGA development board while travelling. This project from Tim ‘mithro’ Ansell and Sean ‘xobs’ Cross is not new, but remains a favorite of mine because of how portable it is — the entire board can fit in your USB port! The Fomu includes a Lattice Semiconductor iCE40 UltraPlus 5K, which has been a popular FPGA option over the past few years due to the reverse engineered bitstream format and ability to program it with a fully open source toolchain (see updated repository here). https://danielmangum.com/posts/laptop-hdmi-monitor-sbc/ Thu, 09 Oct 2025 01:41:34 -0600 https://danielmangum.com/posts/laptop-hdmi-monitor-sbc/ Though I spend the majority of my time working with microcontroller class devices, I also have an embarassingly robust collection of single board computers (SBC), including a few different Raspberry Pi models, the BeagleV Starlight Beta (RIP), and more. Typically when setting up these devices for whatever automation task I have planned for them, I’ll use “headless mode” and configure initial user and network credentials when writing the operating system to the storage device using a tool like Raspberry Pi’s Imager. https://danielmangum.com/posts/ai-microcontrollers-registering-operators/ Mon, 14 Jul 2025 01:41:34 -0600 https://danielmangum.com/posts/ai-microcontrollers-registering-operators/ We started this series with a look at operators and kernels, the “instructions” used by models and the implementation of those instructions on the available hardware. We then explored the computation graph, which defines the sequence of operators for a given model, and explored how different model formats opt to include the explicit computation graph in the distributed file, or defer it to the inference application. With tflite-micro and the . https://danielmangum.com/posts/ai-microcontrollers-computation-graph/ Mon, 07 Jul 2025 01:41:34 -0600 https://danielmangum.com/posts/ai-microcontrollers-computation-graph/ In our last post we explored operators and kernels in Tensorflow Lite, and how the ability to swap out kernels depending on the hardware capabilities available can lead to dramatic performance improvements when performing inference. We made an analogy of operators to instruction set architectures (ISAs), and kernels to the hardware implementation of instructions in a processor. Just like in traditional computer programs, the sequence of instructions in a model needs to be encoded and distributed in some type of file, such as an Executable and Linkable Format (ELF) on Unix-based systems or Portable Executable (PE) on Windows. https://danielmangum.com/posts/ai-microcontrollers-operators-kernels/ Mon, 30 Jun 2025 01:41:34 -0600 https://danielmangum.com/posts/ai-microcontrollers-operators-kernels/ The buzz around “edge AI”, which means something slightly different to almost everyone you talk to, is well past reaching a fever pitch. Regardless of what edge AI means to you, the one commonality is typically that the hardware on which inference is being performed is constrained in one or more dimensions, whether it be compute, memory, or network bandwidth. Perhaps the most constrained of these platforms are microcontrollers. I have found that, while there is much discourse around “running AI” (i. https://danielmangum.com/posts/nrf9151-wifi-station/ Mon, 17 Feb 2025 01:41:34 -0600 https://danielmangum.com/posts/nrf9151-wifi-station/ In my last post on the Nordic Semiconductor Thingy:91 X IoT prototyping platform, I outlined the features and architecture of the device. The combination of wireless protocols on the Thingy:91 X (Bluetooth LE, LTE-M, Wi-Fi) make it a compelling foundation for a wide variety of applications. However, there are a few intricacies to the protocol support. Namely, the primary stated purpose of the Wi-Fi support is for network-based positioning (i.e. scan for local access points, send them to a server, get approximate location back). https://danielmangum.com/posts/modem-usb-rak5010/ Thu, 30 Jan 2025 01:41:34 -0600 https://danielmangum.com/posts/modem-usb-rak5010/ I have recently been working with the RAKwireless RAK5010 development board. It includes the popular Nordic nRF52840 MCU for running applications on its Cortex-M4 CPU that can leverage the integrated 2.4 GHz multiprotocol support, as well as the LTE and GNSS support offered by the on-board Quectel BG95-M3 module. The micro-USB port on the board is connected to USB on the nRF52840, which allows for viewing serial output, but is not a mechanism for flashing new firmware. https://danielmangum.com/posts/vpr-arm-risc-v-inter-processor/ Tue, 31 Dec 2024 01:41:34 -0600 https://danielmangum.com/posts/vpr-arm-risc-v-inter-processor/ In our last post, we explored the Nordic VPR RISC-V processor through the lens of the peripheral processor (PPR) on the nRF54H20. While we demonstrated how the application processor can configure and start a VPR processor, we stopped short of demonstrating any further communication between them. Most meaningful use-cases of the PPR and the FLPR, involve communicating with the controlling processor. Nordic uses two different hardware peripherals for inter-processor communication (IPC) on the nRF54H20: VEVIF (VPR Event Interface) and BELLBOARD. https://danielmangum.com/posts/vpr-nordic-risc-v-processor/ Tue, 24 Dec 2024 01:41:34 -0600 https://danielmangum.com/posts/vpr-nordic-risc-v-processor/ VPR (pronounced “Viper”) is Nordic Semiconductor’s first RISC-V processor, landing in the new nRF54H and nRF54L lines of SoCs after their initial announcements in April and October of 2023 respectively. Readers of this blog are familiar with my long-running obsession interest in RISC-V (see my RISC-V Tips and RISC-V Bytes series). However, Nordic’s introduction of a RISC-V processor is particularly interesing to me as their lineup of microcontrollers is extremely popular in low power wireless domains, a common use case for Golioth customers. https://danielmangum.com/posts/usb-uart-thingy91-x/ Sun, 15 Dec 2024 01:41:34 -0600 https://danielmangum.com/posts/usb-uart-thingy91-x/ Nordic Semiconductor recently made their new IoT prototyping platform, the Thingy:91 X, generally available. The Thingy:91 X is an upgrade to their existing prototyping platform, the Thingy:91, replacing the nRF9160 System-in-Package (SiP) with an nRF9151 SiP, the nRF52840 System-on-Chip (SoC) with an nRF5340 SoC, and adding the nRF7002 integrated circuit (IC). Each of these components enables a different type of connectivity: nRF9151: cellular (LTE-M / NB-IoT), DECT NR+, GNSS nRF5340: Bluetooth LE, 802. https://danielmangum.com/posts/this-website-is-hosted-on-bluesky/ Sun, 24 Nov 2024 01:41:34 -0600 https://danielmangum.com/posts/this-website-is-hosted-on-bluesky/ Well, not this one. But this one is! How? Let’s take a closer look at Bluesky and the AT Protocol that underpins it. Note: I communicated with the Bluesky team prior to the publishing of this post. While the functionality described is not the intended use of the application, it is known behavior and does not constitue a vulnerability disclosure process. My main motivation for reaching out to them was because I like the folks and don’t want to make their lives harder. https://danielmangum.com/posts/usb-otg-esp32s3/ Mon, 11 Nov 2024 01:41:34 -0600 https://danielmangum.com/posts/usb-otg-esp32s3/ The ESP32-S3 is a popular microcontroller (MCU) for a variety of reasons, such as its support for external pseudostatic RAM (PSRAM). One of its lesser known features is its Universal Serial Bus (USB) On-The-Go (OTG) controller. The previously released ESP32-S2, as well as the new ESP32-P4, also have USB OTG support, with the latter having two controllers. USB OTG devices can act as a device or as a host. This is a popular feature for smartphones, which, when attached to a laptop or desktop should act as a device, but may want to act as a host for some peripherals, such as a keyboard, that may be attached to it. https://danielmangum.com/posts/better-to-fail-spectacularly/ Sun, 20 Oct 2024 01:41:34 -0600 https://danielmangum.com/posts/better-to-fail-spectacularly/ Three weeks ago I wrote the following draft of a blog post entitled “Is It Better to Fail Spectacularly?”. I am having a lot of doubts. I’ve been training for the Chicago Marathon in earnest since June, but in reality the preparations began a year ago when I was accepted based on my qualifying time from the 2023 Ventura Marathon. I don’t have doubt that I can run a marathon. I have run three in the last year and a half, and I routinely go on weekend long runs that approach or surpass 20 miles. https://danielmangum.com/posts/taxonomy-hardware-security-mechanisms/ Sun, 29 Sep 2024 01:41:34 -0600 https://danielmangum.com/posts/taxonomy-hardware-security-mechanisms/ Isolating sensitive data and operations is a fundamental issue in computing. Ideally, we want to minimize the possibility of a software defect compromising the security of a device. However, in order for the software we write to be useful, it typically needs to interact with that sensitive data in some form or fashion. So how do we interact with sensitive data without being able to access it? The answer is that we bring only the operations that must access the sensitive data closer to the data, then force all other software to invoke those operations via some sort of interface. https://danielmangum.com/posts/founder-mode-non-founders/ Tue, 03 Sep 2024 01:41:34 -0600 https://danielmangum.com/posts/founder-mode-non-founders/ Paul Graham’s Founder Mode essay, based on a recent talk from AirBnB founder Brian Chesky, has been getting quite a lot of attention over the past few days. It has prompted many a quote tweet, and founders, such as Bryan Cantrill of Oxide Computer, have started contributing their own thoughts to what founder mode means to them. Having held positions of influence at a few companies, but never having been a founder myself, my initial read raised a few thoughts about my own experience of trying to “scale myself” in a growing organization. https://danielmangum.com/posts/static-alloc-external-ram-esp32/ Sun, 30 Jun 2024 01:41:34 -0600 https://danielmangum.com/posts/static-alloc-external-ram-esp32/ I frequently work with ESP32 microcontrollers (MCU), both at my day job and in my free time. These devices are very flexible, but like any microcontroller they are quite resource constrained in comparison to anything equivalent to or larger than a single-board computer. There are a few different variants of the ESP32 these days, but one of the newer and most popular is the ESP32-S3. Compared to the ESP32-S2, it offers a dual-core 32-bit Xtensa processor, support for Bluetooth 5. https://danielmangum.com/posts/wireframes-cheap-engineering-too/ Sat, 15 Jun 2024 01:41:34 -0600 https://danielmangum.com/posts/wireframes-cheap-engineering-too/ I have spent the majority of my career in engineering roles at startups. Both at companies I have worked at, and in the general startup ecosystem, I have frequently heard some variation of the refrain “engineers are expensive, but wireframes are cheap”. While I align with the underlying sentiment that doing the least amount of work to get customer signal is optimal, the phrase has always bothered me. As an engineering leader, I do not want the rest of the organization to view the work that my colleagues and I do as some luxury that should only be leveraged after we have reached complete confidence that a product or feature needs to be built. https://danielmangum.com/posts/most-important-skill-startup-engineering-leadership/ Sun, 10 Mar 2024 01:41:34 -0600 https://danielmangum.com/posts/most-important-skill-startup-engineering-leadership/ I have been very fortunate to have both worked alongside some incredible engineering leaders, as well as lead engineering teams myself. These experiences have primarily been in the context of startups that are growing rapidly in terms of both customers and employees. The longer I have worked in these environments, the more convinced I have become that there is a singular skill that ultimately decides the success of a leader, and thus their team: pacing. https://danielmangum.com/posts/risc-v-bytes-accessing-pinecil-uart-picoprobe/ Mon, 29 Jan 2024 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-accessing-pinecil-uart-picoprobe/ This post is the second in a RISC-V Bytes subseries on the PINE64 Pinecil soldering iron and development board. Previous and subsequent posts can be found under the RISC-V Bytes category. In the most recent Pinecil post, we walked through how to solder the header pins on the Pinecil breakout board. With the headers attached, we can now communicate with the Pinecil’s microcontroller via a number of protocols. Today we are going to focus on accessing the Universal Asynchronous Receiver / Transmitter (UART) hardware in order to receive serial data from the microcontroller, such as log messages, on a development machine (e. https://danielmangum.com/posts/risc-v-bytes-soldering-pinecil-breakout-board/ Mon, 22 Jan 2024 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-soldering-pinecil-breakout-board/ This post is the first in a RISC-V Bytes subseries on the PINE64 Pinecil soldering iron and development board. Subsequent posts can be found under the RISC-V Bytes category. I’ve been using the Pinecil as my primary soldering iron for a few months now. The neat thing about the Pinecil is that it is not only a highly portable USB-C powered iron, but it is also an interesting RISC-V development board. https://danielmangum.com/posts/3000-miles-2023/ Tue, 02 Jan 2024 00:10:34 -0600 https://danielmangum.com/posts/3000-miles-2023/ I spent the final week of 2022 feeling extremely sick, mostly confined to a bed. I was particularly disappointed in getting sick at that point in the year given that I was wrapping up the best running year of my life. I was very consistent with training, ran a few races, and was closing in on 1,400 miles. I am a big proponent of setting ambitious goals, and will go to pretty extreme lengths to reach them. https://danielmangum.com/posts/every-byte-wasm-module/ Fri, 22 Dec 2023 00:10:34 -0600 https://danielmangum.com/posts/every-byte-wasm-module/ In my last post, we explored how to build WASM modules, both with and without WASI support, using Clang. In a comment on Reddit, it was mentioned that much of the setup I walked through in that post could be avoided by just leveraging Zig’s WASI supprt. This is a great point, and I would recommend doing the same. The following command is inarguably simpler than what I described. $ zig cc --target=wasm32-wasi However, there are two reasons why knowing how to use Clang for compilation is useful. https://danielmangum.com/posts/wasm-wasi-clang-17/ Tue, 19 Dec 2023 00:10:34 -0600 https://danielmangum.com/posts/wasm-wasi-clang-17/ I am currently working on a few projects that involve leveraging WebAssembly (WASM) modules, particularly with WebAssembly System Interface (WASI) support. While WASI is still in its early stages, support has already been added to the Rust compiler and Clang, as well as runtimes such as wasmtime and WAMR. However, getting an environment setup to compile arbitrary C programs to WASM can still be challenging. I recently updated to Clang 17, which was first released as 17. https://danielmangum.com/posts/supercon-2023-day-3/ Mon, 06 Nov 2023 00:10:34 -0600 https://danielmangum.com/posts/supercon-2023-day-3/ Screenshot of Badgecase gallery page. The final day of Supercon 2023 had more great talks, including an incredible recollection of Restoring the Apollo Guidance Computer. However, the real highlight was seeing all of the various badge hacks starting to take their final form, ultimately culminating with the Badge Hacking Ceremony at the end of the day. Mike and I had made enough progress on Saturday after pivoting away from our PIO / DMA exploits that the remaining work on Sunday morning primarily revolved around final hardware setup and managing DNS records (riveting stuff I know! https://danielmangum.com/posts/supercon-2023-day-2/ Sun, 05 Nov 2023 00:10:34 -0600 https://danielmangum.com/posts/supercon-2023-day-2/ The energy from Friday at Supercon 2023 carried over into Saturday, and adding a stream of ongoing talks to the badge hacking and hallway track made it feel like even more was going on. The setup today was the traditional Supercon “hacker alley”, with the two talk venues connected by a long, narrow corridor packed with people, parts, and soldering irons. Space was at a premium, but interesting conversation was readily available. https://danielmangum.com/posts/supercon-2023-day-1/ Sat, 04 Nov 2023 00:10:34 -0600 https://danielmangum.com/posts/supercon-2023-day-1/ Just a few minutes after arriving at Hackaday Supercon 2023, I decided that I needed to document my experience. Working with two longtime Supercon veterans (they literally started the thing!), I had been adequately prepared for experiencing the event for the first time, but there is nothing quite like actually being there in-person. Even at 9 AM on Friday, the energy and activity was already bubbling. Despite not knowing many folks, or only knowing of them by their online presence, I felt as though I was attending a gathering of old friends. https://danielmangum.com/posts/setup-verible-verilog-neovim/ Fri, 03 Nov 2023 00:10:34 -0600 https://danielmangum.com/posts/setup-verible-verilog-neovim/ I have been using Vivado for moss RTL development, which, despite its notoriously large install size, offers a fairly decent developer experience. Or maybe I have just been using it for too long. I’m not sure I would have said this a few months ago. However, I still prefer to write Verilog in Neovim, as it allows me to use vim motions, as well as switch between RTL and software code without changing my workflow. https://danielmangum.com/posts/go-gnarly-non-nil-interfaces/ Fri, 20 Oct 2023 00:10:34 -0600 https://danielmangum.com/posts/go-gnarly-non-nil-interfaces/ Most seasoned Go programmers are familiar with the memory representation of an interface. In fact, A Tour of Go, the canonical starting point for new Go programmers, makes sure to describe how interface values contain a value and a type (for a more specific description, see Russ Cox’s blog post on how interfaces are implemented), and even goes so far as to distinguish between interface values with nil underlying values and nil interface values. https://danielmangum.com/posts/how-luts-used-storage-fpga/ Sat, 14 Oct 2023 00:10:34 -0600 https://danielmangum.com/posts/how-luts-used-storage-fpga/ If you are interested in what went into writing this blog post, you can view a replay of the livestream here. In a recent post we explored when Vivado inferred Block RAM (BRAM) for memories in FPGA designs, and when it used distributed RAM instead. While it is somewhat obvious why BRAM can be used for memory in an FPGA (i.e. it is literally a discrete memory element), distributed RAM is a bit more complicated. https://danielmangum.com/posts/value-livestreaming-long-term/ Fri, 06 Oct 2023 00:10:34 -0600 https://danielmangum.com/posts/value-livestreaming-long-term/ This is less of a blog post, and more of a collection of Friday thoughts that occurred to me on my morning run. Last night I was livestreaming some work on a new moss blog post in which I describe the use of Look-Up Tables (LUTs) as storage elements on an FPGA (this will be published in a few days). However, I ended up spending the majority of the time scouring the internet for documentation on the relationship between 5-input LUTs (LUT5) and 6-input LUTs (LUT6) on Xilinx 7 Series FPGAs. https://danielmangum.com/posts/when-vivado-infer-bram/ Sun, 01 Oct 2023 00:10:34 -0600 https://danielmangum.com/posts/when-vivado-infer-bram/ If you are interested in what went into writing this blog post, you can view a replay of the livestream here. As I’ve been working on the logic design for moss, I have been regularly investigating how Vivado translates the Verilog RTL (Register Transfer Level) source into Basic Elements of Logic (BELs), a process known as synthesis. BELs represent the physical components on an FPGA that can be used to implement a design. https://danielmangum.com/posts/microprocessors-tiny-cant-fit-in-head/ Sat, 02 Sep 2023 00:10:34 -0600 https://danielmangum.com/posts/microprocessors-tiny-cant-fit-in-head/ I have not been able to make as much progress on moss over the last 14 days or so as I would like, in large part because of limited time due to getting some exciting work across the finish line at $dayjob. However, whenever I find myself limited in the amount of “hands on keyboard” time I have to spend on a project, I try to invest more of my idle brain time (IBT, if you will) thinking about the next stages of development, as well as higher level long-term goals. https://danielmangum.com/posts/retrospective-sparc-register-windows/ Mon, 21 Aug 2023 00:10:34 -0600 https://danielmangum.com/posts/retrospective-sparc-register-windows/ As I work on moss and research modern processor design patterns and techniques, I am also looking for patterns and techniques from the past that, for one reason or another, have not persisted into our modern machines. While on a run this week, I was listening to an old Oxide and Friends episode where Bryan, Adam, and crew were reminiscing on the SPARC instruction set architecture (ISA). SPARC is a reduced instruction set computer (RISC) architecture originally developed by Sun Microsystems, with the first machine, the SPARCstation1 (a. https://danielmangum.com/posts/how-to-dissect-critical-hackernews/ Wed, 09 Aug 2023 00:10:34 -0600 https://danielmangum.com/posts/how-to-dissect-critical-hackernews/ Note: while I was writing this post, Julia Evans published a wonderful entry on her blog entitled Some tactics for writing in public. I highly recommend reading as it includes some wonderful guidance about how to preempt some of the discussion I reference in this post, as well as a short but highly relevant section on analyzing negative comments. You can think of this post as putting some of that theory into practice. https://danielmangum.com/posts/single-cycle-rv64-register-file/ Fri, 04 Aug 2023 00:10:34 -0600 https://danielmangum.com/posts/single-cycle-rv64-register-file/ It’s a simple question really: how can you read and write to the same register in a single-cycle processor? If you have spent most of your life working with software, it is tempting to think of all events as happening sequentially. However, that sequential model that we have become so familiar with as software engineers is really an abstraction that hardware offers to us to help our simple brains reason about logic. https://danielmangum.com/posts/single-cycle-multicycle-processor-performance/ Fri, 28 Jul 2023 00:10:34 -0600 https://danielmangum.com/posts/single-cycle-multicycle-processor-performance/ If you read most literature about processor design, you’ll inevitably be presented with three broad categories of CPU architectures: Single-Cycle Multicycle Pipelined We’ll just be focusing on the first two for today. In fact, my favorite introductory book on computer architecture, Computer Organization and Design (Patterson & Hennessy) progresses through Chapter 4: The Processor by explaining these three models in sequence. The first big idea can be synthesized into the following logic: https://danielmangum.com/posts/why-create-new-isa/ Fri, 21 Jul 2023 00:10:34 -0600 https://danielmangum.com/posts/why-create-new-isa/ TL;DR: even if you’re not being pragmatic, you probably don’t need to. One of the things I have been thinking about while starting to work on moss again is whether I should implement one of the many RISC-V flavors, or whether I should design an entirely new instruction set architecture (ISA). Designing a new one might seem like the ultimate bike-shedding effort, and if my immediate goal was getting something useful into production, I almost certainly would not embark on the journey. https://danielmangum.com/posts/a-three-year-bet-on-chip-design/ Wed, 19 Jul 2023 00:10:34 -0600 https://danielmangum.com/posts/a-three-year-bet-on-chip-design/ I turn 27 years old today, which feels both very old and very young. 30 is often seen as a milestone, perhaps because you have spent nearly a decade operating as an “adult”, but likely are still considered in the earlier part of your career. I am a firm believer that doing most things of significance takes at least 3 years, which makes 27 a good time to decide to commit to “doing something before you are 30”. https://danielmangum.com/posts/risc-v-bytes-semihosting-zephyr-esp32/ Tue, 30 May 2023 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-semihosting-zephyr-esp32/ Note: all analysis and code samples used in this post correspond to the v3.3.0 release of Zephyr. Having a good debugging workflow is critical to developing software quickly with high confidence. Fortunately, writing software for computers is often done, well, on a computer, meaning that while writing programs we can run other programs that help us understand the behavior of what we are writing. Typically the machine we are writing software for, though it may run in a data center and have a different form factor, doesn’t look so different from the machine we are writing it on. https://danielmangum.com/posts/risc-v-bytes-zephyr-before-main/ Fri, 28 Apr 2023 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-zephyr-before-main/ In the last two posts in the RISC-V Bytes series we have looked at a bootloader for the ESP32-C3, then built a Zephyr application that was loaded by it. In this post we’ll take a closer look at that “Hello, World” application, diving into what happens prior to printing our message to the UART console. Note: all analysis and code samples used in this post correspond to the v3.3.0 release of Zephyr. https://danielmangum.com/posts/risc-v-bytes-zephyr-on-esp32/ Mon, 17 Apr 2023 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-zephyr-on-esp32/ In the most recent post in the RISC-V Bytes series, we had our first experience with real hardware, exploring the bootloader on an ESP32-C3-DevKitC-02 module. We were using esp-idf, which, behind the scenes uses an implementation of FreeRTOS. In this post, we’ll swap out the Espressif FreeRTOS implementation for Zephyr, exploring some similarities and differences between the build process and produced artifacts. We’ll also see how we can slim down a Zephyr installation, only fetching the code and tools that we need to target the ESP32-C3 chipset. https://danielmangum.com/posts/risc-v-bytes-exploring-custom-esp32-bootloader/ Sun, 09 Apr 2023 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-exploring-custom-esp32-bootloader/ I recently acquired an ESP32-C3-DevKitC-02 module, and, as I tend to do, jumped right into reading about how the system boots and how the (pretty good!) tooling Espressif offers works. We have typically used QEMU in the RISC-V Bytes series, but getting our hands on physical hardware starts to make things feel a bit more real. In this first post on the ESP32, we’ll do some basic setup and look at a simple custom bootloader. https://danielmangum.com/posts/leap-of-faith/ Thu, 06 Apr 2023 00:10:34 -0600 https://danielmangum.com/posts/leap-of-faith/ Upbound reached General Availability on Tuesday and today is my last day at the company. It feels surreal to write that, despite knowing this day was coming for quite some time. With my time coming to a close, I wanted to take a moment to reflect on one of the most wonderful and impactful experiences of my life.1 Joining Upbound Link to heading Inception is one of my favorite movies.2 I’ve always loved the scene, and the subsequent callback to it, where Cobb is deciding whether to accept Saito’s proposal. https://danielmangum.com/posts/where-does-the-kubelet-mount-volumes/ Sat, 18 Mar 2023 00:10:34 -0600 https://danielmangum.com/posts/where-does-the-kubelet-mount-volumes/ Don’t have time to read this post? I get it. The answer to your question is /var/lib/kubelet/<pod-id>/volumes/. Every so often I will be pairing with someone or showing off a demo and realize that some common operation I perform is not well-documented. We all have examples of domain knowledge we learned somewhere along the way and stashed in our toolbox. Whenever I encounter these situations I try to remember to post about them so that the next person can find the information at least a little bit faster than I did. https://danielmangum.com/posts/k8s-asa-watching-and-caching/ Mon, 13 Feb 2023 00:10:34 -0600 https://danielmangum.com/posts/k8s-asa-watching-and-caching/ In our most recent post in the Kubernetes API Server Adventures series we took a look at the storage interface and explored the only in-tree implementation: etcd3. However, a careful read of the footnotes in that post revealed I wasn’t being completely honest about etcd3 being the only implementation. This could be disputed as Cacher is technically an implementation as well. However, it requires an underlying implementation in order to perform its operations. https://danielmangum.com/posts/k8s-asa-the-storage-interface/ Mon, 23 Jan 2023 00:10:34 -0600 https://danielmangum.com/posts/k8s-asa-the-storage-interface/ Like most API servers, a, if not the, primary function of the Kubernetes API Server is to ingest data, store it, then return it when requested. Today we are going to be focusing on how the API Server stores data. Table of Contents: The apiserver Module (👈 “I want all the details.”) The storage Package Our Good Friend etcd The API Server and etcd Calling storage.Interface Directly (👈 “Can we skip the background info? https://danielmangum.com/posts/k8s-asa-welcome/ Mon, 16 Jan 2023 00:10:34 -0600 https://danielmangum.com/posts/k8s-asa-welcome/ Kubernetes is comprised of a variety of components, yet most end-user interaction with the system flows through the API Server. It is the entrypoint to many of the features that the project has built up over its lifetime, and can be extended to support arbitrary additional functionality. Because of this, the API Server has proved to be a bottleneck in some cases that it was not originally designed to accommodate, or at least accommodate well. https://danielmangum.com/posts/risc-v-bytes-timer-interrupts/ Tue, 27 Dec 2022 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-timer-interrupts/ Operating systems do great work, but sometimes they need a little bit of help to know when to switch from one task to another. Thankfully, hardware is there to help! Today we are going to take a look at how operating systems schedule reminders for themselves using timer interrupts. Sections Link to heading Don’t care about the why and just want to see the code? Jump ahead to The Full Picture. https://danielmangum.com/posts/im-on-mastodon/ Sun, 18 Dec 2022 00:10:34 -0600 https://danielmangum.com/posts/im-on-mastodon/ Twitter has been a huge part of my online community, but it has become untenable as a platform. I have found a nice community of folks over on the types.pl server. I would love to reconnect with all of the wonderful people I have interacted with on Twitter and elsewhere. You can find me at @hasheddan@types.pl! https://danielmangum.com/posts/risc-v-bytes-go-1-19-register-calling/ Mon, 08 Aug 2022 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-go-1-19-register-calling/ In our last post in the RISC-V Bytes series, I briefly alluded to the proposal to switch the Go Application Binary Interface (ABI) from a stack-based calling convention to a register-based calling convention. I also mentioned that it appeared at that time that the RISC-V port would support the new calling convention as early as Go 1.19. Last week, Go 1.19 was officially released, and sure enough, tucked in the release notes was a section mentioning that the riscv64 port now supports passing arguments and results using registers. https://danielmangum.com/posts/risc-v-bytes-stack-use-after-return/ Mon, 01 Aug 2022 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-stack-use-after-return/ If you write any code that deals with manual memory management, you are likely familiar with the concept of a “use after free” bug. These bugs can be the source of, at best, program crashes, and at worst serious vulnerabilities. A lesser discussed counterpart to use after free, is “use after return”. In some cases, the latter can be even more troublesome, due to the operations that are performed when one procedure calls another. https://danielmangum.com/risc-v-tips/2022-07-03-dynamically-linked-binfmt-misc/ Sun, 03 Jul 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-07-03-dynamically-linked-binfmt-misc/ Today’s @risc_v Tip: If cross-compiling a dynamically linked program, then executing using binfmt_misc, you’ll need to both: Inform the OS where the dynamic linker resides (or invoke directly) Inform dynamic linker where other shared libraries reside (LD_LIBRARY_PATH) Original Tweet https://danielmangum.com/posts/sandbox-programmers/ Sun, 01 May 2022 00:10:34 -0600 https://danielmangum.com/posts/sandbox-programmers/ As a relatively young person in the technology industry who is interested in low-level software and designing hardware, but spends most of my day job working on backend and distributed systems, I frequently find myself lamenting the fact that many folks in my generation mostly grew up in a world where compute is thought of more in terms of an infinite abstract resource, rather than a capability of a physical machine. https://danielmangum.com/risc-v-tips/2022-05-14-opening-a-udp-socket-risc-v/ Thu, 14 Apr 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-05-14-opening-a-udp-socket-risc-v/ The following is an aggregation of a Twitter thread I posted on April 14th, 2022. Ever wondered how to open a UDP socket in @risc_v assembly? Wonder no more! li a0, 2 li a1, 2 li a2, 0 li a7, 198 ecall Let’s walk through it! 👇🏼🧵 The first thing to understand is that we are just a “normal” program running in user space. We don’t have special privileges in the system, and opening a socket is a privileged operation. https://danielmangum.com/posts/graceful-shutdown-responsibilities-organization/ Sun, 13 Feb 2022 00:10:34 -0600 https://danielmangum.com/posts/graceful-shutdown-responsibilities-organization/ I usually write about deep technical topics, frequently going into extreme detail about how systems work. I love a good technical challenge, but recently the most challenging thing I have been working on at my day job has not been technical. Achieving Outsized Impact Link to heading I joined Upbound essentially straight out of college after working on the open source Crossplane project on nights and weekends. The team was quite small and quite senior at that point, making me a bit of an anomaly in the organization. https://danielmangum.com/posts/the-missing-kubernetes-type-system/ Mon, 07 Feb 2022 00:10:34 -0600 https://danielmangum.com/posts/the-missing-kubernetes-type-system/ Sometimes I hear folks in the Crossplane community ask if they can just use Helm instead of opting into our package manager. The technical answer to this question is “yes”, but it typically represents a misinterpretation of what Crossplane is providing in a Kubernetes cluster. That being said, I completely understand why someone would ask this question, and quite frankly, I think the confusion is our fault. In Crossplane and across the Kubernetes community we lean in heavily to the idea that everything is “just an object”. https://danielmangum.com/posts/risc-v-bytes-rust-cross-compilation/ Sun, 30 Jan 2022 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-rust-cross-compilation/ This is part of a series on the blog where we explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. Today we are going to take a brief detour from our previous posts in this series and look at Rust Cross-Compilation for RISC-V. This will be a shorter post focused on providing useful information about how rustc works, as well as offering exact steps and configuration to target RISC-V when compiling your Rust programs. https://danielmangum.com/risc-v-tips/2022-01-17-lr-sc-release-acquire/ Mon, 17 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-17-lr-sc-release-acquire/ Tonight’s @risc_v Tip: The A extension defines 2 types of instructions for atomic operations: load-reserved/store-conditional (LR/SC) and atomic fetch-and-op (AMO). Both support acquire and release bits to impose additional ordering semantics. LR/SC uses them as follows: Note that LR.rl should not be set unless http://LR.aq is also, and http://SC.aq should not be set unless SC.rl is also. This is due to the fact that those arrangements would provide no additional ordering guarantees, but could impact performance. https://danielmangum.com/risc-v-tips/2022-01-09-rvwmo-ppo-rule-2/ Sun, 09 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-09-rvwmo-ppo-rule-2/ Today’s @risc_v Tip: The second PPO rule defines “Same-Address Load-Load” ordering. This rule serves to preserve “Coherence for Read-Read pairs” (CoRR), specifying that instructions in same hart reading same byte preserve order if return values were written by different mem ops. Original Tweet https://danielmangum.com/risc-v-tips/2022-01-06-rvwmo-ppo-rule-1/ Thu, 06 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-06-rvwmo-ppo-rule-1/ Tonight’s @risc_v Tip: The first rule in RVWMO Preserved Program Order falls under the Overlapping-Address Orderings category and ensures that any loads or stores to a memory address are ordered before a subsequent store to an overlapping memory address. Original Tweet https://danielmangum.com/risc-v-tips/2022-01-05-rvwmo/ Wed, 05 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-05-rvwmo/ Today’s @risc_v Tip: RISC-V defines its memory model (RVWMO) in the context of 3 orderings: Program Order: order of ops performed by a single hart Global Memory Order: order of ops performed by all harts Preserved Program Order: subset of program order respected globally This diagram is an abstract example, but the key points are illustrated: memory operations appear to perform sequentially in the context of a single hart, but may not be observed in the same order globally. https://danielmangum.com/risc-v-tips/2022-01-04-the-zmmul-extension/ Tue, 04 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-04-the-zmmul-extension/ Tonight’s @risc_v Tip: The Zmmul extension species only the multiplication instructions from the M extension, allowing constrained RISC-V implementations to opt not to support division. The spec calls out FPGAs as an example, as many have built-in multiplier hardware. You’ll notice that MULW is only supported on RV64 implementations. This instruction multiplies the lower 32 bits (i.e. “Multiply Word”) of rs1 and rs2 and places the sign-extension of the lower 32 bits of the result in rd. https://danielmangum.com/risc-v-tips/2022-01-02-instruction-address-misaligned-exceptions/ Sun, 02 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-02-instruction-address-misaligned-exceptions/ Today’s @risc_v Tip: Instruction-Address-Misaligned exceptions can occur when a control transfer instruction (e.g. branch / jump) provides a misaligned target. The base ISA specifies 4 byte alignment (IALIGN=32), but extensions (such as C) may relax to 2 bytes (IALIGN=16). Original Tweet https://danielmangum.com/risc-v-tips/2022-01-01-fine-grained-address-translation-cache-invalidation/ Sat, 01 Jan 2022 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2022-01-01-fine-grained-address-translation-cache-invalidation/ First @risc_v Tip of 2022! The final new extension added in the v1.12 Privileged Spec is “Fine-Grained Address-Translation Cache Invalidation” (Svinval). It breaks SFENCE.VMA into three distinct instructions, allowing for its operations to be more efficiently pipelined. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-31-napot-translation-continuity/ Fri, 31 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-31-napot-translation-continuity/ Today’s @risc_v Tip: Another new extension in the v1.12 Privileged Spec is “NAPOT Translation Continuity” (Svnapot), which allows a PTE to indicate a 64 KiB range with consistent “flags” (bits [5:0]). The lower bits of the VPN are used to replace indicator bits in PPN on read. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-30-page-based-memory-types/ Thu, 30 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-30-page-based-memory-types/ Today’s @risc_v Tip: A new version of the RISC-V Privileged Architecture (v1.12) was released on Dec 3rd. One of the larger changes is the addition of the “Page-Based Memory Types” extension (Svpbmt). It is configured in leaf PTE bits [62:61] in Sv39, Sv48, and the new Sv57. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-29-memory-ordering-fencei/ Wed, 29 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-29-memory-ordering-fencei/ Today’s @risc_v Tip: The Zifencei extension defines one instruction, FENCE.I, which orders memory writes and instruction fetches. Unlike FENCE, it only synchronizes instructions visible to a single hart. The rd / rs1 / imm[11:0] fields are reserved for future use. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-28-memory-ordering-fence/ Tue, 28 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-28-memory-ordering-fence/ Today’s @risc_v Tip: The FENCE instruction is defined as part of the base ISA and allows for explicit ordering of instructions prior to (“predecessor set”) and following (“successor set”). Types of instructions to be ordered are specified in each set using the P and S bits. Note that it is common to just see a plain fence in RISC-V assembly, which is actually a pseudoinstruction that maps to fence iorw, iorw. https://danielmangum.com/posts/risc-v-bytes-privilege-levels/ Mon, 27 Dec 2021 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-privilege-levels/ This is part of a series on the blog where we explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. It has been a bit since our last post, but today we are going to begin our journey into some of the more interesting areas of RISC-V systems. In the first post in the series, we installed our RISC-V toolchain, which included QEMU. https://danielmangum.com/risc-v-tips/2021-12-26-non-maskable-interrupts/ Sun, 26 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-26-non-maskable-interrupts/ Tonight’s @risc_v Tip: Implementations may define an arbitrary number of Non-Maskable Interrupts (NMIs). NMIs cannot be disabled and must only be used to represent hardware errors. The mcause CSR may be updated to specify a dedicated interrupt code, or otherwise must be 0. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-25-csr-clear-set-bits/ Sat, 25 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-25-csr-clear-set-bits/ Christmas @risc_v Tip: The Zicsr extension defines instructions for clearing and setting CSR bits, which are abstracted by the pseudoinstructions csrc and csrs. Example tandem usage below with bit masks (t0 / t1) to set “Machine Previous Privilege” (mstatus[12:11]): Original Tweet https://danielmangum.com/risc-v-tips/2021-12-24-4-byte-aligned-trap-vectors/ Fri, 24 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-24-4-byte-aligned-trap-vectors/ Today’s @risc_v Tip: The trap vector BASE address CSRs (mtvec / stvec) can use the lowest two bits for MODE because the BASE address must be 4-byte aligned (i.e. lowest two bits = 00). Note that a non-masked write of a valid address will overwrite MODE to Direct (00). Original Tweet https://danielmangum.com/risc-v-tips/2021-12-23-ld-default-entry-point/ Thu, 23 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-23-ld-default-entry-point/ Today’s @risc_v Tip: If using ld as your linker, a global symbol defined as start will take precedence over earlier symbols in your .text section for program entry point when explicit ENTRY is not defined in your script or via -e flag on the command line. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-22-trap-precision/ Wed, 22 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-22-trap-precision/ Today’s @risc_v Tip: Traps become more complicated in a pipelined implementation if exceptions occur after subsequent instructions have been issued. The sepc CSR holds the address of the offending instruction, but an implementation may choose whether it is precise or not. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-20-sifive-p650/ Mon, 20 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-20-sifive-p650/ Tonight’s @risc_vTip: Understanding marketing material for processors can be confusing. @SiFive recently released its highest performance RISC-V processor: P650. Let’s break down what it broadly means to be a “thirteen-stage, four-issue, out-of-order processor”. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-18-instruction-format-regularity/ Sat, 18 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-18-instruction-format-regularity/ Today’s @risc_v Tip: Regularity is a key design principle of RISC-V and has a large impact on implementation complexity. Fields always reside in the same location when present in an instruction, meaning that generic decode can be performed regardless of the eventual operation. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-14-atomicity-pmas/ Tue, 14 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-14-atomicity-pmas/ Tonight’s @risc_v Tip: Atomicity Physical Memory Attributes (PMAs) specify support for atomic instructions described in the A extension in the Unprivileged Spec for a given range. There are two types: Atomic Memory Operations (AMO) Load Reserved / Store Conditional (LR/SC) Original Tweet https://danielmangum.com/risc-v-tips/2021-12-12-physical-memory-attributes/ Mon, 13 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-12-physical-memory-attributes/ Tonight’s @risc_v Tip: Physical Memory Attributes (PMAs) define the capabilities of a given address range. A range may be mapped to main memory, I/O devices, or may be empty. PMAs include: Access Type Atomicity Memory-Ordering Coherence / Cacheability Idempotency Original Tweet https://danielmangum.com/risc-v-tips/2021-12-12-access-privilege-csr-addresses/ Sun, 12 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-12-access-privilege-csr-addresses/ Today’s @risc_v Tip: The address of a Control and Status Register (CSR) encodes access and privilege level in the top 4 bits. CSRs are accessible at their privilege level + all higher privilege levels. The Use bits further segment address space into Standard and Custom CSRs. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-11-opentitan-assembly-style-guide/ Sat, 11 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-11-opentitan-assembly-style-guide/ Today’s @risc_v Tip: Today’s tip comes courtesy of the OpenTitan (a @lowRISC project) RISC-V assembly style guide. Using n(reg) offset syntax (even if n=0) when interacting with registers that are storing pointers makes it visually clear that the contents are a memory address. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-10-xv6-teaching-os/ Fri, 10 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-10-xv6-teaching-os/ Tonight’s @risc_v Tip: MIT’s xv6 teaching OS is a great introduction to RISC-V. For example, start() contains most of the logic required to jump from Machine (M) mode to Supervisor (S) mode. Original Tweet https://danielmangum.com/risc-v-tips/2021-12-09-interrupt-controllers/ Thu, 09 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-09-interrupt-controllers/ Tonight’s @risc_v Tip: RISC-V contains a few interrupt controller specs, each providing additional functionality over basic privilege-based preemption: Core-Local Interrupt Controller (CLIC) Platform-Level Interrupt Controller (PLIC) Advanced Interrupt Architecture (AIA) The Advanced Interrupt Architecture (AIA) spec encompasses two different interrupt controllers: Advanced Platform-Level Interrupt Controller (APLIC) Incoming Message-Signaled Interrupt Controller (IMSIC) Original Tweet https://danielmangum.com/risc-v-tips/2021-12-08-hypervisor-extension/ Wed, 08 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-08-hypervisor-extension/ Today’s @risc_v Tip: The RISC-V Hypervisor extension recently reached v1.0 and was ratified. Hypervisor (HS) mode extends Supervisor (S) mode with additional CSRs and instructions, allowing for two additional privilege levels: Virtual Supervisor (VS) and Virtual User (VU). Original Tweet https://danielmangum.com/risc-v-tips/2021-12-02-open-hardware-for-the-open-cloud/ Thu, 02 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-02-open-hardware-for-the-open-cloud/ Tonight’s @risc_v Tip: Come join me (virtually or in person) on Monday to kick off #RISCVSummit! We’ll be talking about @crossplane_io and how open hardware fits into the open cloud 🏗 Schedule Original Tweet https://danielmangum.com/risc-v-tips/2021-12-01-supervisor-trap-base-address/ Wed, 01 Dec 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-12-01-supervisor-trap-base-address/ Tonight’s @risc_v Tip: The Supervisor Trap Base Address CSR (stvec) indicates the location of the Supervisor (S) trap handler(s). The BASE address may be virtual or physical, and two modes are supported, with “Vectored” allowing for different handlers for each interrupt type. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-30-supervisor-mm-fence/ Tue, 30 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-30-supervisor-mm-fence/ Tonight’s @risc_v Tip: Supervisor (S) mode has a dedicated memory-management (mm) fence instruction (SFENCE.VMA) that ensures visible stores are ordered before subsequent implicit references to mm data structures. The values of registers in rs1 and rs2 dictate behavior. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-29-sv-32-megapages/ Mon, 29 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-29-sv-32-megapages/ Tonight’s @risc_v Tip: Sv32 supports a 2-level page table, but any Page Table Entry (PTE) may be a leaf. Page tables are the size of a page, so a leaf level 1 PTE corresponds to a “megapage” (4 MiB). 1 Page = 4 KiB 1 PTE -> 1 Page 1 Page Table -> 1024 PTE 4 KiB * 1024 = 4 MiB Errata: Small correction to diagram: VPN[0] is used to populate PPN[0], while PPN[1] is populated with PPN in the Level 1 leaf PTE. https://danielmangum.com/risc-v-tips/2021-11-27-sv-32-address-translation/ Sat, 27 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-27-sv-32-address-translation/ Tonight’s @risc_v Tip: Sv32 uses a two-level page table to enable virtual memory. A virtual address contains two Virtual Page Numbers (VPN) and an offset. The Physical Page Number (PPN) of the leaf Page Table Entry (PTE) is combined with the offset to form the physical address. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-25-sum-bit-supervisor-status/ Thu, 25 Nov 2021 00:11:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-25-sum-bit-supervisor-status/ Bonus Holiday @risc_v Tip: If the SUM bit in the sstatus CSR is 0, a PTE with U=1 means the page is not accessible from Supervisor (S) mode. If SUM=1, supervisor access is permitted. A supervisor may never execute code from a page accessible from User (U) mode. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-25-sv-32-pte-permissions/ Thu, 25 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-25-sv-32-pte-permissions/ Tonight’s @risc_v Tip: A 32-bit Page Table Entry (PTE) in Sv32 virtual memory mode contains four bits that indicate access permissions. The R, W, X bits correspond to Read, Write, and Execute access respectively. The U bit indicates whether the page is accessible in User (U) mode. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-21-virtual-memory-addressing-modes/ Sun, 21 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-21-virtual-memory-addressing-modes/ Tonight’s @risc_v Tip: The satp CSR configures Supervisor (S) mode address translation and protection. RV32 and RV64 support different sets of virtual addressing schemes, which can be configured by writing MODE bits. Writing an unsupported scheme is ignored (WARL). Original Tweet https://danielmangum.com/risc-v-tips/2021-11-20-pmp-top-of-range/ Sat, 20 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-20-pmp-top-of-range/ Today’s @risc_v Tip: Our last PMP addressing mode is Top of Range (TOR). A TOR entry forms an address range from the preceding entry’s pmpaddr (inclusive) to its pmpaddr. If a TOR entry is in the first pmpconfig CSR, the bottom bound of its address range is 0. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-19-pmp-and-virtual-memory/ Fri, 19 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-19-pmp-and-virtual-memory/ Tonight’s @risc_v Tip: Physical Memory Protection (PMP) and page-based virtual memory are designed to work together. Accessing virtual memory sometimes results in physical memory accesses. In those situations, the physical memory accesses are checked against PMP entries. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-18-pmp-naturally-aligned-powers-of-two/ Thu, 18 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-18-pmp-naturally-aligned-powers-of-two/ Tonight’s @risc_v Tip: Looking again at Physical Memory Protection (PMP) address matching modes, Naturally Aligned Powers of Two (NAPOT) addressing allows you to specify ranges with four-byte granularity by encoding the size in the low-order bits of the pmpaddr CSRs. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-17-pmp-address-matching/ Wed, 17 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-17-pmp-address-matching/ Tonight’s @risc_v Tip: Yesterday we talked about the Physical Memory Protection (PMP) unit. PMP entries are defined with separate config and address CSRs. The 8-bit config CSR for an entry dedicates 2 bits (A) to defining the matching mode of its address CSR. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-16-physical-memory-protection/ Tue, 16 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-16-physical-memory-protection/ Tonight’s @risc_v Tip: An optional Physical Memory Protection (PMP) unit is defined that enables memory access control for software on a given hart. This is accomplished through a set of configuration and address CSRs, and applies to all accesses with effective mode of S or U. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-15-machine-exception-delegation-register/ Mon, 15 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-15-machine-exception-delegation-register/ Tonight’s @risc_v Tip: You might assume some exceptions, such as an ecall from User mode (U), are handled in Supervisor mode (S), but all traps are handled in Machine mode (M) by default. However, the medeleg CSR can be used to delegate some traps to a lower privilege level.. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-14-identifying-debug-triggers/ Sun, 14 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-14-identifying-debug-triggers/ Tonight’s @risc_v Tip: Continuing with the Trigger Module (TM), the RISC-V debug spec provides access to triggers via the tselect and tdata1 / tdata2 / tdata3 CSRs. A list of supported triggers for a hart can be obtained by a sequence of write / read back operations. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-13-debug-spec-architecture/ Sat, 13 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-13-debug-spec-architecture/ Today’s @risc_v Tip: RISC-V has a separate debug spec that defines a Debug Module (DM), Debug Module Interface (DMI), Debug Transport Module (DTM), and Trigger Module (TM). The TM can be implemented independently of a DM, and adds support for setting native hardware breakpoints. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-11-exceptions-interrupts-traps/ Thu, 11 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-11-exceptions-interrupts-traps/ Tonight’s @risc_v Tip: If you have ever worked with low-level programming, you may be familiar with the ambiguity of the terms exception / interrupt / trap. RISC-V clearly defines each in the unprivileged spec (S 1.6), with the definitions adhering to the IEEE-754 standard. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-10-gnu-assembler-directives/ Wed, 10 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-10-gnu-assembler-directives/ Tonight’s @risc_v Tip: The GNU assembler (gas) supports a few specific RISC-V directives, including .option, which allows you to modify assembler options inline. A common use case: temporarily disabling relaxation to perform initial global pointer load into gp register. Original Tweet https://danielmangum.com/risc-v-tips/2021-11-09-golang-compare-and-swap/ Tue, 09 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-09-golang-compare-and-swap/ Tonight’s @risc_v Tip (feat. @golang): Go uses a compare and swap (CAS) implementation similar to the example provided in the RISC-V unprivileged spec. The Go assembler always uses acquire access (aq=1) to align with the language’s memory requirements. Original Tweet https://danielmangum.com/posts/how-kubernetes-validates-custom-resources/ Mon, 08 Nov 2021 01:41:34 -0600 https://danielmangum.com/posts/how-kubernetes-validates-custom-resources/ This post references the Kubernetes codebase at commit d92a443ca7 and kube-openapi at commit ee342a809c, but should remain mostly applicable for an extended period of time barring any massive refactor to Kubernetes internals. This is also intended to be a very active read and a reference to come back to over time. There are a lot of links to source code that is not embedded because the post would have become even more unwieldy than it already is. https://danielmangum.com/risc-v-tips/2021-11-02-load-address-csr/ Tue, 02 Nov 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-11-02-load-address-csr/ Tonight’s @risc_v Tip: You can use two convenient pseudo-instructions to load the address of a symbol into a CSR. la t1, main => auipc t1, main[31:12]; addi t1, t1, main[11:0] csrw mepc, t1 => csrrw x0, mepc, t1 Original Tweet https://danielmangum.com/risc-v-tips/2021-10-30-all-harts-gdb-and-mhartid/ Sat, 30 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-30-all-harts-gdb-and-mhartid/ Tonight’s @risc_v Tip: You can list all the harts on the platform you are debugging with gdb using info threads. Switching to another hart can be done with thread <id>. A quick way to check the current hart is to display the contents of the mhartid CSR. Original Tweet https://danielmangum.com/risc-v-tips/2021-10-23-machine-and-supervisor-cause-csrs/ Sat, 23 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-23-machine-and-supervisor-cause-csrs/ Today’s @risc_v Tip: The mcause (M) / scause (S) CSRs indicate what type of exception caused a trap to the respective privilege level. A single instruction could cause multiple synchronous exceptions, in which case the register indicates event with the following priority: Original Tweet https://danielmangum.com/posts/infrastructure-in-your-software-packages/ Tue, 19 Oct 2021 01:41:34 -0600 https://danielmangum.com/posts/infrastructure-in-your-software-packages/ This post explores what a future of shipping infrastructure alongside software may look like by detailing where we are today, and evaluating how the delivery of software has evolved over time. If you just want the big ideas, skip to the final section: A New Kind of Software Marketplace. Almost all software depends on infrastructure. Installation documentation typically has a section detailing how to run with your favorite cloud provider managed services, and, if you’re lucky, may even include a script to provision that infrastructure for you. https://danielmangum.com/risc-v-tips/2021-10-17-supervisor-previous-privilege/ Sun, 17 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-17-supervisor-previous-privilege/ Today’s @risc_v Tip: The 8th bit in the Supervisor (S) Status (sstatus) CSR is called the SPP bit and indicates the hart’s privilege level before entering S mode. 0 indicates User (U) mode, and 1 indicates other. An sret instruction changes mode to U if SPP is 0 and S if 1. Original Tweet https://danielmangum.com/risc-v-tips/2021-10-16-hpm-hardware-performance-monitoring/ Sat, 16 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-16-hpm-hardware-performance-monitoring/ Today’s @risc_v Tip: Machine (M) mode supports hardware performance monitoring (HPM) with the following CSRs: mcycle: number of clock cycles executed minstret: number of instructions retired mhpmcounter[3-31]: event counters mhpmevent[3-31]: event selectors Original Tweet https://danielmangum.com/risc-v-tips/2021-10-12-supervisor-address-translation-and-protection/ Tue, 12 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-12-supervisor-address-translation-and-protection/ Today’s @risc_v Tip: The satp (Supervisor Address Translation and Protection) CSR contains virtual memory translation information, including MODE. Valid modes for RV32 & RV64 include: RV32: Bare / Sv32 RV64: Bare / Sv39 / Sv48 Bare indicates no translation or protection. Original Tweet https://danielmangum.com/risc-v-tips/2021-10-09-three-main-privilege-levels/ Sat, 09 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-09-three-main-privilege-levels/ Today’s @risc_v Tip: RISC-V systems may support 3 main privilege levels: Machine (M) (Req.) Supervisor (S) (Opt.) User (U) (Opt.) Execution context changes via traps. A trap that moves to a higher privilege level is a vertical trap, one that does not is a horizontal trap. Original Tweet https://danielmangum.com/risc-v-tips/2021-10-03-csr-field-behaviors/ Sun, 03 Oct 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-10-03-csr-field-behaviors/ Today’s @risc_v Tip: Fields of CSRs adhere to one of the following behaviors: WIRI: Reserved Writes Ignored, Reads Ignore Values WPRI: Reserved Writes Preserve Values, Reads Ignore Values WLRL: Write/Read Only Legal Values WARL: Write Any Values, Reads Legal Values Original Tweet https://danielmangum.com/risc-v-tips/2021-09-26-hart-state-management/ Sun, 26 Sep 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-09-26-hart-state-management/ Today’s @risc_v Tip: You likely think “Hardware Security Module” when you see “HSM”. When working with RISC-V systems you’ll frequently see the term “Hart”, which is a “Hardware Thread”, and in related contexts “HSM” will typically refer to “Hart State Management”. Original Tweet https://danielmangum.com/risc-v-tips/2021-09-22-qemu-bios-opensbi/ Wed, 22 Sep 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-09-22-qemu-bios-opensbi/ QEMU @risc_v Tip of the Night: Running without -bios specified or with -bios default will automatically load the OpenSBI binary. Original Tweet https://danielmangum.com/risc-v-tips/2021-09-10-view-registers-gdb/ Sun, 19 Sep 2021 00:10:34 -0600 https://danielmangum.com/risc-v-tips/2021-09-10-view-registers-gdb/ GDB tip of the day: info registers will show you the contents of general purpose registers, but info all-registers will expand the output to floating point registers and CSRs. Original Tweet https://danielmangum.com/posts/risc-v-bytes-intro-instruction-formats/ Mon, 12 Jul 2021 00:10:34 -0600 https://danielmangum.com/posts/risc-v-bytes-intro-instruction-formats/ This is part of a series on the blog where we explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. So far in this series, we have been looking at the assembly generated when compiling relatively simple programs. At this point, we have seen instructions that perform a wide variety of operations. Let’s take another look at our minimal example from the Passing on the Stack post: https://danielmangum.com/posts/research-triangle-risc-v-group/ Fri, 02 Jul 2021 01:41:34 -0600 https://danielmangum.com/posts/research-triangle-risc-v-group/ I am excited to announce the launch of the Research Triangle RISC-V Community Group! As evidenced by my recent posts and conference talks, I have been spending more and more time learning and working in and around the RISC-V community. While there are numerous commercial benefits of an open source instruction set architecture (ISA), I am particularly excited about the opportunities it provides for folks like myself who do not have formal training in processor design. https://danielmangum.com/posts/risc-v-bytes-passing-on-the-stack/ Wed, 30 Jun 2021 01:41:34 -0600 https://danielmangum.com/posts/risc-v-bytes-passing-on-the-stack/ This is part of a series on the blog where we explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. I once took a class on compilers where my professor told us that a CPU is like a human brain: it can store important data and access it quickly, but there is a limit to the amount of data that can be stored. https://danielmangum.com/posts/stepping-away-upstream-kubernetes/ Tue, 22 Jun 2021 01:41:34 -0600 https://danielmangum.com/posts/stepping-away-upstream-kubernetes/ This post is adapted from my message sent to the Kubernetes SIG Release mailing list. I got involved in the Kubernetes community right after finishing school, primarily by working on the tooling used to test and release each of the components of the project. From the beginning, I was shown a tremendous amount of respect and care, and that has remained constant since. That being said, over the past two years I have seen my interests evolve rapidly. https://danielmangum.com/posts/risc-v-bytes-caller-callee-registers/ Fri, 18 Jun 2021 01:41:34 -0600 https://danielmangum.com/posts/risc-v-bytes-caller-callee-registers/ This is part of a new series I am starting on the blog where we’ll explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. When looking at the generated assembly for a function, you may have noticed that the first few instructions involve moving values from registers to the stack, then loading those values back into the same registers before returning. https://danielmangum.com/posts/risc-v-bytes-qemu-gdb/ Tue, 01 Jun 2021 01:41:34 -0600 https://danielmangum.com/posts/risc-v-bytes-qemu-gdb/ This is part of a new series I am starting on the blog where we’ll explore RISC-V by breaking down real programs and explaining how they work. You can view all posts in this series on the RISC-V Bytes page. To start of the series, we are just going to get setup to do some exploration. I am going to assume you will not primarily be using a RISC-V machine1, so we need to configure our local development environment for cross-platform compiling, emulation, and debugging. https://danielmangum.com/posts/config-map-oci-image-cache/ Sat, 22 May 2021 01:41:34 -0600 https://danielmangum.com/posts/config-map-oci-image-cache/ For folks familiar with Crossplane, you likely know that we adopt the design practice of using interfaces over implementations as frequently as possible. Even if we begin with an implementation, such as the current composition engine, we make sure to consider a future with potentially many implementations for the same functionality. One of the places where we have taken advantage of Kubernetes’ similar approach to interfaces is in how we cache Crossplane package images. https://danielmangum.com/posts/runc-chdir-to-cwd/ Sun, 18 Apr 2021 01:41:34 -0600 https://danielmangum.com/posts/runc-chdir-to-cwd/ This post describes a breaking change in runc v1.0.0-rc93, that has subsequently had a workaround implemented that will presumably be included in v1.0.0-rc94. Thanks to @haircommander for talking through the issue with me and implementing the subsequent workaround, and to @mattomata for his consultation on the distroless/static:nonroot behavior. If you are not interested in the background of the issue, you can skip reading this post and take a look at my detailed testing scenarios on the Crossplane repo, or my breakdown of the conflict with the nonroot image on the distroless repo. https://danielmangum.com/posts/crossplane-infrastructure-llvm/ Sat, 13 Mar 2021 01:41:34 -0600 https://danielmangum.com/posts/crossplane-infrastructure-llvm/ If I was to explain LLVM in a painfully simple manner, I might say something like: “LLVM is a framework that allows you to define a syntax for interacting with computers, and instantly have it work for all computers”. This description does a colossal disservice to the scope of the project, but it serves to illustrate the basic idea: there are many languages (frontends) and many CPU architectures (backends) and we don’t want to re-implement every translation permutation. https://danielmangum.com/posts/controller-runtime-scrape-prometheus-local/ Sat, 20 Feb 2021 01:41:34 -0600 https://danielmangum.com/posts/controller-runtime-scrape-prometheus-local/ controller-runtime exposes a metrics server by default on port 8080 for any controller Manager. Metrics are registered for the client, workqueue, and on a per-controller basis. Controllers initialize metrics when started, and write to the registry at various points throughout operation, such as when processing items off the workqueue and after completed reconciliation loops. If you are using a framework like Kubebuilder, it will generate manifests for the necessary objects, such as a ServiceMonitor, to scrape these metrics using kube-prometheus in your Kubernetes cluster. https://danielmangum.com/posts/controller-runtime-client-go-rate-limiting/ Sun, 14 Feb 2021 01:41:34 -0600 https://danielmangum.com/posts/controller-runtime-client-go-rate-limiting/ If you have written a Kubernetes controller, you are likely familiar with controller-runtime, or at least client-go. controller-runtime is a framework for building controllers that allows consumers to setup multiple controllers that are all handled under a controller manager. Behind the the scenes, controller-runtime is using client-go to communicate with the Kubernetes API server to watch for changes on resources and pass them along to the relevant controllers. It handles a number of aspects of plumbing up these controllers, including caching, queuing, and more. https://danielmangum.com/posts/kubecon-na-20-infra-control-plane/ Wed, 09 Dec 2020 05:51:26 -0500 https://danielmangum.com/posts/kubecon-na-20-infra-control-plane/ I had the privilege of joining Steven Borrelli from Mastercard for a tutorial at Kubecon North America 2020 on building an enterprise infrastructure control plane on Kubernetes using Crossplane. Relevant links and the talk recording can be found below. Slide Deck Source Code Text Transcript Please feel free to send me a message @hasheddan on Twitter with any questions or comments! https://danielmangum.com/posts/vivado-2020-x-ubuntu-20-04/ Sun, 06 Dec 2020 05:51:26 -0500 https://danielmangum.com/posts/vivado-2020-x-ubuntu-20-04/ Vivado is Xilinx’s IDE for HDL synthesis and analysis. It is a powerful tool, but can be a bit of a pain to setup and use. I recently went through the installation process on my main development machine, where I cam currently running Ubuntu 20.04, after I purchased a Digilent Arty A7-35T development board, which is designed around the Xilinx Artix-7 FPGA. While it didn’t take too long to get up and running (ignoring the time waiting for the actual installation to complete), I found the existing installation documentation quite verbose, which made following along more difficult than it should have been. https://danielmangum.com/posts/crossplane-packages-k8s-features/ Mon, 30 Nov 2020 05:51:26 -0500 https://danielmangum.com/posts/crossplane-packages-k8s-features/ The following is an unroll of a tweet thread about Crossplane packages that I posted after reading Dave Anderson’s post “A better Kubernetes, from the ground up”. I found many of the points in the post compelling, but feel that the existing extensibility model of Kubernetes allows for implementing at least some of the desired features without tearing down the entire system, as evidenced by the implementation of Crossplane packages. It is my hope that some of the design decisions we have made with Crossplane can be generally abstracted and improved upon to continue to enhance the Kubernetes ecosystem. https://danielmangum.com/posts/non-local-jumps-riscv/ Sun, 25 Oct 2020 18:51:26 -0500 https://danielmangum.com/posts/non-local-jumps-riscv/ This post explores RISC-V assembly by examining the implementation of the setjmp and longjmp functions from the C standard library. I frequently find that I grasp concepts more quickly when I have actual code that I can disassemble because it allows me to connect information with intent. I believe RISC-V and similar efforts will fundamentally shift how computers are made and programmed. I hope that sharing my knowledge will inspire the same joy in others that I feel when imagining a future of open hardware. https://danielmangum.com/posts/podcast-fullstackjourney-crossplane/ Tue, 20 Oct 2020 18:51:26 -0500 https://danielmangum.com/posts/podcast-fullstackjourney-crossplane/ I joined Scott Lowe on the Full Stack Journey podcast for a chat about how Crossplane enables you to provision infrastructure from your Kubernetes cluster and allows you to compose abstractions that define your own PaaS. You can listen here. https://danielmangum.com/posts/upper-v-lower-extensions-assembly/ Sun, 18 Oct 2020 18:51:26 -0500 https://danielmangum.com/posts/upper-v-lower-extensions-assembly/ If you have ever written assembly for the GNU Assembler (GAS), you may have noticed that files sometimes have an .S extension and sometimes .s. This is not a meaningless distinction, and you could have a frustrating time if you accidentally use the wrong one. The uppercase .S indicates that the file contents should be run through the preprocessor, while the lowercase .s indicates that the file contents should be assembled directly. https://danielmangum.com/posts/podcast-droiddevcast-rapid-prototyping/ Fri, 25 Sep 2020 18:51:26 -0500 https://danielmangum.com/posts/podcast-droiddevcast-rapid-prototyping/ I joined Rin Oliver on the esper.io DroidDevCast for a chat about rapid prototyping. You can listen here. https://danielmangum.com/posts/podcast-lote-crossplane-kubernetes/ Wed, 08 Jul 2020 18:51:26 -0500 https://danielmangum.com/posts/podcast-lote-crossplane-kubernetes/ I joined Daniel Bryant on the Ambassador Livin’ on the Edge podcast for a chat about Crossplane, building your own PaaS, and the future of multi-cluster Kubernetes. You can listen here. https://danielmangum.com/posts/crossplane-openfaas/ Mon, 30 Mar 2020 14:39:17 -0500 https://danielmangum.com/posts/crossplane-openfaas/ I had the opportunity to write up a recap and guide for the livestream I did with Alex Ellis on using Crossplane with OpenFaas. It is available here. https://danielmangum.com/posts/crossplane-aws-open-source/ Tue, 10 Mar 2020 14:39:17 -0500 https://danielmangum.com/posts/crossplane-aws-open-source/ I had the privilege of writing a guest post on the AWS Open Source Blog entitled “Connecting AWS managed services to your Argo CD pipeline with open source Crossplane”. You can read it here. https://danielmangum.com/posts/podcast-changelog-kubecon-crossplane/ Fri, 27 Dec 2019 18:51:26 -0500 https://danielmangum.com/posts/podcast-changelog-kubecon-crossplane/ Jared Watts, Marques Johansson, and I sat down for a chat about Crossplane and the cloud native community with Gerhard Lazu on the Changelog Podcast at Kubecon North America 2019. You can listen here. https://danielmangum.com/posts/please-mind-your-metaphors/ Mon, 19 Aug 2019 00:07:58 -0500 https://danielmangum.com/posts/please-mind-your-metaphors/ Note: While writing this post, I looked back at a post I wrote entitled Understanding ETL to ELT by Going to Costco. That post does exactly what I say we should not do in this post. It takes a process and explains it using a metaphor that cannot hope to fully encompass what I try to say. I do think that metaphors can be somewhat useful when attempting to give a high-level overview of a subject, but I think I did it rather poorly in that post. https://danielmangum.com/posts/tf-remote-state-backend-locking/ Mon, 17 Jun 2019 00:31:39 -0500 https://danielmangum.com/posts/tf-remote-state-backend-locking/ This is the first installment of HashiCode, a blog post series where I go through the source code of HashiCorp tools to learn more about what happens behind the scenes when you interact with tools as a user. Disclaimer: this episode is referencing code from the Terraform codebase as of commit 43a7548. Becuase Terraform is a constanly evolving open source tool, the code is subject to change. However, the ideas expressed will largely remain the same. https://danielmangum.com/posts/introducing-hashicode/ Mon, 17 Jun 2019 00:21:59 -0500 https://danielmangum.com/posts/introducing-hashicode/ Today I am excited to announce a new series of blog posts called HashiCode. I have been involved with the HashiCorp community for some time now, and I have loved the opportunity to contribute to some of my favorite tools because of the open source model of the company. Recently, I have been organizing the new HashiCorp User Group in St. Louis, a market that is starting to show a lot of interest in the various products the company offers. https://danielmangum.com/posts/presence-vs-planning/ Wed, 22 May 2019 16:36:56 -0500 https://danielmangum.com/posts/presence-vs-planning/ Sometimes I find it hard to focus on the work I am doing. It can be easy to constantly be evaluating how everything you are doing affects the present, affects your future, and affects those around you. These are good questions to be asking, but at the right time. If we are always planning, how are we ever going to get anything done? On the other hand, if we are never planning, how do we have context when choosing what to do next? https://danielmangum.com/posts/etl-to-elt/ Sat, 13 Apr 2019 14:39:17 -0500 https://danielmangum.com/posts/etl-to-elt/ If you have dealt with any data platform in the last few years, you have likely heard about the movement from traditional ETL (Extract Transform Load) to ELT (Extract Load Transform). The name ELT is self-explanatory as the sequential order of tasks is switched such that loading comes before the transformation, but it takes a little more investigation to understand why the movement has taken place and how it is even possible. https://danielmangum.com/posts/aws-solutions-architect-associate-exam-reflections/ Mon, 11 Feb 2019 15:41:34 -0600 https://danielmangum.com/posts/aws-solutions-architect-associate-exam-reflections/ I passed the AWS Solutions Architect Associate Certification Exam today and I wanted to write up a few immediate thoughts because I still feel as though the process is somewhat opaque for most people. Part of this may be because of the NDA that you are required to agree to prior to taking the exam. To be clear, everything mentioned in this post will be from a broad perspective and will not include any questions, materials, or test-specific information. https://danielmangum.com/posts/why-you-shouldnt-use-parameters-with-cloudformation-templates/ Thu, 07 Feb 2019 15:17:47 -0600 https://danielmangum.com/posts/why-you-shouldnt-use-parameters-with-cloudformation-templates/ ^Run-Time (I admit that the title is intended to be clickbait) CloudFormation has become a popular Infrastructure as Code (IaC) tool for organizations that use AWS exclusively as their cloud provider (whether it should be or not is another whole discussion). The tool features the ability to add parameters to your configuration scripts (written in either YAML or JSON). However, I will argue in this post that you should not use parameters in your (top-level) scripts by enumerating Adam Jacob’s (creator of Chef) 10 principles of IaC as detailed in his chapter in Web Operations and illustrating how the use of parameters either violates or does not add any further value for each of them. https://danielmangum.com/posts/dockerfile-for-building-ionic-apps/ Tue, 16 Oct 2018 22:33:54 -0500 https://danielmangum.com/posts/dockerfile-for-building-ionic-apps/ Building apps using Ionic is useful for the ability to build for both IOS and Android from the same codebase. However, mostly because Ionic is build on top of the Apache Cordova framework, it can be difficult to make sure your environment is configured with the required version of each build component. This is where Docker can be helpful. You can create a container that has a consistent environment and run it locally to build your project. https://danielmangum.com/posts/simple-linux-command-line-using-docker/ Sat, 13 Oct 2018 13:21:42 -0500 https://danielmangum.com/posts/simple-linux-command-line-using-docker/ Docker containers are widely used for developing and running anything from web applications to redis caches. However, they can also be useful for running what can effectively be a light VM (a container operates very differently from a VM, but we are just talking about the use case). I like to use a container for accessing the the Linux command line. However, many users do not know how to run a container in the background and access the shell. https://danielmangum.com/posts/local-kong-go-web-server/ Thu, 26 Jul 2018 15:52:16 -0600 https://danielmangum.com/posts/local-kong-go-web-server/ This guide will teach you how to run the Kong API gateway locally as a proxy server for a Golang API using Docker. The Go API Link to heading The Golang standard library has a very simple http library that makes it very easy to spin up a web server. For now, we will build the simplest implementation of a web server. Start by creating a new directory in your go/src/. https://danielmangum.com/posts/why-i-am-starting-a-blog/ Wed, 20 Jun 2018 20:18:47 -0600 https://danielmangum.com/posts/why-i-am-starting-a-blog/ I have always been envious of developers who share valuable information on their blog. I have thought for a long time that I wanted to be one of those developers that became famous in programming circles for the insight they shared. However, this also led me to be intimidated by the idea of writing my own posts. How could I ever measure up to these developers? That mindset changed when I realized how much I had benefitted in work, school, and on personal projects from the blog posts of developers. https://danielmangum.com/about/ Mon, 01 Jan 0001 00:00:00 +0000 https://danielmangum.com/about/ My name is Daniel Mangum and I am the Chief Technology Officer at Golioth, where I lead engineering efforts that span hardware, firmware, and cloud software. Previously, I was a principal software engineer at Upbound where I helped build Upbound Cloud, Upbound Marketplace, and the open source Crossplane project. Prior to Upbound, I worked as a counsultant on large-scale cloud deployments at Fortune 500 companies. I have participated in multiple open source communities, including holding leadership positions in the Kubernetes project.