{"pinia":{"ui":{"prefs":{"theme":"system","textScale":"md","fontFamily":"sans","reducedMotion":false,"highContrast":false}},"academy":{"universities":[],"universitySummaries":[{"slug":"rtu","name":"RTU","fullName":"Rajasthan Technical University","branches":[{"slug":"first-year-common","name":"First Year (Common)"},{"slug":"computer-science","name":"Computer Science"},{"slug":"mechanical","name":"Mechanical"},{"slug":"civil","name":"Civil"},{"slug":"ai-data-science","name":"AI & Data Science"},{"slug":"ee-ec-eee","name":"EE / EC / EEE"}]},{"slug":"aktu","name":"AKTU","fullName":"Dr. A. P. J. Abdul Kalam Technical University","branches":[{"slug":"first-year-common","name":"First Year (Common)"},{"slug":"computer-science","name":"Computer Science"}]}],"activePapers":[{"id":"distributed-systems-2020","title":"Distributed Systems (2020)","subjectSlug":"distributed-systems","subjectName":"Distributed Systems","universitySlug":"rtu","branchSlug":"computer-science","year":4,"semester":8,"examYear":2020,"paperCode":"8E8163","questions":[{"id":"v2-distributed-systems-2020-pA-q1","number":1,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define a distributed system."}],"answer":{"summary":"A distributed system is a massive collection of independent, autonomous physical computers that mathematically communicate over a network to present themselves to the end-user as a single, coherent computing architecture.","explanation":[{"type":"paragraph","content":"It completely abstracts the catastrophic physical complexity of the hardware. The user executing a search on Google mathematically interacts with tens of thousands of distributed Linux servers, but the UI makes it appear as if a single supercomputer is instantly returning the result."}]}},{"id":"v2-distributed-systems-2020-pA-q2","number":2,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is transparency in distributed systems?"}],"answer":{"summary":"Transparency is the absolute architectural goal of a distributed system to mathematically hide the physical distribution of resources, failures, and network latency from the end-user and application programmer.","explanation":[{"type":"paragraph","content":"Location transparency ensures a user can access a file `/data/file.txt` without needing to know mathematically that it is physically stored on Server Node 45 in a datacenter in Iceland. Failure transparency completely hides server crashes by automatically routing traffic to redundant backups."}]}},{"id":"v2-distributed-systems-2020-pA-q3","number":3,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Briefly explain RPC (Remote Procedure Call)."}],"answer":{"summary":"RPC is a highly aggressive inter-process communication mechanism allowing a local program to execute a subroutine on a remote physical server as if it were a local mathematical function call.","explanation":[{"type":"paragraph","content":"RPC violently abstracts the network layer (TCP/IP). The developer simply writes `server.calculateTax()`. The RPC architecture automatically serializes the parameters into a binary payload, blasts it across the internet, executes the math on the remote CPU, and returns the result completely transparently."}]}},{"id":"v2-distributed-systems-2020-pA-q4","number":4,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is the difference between a stateful and stateless server?"}],"answer":{"summary":"A stateful server mathematically remembers historical client data between requests (maintaining session state), whereas a stateless server violently forgets the client immediately after executing a single request.","explanation":[{"type":"paragraph","content":"Stateful servers (like old FTP) crash catastrophically because they lose memory of what file the client had open. Stateless servers (like REST APIs) are architecturally invincible to crashes because every single incoming request strictly contains all the mathematical metadata required to execute it independently."}]}},{"id":"v2-distributed-systems-2020-pA-q5","number":5,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is a logical clock?"}],"answer":{"summary":"A logical clock (like Lamport timestamps) completely abandons absolute physical time (hours/minutes), instead using a rigid mathematical counter to strictly determine the chronological cause-and-effect ordering of distributed events.","explanation":[{"type":"paragraph","content":"Physical clocks in a distributed system violently drift out of sync due to quartz crystal physics. Logical clocks mathematically prove that \"Event A caused Event B\" across the network by passing incremented integers, entirely bypassing the need for perfectly synchronized atomic hardware."}]}},{"id":"v2-distributed-systems-2020-pA-q6","number":6,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define mutual exclusion in distributed systems."}],"answer":{"summary":"Mutual exclusion is a strict mathematical algorithm that violently prevents multiple distributed processes from simultaneously modifying a shared resource (like a database row), preventing catastrophic data corruption.","explanation":[{"type":"paragraph","content":"If two bank servers try to deduct $100 from an account simultaneously without mutual exclusion, a race condition occurs, mathematically destroying the database integrity. It is executed using centralized coordinators, token rings, or distributed voting algorithms (like Ricart-Agrawala)."}]}},{"id":"v2-distributed-systems-2020-pA-q7","number":7,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What are the advantages of a Distributed File System (DFS)?"}],"answer":{"summary":"A DFS (like Hadoop HDFS) provides massive fault tolerance, exponential read/write scaling, and location transparency by mathematically shattering and distributing files across thousands of cheap commodity hard drives.","explanation":[{"type":"paragraph","content":"If a single hard drive physically catches fire, the DFS does not lose a single byte of data because the architecture strictly replicates the blocks across multiple distinct physical racks. It mathematically enables infinite storage capacity without buying massive, expensive mainframe disks."}]}},{"id":"v2-distributed-systems-2020-pA-q8","number":8,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Explain process migration in distributed OS."}],"answer":{"summary":"Process migration is the violent, real-time transfer of an executing program from one physical CPU to another across the network without mathematically stopping or resetting its execution state.","explanation":[{"type":"paragraph","content":"If Server Node A mathematically detects that its CPU is operating at 99% capacity and is about to melt, the distributed OS freezes the thread, packages its entire RAM footprint, and blasts it to idle Server Node B, where execution resumes perfectly at the exact instruction it paused."}]}},{"id":"v2-distributed-systems-2020-pA-q9","number":9,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"What is load balancing?"}],"answer":{"summary":"Load balancing is the mathematical routing architecture used to violently distribute incoming network traffic equally across massive server clusters to prevent any single node from catastrophic overload.","explanation":[{"type":"paragraph","content":"A hardware or software load balancer uses algorithms like Round-Robin or Least-Connections to mathematically calculate which web server has the lowest CPU utilization, seamlessly pushing the user's request there to ensure microsecond latency."}]}},{"id":"v2-distributed-systems-2020-pA-q10","number":10,"marks":2,"tags":["Part A"],"text":[{"type":"paragraph","content":"Define fault tolerance in distributed systems."}],"answer":{"summary":"Fault tolerance is the absolute mathematical capacity of a distributed system to continuously and seamlessly execute its functions despite the catastrophic physical failure of individual hardware components or network links.","explanation":[{"type":"paragraph","content":"It completely abandons the fantasy of perfect hardware. By implementing massive redundancy (RAID, multiple NameNodes, consensus algorithms like Paxos), a fault-tolerant system mathematically guarantees $99.999\\%$ uptime even if an entire datacenter is physically destroyed."}]}},{"id":"v2-distributed-systems-2020-pB-q11","number":11,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the different types of transparencies in a distributed system with examples."}],"answer":{"summary":"A rigorous theoretical exposition on Distributed System Transparencies. Details how Access, Location, Migration, and Failure transparency mathematically shield the user from the chaotic underlying physics of the network.","explanation":[{"type":"heading","content":"Transparencies in Distributed Systems"},{"type":"paragraph","content":"The absolute holy grail of distributed computing is to take 10,000 chaotic, unreliable physical servers and mathematically present them to the user as a single, flawless, invisible supercomputer. This illusion is architected through multiple rigid layers of Transparency."},{"type":"subheading","content":"1. Access Transparency"},{"type":"paragraph","content":"It mathematically hides the differences in data representation and machine architectures. \n*Example:* An Intel x86 Windows client requests a file from an ARM-based Linux server. Access transparency mathematically handles the Endianness (byte-order) translation so the user has zero idea the hardware architectures are completely alien to each other."},{"type":"subheading","content":"2. Location Transparency"},{"type":"paragraph","content":"It completely decouples the logical name of a resource from its physical coordinate. \n*Example:* The user accesses a URL `www.google.com`. The user does not mathematically know if that server is physically in California or Tokyo. The DNS architecture violently abstracts the physical IP address."},{"type":"subheading","content":"3. Migration Transparency"},{"type":"paragraph","content":"It mathematically allows the system to physically move resources without changing their names or breaking client connections. \n*Example:* A database table is violently transferred from Server Rack 1 to Server Rack 10 because Rack 1 is overheating. The client application mathematically continues to query the table without requiring a configuration update."},{"type":"subheading","content":"4. Replication Transparency"},{"type":"paragraph","content":"It hides the mathematical fact that multiple physical copies of the data exist. \n*Example:* A YouTube video is copied to 50 CDN servers globally. The user simply hits \"Play\", completely unaware that the distributed system dynamically routed them to the closest physical copy."},{"type":"subheading","content":"5. Failure Transparency"},{"type":"paragraph","content":"The most critical. It mathematically conceals catastrophic hardware crashes. \n*Example:* If an Amazon checkout server physically catches fire mid-transaction, the system violently reroutes the state to a backup server in milliseconds, ensuring the user's shopping cart doesn't crash."}]}},{"id":"v2-distributed-systems-2020-pB-q12","number":12,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Discuss the client-server communication model using sockets."}],"answer":{"summary":"An architectural breakdown of Socket Communication. Details the strict mathematical TCP/IP sequence of binding, listening, accepting, and bi-directional byte-stream execution between distributed Client and Server nodes.","explanation":[{"type":"heading","content":"Client-Server Communication Model using Sockets"},{"type":"paragraph","content":"A Socket is the absolute fundamental mathematical endpoint for inter-process communication (IPC) across a distributed network. It physically binds an IP Address to a Port Number, creating a strict, bidirectional pipeline that completely abstracts the underlying hardware of the network interface card."},{"type":"heading","content":"The Server Architecture (The Listener)"},{"type":"list","items":["**1. `socket()`:** The server mathematically allocates OS kernel resources to create a raw endpoint.","**2. `bind()`:** It violently anchors the socket to a specific local port (e.g., Port 80 for HTTP). If another process tries to use this port, the OS throws a catastrophic failure.","**3. `listen()`:** The server physically transitions the socket into a passive listening state, mathematically creating a queue in RAM to hold incoming client connection requests.","**4. `accept()`:** A massive architectural bottleneck. The server thread mathematically blocks (sleeps) until a physical client attempts to connect. When a connection hits, the OS violently spawns a brand new, dedicated socket just for that specific client, freeing the main port to continue listening for others."]},{"type":"heading","content":"The Client Architecture (The Initiator)"},{"type":"list","items":["**1. `socket()`:** The client creates its own local endpoint.","**2. `connect()`:** The client executes a violent TCP 3-way handshake (`SYN`, `SYN-ACK`, `ACK`). It mathematically calculates the physical route to the Server's IP and Port."]},{"type":"heading","content":"The Execution (Data Transfer)"},{"type":"paragraph","content":"Once the mathematical pipeline is locked, both nodes execute `send()` and `recv()`. They blast streams of raw bytes (serialized objects, JSON) back and forth. Because TCP is mathematically reliable, if a byte is dropped by a router, the socket architecture violently forces a retransmission without the application programmer ever knowing."}]}},{"id":"v2-distributed-systems-2020-pB-q13","number":13,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"How does the Berkeley algorithm achieve clock synchronization?"}],"answer":{"summary":"A critical mathematical exposition of the Berkeley Algorithm. Explains how an active Time Daemon violently polls distributed nodes, calculates the average physical drift, and forces catastrophic time corrections to synchronize the cluster without relying on external atomic clocks.","explanation":[{"type":"heading","content":"Clock Synchronization: The Berkeley Algorithm"},{"type":"paragraph","content":"In a distributed system, physical quartz clocks drift wildly due to temperature and voltage variations. The Berkeley Algorithm completely abandons the requirement for an external, perfect atomic time server (like UTC). Instead, it relies strictly on mathematical averaging across the internal cluster to achieve relative synchronization."},{"type":"heading","content":"The Algorithmic Execution"},{"type":"list","items":["**1. The Time Daemon:** One physical machine is strictly elected as the master Time Daemon. It is not assumed to have the correct time; it is merely the mathematical orchestrator.","**2. The Polling Phase:** The Daemon violently broadcasts a \"Time Request\" to all subordinate nodes in the cluster. It must mathematically calculate the round-trip network latency for every single node to ensure accurate offset calculations.","**3. The Mathematical Averaging:** The nodes return their physical clock values. The Daemon calculates the mathematical average of all clocks (including its own). Crucially, it violently rejects \"Faulty Clocks\" (nodes whose time is wildly skewed by hours) to prevent the average from being catastrophically corrupted.","**4. The Correction Broadcast:** The absolute genius of Berkeley. The Daemon DOES NOT broadcast the new exact time to the nodes. Because network latency is chaotic, broadcasting exact time causes further drift. Instead, it mathematically calculates the exact offset needed for each node. \n*Example:* It tells Node A, \"You are too fast, mathematically slow your clock tick rate down by 15 milliseconds per second until you match the average.\""]},{"type":"heading","content":"The Merit"},{"type":"paragraph","content":"By violently forcing clocks to slow down instead of jumping backward in time, the Berkeley algorithm prevents catastrophic software failures (like files suddenly having negative creation times or `Make` compilers crashing)."}]}},{"id":"v2-distributed-systems-2020-pB-q14","number":14,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the Bully Election Algorithm with an example."}],"answer":{"summary":"A rigorous breakdown of the Bully Election Algorithm. Details the brutal hierarchical architecture where nodes with higher mathematical IDs violently overpower subordinate nodes to assume total control when the master crashes.","explanation":[{"type":"heading","content":"The Bully Election Algorithm"},{"type":"paragraph","content":"In a distributed system requiring a centralized coordinator, if that master node catastrophically crashes, the cluster is instantly paralyzed. An Election Algorithm mathematically forces the surviving nodes to violently vote for and install a new master. The Bully algorithm operates on strict, brutal mathematical hierarchy: the node with the absolute highest ID number always wins."},{"type":"heading","content":"The Algorithmic Execution (The Physics of the Bully)"},{"type":"paragraph","content":"Assume a cluster with Nodes 1 through 7. Node 7 is the current Coordinator. Node 7 physically catches fire and dies."},{"type":"list","items":["**1. The Detection:** Node 4 mathematically detects the failure (a timeout on a heartbeat ping). Node 4 immediately initiates an election by blasting an `ELECTION` message strictly to all nodes with a higher ID (Nodes 5 and 6).","**2. The Mathematical Suppression:** Node 5 and Node 6 receive the message. Because they possess higher IDs, they instantly fire back an `OK` message to Node 4. This `OK` violently suppresses Node 4, mathematically telling it to shut up and drop out of the election.","**3. The Escalation:** Node 5 and Node 6 now initiate their own elections. Node 5 sends an `ELECTION` message to Node 6. Node 6 sends an `OK` to Node 5, violently knocking Node 5 out of the race.","**4. The Victory:** Node 6 sends an `ELECTION` message to Node 7. Because Node 7 is physically dead, there is zero response. Node 6 mathematically realizes it is now the absolute highest surviving ID.","**5. The Coronation:** Node 6 blasts a `COORDINATOR` message to every single node (1 through 5), violently announcing its dictatorship. The cluster instantly resumes operation under Node 6."]},{"type":"heading","content":"The Catastrophic Demerit"},{"type":"paragraph","content":"If the dead Node 7 reboots, it instantly blasts a `COORDINATOR` message, violently usurping Node 6. If Node 7 has failing hardware and constantly reboots, it will mathematically trap the entire cluster in an infinite loop of elections, completely paralyzing the system."}]}},{"id":"v2-distributed-systems-2020-pB-q15","number":15,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Discuss the architecture of Sun Network File System (NFS)."}],"answer":{"summary":"An architectural exposition of the Sun Network File System (NFS). Details its stateless mathematical design, VFS integration, and how it violently abstracts remote server storage into local UNIX directory structures.","explanation":[{"type":"heading","content":"Architecture of the Sun Network File System (NFS)"},{"type":"paragraph","content":"Sun NFS is the absolute foundational architecture for distributed file sharing in UNIX environments. It allows a client machine to mathematically mount a hard drive located on a physical server 1,000 miles away, presenting it perfectly to the local user as if it were a local `/home` directory."},{"type":"heading","content":"1. The Virtual File System (VFS) Layer"},{"type":"paragraph","content":"The genius of NFS is its integration with the OS kernel via VFS. When a user executes a `cat /data/file.txt` command, the kernel violently intercepts it at the VFS layer. VFS mathematically analyzes the inode. If it is local, it sends the command to the local hard drive (ext4). If the inode mathematically points to NFS, VFS instantly routes the request to the NFS Client daemon, completely hiding the physical network from the user application."},{"type":"heading","content":"2. The Stateless Server Architecture"},{"type":"paragraph","content":"NFSv2 and NFSv3 were designed strictly as **Stateless Servers**. This is a massive architectural decision."},{"type":"list","items":["The NFS server mathematically remembers absolutely nothing about the clients. It does not track who has which file open.","Every single RPC request from the client (e.g., `READ`) must mathematically contain the complete File Handle, the exact Offset, and the byte length.","**The Merit:** If the NFS Server mathematically crashes and reboots, it does not need to execute catastrophic state recovery. The clients simply keep sending their RPC requests until the server wakes up and blindly answers them."]},{"type":"heading","content":"3. Client-Side Caching (The Performance Hack)"},{"type":"paragraph","content":"To prevent the network from bottlenecking on every single read, the NFS Client aggressively caches data blocks in its local physical RAM. However, this introduces catastrophic Cache Consistency issues. If Client A modifies the file in its RAM, Client B might mathematically read stale data until the blocks are violently synced back to the master server."}]}},{"id":"v2-distributed-systems-2020-pB-q16","number":16,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"Explain the various approaches for distributed deadlock detection."}],"answer":{"summary":"A critical analysis of Distributed Deadlock Detection. Contrasts Centralized coordinators against fully Distributed Edge-Chasing algorithms to mathematically map and destroy cyclical dependency graphs across multiple physical servers.","explanation":[{"type":"heading","content":"Distributed Deadlock Detection Architectures"},{"type":"paragraph","content":"A deadlock occurs when a set of processes are mathematically trapped in a cyclical wait, each holding a lock on a resource that another process desperately needs. In a single machine, the OS simply maps a Wait-For Graph (WFG) and checks for mathematical cycles. In a distributed system, a process on Server A might be waiting for a lock on Server B, making the global WFG completely shattered across the network."},{"type":"heading","content":"1. Centralized Deadlock Detection"},{"type":"paragraph","content":"A highly primitive, brute-force architecture."},{"type":"list","items":["Every single physical server mathematically constructs its own Local WFG.","Periodically, they violently blast their Local WFGs across the network to a single, dedicated Coordinator Node.","The Coordinator mathematically fuses them into a massive Global WFG. If it detects a cycle, it violently murders (aborts) one of the processes to break the deadlock.","**Demerit:** The Coordinator is a catastrophic Single Point of Failure. Furthermore, network latency can cause False Deadlocks (Phantom Deadlocks), where the Coordinator kills a process based on outdated WFG data."]},{"type":"heading","content":"2. Distributed Detection (Edge-Chasing / Chandy-Misra-Haas)"},{"type":"paragraph","content":"A completely decentralized mathematical approach."},{"type":"list","items":["If Process 1 on Server A is blocked waiting for Process 2 on Server B, it violently fires a mathematical Probe message: `Probe(Initiator: P1, Sender: P1, Receiver: P2)`.","Server B receives it. If Process 2 is blocked waiting for Process 3 on Server C, it forwards the Probe: `Probe(Initiator: P1, Sender: P2, Receiver: P3)`.","**The Mathematical Trap:** The Probe violently chases the edges of the dependency graph across the network. If the Probe eventually circles completely back and is received by the original Initiator (`P1`), a global deadlock is mathematically proven to exist. The system then initiates a rollback."]}]}},{"id":"v2-distributed-systems-2020-pB-q17","number":17,"marks":4,"tags":["Part B"],"text":[{"type":"paragraph","content":"What are the primary design issues of a Distributed OS?"}],"answer":{"summary":"An exhaustive breakdown of the Primary Design Issues in a Distributed OS. Details the catastrophic architectural challenges of Transparency, Scalability, Fault Tolerance, and mathematical Clock Synchronization.","explanation":[{"type":"heading","content":"Primary Design Issues of a Distributed Operating System"},{"type":"paragraph","content":"Building a Distributed OS (like Plan 9 or Amoeba) is exponentially more difficult than a single-node OS (like Linux). The engineers must mathematically solve catastrophic problems related to network physics, latency, and hardware failure."},{"type":"list","items":["**1. Transparency (The Grand Illusion):** The OS must violently mask the distributed nature of the cluster. The user must be able to compile code without mathematically knowing that the OS split the compilation across 50 different physical CPUs.","**2. Scalability Bottlenecks:** Centralized algorithms fail catastrophically at scale. If a system relies on a single master node for naming or security, adding 10,000 new nodes will mathematically melt the master. The architecture must utilize decentralized, distributed hash tables (DHTs) or hierarchical trees to ensure $O(1)$ or $O(\\log N)$ scaling.","**3. Fault Tolerance and Reliability:** The OS must assume the hardware is garbage. It must implement mathematical consensus algorithms (Paxos/Raft) and aggressive data replication so that if a rack loses power, the OS instantly redirects pointers to redundant nodes with zero user disruption.","**4. Distributed Synchronization (Lack of Global Clock):** Because there is no single physical clock, the OS cannot use standard timestamps to lock files. It must violently enforce Logical Clocks or complex Distributed Mutual Exclusion algorithms to prevent data corruption.","**5. Security Architecture:** In a single machine, the OS kernel trusts its own memory. In a distributed OS, messages traverse hostile physical networks. The OS must violently encrypt all IPC traffic and implement mathematical cryptographic tickets (like Kerberos) to guarantee node identity."]}]}},{"id":"v2-distributed-systems-2020-pC-q18","number":18,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Describe the communication protocols in distributed systems. Explain the layered protocols and their mapping to the OSI reference model."}],"answer":{"summary":"A massive architectural exposition on Distributed Communication Protocols. Violently dissects the OSI 7-Layer model, contrasting the raw, lossy physics of the Physical/Data Link layers against the mathematically robust Session/Transport layers that enable RPC execution.","explanation":[{"type":"heading","content":"Communication Protocols and the OSI Reference Model in Distributed Systems"},{"type":"paragraph","content":"Distributed systems are mathematically impossible without a rigidly structured communication architecture. A process on Node A cannot simply send a variable to Node B; the data must be violently disassembled into raw electrical impulses, blasted across chaotic copper wires, and reassembled flawlessly. This catastrophic complexity is managed by layered protocols, specifically mapped against the OSI (Open Systems Interconnection) Reference Model."},{"type":"heading","content":"The 7-Layer OSI Architecture"},{"type":"subheading","content":"1. The Hardware Layers (Physical, Data Link, Network)"},{"type":"paragraph","content":"These layers deal strictly with the violent physics of the network."},{"type":"list","items":["**Layer 1: Physical Layer:** The absolute lowest level. It mathematically converts binary `1`s and `0`s into raw voltages on Ethernet cables or photons in fiber optics. It has zero concept of data integrity.","**Layer 2: Data Link Layer:** It takes the raw stream of bits and mathematically groups them into \"Frames\". It introduces MAC addressing to move frames between physically connected switches and implements primitive checksums (CRC) to violently drop frames corrupted by electrical noise.","**Layer 3: Network Layer (IP):** The routing brain. It handles logical IP addresses and mathematically calculates the shortest path (using algorithms like OSPF or BGP) through a massive web of global routers. It is completely connectionless and unreliable; it simply blasts packets into the void and hopes they arrive."]},{"type":"subheading","content":"2. The Transport Layer (The Mathematical Guarantee)"},{"type":"paragraph","content":"The absolute most critical layer for distributed systems (Layer 4)."},{"type":"list","items":["**TCP (Transmission Control Protocol):** It completely shields the upper layers from the catastrophic unreliability of the Network layer. It mathematically numbers every single packet. If a packet is destroyed, TCP violently demands a retransmission. It guarantees that the data stream arrives perfectly in order, which is mandatory for RPC and RMI execution.","**UDP (User Datagram Protocol):** A raw, fast protocol that provides zero mathematical guarantees. Used in distributed streaming media or DNS where speed is more critical than absolute data perfection."]},{"type":"subheading","content":"3. The Application Layers (Session, Presentation, Application)"},{"type":"paragraph","content":"These layers handle the high-level logic of distributed computing."},{"type":"list","items":["**Layer 5: Session Layer:** It establishes, maintains, and violently tears down communication sessions. In distributed systems, it handles checkpointing so that if a massive 5GB file transfer crashes at 99%, it mathematically resumes from the exact checkpoint instead of restarting.","**Layer 6: Presentation Layer:** It handles the catastrophic problem of heterogeneous hardware. If an IBM mainframe (Big Endian) talks to an Intel PC (Little Endian), the Presentation layer mathematically flips the byte order. It also executes encryption (SSL/TLS) and compression.","**Layer 7: Application Layer:** The actual distributed protocols the user interacts with (HTTP, FTP, SMTP, and high-level RPC/RMI interfaces)."]},{"type":"svg","content":""}]}},{"id":"v2-distributed-systems-2020-pC-q19","number":19,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the mechanisms of Remote Method Invocation (RMI) in distributed computing. How does it differ from RPC? Explain with the help of a diagram."}],"answer":{"summary":"An exhaustive theoretical breakdown of Remote Method Invocation (RMI). Violently contrasts the purely procedural nature of RPC against the massive Object-Oriented architecture of Java RMI, detailing the execution of Stubs, Skeletons, and distributed Garbage Collection.","explanation":[{"type":"heading","content":"Mechanisms of Remote Method Invocation (RMI) vs. RPC"},{"type":"paragraph","content":"RPC (Remote Procedure Call) was designed for primitive C programs, allowing a local machine to execute a procedural function on a remote machine. RMI (Remote Method Invocation), pioneered by Java, represents a massive architectural leap. It completely integrates distributed computing with strict Object-Oriented paradigms, allowing a program on Node A to violently invoke methods on an Object physically residing in the RAM of Node B, passing complex objects (not just primitive integers) by value or reference."},{"type":"heading","content":"The RMI Architecture (Stub and Skeleton)"},{"type":"paragraph","content":"The absolute core of RMI is achieving total transparency through Proxy objects."},{"type":"list","items":["**The Stub (Client-Side Proxy):** The client program does not talk to the network. It calls a method on a local `Stub` object. The Stub acts as a violent interceptor. It mathematically serializes the method name and complex object parameters into a flat binary stream (Marshalling) and blasts it via TCP to the server.","**The Skeleton (Server-Side Proxy):** The server network socket passes the byte stream to the `Skeleton`. The Skeleton violently unmarshals the binary back into Java Objects, locates the actual target Object in server RAM, and invokes the physical method. The return value is marshalled and sent backward through the pipeline."]},{"type":"heading","content":"How RMI Mathematically Differs from RPC"},{"type":"list","items":["**Paradigm:** RPC is Procedural (invokes flat functions). RMI is Object-Oriented (invokes methods on specific instantiations of objects with state).","**Parameter Passing:** RPC can only pass primitive structs by value. RMI can mathematically pass massive, complex Object Graphs by value (Serialization) OR pass remote object references. If RMI passes a reference, the client can mathematically invoke methods on the returned object, creating a massive chain of distributed execution.","**Distributed Garbage Collection:** Because RMI objects exist across networks, Java must execute Distributed Garbage Collection. The server mathematically tracks leased references; if a client disconnects or times out, the server violently purges the object from RAM to prevent catastrophic memory leaks."]},{"type":"svg","content":""}]}},{"id":"v2-distributed-systems-2020-pC-q20","number":20,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Discuss distributed mutual exclusion. Explain Ricart-Agrawala's algorithm for mutual exclusion in detail."}],"answer":{"summary":"A definitive mathematical dissection of the Ricart-Agrawala Algorithm. Violently details how this fully distributed, decentralized mutual exclusion architecture uses Lamport logical clocks and a massive broadcast voting mechanism to mathematically guarantee lock safety without a centralized coordinator.","explanation":[{"type":"heading","content":"Distributed Mutual Exclusion: The Ricart-Agrawala Algorithm"},{"type":"paragraph","content":"In a centralized mutual exclusion algorithm, a single master node grants access to the Critical Section. If that master crashes, the entire system is paralyzed. The Ricart-Agrawala algorithm completely shatters this bottleneck. It is a highly aggressive, fully distributed, permission-based algorithm. To enter the Critical Section, a node must mathematically force ALL other nodes in the network to explicitly vote and grant it permission."},{"type":"heading","content":"The Mathematical Architecture"},{"type":"paragraph","content":"The algorithm relies absolutely on Lamport Logical Clocks to mathematically break ties. Every request message contains `(Timestamp, Node_ID)`."},{"type":"subheading","content":"1. The Request Phase"},{"type":"paragraph","content":"When Node A wants to enter the Critical Section to write to the database, it violently broadcasts a `REQUEST(T_A, Node_A)` message to every single other node in the cluster. It then blocks and mathematically waits to receive an `REPLY` from EVERY node."},{"type":"subheading","content":"2. The Evaluation Phase (The Conflict Resolution)"},{"type":"paragraph","content":"When Node B receives Node A's request, it executes strict mathematical logic:"},{"type":"list","items":["**Condition 1:** If Node B does NOT want to enter the critical section, it immediately sends a `REPLY` to Node A.","**Condition 2:** If Node B is CURRENTLY IN the critical section, it violently ignores Node A, placing Node A's request into a local Deferred Queue.","**Condition 3 (The Collision):** If Node B ALSO wants to enter the critical section concurrently. Node B mathematically compares its own Logical Timestamp ($T_B$) against Node A's ($T_A$).","**The Math:** If $T_A < T_B$ (Node A asked first), Node B yields and sends a `REPLY` to A. If $T_B < T_A$, Node B defers A's request and forces A to wait."]},{"type":"subheading","content":"3. Execution and Release"},{"type":"paragraph","content":"Once Node A mathematically accumulates $N-1$ `REPLY` messages (total network consensus), it violently executes the Critical Section. Upon finishing, it checks its Deferred Queue and fires `REPLY` messages to any nodes it forced to wait, unleashing them."},{"type":"heading","content":"Merits and Catastrophic Demerits"},{"type":"list","items":["**Merit:** Zero single points of failure. Absolute mathematical fairness based on logical timestamps.","**Demerit:** The message complexity is horrific: $2(N-1)$ messages per critical section entry. If even a SINGLE node physically crashes, it will never send a `REPLY`. The initiator will mathematically wait forever, completely deadlocking the entire distributed system. It requires massive timeout and failure-detection hacks to survive in reality."]}]}},{"id":"v2-distributed-systems-2020-pC-q21","number":21,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Describe the principles of Distributed Shared Memory (DSM). Explain the various consistency models used in DSM."}],"answer":{"summary":"A massive architectural breakdown of Distributed Shared Memory (DSM). Details how DSM violently abstracts physically separated RAM banks into a single logical address space, and critically exposes the catastrophic performance penalties governed by Strict vs. Sequential Consistency Models.","explanation":[{"type":"heading","content":"Distributed Shared Memory (DSM) Architecture"},{"type":"paragraph","content":"Programming distributed systems using raw message passing (Sockets/MPI) is mathematically exhausting. Distributed Shared Memory (DSM) is an OS-level illusion. It mathematically fuses the physically separated RAM banks of 1,000 distinct servers into a single, massive virtual address space. A thread on Server A can literally execute `x = 5`, and a thread on Server B can read `print(x)`, with the OS violently handling the catastrophic network page faults in the background."},{"type":"heading","content":"The Physics of DSM Execution"},{"type":"paragraph","content":"When Server A accesses a memory page physically located on Server B, the local CPU throws a mathematical Page Fault. The distributed OS intercepts this, pauses the thread, blasts a TCP request to Server B, violently pulls a 4KB chunk of RAM across the network, caches it locally, and resumes the CPU. This allows standard multi-threaded code to run across datacenters."},{"type":"heading","content":"The Catastrophe of Consistency Models"},{"type":"paragraph","content":"Because DSM caches data locally to prevent horrific network latency, data duplication occurs. If Server A modifies `x`, Server B's cache is instantly mathematically invalid. The system must enforce a rigid Consistency Model to dictate EXACTLY when changes propagate."},{"type":"subheading","content":"1. Strict Consistency (Absolute Physics)"},{"type":"paragraph","content":"The mathematically perfect model. Any read to memory location $X$ MUST instantly return the value of the absolute most recent write to $X$. \n*The Reality:* Due to Einstein's speed of light limitation, if Server A in New York writes to $X$, Server B in Tokyo mathematically cannot read the change instantly. Strict consistency is physically impossible in wide-area distributed systems."},{"type":"subheading","content":"2. Sequential Consistency (The Compromise)"},{"type":"paragraph","content":"Instead of strict physical time, it enforces a rigid logical order. The result of any execution is the same as if the operations of all processors were executed in SOME sequential order, and the operations of each individual processor appear in the order specified by its program. It mathematically guarantees that all servers agree on the *order* of events, even if they see them slightly delayed."},{"type":"subheading","content":"3. Release Consistency (Elite Optimization)"},{"type":"paragraph","content":"Synchronizing RAM on every single instruction mathematically destroys network bandwidth. Release consistency forces the programmer to explicitly use `Acquire()` and `Release()` synchronization variables. The OS violently hoards all memory changes locally and ONLY blasts the updates across the network when the programmer mathematically executes `Release()`. This drastically slashes network traffic."}]}},{"id":"v2-distributed-systems-2020-pC-q22","number":22,"marks":10,"tags":["Part C"],"text":[{"type":"paragraph","content":"Explain the Byzantine Generals Problem in detail. Discuss the conditions for achieving consensus and fault tolerance mechanisms."}],"answer":{"summary":"An exhaustive mathematical dissection of the Byzantine Generals Problem. Violently details the absolute hardest fault-tolerance paradigm, proving mathematically that consensus requires $3m+1$ loyal nodes to survive $m$ traitorous, intentionally malicious servers.","explanation":[{"type":"heading","content":"The Byzantine Generals Problem and Consensus Fault Tolerance"},{"type":"paragraph","content":"In standard fault tolerance (Fail-Stop), a server simply crashes and stops responding. This is easy to mathematically detect. The **Byzantine Generals Problem** (formulated by Lamport) models the absolute worst-case scenario: Byzantine Failure. The server does not crash. Instead, it is physically compromised (hacked or suffering horrific hardware corruption) and mathematically lies, sending completely conflicting data to different nodes in the cluster to intentionally trigger a catastrophic systemic collapse."},{"type":"heading","content":"The Mathematical Allegory"},{"type":"paragraph","content":"Imagine a Byzantine army surrounding a city. The army is split into divisions, commanded by Generals (Server Nodes) who can only communicate via messengers (Network). They must reach an absolute mathematical consensus: either ALL attack, or ALL retreat. If half attack, they are annihilated."},{"type":"list","items":["The absolute complication: Some Generals are traitors (Hacked Nodes).","A Traitorous General will mathematically send a message \"ATTACK\" to General A, but simultaneously send \"RETREAT\" to General B.","General A and General B are loyal, but they now possess completely conflicting data and do not mathematically know who is lying."]},{"type":"heading","content":"The Mathematical Proof of Consensus ($3m+1$)"},{"type":"paragraph","content":"Lamport mathematically proved that if the system contains $m$ traitorous (faulty) nodes, the system MUST contain a minimum of $N = 3m + 1$ total nodes to violently force consensus. The number of loyal nodes must fiercely overpower the traitors."},{"type":"list","items":["**Example ($m=1$ Traitor):** You mathematically need $N = 3(1) + 1 = 4$ total nodes. You need 3 loyal nodes to outvote 1 traitor.","**Why 3 nodes ($N=3$) mathematically fails:** Assume Commander (Traitor) tells Lieutenant 1 to Attack, and Lieutenant 2 to Retreat. L1 tells L2 \"Commander said Attack\". L2 is now holding \"Attack\" from L1 and \"Retreat\" from Commander. L2 mathematically cannot determine if the Commander is the traitor, or if L1 is the traitor. Consensus violently fails."]},{"type":"heading","content":"Practical Mechanisms in Distributed Systems"},{"type":"paragraph","content":"Modern distributed blockchains and aerospace flight computers must survive Byzantine failures."},{"type":"list","items":["**Practical Byzantine Fault Tolerance (PBFT):** An aggressive algorithm that uses three strict phases (Pre-Prepare, Prepare, Commit) with massive cryptographic signing. A node mathematically requires a two-thirds majority quorum of identically cryptographically signed messages before it violently executes an action to the ledger, completely paralyzing any malicious node attempting to inject corrupt data."]}]}}]}],"loading":false,"error":null}}}

Q4Distributed Systems

Question

Answer