1.1.2

• RISC Processors


  Processors with a small instruction set, where each instruction is approximately one line of machine code and takes one clock cycle
• CISC Processors


  Processors with a large instruction set, where the aim is to accomplish tasks in as few lines of assembly code as possible
• RISC vs CISC


  RISC: Compiler has to do more work to translate high level code into machine code, more RAM required to store code, pipelining possible since each instruction takes one clock cycle

  CISC: Compiler has less work to translate high level code into machine code, less RAM required since code is shorter, many specialised instructions are made even though only a few are used
• Multi-core CPUs


  Have multiple independent cores that can complete instructions separately, resulting in higher performance
• Parallel Systems


  Can complete tasks with a single core by using threading
• Multi-core vs Parallel Systems

  Multi-core systems generally perform better in larger projects than parallel systems
• Graphics Processing Unit (GPU)

  A device with lots of independent processors that work in parallel, making it very efficient at completing repetitive tasks such as image processing and machine learning. GPUs are a type of co-processor (a secondary processor designed to supplement the activities of the primary processor).
• Threading

  
  
• A technique where a single core or processor executes multiple threads (sequences of instructions) concurrently.
• Scalability

  
  
• The ability of a system to adapt to changing demands by increasing its capacity.
• Flexibility

  
  
• The ability of a system to adapt to changing situations and be easily modified to suit different needs.
• Parallel Systems


  
  
• Multiple computing systems or processors that work together to perform tasks concurrently.
• Thread


  A flow of execution within a process, sharing the same memory space
• Thread Scheduling


  The process of allocating CPU time to threads, ensuring fair allocation
• Context Switching


  The process of saving the context of the previous thread and loading the context of the new thread
• Thread Limitations


  Threading can lead to issues like context switching overhead, synchronization challenges, and debugging complexities