re-write memory section

Author: msarkis-icr

episodes/optimisation-memory.md

@@ -24,36 +24,32 @@ exercises: 0
 The storage and movement of data plays a large role in the performance of executing software.
 
 <!-- Brief summary of hardware -->
-Modern computer's typically have a single processor (CPU), within this processor there are multiple processing cores each capable of executing different code in parallel.
-
-Data held in memory by running software is exists in RAM, this memory is faster to access than hard drives (and solid-state drives).
-But the CPU has much smaller caches on-board, to make accessing the most recent variables even faster.
+Modern computers have a single CPU with multiple cores, each capable of working on tasks at the same time. Data used by programs is stored in RAM, which is faster than hard drives or solid-state drives. However, the CPU has even faster memory called caches to access frequently used data quickly.
 
 ![An annotated photo of a computer's hardware.](episodes/fig/annotated-motherboard.jpg){alt="An annotated photo of inside a desktop computer's case. The CPU, RAM, power supply, graphics cards (GPUs) and harddrive are labelled."}
 
 <!-- Read/operate on variable ram->cpu cache->registers->cpu -->
-When reading a variable, to perform an operation with it, the CPU will first look in it's registers. These exist per core, they are the location that computation is actually performed. Accessing them is incredibly fast, but there only exists enough storage for around 32 variables (typical number, e.g. 4 bytes).
-As the register file is so small, most variables won't be found and the CPU's caches will be searched.
-It will first check the current processing core's L1 (Level 1) cache, this small cache (typically 64 KB per physical core) is the smallest and fastest to access cache on a CPU.
-If the variable is not found in the L1 cache, the L2 cache that is shared between multiple cores will be checked. This shared cache, is slower to access but larger than L1 (typically 1-3MB per core).
-This process then repeats for the L3 cache which may be shared among all cores of the CPU. This cache again has higher latency to access, but increased size (typically slightly larger than the total L2 cache size).
-If the variable has not been found in any of the CPU's cache, the CPU will look to the computer's RAM. This is an order of magnitude slower to access, with several orders of magnitude greater capacity (tens to hundreds of GB are now standard).
+How the CPU Accesses Data?
+When the CPU needs to use a variable, it follows these steps:
 
-Correspondingly, the earlier the CPU finds the variable the faster it will be to access.
-However, to fully understand the cache's it's necessary to explain what happens once a variable has been found.
+1) Registers: First, the CPU checks its own small, super-fast storage (registers). But it only has room for about 32 variables, so it usually doesn’t find the data here.
+2) L1 Cache: Next, the CPU looks in the L1 cache. It’s small (64 KB per core) and fast, but it only stores data for a single core.
+3) L2 Cache: If the variable isn’t in L1, it checks the larger L2 cache, which is shared by several cores. It’s slower than L1 but still faster than RAM.
+4) L3 Cache: If the variable isn’t in L2, the CPU checks the L3 cache, which is shared by all cores. It’s slower than L2 but bigger.
+5) RAM: If the variable is still not found, the CPU fetches it from the much slower RAM.
+The faster the CPU finds the data in the cache, the quicker it can do the job. 
+This is why understanding how the cache works can help make things run faster.
 
-If a variable is not found in the caches, so must be fetched from RAM.
-The full 64 byte cache line containing the variable, will be copied first into the CPU's L3, then L2 and then L1.
-Most variables are only 4 or 8 bytes, so many neighbouring variables are also pulled into the caches.
-Similarly, adding new data to a cache evicts old data.
-This means that reading 16 integers contiguously stored in memory, should be faster than 16 scattered integers
+Cache Details:
+When the CPU pulls data from RAM, it loads not just the variable, but also a full 64-byte chunk of memory called a "cache line." 
+This chunk often contains nearby variables that might be needed soon. When new data is added to the cache, old data is pushed out.
 
-Therefore, to **optimally** access variables they should be stored contiguously in memory with related data and worked on whilst they remain in caches.
-If you add to a variable, perform large amount of unrelated processing, then add to the variable again it will likely have been evicted from caches and need to be reloaded from slower RAM again.
+Because of this, reading a list of data that’s next to each other in memory (like 16 numbers in a row) is much faster than reading scattered data, since the CPU can keep more of it in the cache.
+To make programs run faster, related data should be stored next to each other in memory. 
+By working with this data while it's still in the cache, the CPU doesn’t have to go all the way to RAM, which is much slower.
 
 <!-- Latency/Throughput typically inversely proportional to capacity -->
-It's not necessary to remember this full detail of how memory access work within a computer, but the context perhaps helps understand why memory locality is important.
-
+While you don’t need to know all the details of how memory works, it’s helpful to know that memory locality—keeping related data together and accessing it in chunks—is key to making programs run faster.
 ![An abstract diagram showing the path data takes from disk or RAM to be used for computation.](episodes/fig/hardware.png){alt='An abstract representation of a CPU, RAM and Disk, showing their internal caches and the pathways data can pass.'}
 
 ::::::::::::::::::::::::::::::::::::: callout