WorksheetsCSW20103_Chap 1-3: Revision
Total questions: 51
Worksheet time: 26mins
Which scenario best illustrates a violation of distribution transparency?
A user accesses cloud storage without knowing its physical location
A database query performs slower when a server is geographically far
A distributed file system hides replication from the user
A middleware masks network failures
Which analytical argument best disproves the misconception that centralized systems do not scale?
The system uses synchronous communication
Logically centralized systems can still be physically distributed
Single points of failure always appear in centralized systems
Centralized systems cannot use caching
Which factor best distinguishes a decentralized system from a distributed system?
The number of network nodes
The degree to which processes/resources are sufficiently spread
The topology used in the network
Whether middleware is present
Which design goal is violated when users must manually track resource locations?
Openness
Replication
Location transparency
Reliability
Which scenario best matches migration transparency?
A file moved to another server while a user is still accessing it
A cached object being updated periodically
A replicated server taking over after failure
A user hiding their geographic IP address
What is the strongest argument against implementing full transparency?
Full transparency reduces naming complexity
Users prefer manual interaction with system internals
Full transparency imposes performance penalties due to synchronization
Transparency is incompatible with RPC
Why can’t transparency fully conceal failures?
Middleware limitations
Indistinguishability between slow and failed servers
Poor interface design
Which scenario shows administrative scalability as the limiting factor?
Running out of storage on a server
Increasing user count causing congestion
Policies conflicting across organizational domains
Bandwidth saturation in WAN
Which scenario best demonstrates openness?
Migrating applications across different hardware architectures
Replicating data for performance
Avoiding global synchronization
Handling network latency
What does utilization (U → 1) imply in queueing analysis?
All requests are instantly processed
System becomes unstable due to long response times
Replication should be disabled
Throughput becomes zero
Why does global synchronization prevent large-scale replication?
Synchronization must occur across all cached copies
Servers cannot communicate across WAN
Caches invalidate too quickly
Middleware cannot support replication
Which factor improves availability without improving reliability?
Increasing MTTF
Reducing MTTR
Increasing consistency
Performing global synchronization
Which example shows fault tolerance?
Using code reviews
Employing two independent implementations of a component
Hiring better programmers
Estimating faults
Why is trust essential in distributed system security?
Trust allows faster authentication
Trust enables assumptions about expected behaviour across nodes
Trust ensures no node can fail
Trust removes the need for encryption
Geographical scalability limits synchronous communication because:
it increases latency and makes real-time interaction difficult
it improves network speed across regions
it ensures all users are always online
it reduces the need for data synchronization
Clients require portable interfaces
Clients require portable interfaces
Latency makes blocking RPC impractical
Multicast is unavailable
Middleboxes distort packets
Using mirrored websites demonstrates which technique?
Code migration
Caching
Replication
Failover
Why is completely hiding replication impractical?
Network routing
Different consistency requirements
Encryption overhead
Naming conflicts
Which transparency type should NOT be used for location-based services?
Failure
Replication
Location
Data format
Why do behaviour-sensitive instructions complicate virtualization?
They execute too quickly
They behave unpredictably in user mode
They require multiple threads
They disable the MMU
Why do containers require namespaces?
To virtualize bandwidth
To isolate process identifiers across environments
To reduce CPU consumption
To prevent fragmentation
Why is thread switching cheaper than process switching?
Threads require no memory
Threads share address space, reducing context-switch overhead
Threads execute faster
Processes reuse registers inefficiently
Which situation demonstrates indirect context-switch cost?
Page table updates
Cache pollution requiring block reload
Increased thread creation time
Failure in scheduling
What is the main limitation of user-level threads?
They require too much memory
A blocking system call blocks the entire process
They cannot be scheduled
They do not support multithreading
Why are kernel-supported threads valuable?
They execute faster
OS handles thread-level blocking independently
They require no system calls
They remove context switching
Why combine user-level & kernel-level threads?
To eliminate kernel traps
To handle blocking operations without losing flexibility
To avoid memory sharing
To disable scheduling
Why does a multithreaded web client perform better?
Serial execution of downloads
Parallel fetching of embedded resources
Use of nonblocking sockets only
Disabling asynchronous scripts
Why do multithreaded servers scale better?
They avoid disk I/O
They handle multiple blocking I/O operations concurrently
They eliminate network latency
They require no locks
What is the key advantage of dispatcher–worker model?
No scheduling required
Workers block independently while dispatcher accepts new requests
All threads share a single stack
No context switching
What happens when too many threads exist?
Increased CPU clock rate
Scheduler overhead grows and context switching becomes expensive
Memory protection improves
Cache locality becomes perfect
Why does virtualization improve reliability?
VMs operate faster
VM isolation prevents failures from propagating
Why do sensitive instructions complicate virtualization?
They execute too quickly
They behave unpredictably when executed in user mode
They require multiple threads
They disable MMU
What problem does paravirtualization solve?
Lack of encryption
Guest OS executing sensitive instructions without trapping
Slow disk performance
Replication conflicts
Why does PlanetLab require virtualization?
To improve network speed
To isolate multiple experiments on shared machines
To reduce code complexity
To eliminate user threads
Why do PlanetLab slices require separation?
To run different kernels
To avoid interference between experiments
To reduce memory usage
To disable scheduling
Why do containers scale better than VMs?
VMs offer weaker isolation
Containers are lighter because they reuse the host OS
Containers disable OS scheduling
VMs cannot run Linux
Why do raw sockets violate access transparency?
They hide transport details
They expose unnecessary low-level operations
They encrypt data automatically
They support synchronous messaging only
Why prefer persistent over transient messaging?
Persistent messaging reduces latency
Messages are stored until delivery is possible
Persistent requires fewer servers
It eliminates routing
A. Client blocks until server finishes B. Client sends request and continues executing C. Both must be active simultaneously D. Server waits for synchronous reply
A. Client blocks until server finishes
B. Client sends request and continues executing
C. Both must be active simultaneously
D. Server waits for synchronous reply
Which RPC characteristic breaks full access transparency?
Copy-in/copy-out semantics
Stubs hiding communication
Machine-independent marshaling
Remote reference passing
Why is marshaling needed in RPC?
To reduce message size
To convert parameters to a common byte format
To authenticate procedures
To measure latency
Which step hides network latency in RPC?
Server executes local calls
Client stub packs/unpacks
Middleware abstracts communication
OS handles interrupts
Why do asynchronous RPCs improve performance?
They allow multiple non-blocking client calls
They eliminate marshaling
They reduce server load
They avoid transport protocols
Why is pub-sub efficient in ZeroMQ?
Clients maintain direct socket control
Subscribers receive only topic-matching messages
Messages are always stored persistently
Publisher blocks until all subscribers respond
Which model best supports workload distribution?
Request-reply
Publish-subscribe
Pipeline (PUSH-PULL)
Stream sockets
Why does message-oriented middleware improve fault tolerance?
All messages are deleted immediately
Messages are queued until delivery
Middleware bypasses OS
No marshaling needed
Why is a message broker needed?
It accelerates TCP
It translates message formats across applications
It removes queues
It replaces routing
Why is AMQP considered a high-level protocol?
It hides routing
It defines messaging semantics (queues, exchanges, bindings)
It supports only transient messaging
It uses no channels
What is the primary WAN limitation of synchronous client-server communication?
Server cannot handle multiple clients
Blocking model forces client to wait for slow responses
No encryption
Messages cannot be marshaled
Why is POLL unsuitable for guaranteed delivery?
It is asynchronous
It never blocks, risking missed messages
It uses too much memory
It requires RPC
What accurately differentiates RPC from sockets?
RPC always provides persistence
RPC enforces procedure-call abstraction; sockets provide raw message passing
Sockets cannot run over TCP
RPC requires no stubs
