Types of Processors (1.1.1 - 1.1.2)

20p13280
Oct 14, 2025
6 min read

Updated: Oct 20, 2025

This post covers:

CISC and RISC
Von Neumann, Harvard and Contemporary Architectures
Multicore and Parallel Systems
Pipelining
GPUs

1.1 - Von Neumann and Harvard

Von Neumann archetecture shared memory space is used for oth the instrucitons and date stored.

It can do one insturciton at a time, Von Neumann uses registers for fast access to instrucitons and data.

Harvard is diferent, instructions and memory are stored seperately and each have thier own memory address, compared to Von Neumann arcetecture which uses one memory address for both instructions and data.

In Harvard there are seperate busses for reading and writing data so it can be done at the same time, wheras in Von Neumann there is a common bus.

Contemporary architechtures are newer archetechtures, whereas Von Neumann and Harvard are examples of older computer archetectures, being created in 1940s.

SIMD (Single Instruction Multiple Data) is parralel processing. This is where a processor can carry out a single instruction on multiple bits of data at once. This is typically used in graphic processing.

MIMD (Multiple Instructions Multiple Data) is another version but in this cae multiple instructions are carried out on multiple pieces of data at once. This can be done across several cores.

Distributed computing is where multiple comptuers on a network will all work in paralel to take on a larger problem. This can be done on any computer as long as it has an internet connection. An example of this was minecraft@home where people lent their resources to crack a seed (bruteforcing).

1.1.2 - CISC and RISC

The instruction set is the set of all instructions written in machine code that can be recognised and executed by the CPU. There are two main different categories of this. CISC and RISC.

CISC -> Complex Instruction Set Computer

RISC -> Reduced Instruction Set Computer

CISC

CISC is trying to complete te task in as few lines of assembley as possible. This means the processor, hardware and the circuitary is more complicated so it's able to understand and execute a series of operations.

For example, a CISC processor may include specific instructions for multiplying 2 differnet numbers (e.g. MULT).

When it's executed the instruction would load the two values into the register, multiply them together and store the result.

The MULT command is an example of a complex instruction.

It resembles the origional command from a high-level language, for example product = num1*num2.

This means that the compiler has little work to do to translate the high-level language code into assembley.

However, the complex instruction might take more than one FDE cycle to execute.

CSIC is typically used in desktop computers and laptops.

Intel's x86 processor line uses CISC archetecture, however there were a few changes made so it works more like RISC.

RISC

RISC processors use simple instructions that will be executed within a single FDE cycle.

This means that a command like MULT from CISC won't exist as it's a complex command.

Each action would need to be seperated into a number of simpler commands.

For a simple multiplication it may need 4 assembley command instead of the one needed in CISC.

Because of the increased line count, this means that the compiler has to do more work to convert to assembley. So as a result more RAM is required, this appears less efficient than CISC.

Each instruction can be completed in a single clock cycle, but compared to CISC RISC requires fewer transistors, this means that more registers and cache can be included within the CPU.

Pipelining is possible? (further content?)

Using RISC it means that less energy is needed.

RISC has become more popular in low-power devices such as Smart TVs, Thermostats, watches, etc.

ARM Processors and other architectures also work based on RISC and they make up the majority of processors in use.

Below is a table that summarises CISC and RISC:

Advantages and disadvantages table for CISC vs RISC

Multicore and Parrallel systems

Classic Von Neumann uses only a single processor to execute instructions, so to improve the compute rpower the physical complexity of the CPU had to be increased. This was done by adding new transistors to the chip, there was a law called Moore's Law that said the number of transistors that could be placed on a chip would be doubble every two years.

However once the physical limit had been reached new ways had to be found to increase the processing power. One of the most effective methods was the creation of multicore systems, these are computer systems with multipele processors. Multicore processors are now very common and popular and they have many cores which allows for multiple threads and programms to be run at once.

The most common type of multicore is a parallell processor. These are typically refered to as dual-core and quad-core processors. Using parallel processing 2+ processors work together to perform a single task. Each task is split into sub-tasks, called threads, and they are executed simultaniously. This decreases the time taken to execute a program, but the only downside to it is that software has to be written with this in mind to take advantage of it. An example of this is the Minecraft Server, the official Minecraft server file, paper (what Project Volt used), spigot, etc. they are wrtten without multi-core in mind so the servers can slow down once there is a large load is it's fully dependent on a single-core. Whereas a version of a minecraft server called Folia (by the PaperMC team) is written with multi-core in mind so it get's better performance because of this.

Parallel typicaly falls into 3 categories:

MISD (Multiple Instruction, Single Data): Systems have have multiple processors which each having a different set of instructions to do on the same set of data. e.g. Space Shuttle flight control computers.
SIMD (Single Instruction, Multiple Data): Systems have multiple processors which each processor taking a different set of data. e.g. Weather forecasting, they are also known as array processors.
MIMD (Multiple Instruction, Multiple Data): Computers have multiple processors, each processes instructions independently and so therefore MIMD can process a number of different instructions simultaniously. They are the most common parallel computing arcitecture. e.g CAD/CAM and flight simulators.

All multicore processors have smaller processors within them that act the same as single-core processors. However, they all need to be able to communicate for when a processor changes a key bit of data, the other processors are aware. Because of this complexity, older systems saw better performance.

Co-Processing is another form of multi-processor arcitechture, this is where multiple CPUs are used but each individual CPU is responsible for carying out one task such as graphic processing or advanced mathematic operations. The CPUs can do different tasks at the same time, this is a reason why a computer wtih a dedicated GPU will perform better than one without.

There are three types:

FPU (Floating Point Units): They are built into the CPU to run floating point maths.
DSP (Digital Signal Processor): Used to process sound effects and merge sound channels.
GPU (Graphics Processing Unit): Performs complex (3D) calculations for graphics.

Table of the advantages and disadvantages of multicore systems

Pipelining

Latency - The time to complete a single task
Throughput - The rate rate at which tasks complete

Pipelining is where multiple stages of the same process is run in parallel to efficiently use all the avaliable resources whilst respecting the dependencies of each stage upon the previous stage. This is done by staggerign the FDE cycle into three or more "hardware processing paths" (CPUs/Cores), which is called a "pipeline".

The FDE Cycle is split into stages, each part completes a part of an instruction in parallel. The stages are then joined with one and other and almost form a pipe, hence the name pipelining. It doesn't decrease the time for individual instructions to be executed but it increases the throughoput that the computer system can do. It's measured here by how often an instruction exists the pipeline. A machine cycle is the time required to move an instructoin one step further in the pipeline a machine cycle. The length of the cycle is set at the slowest pipe.

GPUs

Graphics Processing Unit. They are a type of processor thats dedicated to doing complex calculations that are required to render graphics. They are a common example of co-processing. GPUs are normally part of seperate graphics cards. This takes the workload off the CPU and so therefore the performance is significantly better.

Some CPUs do have built-in GPUs/Graphics Chips. However they aren't that powerful and aren't able to efficently handle complex tasks. As seen recently GPUs aren't just for graphics rendering, because of their nature of being able to do complex calculations it makes them perfect for AI and that's why NVIDIA, AMD and INTEL all play large parts within the AI game because they all offer GPUs (Intel do some GPUs but mainly CPUs).