Openness and Policies in Distributed Systems

Openness of Distributed Systems

• Open systems can interact with each other regardless of their underlying structures
• Systems should follow well-defined standards for seamless communication and interoperability.
• Portability of applications should be supported, allowing applications to run on different systems.
• Systems must be expandable to adapt to evolving needs.

Policies Versus Mechanisms

• Policies: Determine the level of consistency for client-cached data, operations allowed for downloaded code, QoS adjustments for varying bandwidth, and security requirements for communication.
• Mechanisms: Implement these policies, such as allowing dynamic caching settings, offering various trust levels for mobile code, adjustable QoS parameters for data streams, and different encryption algorithms.

Strict Separation

• A strict policy-mechanism separation requires many configuration parameters, leading to complex management.
• Hardcoding policies simplifies management but reduces flexibility.

Scale in Distributed Systems

• Modern distributed systems often use "scalable" but don't always clearly explain their scalability.
• The key components for scalability include:
  • The number of users and processes (size scalability)
  • Network distance between nodes (geographical scalability)
  • The number of administrative domains (administrative scalability)
• Current systems primarily focus on size scalability, with geographical and administrative scalability remaining a challenge.

Size Scalability

• Centralized solutions often face scalability limits due to:
  • Finite CPU capacity.
  • Limited storage capacity and transfer speed between CPUs and disks.
  • Network limitations between the central service and users.

Formal Analysis

• A centralized service can be modeled as a queuing system.
• Assumptions for the queuing system include:
  • Infinite queue capacity.
  • Constant arrival rate of requests independent of the queue length.
• Processing capacity: represented by the service rate.

Formal Analysis (Continued)

• Utilization (U): The fraction of time a service is busy. U = 1 - P0
• Average number of requests (Ñ): The average number in the system = (1-U)U/μ
• Average throughput (X): The average rate at which requests are processed = U.μ +(1-U).0

Formal Analysis (Continued)

• Response time (R): Total time to process a request after submission, with S (service time) = 1/μ: R = S/(1-U)
• Observation: If U is small, response time is close to S. When U approaches 1, the system becomes heavily loaded, leading to extremely long response times. In this case, reducing the service time (S) is needed to improve scalability.

Client-Server vs. P2P: Example

• Client-server systems typically show a linear upload rate increase with the number of clients (N).
• P2P systems exhibit a slower upload rate increase for the same number of clients.

Problems with Geographical Scalability

• Synchronous client-server interactions are ineffective over wide area networks (WANs) due to high latency.
• WAN links, often unreliable, present a challenge for streaming or transferring large amounts of data.
• Lack of multipoint communication can also hinder distributed application scalability over geographically dispersed nodes.

Problems with Administrative Scalability

• Conflicting policies related to usage, management, and security can complicate the administration of distributed systems.
• Sharing large-scale resources (e.g., computational grids, shared telescopes) among different administrative domains or users requires careful management.
• Several peer-to-peer networks (e.g., file-sharing, telephony, streaming) offer alternative solutions but often rely on end-user collaboration rather than administrative control.

Techniques for Scaling

• Hiding communication latencies: Asynchronous communication and dedicated response handlers provide greater efficiency, but not applicable to all applications.
• Moving computations to clients: Reduces the workload on the server, optimizing response time for specific applications.
• Partitioning: Dividing data and computations across multiple machines to balance workload.
• Decentralized naming services (DNS): Allows efficient resource allocation and location discovery in large distributed environments.
• Replication and caching: Creating multiple copies of data and/or functionality for wider accessibility and reduced load.

Scaling: The Problem with Replication

• Replication introduces issues of maintaining consistency across multiple copies.
• Global synchronization is often necessary but prevents large-scale replication due to performance overhead and complexities.