For years, single board computers have been tightly coupled to motherboards. They performed similar tasks and both strived towards faster speeds, better graphics, and better memory. With the advent of hobbyist SBCs like the Raspberry Pi 3 that perform basic tasks acceptably and require a much smaller financial investment, we have seen a split in single board computers. Some, like the Pi and BeagleBone, aim for wide acceptance and a reasonable price point. Others, like the NVIDIA Jetson and Intel Joule 570x, are still pushing the capability boundaries for SBCs.
Architecture Basics
It’s a tale as old as time –RISC vs. CISC. People tend to pick a favorite side based on experiences with desktop computers and phones or other high-level interactions with devices grounded on these architectures, but the SBC market has given people a more intimate view on the differences and benefits.
The CPU (central processing unit) of a device, whether RISC or CISC, uses special code called “instructions” to control the surrounding hardware. These instructions make up assembly code, which is one of the final layers of abstraction from the actual binary code and extremely granular, though somewhat human readable.
Figure 1. A64 Assembly code, like what would run on the Raspberry Pi.
RISC stands for “Reduced Instruction Set Computing”, while CISC stands for “Complex Instruction Set Computing”. RISC instructions, like those shown above, are simple enough to be considered executable within a single clock cycle. These include basic instructions like ADD, SUB (subtract), MOV (move) and BIC (bitwise bit clear). RISC code looks longer because each operation must be done in multiple, simple steps, but it is a closer one-to-one representation of how the processor is interpreting the code. CISC allows more complex operations like IMUL (signed multiply) and MOVS (move data from string to string) that cannot be completed in a single clock cycle and would require several lines of code in RISC assembly.
Detailed discussion of these two architectures has been the subject of entire books. For our purposes, the important points are that CISC programs are shorter and therefore require less RAM, but RISC programs allow for higher clock speeds because more complex instructions limit the max clock speed of a CPU. Early computers were almost entirely built using CISC, but as RAM decreased in price, RISC became the more common architecture. ARM has traditionally used RISC for the potential power savings, and thus ARM cores are typically efficient and commonly used in embedded or mobile designs. Intel is the biggest name that still uses CISC, and they use the complex instructions to their advantage in high-end computers and servers that do not need to conserve battery life or worry as much about heat.
Implications for Single Board Computers
When it comes to purchasing a single board computer, the considerations come down to more than just preference. Embedded processors (almost always RISC) dominate the hobbyist SBC space because of their efficiency and speed. The Dragonboard410c is based on Qualcomm’s Snapdragon410c processor, which is found in many cell phones.
Boards like this expose the highest possible performance of the core to allow the best experience for development and experimentation. These boards can run Android like a phone yet use a 1080 HDMI display and accept a USB keyboard/mouse like a standard desktop computer, eliminating the need for a developer to hop between virtual environments. Unfortunately, these boards do not necessarily mitigate any of the downsides of an embedded processor. Mobile processors like the Snapdragon 410 use 1.8V GPIO, which can be difficult to integrate with sensors or other hardware. Developers may also run into the inherent memory or speed limitations of the core if they try to use it as a proper desktop computer.
A board like the Intel Joule 570x, however, is designed down rather than up. Intel is still a large name in motherboards and high-performance computing, so their challenge is scaling a full CISC core down to be used on an SBC. Processors like the Intel Pentium can consume 20+ watts under high loads, which requires much more thermal management than can be expected from a single board computer.
Thus, the Atom processor found on the new Joule SBCs is the result of efforts to squeeze as much processing power as possible into a core suited for lower power consumption applications. The Atom family uses x86 architecture, which is technically a CISC architecture that draws on RISC in some ways and is truly more of a hybrid than strictly CISC. It can indisputably handle complex instructions, but it uses a secondary operation to regulate these instructions to reduce the impact of long instructions on throughput.
The results of trying the same project based around a scaled-up vs. scaled-down core can be strikingly difficult. When you need minimal computing power and a small form factor, the Raspberry Pi is a great place to start and the more expensive boards would likely be overkill. When you think about projects like server farms, media centers, or even gaming rigs, they can be very difficult to accomplish on embedded processor-based boards. The speed and performance just isn’t there, and you may be forced to use unfamiliar programs because of operating system constraints. CISC based boards tend to feel much more like a proper desktop computer in performance and availability of common programs, since x86-64 is used in most commercial computers. Choosing the right board for your application is the difference between building a powerful system that has performance to spare and trying to play StarCraft on a setup with the same processor as your phone.
If you want to learn more, subscribe to our newsletter to get the latest news.