A Supercomputer For Everyone – the title of Kickstarter campaign got my attention. A single-board computer 2-core ARM with a powerful 16-core Epiphany coprocessor just for just a 99$ seemed to be an affordable option, even for a first-year student like me.
Without much hesitation, I ordered two boards and waited till 2015 to finally get them in my hands. However, that was a hectic year (graduating university, relocating to Ireland), so I didn’t have much time to get my hands dirty.
Even though I previously had an episode with eSDK and one naive attempt to do something useful with the hardware, I still felt like I scratched only the surface of Parallella true potential.
It’s 2020, the state of the world changed a lot. The parallella community doesn’t seem to be around anymore.The head of Adapteva works at DARPA and the support seems to be ~gone…
But hey! In the past 5 years, researchers from all around the world published many great papers that we could investigate.
It’s time to remove the dust from parallella boards!
For a while, I was gathering a list of things I want to learn about hardware design and low-level systems development, but as you go deeper into the rabbit hole, the more items you get. With a long "must-read" list, I decided to take a more practical approach that would prevent me from drowning in the pile of books. To be specific, I decided to find answers to the following questions by building small subproject for each topic of interest:
- How does the Epiphany chip work?
- What it takes to build ISA?
- What it takes to make Epiphany operable with the rest of the hardware on SBC? (both software and hardware side)
- What applications are suitable for the parallella board?
I documented the whole attempt in the form of miniseries.
For learning purposes, we could pick some other development boards currently available on the market, so why focusing on Parallella? A few reasons that make the board unique:
- ~90% of the design is open-sourced – that includes the schematics, hardware (Verilog) designs, etc.
- More than a few research papers are available to read
- Unique low-powered Epiphany RISC coprocessor with Zynq FPGA as interconnection layer
- C/C++ Toolchain available with plenty of examples
- Third-party frameworks available (i.e., OpenMP) or languages (i.e., epython, erlang)
- (used to be) pretty good community (forums.parallella.org)
I have been looking for another development board with a programmable coprocessor, but I couldn’t find any. The alternatives usually have embedded ASIC (like coral board) that are application-specific. While ASICs are way more performant than general-purpose CPU, there is a limited domain where those are useful. Also, for learning, research, or hacking purposes, we’d like to have something more flexible.
So what can we potentially do with Parallella? The sky’s the limit, but here are a few ideas:
- play with the FPGA, create a custom accellerator
- play with Epiphany RISC coprocessor, write highly parallel applications
- play with the Linux Kernel (i.e., how to provide communication between Epiphany and ARM CPU)
- learn about low-level system design (i.e., MMU, DMA, interrupts)
- revise your (custom) assembly knowledge by hacking the GCC or LLVM
- learn about (RT)OS systems by porting one on new, yet unsupported architecture
- exercise troubleshooting skills in heterogeneous system design
One might say we could use some other board or play with other microcontrollers like STM32?
While that is true to some extent (i.e., Epiphany chip is unique), working with well-defined systems used by hundreds of thousands of engineers is not as much fun because many things work out of the box.
Here we have a board that works, has reached a certain level of support, but still, there is plenty of room for experimentation, since "no-one tried X before" or X could be improved. I find this way of learning very rewarding.
In the series, I am going to touch many components. We’ll take a journey from hardware, kernel, compilers, and the rest of the software layer. It’s a lot to cover for one human being, so please take into account that I am not an expert in neither of those domains. I have a moderate understanding of how each layer works, and the goal here is to learn something new.
I am looking forward to your comments, critique, and suggestions!
I tried to stay honest and reference all the resources, but I might have skipped some. In general, this is a non-exhaustive list of places I drew knowledge from:
- Parallella forum
- Parallella docs:
- Various github repos:
See other posts!
- # Parallella (part 1): Case study
- # Parallella (part 10): Power efficiency
- # Parallella (part 11): malloc
- # Parallella (part 12): Tensorflow?
- # Parallella (part 13): Closing notes
- # Parallella (part 2): Hardware
- # Parallella (part 3): Kernel
- # Parallella (part 4): ISA
- # Parallella (part 5): elibs
- # Parallella (part 6): FreeRTOS