1.1.2 Types of Processors

i. One reason why it can be true:
A multi-core processor can execute multiple instructions (FDE cycles) at the same time, so some instructions in the program can run in parallel, making the program complete faster.

ii. Why it is not always true:
Some instructions cannot be run in parallel because they depend on the results of previous instructions and must wait for them to finish. In addition, other factors such as clock speed, cache size, or system bottlenecks can affect performance. The program (and OS) must also be written to specifically use multiple cores; otherwise, the extra cores will not increase speed.

One clear difference between CISC and RISC processors is the size and complexity of their instruction sets.

A CISC (Complex Instruction Set Computer) processor has a larger, more complex instruction set, and its instructions can take multiple clock cycles to execute. It also tends to have more addressing modes and more complex circuitry.

In contrast, a RISC (Reduced Instruction Set Computer) processor has a smaller, simpler instruction set, with instructions that typically execute in one clock cycle. RISC designs usually have fewer addressing modes, simpler circuitry, and are easier to pipeline.

Parallel processing means multiple processors or CPU cores run instructions at the same time (concurrently) instead of one after another.

In a video rendering system, the rendering task can be split into smaller parts (for example, different frames, sections, or components of a frame). Each core can carry out its own fetch–decode–execute (FDE) cycle on a different part of the job simultaneously.

Because multiple cores are working at the same time:

• Longer rendering jobs are divided up.

• Different CPUs/cores process different frames or sections simultaneously.

• The overall time taken to render the video is reduced.

So, parallel processing increases performance by completing more work at once, meaning videos render significantly faster.

When deciding whether the charity should use CISC processors in their mobile devices or switch to RISC processors, it is important to compare how each type works and then evaluate their suitability for mobile use. CISC (Complex Instruction Set Computer) processors have a large and complex instruction set. A single instruction can perform multiple operations, meaning fewer lines of code are needed to complete a task. However, many of these instructions are rarely used. CISC processors often take multiple clock cycles to complete one instruction and require more complex circuitry with more transistors. This makes the hardware more complicated, although compilers are generally simpler. In contrast, RISC (Reduced Instruction Set Computer) processors use a smaller, simplified instruction set. Each instruction performs one simple task, and complex operations are achieved by combining multiple instructions. Most RISC instructions execute in a single clock cycle. Because the circuitry is simpler and uses fewer transistors, the processor is less complex, although the compiler must work harder to translate high-level code into machine instructions.

In terms of suitability for mobile devices, several factors must be considered, including battery life, heat output, portability, and cost. If the charity chose CISC processors for their mobile devices, an advantage would be software compatibility. The devices would run the same software as the desktop computers, saving money on new software and ensuring consistency for staff working in and out of the office. However, CISC processors generally consume more power due to their complex circuitry. This would require larger batteries and more cooling, increasing the size and weight of the devices. Greater heat output would also reduce efficiency and shorten battery life, making them less practical for mobile use. They may also be more expensive to manufacture and purchase.

RISC processors, on the other hand, are more power efficient because of their simpler design. They generate less heat and therefore require little or no cooling, allowing devices to be thinner, lighter, and more portable. They also provide longer battery life, which is essential for staff who are away from the office for extended periods. RISC processors are often cheaper to produce. A disadvantage is that they may not run desktop CISC software directly, meaning alternative software versions may be needed. Programs can sometimes be larger because more instructions are required, potentially increasing RAM usage. However, compatibility issues can be reduced through emulators, translators, or cloud-based applications.

Overall, although CISC processors offer better direct compatibility with the charity’s existing desktop systems, they are less suitable for mobile devices due to higher power consumption, increased heat, and reduced portability. RISC processors are specifically designed with efficiency in mind and are better suited to mobile environments. Therefore, the charity should choose RISC processors for their mobile devices, as they provide longer battery life, lower heat output, reduced cost, and improved portability, making them the most practical option for staff working outside the office.

One clear difference is in the complexity and execution of instructions:

• CISC uses a large set of complex instructions, and a single instruction can take multiple clock cycles to execute (one mnemonic can perform several tasks).

• RISC uses a smaller set of simple instructions, with each instruction typically taking one clock cycle to execute (so more instructions may be needed to perform the same task).

A Complex Instruction Set Computer (CISC) architecture has many instructions and many addressing modes available. Its instructions can vary in format and often take multiple clock cycles to execute. It typically uses a single register set. Because of the large instruction set and complexity, the processor design is more complicated, making the integrated circuit more expensive.

In contrast, a Reduced Instruction Set Computer (RISC) architecture uses a limited number of simple instructions, where each instruction performs a simple task. More complex operations must be carried out by combining multiple instructions. This results in a simpler processor design, which is generally easier and cheaper to implement.

Programs run faster due to simpler instructions

(i) Complex calculations for scientific research

A maths co-processor performs the calculations instead of the main CPU.
It is designed to handle floating-point arithmetic efficiently, so processing is faster.

