. Implementing a Cache Coherence Protocol (Practical) Cache coherence protocol is a set of rules and mechanisms used in multiprocessor systems to maintain consistency among the caches (small, fast memory units) of multiple processors accessing the same shared memory. Simply speaking, imagine you have several people (processors) working together on a project and each person has their own notebook (cache) where they keep information about the project. Now, if one person updates information in their notebook, the others need to know about it to avoid confusion or mistakes. Similarly, in a multiprocessor system, if one processor updates data in its cache (I hope you all know what cache means), the cache coherence protocol ensures that all other caches are updated accordingly. This way, all processors have a consistent view of the shared memory, preventing data inconsistencies or errors. • Objective: Simulate a basic cache coherence protocol in a multiprocessor system. • Guidelines: • Create a new Python file named cache_coherence_simulation.py. • Implement the SharedMemory class to represent shared memory. • Implement the Processor class to represent each processor/thread. • Simulate read and write operations by multiple processors and observe cache coherence behaviors. Advanced Operating Systems/ Astana IT University / Lab 6 • Run the program and analyze the output. Example output:  Simulation of Cache Coherence Protocol in Multiprocessor System Initializing processors and shared memory... Processor 1 reads from memory: Value at address 0x0001 = 0 Processor 2 reads from memory: Value at address 0x0001 = 0 Processor 2 writes to memory: Set value at address 0x0002 = 30 Processor 1 writes to memory: Set value at address 0x0001 = 20 Processor 1 reads from memory: Value at address 0x0002 = 30Processor 2 reads from memory: Value at address 0x0002 = 30 Simulation completed.

class SharedMemory:
    def __init__(self, size):
        self.memory = [0]*size

    def read(self, address):
        return self.memory[address]

    def write(self, address, value):
        self.memory[address] = value


class Processor:
    def __init__(self, id, shared_memory):
        self.id = id
        self.cache = {}
        self.shared_memory = shared_memory

    def read(self, address):
        if address not in self.cache:
            self.cache[address] = self.shared_memory.read(address)
        print(f"Processor {self.id} reads from memory: Value at address 0x{address:04x} = {self.cache[address]}")

    def write(self, address, value):
        self.cache[address] = value
        self.shared_memory.write(address, value)
        print(f"Processor {self.id} writes to memory: Set value at address 0x{address:04x} = {value}")


if __name__ == "__main__":
    print("Simulation of Cache Coherence Protocol in Multiprocessor System")
    print("Initializing processors and shared memory...")

    shared_memory = SharedMemory(10)
    processors = [Processor(i, shared_memory) for i in range(2)]

    processors[0].read(1)
    processors[1].read(1)
    processors[1].write(2, 30)
    processors[0].write(1, 20)
    processors[0].read(2)
    processors[1].read(2)

    print("Simulation completed.")