CPUs and instruction set architecture (ISA)s - Introduction

As programmers we often work several layers above cpu instructions, working with tools that make our lives simple, easy, and stress free!

Hahah, of course that isn't the case. We face different challenges at different levels in the system.

It really is amazing to think about what goes into a typical appliation level software stack, for example:

These millions+ lines of code that a Linux, Windows, or web application is running on top of means the details of the hardware and processor are abstracted to a far away land. Processor features and the Instruction Set Architecture (ISA) often don't matter from a functional perspective. Tools, OSes and other systems take care of lower level details.

You might choose a particular processor or processor family for specific attributes, but often as long as you've got a compiler and other tools for that processor you don't really care what ISA is being used.

Goal	Care about CPU and ISA?
Application development	Nope
Low power	Nope
DSP selection	I don't think so
Microprocessor device drivers	Nope
Microprocessor debugging	Yes
OS/RTOS development	Yes (sometimes)

Note: These are generalizations, your needs may vary

Application development

Almost all application development (Linux, Windows, OSX, iOS etc) is done using higher level tools. We don't need to concern ourselves with the CPU or ISA.

Low power cpu

If you are targetting low power consumption you'll very likely end up with an ARM or other non-x86 CPU. Do the particular instructions matter? Not really. We'll be writing our software in C/C++/golang/rust etc, and we'll be using an OS or RTOS.

Choosing a DSP

I have no idea. I've never worked on DSPs, however if you are implementing an algorithm that requires high performance mathematical operations, and you are writing it in assembly, then you might care about the ISA of your processor. If it matches up with the mathematical operations you are using that could be a bonus.

Writing device drivers for microprocessors

Perhaps surprisingly, writing a device driver for a piece of hardware, for example the UART device in an STM32 microcontroller, doesn't require knowing anything about a processor's ISA. You will however have to know the details of the hardware and its registers and function. To interact with the hardware you'll be reading and writing memory using C/C++ etc but likely won't need to know about the processor's ISA, except of course if you've got to debug your driver or application on said microprocessor...

Debugging on a microcontroller

When debugging faults and crashes on a microprocessor you'll need to know about the CPU and processor ISA. Processor details like the CPU fault registers and how the CPU detects and handles faults can be necessary to efficently debug your application. Understanding assembly instructions can lead to tracing faults back to what your software is doing and locating faults like reads from misaligned addresses, null pointer dereferences, stack overflows etc.

Developing an RTOS/OS

OSes need to be CPU/ISA aware as they often provide features like thread synchronization through atomic memory access, and this requires the use of specific instructions/registers. OSes such as Linux and Windows that run on more capable processors will make use of processor MMUs for paging, exceptions, and protection, things like execution rings to protect the OS from applications, virtualization features, and countless other processor features.

What's next?

I'd like to learn more about the internals of processors. What better way thank by designing, implementing, and testing our own toy processor and instruction set for fun!

Upcoming posts will cover how this goes!