co

- cache locality (temporal, spacial locality & average memory access time, cache hit)
- cache miss (cache write miss)
- cpu cache (cache line)
- cache strategy
- cache eviction

Author: xy-241

content/Algorithm/Recursion/Sorting.md

@@ -458,7 +458,7 @@ import java.util.*;
 > And we can perform sorting on subset of the dataset at a time. For example, if our dataset is 10GB, and we need to load the data into the RAM to perform the sorting, but there is only 2GB RAM. With merge sort, we are able to load in 2GB at a time to perform sorting, and eventually sort the dataset.
 
 >[!caution]- Slow on small arrays!
-> The allocation of different arrays are scattered in the [[Main Memory]]. Merge sort has a **space complexity of $O(n)$** with different temporary arrays at each merge layer. Working on multiple arrays means we sacrifice the performance gain from [[CPU Cache#Cache Locality]]. 
+> The allocation of different arrays are scattered in the [[Main Memory]]. Merge sort has a **space complexity of $O(n)$** with different temporary arrays at each merge layer. Working on multiple arrays means we sacrifice the performance gain from [[Cache Locality]]. 
 > 
 > The [[Recursion]] nature of the algorithm comes with extra overhead too. Recursion is also less predicable, thus impact the [[Branch Prediction]] negatively.
 > 

content/C/C Function.md

@@ -17,7 +17,7 @@ description:
 
 
 ### Function Prototype
-- In [[C]], a function prototype consists of the **return type**, **name of the function**, and the **list of parameter [[Datatype|datatypes]]** (names of parameters are **optional**)
+- In [[C/C]], a function prototype consists of the **return type**, **name of the function**, and the **list of parameter [[Datatype|datatypes]]** (names of parameters are **optional**)
 
 >[!important] Placement of function prototype
 > It's good practice to put function prototypes at the top of the program, before the `main()` function. This informs the [[Language Processors#Compiler|compiler]] of the functions your program may use, along with their return types and parameter types.

content/C/C Structure.md

@@ -32,7 +32,7 @@ typedef struct {
 > Using the code snippet above, we can access and modify the `balance` using `a_1.balance;`
 
 >[!important] Dereferencing a pointer to a structure and accessing its attributes
-> We need to make sure we use parentheses like `(*player_ptr).name`, because `.` has a higher [[C#C Operator Precedence|operator precedence]].
+> We need to make sure we use parentheses like `(*player_ptr).name`, because `.` has a higher [[C/C#C Operator Precedence|operator precedence]].
 > 
 > Or we can simply use `player_ptr->name` to achieve the same, this is a syntactic sugar.
 

content/Computer Organisation/Number System/Character Encoding (字符编码）.md

@@ -40,7 +40,7 @@ description:
 - String in [[Go]] is encoded with [[#UTF-8]] and is treated as an [[Array]] of [[Computer Data Representation#Byte]]. This explains why the index is off and `len(myString)` returns $8$, instead of $6$
 
 ![[utf-8_string_go.png|500]]
-- This behaviour applies to other languages like [[C]], you get $7$ when you run `printf("%d", strlen("😊家"));`, instead of $2$
+- This behaviour applies to other languages like [[C/C]], you get $7$ when you run `printf("%d", strlen("😊家"));`, instead of $2$
 
 
 >[!tip] Abstract away this weird behavior 

content/Data Structure/Array.md

@@ -16,7 +16,7 @@ References:
 
 
 >[!success] Cache Hit
-> Elements of array are stored in [[Main Memory]] in a **compact manner**, thus making great use of [[CPU Cache#Cache Locality]].
+> Elements of array are stored in [[Main Memory]] in a **compact manner**, thus making great use of [[Cache Locality]].
 
 >[!important] 
 > Array has a **fixed size**. If we want to **expand**, we have to **create another bigger array** & **copy all the elements** to the new array which is very **time consuming**.
@@ -59,7 +59,7 @@ References:
 - In most programming languages, `my_array[i]` is a **convenient syntax** that [[Abstraction|abstracts]] the process of accessing the element at index `i` in an array. While the underlying mechanism usually involves **calculating the [[Memory Address]]** of the element and then **[[Pointer#Pointer Dereference|dereferencing]] that address** to **obtain the value**
 
 ### Array Versus Linked List
-- When iterating over **all elements** in an [[Array]] and a [[Linked List]], the **array** is typically **much faster** if the elements are present in the [[CPU Cache]]. This is because arrays store elements in [[Data Structure#Continuous Memory|contiguous memory]], allowing them to benefit from [[CPU Cache#Cache Locality|cache locality]]. However, when [[CPU Cache#Cache Miss|cache misses]] occur, an **array** may be **slightly slower** than a **linked list**, as it needs to **calculate** the [[Memory Address|memory address]] of each **subsequent element**, whereas the next **element's address** is **directly stored** within each **node of a linked list**
+- When iterating over **all elements** in an [[Array]] and a [[Linked List]], the **array** is typically **much faster** if the elements are present in the [[CPU Cache]]. This is because arrays store elements in [[Data Structure#Continuous Memory|contiguous memory]], allowing them to benefit from [[CPU Cache#Cache Locality|cache locality]]. However, when [[Cache Miss|cache misses]] occur, an **array** may be **slightly slower** than a **linked list**, as it needs to **calculate** the [[Memory Address|memory address]] of each **subsequent element**, whereas the next **element's address** is **directly stored** within each **node of a linked list**
 
 
 

content/Data Structure/Linked List.md

@@ -23,12 +23,12 @@ References:
 
 
 >[!attention] Cache Miss!!!
-> Since the connection between 2 nodes are via Pointer, the nodes are scattered around the Main Memory. This means we can't make use of [[CPU Cache#Cache Locality]] and this results in a very high rate [[CPU Cache#Cache Miss]].
+> Since the connection between 2 nodes are via Pointer, the nodes are scattered around the Main Memory. This means we can't make use of [[Cache Locality]] and this results in a very high rate [[Cache Miss]].
 > 
 > ![[linked_list_cache_miss.gif]]
 
 >[!caution] Memory Leak
-> For languages like [[C]] which doesn't come with a [[Garbage Collector]], we need to manually release deleted node from the [[Address Space#Heap Segment]] to prevent [[Address Space#Memory leak]].
+> For languages like [[C/C]] which doesn't come with a [[Garbage Collector]], we need to manually release deleted node from the [[Address Space#Heap Segment]] to prevent [[Address Space#Memory leak]].
 
 
 

content/Data Structure/Stack.md

@@ -58,7 +58,7 @@ References:
 Both support Stack Operations without much difference
 
 **Time Efficiency**
-- [[Array]] has [[CPU Cache#Cache Locality]] to take advantage of [[CPU Cache]] for extreme fast access. However,  array has fixed size. If there isn't any space left in the array, new insertion needs to create a new array and transfer all elements to that new array, and the time complexity will be O(n)
+- [[Array]] has [[Cache Locality]] to take advantage of [[CPU Cache]] for extreme fast access. However,  array has fixed size. If there isn't any space left in the array, new insertion needs to create a new array and transfer all elements to that new array, and the time complexity will be O(n)
 - [[Linked List]] has to use extra time to perform pointer operation 
 - Conclusion: Array has slightly better time efficiency, since expansion is a low frequency operation, while pointer operation occurs whenever there is an insertion operation. However, [[Linked List]] has more stable performance
 

content/Data Structure/Tree/Binary Tree.md

@@ -31,7 +31,7 @@ description:
 ## Binary Tree Linked List Representation
 ---
  ![[binary_tree_linked_list.png|400]]
-- Compared to the [[#Binary Tree Array Representation|array representation]], the linked list representation of a binary tree is **easier to scale in terms of size**, but it comes with **higher memory usage** due to the overhead of storing pointers for each node. Additionally, it cannot take advantage of [[CPU Cache#Cache Locality|CPU cache locality]] as effectively as the array representation
+- Compared to the [[#Binary Tree Array Representation|array representation]], the linked list representation of a binary tree is **easier to scale in terms of size**, but it comes with **higher memory usage** due to the overhead of storing pointers for each node. Additionally, it cannot take advantage of [[Cache Locality|CPU cache locality]] as effectively as the array representation
 ## Degenerate Binary Tree
 ---
 ![[bst_to_skewed_tree.png|400]]

content/NUS/CS2100 Computer Organisation.md

@@ -8,7 +8,7 @@ tags:
   - computer_organisation
   - boolean_algebra
 Creation Date: 2024-02-12, 18:18
-Last Date: 2024-10-29T23:38:17+08:00
+Last Date: 2024-11-06T17:19:42+08:00
 References: 
 draft: 
 description: Find notes and cheat sheets for NUS CS2100 on this website. Get help preparing for your final exam and answers to your questions.
@@ -190,4 +190,11 @@ title: cs2100 nus notes
 >[!seealso] Interesting Related Topics
 > - [[CPU]]
 > - [[GPU]]
-> - [[Specialised Processor]]
+> - [[Specialised Processor]]
+
+## Week 12
+---
+- [ ] [[CPU Cache]]
+- [ ] [[Cache Locality]]
+- [ ] [[Cache Miss]]
+- [ ] [[Cache Strategy]]

content/OOP/Generics.md

@@ -48,7 +48,7 @@ References:
 > Because generic types are the same regardless of their parameterised types. So that means we can swap the same class with different parameterised types which will result in a mismatched assignment like assigning an integer returned from the generic to a string. This will work if the parameterised type is string.
 
 >[!caution] Bad for Caching
-> As you can see for array, the data is actually scattered around the memory. And this means we are unable to take advantage of [[CPU Cache#Cache Locality]] and each element indexing takes [[Latency Number|10-100 times longer]]! This is why Java is slower than system languages! Look at all the jumping around for the [[Linked List]] below.
+> As you can see for array, the data is actually scattered around the memory. And this means we are unable to take advantage of [[Cache Locality]] and each element indexing takes [[Latency Number|10-100 times longer]]! This is why Java is slower than system languages! Look at all the jumping around for the [[Linked List]] below.
 > 
 > ![[java_generics_memory_linked_list.gif]]