Compute The Mandelbrot Set With A Custom RISC-V CPU

When faced with an FPGA, some people might use it to visualize the Mandelbrot set. Others might use it to make CPUs. But what happens if you combine the two? [Michael Kohn] shows us what happens with his RISC-V CPU with an instruction specially made for computing the Mandelbrot set.

[Michael] takes us through the unusual process of turning his 8008 into a RISC-V CPU. Re-using bits of logic here and replacing other logic there leaves him with a functional RISC-V core. Not finished, [Michael] takes it upon himself to also create a custom instruction just for computing a point for the Mandelbrot set, accelerating the demo from twenty-three seconds to merely one!

Still not finished, [Michael] also creates an implementation of the long gone F100-L CPU, once again with added Mandelbrot set flair, simultaneously with the RISC-V project. Finally, he ports his “Java Grinder” Java bytecode compiler to both RISC-V and the F100-L, because Java runs on 1 Billion devicesTM.

Raspberry Pi Pico Parallel Mandelbrot Computation

The Mandelbrot set is — when visualized with some colors — an interesting shape with infinite detail. While the patterns are immediately obvious to the human eye, anyone who’s run one can tell you that they’re pretty computationally expensive to produce. Fortunately, as with many things in graphics, rendering the Mandelbrot set can be easily parallelized.

That’s what [rak277] and [ir93] demonstrate in their RP2040-based finals project. Computron, as they call it, is a network of Raspberry Pi Picos that work together to compute a visualization of the Mandelbrot set and show it on a VGA display. The Computron is made of two or more “math units” and one “projection unit”. The math units communicate over a shared I²C bus with the projection unit to first divide the workload and then compute their share of the work.

This project shows both the strengths and limitations of parallel computation. It makes use of multiple math units on a highly parallelizable workload, but as more math units are added there are diminishing performance gains due to the increased communications load on the network, which [rak277] and [ir93] suspect to be the current bottleneck in the Computron.

If you’re fresh out of Pi Picos, and don’t mind waiting awhile, you could always crank out a Mandelbrot set on your trusty Atari 800 in BASIC.

Zooming Through The Mandelbrot Set On An Atari

The Mandelbrot set, according to Wikipedia, is “the set of complex numbers $c$ for which the function $f_{c}(z)=z^{2}+c$ does not diverge.” Even if you don’t understand the mathematics behind it, you’ve likely seen the complicated fractal images generated by zooming in on the border of the Mandelbrot set. [Scott Williamson] not only got this set rendering on an Atari, but managed to create animated videos of the results.

Doing the work was no mean feat. While it takes just 10 lines of Atari BASIC to render the set on an Atari 800, getting the animations made and into a modern video format took much effort. [Scott] used the Atari800Win-PLus emulator to zoom in on a variety of locations on the fractal curve and recorded the results over a weekend.

However, compositing the various frames into smooth-scrolling videos took more effort, with a Python script and `ffmpeg` required to stitch everything together into the results you see on YouTube. The final videos were combined with Atari chiptune music from [Adam Sporka] to help round out the presentation.

The result is reminiscent of an old-school demo, even if everything here was assembled slowly on modern computers from the raw Atari output. We’ve seen other great Mandelbrot feats before, too, like this real-time explorer built on an FPGA. Video after the break.

Dancing Mandelbrot Set On A FPGA

This FPGA based build creates an interesting display which reacts to music. [Wancheng’s] Dancing Mandelbrot Set uses an FPGA and some math to generate a controllable fractal display.

The build produces a Mandelbrot Set with colours that are modified by an audio input. The Terasic DE2-115 development board, which hosts a Cyclone IV FPGA, provides all the IO and processing. On the input side, UART or an IR remote can be used to zoom in and out on the display. An audio input maps to the color control, and a VGA output allows for the result to be displayed in real time.

On the FPGA, a custom calculation engine, running at up to 150 MHz, does the math to generate the fractal. A Fast Fourier transform decomposes the audio input into frequencies, which are used to control the colors of the output image.

This build is best explained by watching, so check out the video after the break.

Generating The Mandelbrot Set With IBM Mainframes

[Ken Shirriff] is apparently very cool, and when he found out the Computer History Museum had a working IBM 1401 mainframe, he decided to write a program. Not just any program, mind you; one that would generate a Mandelbrot fractal on a line printer.

The IBM 1401 is an odd beast. Even though it’s a fully transistorized computer, these transistors are germanium. These transistors are stuffed onto tiny cards with resistors, caps, and diodes, than then stuck in a pull-out card cage that, in IBM parlance, is called a ‘gate’. The computer used decimal arithmetic, and things like ‘bytes’ wouldn’t be standard for 20 years after this computer was designed – 4,000 characters of memory are stored in a 6-bit binary coded decimal format.

To the modern eye, the 1401 appears to be a very odd machine, but thanks to the ROPE compiler, [Ken] was able to develop his code and run it before committing it to punched cards. An IBM 029 keypunch was used to send the code from a PC to cards with the help of some USB-controlled relays.

With the deck of cards properly sorted, the 1401 was powered up, the cards loaded, and the impressive ‘Load’ button pressed. After 12 minutes of a line printer hammering out characters one at a time, a Mandelbrot fractal appears from a line printer. Interestingly, the first image of the Mandelbrot set was printed off a line printer in 1978. The IBM 1401 was introduced nearly 20 years before that.