1. DISTRIBUTED SYSTEMS Principles and Paradigms Second Edition ANDREW S
DISTRIBUTED SYSTEMS Principles and Paradigms Second Edition ANDREW S. TANENBAUM MAARTEN VAN STEEN Chapter 2 ARCHITECTURES

2. 2.1 Architectural Styles
Architectural style of distributed systems is formulated on
components
how components are connected
data exchanged between components
how the above elements are configured

3. Architectural Styles
Important styles of architecture for distributed systems
Layered architectures
Object-based architectures
Data-centered architectures
Event-based architectures

4. Figure 2-1. The (a) layered architectural style and …
Architectural Styles
Figure 2-1. The (a) layered architectural style and …

5. Figure 2-1. (b) The object-based architectural style.
Architectural Styles
Figure 2-1. (b) The object-based architectural style.

6. Figure 2-2. (a) The event-based architectural style and …
Architectural Styles
Decoupled in space
Figure 2-2. (a) The event-based architectural style and …

7. Architectural Styles Also decoupled in time
event-based + data-centered
Figure 2-2. (b) The shared data-space architectural style.

8. 2.2 System Architecture Centralized Architecture
Decentralized Architecture
Hybrid Architecture

9. Centralized Architectures
Making the connectionless protocol resistant to occasional transmission failures is not trivial
Figure 2-3. General interaction between a client and a server.

10. Application Layering (1)
Recall previously mentioned layers of architectural style
The user-interface level
The processing level
The data level

11. Application Layering (2)
2. DSS for stock brokerage
3.Office suites
persistent
consistent
Figure 2-4. The simplified organization of an Internet search engine into three different layers.

12. Multitiered Architectures (1)
The simplest organization is to have only two types of machines:
A client machine containing only the programs implementing (part of) the user-interface level
A server machine containing the rest,
the programs implementing the processing and data level

13. Multitiered Architectures (2)
Figure 2-5. Alternative client-server organizations (a)–(e).

14. Multitiered Architectures (3)
Figure 2-6. An example of a server acting as client.
(three-tiered architecture)

15. Decentralized Architecture
Multitiered architecture is also called vertical distribution
Placing logically different components on different machines
Horizontal distribution
A client or server may be physically split up into logically equivalent parts, but each on its own share of the complete data set, thus balancing the load
Peer-to-peer is an example of horizontal distribution
Interaction between processes is symmetric
Overlay network: in which the nodes are formed by processes and the links represent the possible communication channels
Structured
Non-structured

16. Structured Peer-to-Peer Architectures (1)
Its distributed hash table:
A data item with key k is mapped to the node with the smallest id with id  k
Membership management: how nodes organize themselves into an overlay network (entering and leaving)
Figure 2-7. The mapping of data items onto nodes in Chord.

17. Structured Peer-to-Peer Architectures (2)
D-dimensional Cartesian coordinate space
Nodes keep track of their neighbors
訂正：p.46 倒數第9 列， P should be Q
Figure 2-8. (a) The mapping of data items onto nodes in CAN (Content-Addressable Network).

18. Structured Peer-to-Peer Architectures (3)
Periodic repartitioning is required due to less symmetric partition caused by leaving
Figure 2-8. (b) Splitting a region when a node joins.

19. Unstructured Peer-to-Peer Architectures (1)
Randomization:
Each node maintains a list of neighbors, constructed in a random way
Figure 2-9. (a) The steps taken by the active thread.

20. Unstructured Peer-to-Peer Architectures (2)
Leaving is easy, but tend to have imbalanced workload P;
Swap part of original view
Discard old entries
Figure 2-9. (b) The steps take by the passive thread

21. Topology Management of Overlay Networks (1)
Figure A two-layered approach for constructing and maintaining specific overlay topologies using techniques from unstructured peer-to-peer systems by carefully exchanging and selecting entries from partial views

22. Topology Management of Overlay Networks (2)
distance = d1 + d2
di = min(N-|ai –bi|, |ai – bi|)
In general, how to capture the semantic proximity of the data items?
Figure Generating a specific overlay network using a two-layered unstructured peer-to-peer system [adapted with permission from Jelasity and Babaoglu (2005)].

23. Superpeers
Maintaining an index or
Acting as a broker
Problem: how to select a superpeer?
Client-superpeer relation could be dynamic
Figure A hierarchical organization of nodes into a superpeer network, to avoid flooding lookups

24. 2.3 Hybrid Architectures
Could be used for replicating content
Figure Viewing the Internet as consisting of a collection of edge servers, which is to serve content, possibly after filtering and transcoding

25. Collaborative Distributed Systems (1)
Client-server: to join
Decentralized: after joining
Where is the bottleneck?
Figure The principal working of BitTorrent [Pouwelse et al. (2004)].

26. Collaborative Distributed Systems (2)
Components of Globule, which resembles the edge-server architecture, collaborative content distribution network:
A component that can redirect client requests to other servers.
A component for analyzing access patterns.
A component for managing the replication of Web pages.

27. 2.3 Architectures vs. Middleware
Commonly, middleware systems follow a specific architectural style
Easier to design applications
No longer optimal for an application
Specific solutions should be adaptable to application requirements
One possible solution: make several versions of a middleware system
Another solution: make the middleware easy to configure, adapt, and customize

28. Figure 2-15. Using interceptors to handle remote-object invocations.
Modules to break usual flow control and allow other code to be executed
Figure Using interceptors to handle remote-object invocations.

29. General Approaches to Adaptive Software
Three basic approaches to adaptive software:
Separation of concerns
Separate functionality implementation from other extra functionalities
Computational reflection
A program could inspect itself and adapt its behavior
Component-based design
Composition
Generality vs.
Simplicity with Restricted applicability

30. 2.4 Self-Management in Distributed Systems
Distributed systems should be adaptive in their execution behavior, not in the software component they comprise
For automatic adaptation, we need to organize the components, and we need to decide where the processes are to be executed to handle the adaptation

31. The Feedback Control Model
Figure The logical organization of a
feedback control system.

32. Example: Systems Monitoring with Astrolabe
Figure Data collection and information aggregation in Astrolabe.

33. Example: Differentiating Replication Strategies in Globule (1)
Replication policy
Figure The edge-server model assumed by Globule.

34. Example: Differentiating Replication Strategies in Globule (2)
Figure The dependency between prediction accuracy and trace length.

35. Example: Automatic Component Repair Management in Jade
Will work only when no crucial data has been lost
Steps required in a repair procedure:
Terminate every binding between a component on a non-faulty node, and a component on the node that just failed.
Request the node manager to start and add a new node to the domain.
Configure the new node with exactly the same components as those on the crashed node.
Re-establish all the bindings that were previously terminated.