(ii) Printing personalised letters for an advertising campaign

There is no increase in speed.
A co-processor is not suitable for this task because printing letters does not involve complex or floating-point calculations.

• Single control unit

• One instruction at a time

• Uses fetch execute cycle

• Program & data stored together / program & data in same format

RISC (Reduced Instruction Set Computer) uses a small, simple instruction set, whereas CISC (Complex Instruction Set Computer) uses a large, more complex instruction set.

RISC instructions are usually fixed length (fixed number of bytes), while CISC instructions can be variable length.

In RISC, most instructions are designed to complete in one machine cycle, whereas CISC instructions often take multiple cycles to complete a single instruction.

CISC supports many addressing modes and may have more registers, while RISC has fewer addressing modes and typically relies more on RAM to store instructions because programs require more individual instructions.

Fetch – The next instruction is fetched from main memory (using the address held in the Program Counter) and loaded into the Current Instruction Register (CIR).

Decode – The instruction in the CIR is decoded by the control unit; it is interpreted and split into the opcode and operand.

Execute – The CPU carries out the instruction; the opcode is performed on the operand (e.g. calculation, data transfer, or branch).

To render detailed 3D models of proposed skyscrapers — for example, using CAD software to create realistic visualisations and run modelling calculations.

RAM (Random Access Memory) is a type of primary memory that temporarily stores data and programs currently in use by the computer. It is volatile, meaning it loses its contents when the power is turned off.

Multiple cores

Fast clock speed

Ability to use pipelining

Lathe cache

A CPU is a general-purpose processor, designed to handle a wide range of different tasks. In contrast, a GPU is specifically designed for graphics processing, so it has built-in circuitry and specialised instructions for common graphics operations.

A GPU can perform the same instruction on many pieces of data at the same time (parallel processing). This is ideal for 3D graphics, where thousands or millions of points and pixels must be processed simultaneously — for example, transforming the points of polygons or shading pixels.

Because of this parallel design and graphics-specific hardware, a GPU can carry out the calculations needed to display 3D graphics much faster and more efficiently than a CPU.

Some computational problems – such as climate modelling, genome sequencing or training large AI models – require far more processing power than a single CPU can provide. There are several approaches to providing increasingly large amounts of computing power, each suited to different types of problems.

Firstly, performance can be increased by raising the clock speed of a processor. A higher clock speed means more instructions are executed per second, so tasks complete faster. In theory, doubling the clock speed halves execution time. However, this approach is limited by heat generation and power consumption. It is most suitable for smaller, sequential problems that cannot easily be split into parallel tasks. For very large-scale problems, simply increasing clock speed is insufficient.

A second approach is to use multi-core processors. Modern CPUs contain multiple cores, allowing true parallel processing. Different threads of a program can run simultaneously, improving performance without increasing clock speed. This is effective when a problem can be divided into independent subtasks, such as rendering different parts of an image or processing separate data files. However, not all problems are fully parallelisable (as described by Amdahl’s Law). Some parts must still run sequentially, limiting the overall speed-up. Writing efficient multi-threaded programs is also more complex.

For even greater performance, systems can use GPUs (Graphics Processing Units). GPUs contain hundreds or thousands of smaller cores designed for SIMD (Single Instruction, Multiple Data) operations, where the same instruction is applied to many data elements at once. This makes them highly effective for scientific simulations, machine learning, video encoding and physics calculations where large datasets require repeated calculations. GPUs are increasingly cost-effective compared to building traditional supercomputers, but they are best suited to highly parallel problems; tasks with complex branching or dependencies may not perform as well.

Beyond a single machine, computing power can be increased using supercomputers. These combine thousands of CPUs and often GPUs, connected via high-speed interconnects. Supercomputers are used for extremely demanding tasks such as weather forecasting, astrophysics simulations and nuclear research. They provide enormous processing power but are prohibitively expensive to build, maintain and power, so they are typically only available to governments or large research organisations.

Another scalable approach is distributed computing, where processing is spread across multiple networked computers. This may take the form of clusters within one organisation or global volunteer systems. Cloud computing platforms also allow organisations to rent distributed resources on demand. Distributed systems are well suited to problems that can be divided into independent chunks (e.g., large data analysis, search indexing, rendering farms). However, communication overhead, latency and fault tolerance must be managed carefully.

In evaluation, increasing clock speed offers limited gains due to physical constraints. Multi-core CPUs and GPUs provide significant improvements for parallelisable tasks, with GPUs particularly strong for SIMD-style workloads. For the largest problems, supercomputers and distributed systems provide the greatest computing power, but at high financial and engineering cost. Ultimately, the “best” approach depends on the nature of the problem: sequential tasks benefit from faster cores, moderately parallel tasks from multi-core CPUs, highly parallel data-heavy tasks from GPUs, and massive-scale scientific or data problems from supercomputers or distributed computing systems.