Chapter 1

1. Describe and define DS

            A distributed system consists of a collection of autonomous computers linked by a computer network and equipped with distributed system software. Distributed system software enables computers to co-ordinate their activities and to share resources such as computer hardware, software and data. Users of a distributed system should perceive a single, integrated computing facility even though the system is implemented using many computers in different locations.

2. Enumerate and describe its characteristics

            Six key characteristics are primarily for the usefulness of distributed system.

            1. Resource sharing – The term “resource” is a rather abstract one, but it best characterized range of things that can be shared usefully in a distributed system. The range extends from hardware components such as disks and printers to software. Users of both centralized and distributed computer systems are having the benefit of resource sharing. The benefits of shared access to a single filing system containing databases, programs, documentation and other information were first recognized with the emergence of multi-user or time-sharing systems.

            2. Openness – The openness of a computer system is the characteristic that determines whether the system can be extended in various ways. A system can be open or closed with respect to hardware extensions. The addition of peripherals, memory or communication interfaces – or with respect to software extensions – the addition of operating system features, communication protocols, and resource sharing services. The openness of distributed systems is determined primarily by the degree to which new resource sharing services can be added without disruption to or duplication of existing services.

            3. Concurrency – when several processes exist in a single computer they are executed concurrently. If the computer is equipped with only a single central processor, this is achieved by interleaving the execution of portion of each process. If the computer has n number of processors, then up to n processors can be executed simultaneously. In distributed systems there are many computers, each with one or more central processors. If there are m computers in a distributed system with one central process each, then up to m processors can run in parallel, provided that the processors are located in different computer.

            4. Scalability – distributed systems operate effectively and efficiently in many different scales. The smallest practicable distributed system probably consists of two workstations and a file server, whereas a distributed system constructed around a single LAN may contain several hundred workstations and many file servers, print servers and other special purpose servers. Several LAN are networks are often interconnected to form internetworks, and these may contain many thousand of computers that form a single distributed system, enabling resources to be shared between all of them

            5. Fault tolerance – computer systems sometimes fail. When faults occur in hardware or software, programs may produce incorrect results or they may stop before they have completed the intended tasks.

            6. Transparency – transparency is defined as the concealment from the user and the application programmer of the separation of components in a distributed system, so that the system is perceived as whole rather than as a collection of independent components. The implications of transparency are a major influence on the design of the system software.

3. Discuss the design issues associated in DS and give a short explanation on each issue.

- Naming:

The name assigned to recourses or objects must have global meanings that are independent of the locations of the object.

They must be supported by a name interpretation system that can translate names in order to enable programs to access named resource.

            A design issue is to design naming schemes that will scale to an appropriate degree and in which names are translated efficiently to meet appropriate goals for performance.

- Communication

The performance and reliability of the communication techniques used for the implementation of distributed system are critical to their performance.

Communication can be time-consuming because of the number and complexity of the software layer involved.

A design issue is to optimize the implementation of communication in distributed systems while retaining a high-level programming model for its use.

- Software structure

The design issues is to structure a system so that new services can be introduced that will inter-work fully with existing services without duplicating existing services elements

A design issue is to structure a system so that new services can be introduced that will inter-work fully with existing services without duplicating existing service elements.

- Workload allocation

The design issues for distributed system is how to deploy the processing, communication and resource in a network to optimum effect in the processing of a changing workload

- Consistency maintenance

The maintenance of consistency at reasonable cost is perhaps the most difficult problem encountered in the design of DS

Chapter 3+4

1. Define the term Remote Procedure Call.

-Two parties in client-server computing in involved. The two parties are the caller and the cal lee.

-The caller passes some parameters to the cal lee.

-The cal lee receives the parameters and returns one or more values to the caller after processing.

-In RPC the caller and the cal lee comes under different hosts.

-Info can be transported from the caller to the cal lee in the parameters and can come back in the procedure result. This method is known as Remote Procedure Call or often just RPC.

2. The advantages of Remote Procedure Call (RPC)

-  Remote interfaces can be specified as a set of named operations

-  Communication code can be generated automatically

-  Portable client-server modules can be developed

-  Widely understood and used by users

3. RPC parameter passing with diagram.

Parameter passing:

-The mechanism used to pass parameters to a procedure (subroutine) or function.

-The most common methods are to pass the value of the actual parameter (call by value), or to pass the address of the memory location where the actual parameter is stored (call by reference).

-The latter parameter allows the procedure to change the value of the parameter, whereas the former method guarantees that the procedure will not change the valued of the parameter.

-Other more complicated parameter-passing methods have been devised, notably call by name in Algol 60, where the actual parameter is re-evaluated each time it is required during execution of the procedure.

4. Message Passing

-When processes interact with one another, two fundamental requirements must be satisfied: synchronization and communication. Processes need to be synchronized to enforce mutual exclusion: cooperating processes may need to exchange info. One approach is to providing both of these functions is message passing.

Chapter 5

Give the differences between logical and physical time.

-Physical time:

+Time is an important and interesting issue in DSs, for several reasons.

+First, time is a quantity we often want to measure accurately.

+Second, algorithms that depend upon clock synchronization have been developed for several problems concerning DSs. These include:

=>Maintaining the consistency of distributed data

=>Checking the authenticity of a request sent to a process

=>Eliminating/Deleting/Removing the processing of duplicate updates

-Logical time:

+All comps have a circuit for keeping track of time that it is called “clock” although the word “timer” would fit better.

+Because of all processes on comp use the same clock, it does not matter if clock off, they will still be internally consistent.

+Clocks in different comps all running exactly the same speed is not sure. It is called clock skew.

Chapter 6

Enumerate and describe the characteristics of a distributed OS.

-The operating systems task is to enable a distributed system to be conveniently programmed, so that it can be used to implement the widest possible range of apps.

-It does this by presenting apps with general, problem-oriented abstractions of the resources in a DS.

-In an open DS, the distributed OS is implemented by a collection of kernels and servers (server processes). There is no clear dividing line between the distributed OS and apps that run on top of it.

Chapter 7

Explain the concepts of concurrency control.

-Is concerned with preventing loss of data integrity due to interference between users in a multi-user environment.

-Prevents problems such as the lost update problem, the temporary update problem and the Inconsistent analysis problem.

-There are two basic approaches to concurrency control:

+A pessimistic approach (involving locking)

+An optimistic approach (involving versioning)

Chapter 8

1. Differentiate simple and nested distributed transaction.

-A distributed transaction is a client transaction that invokes operations in several different servers.

-There is two ways that DTs can be structured: a Simple DT and a Nested DT.

-In a SDT, a client makes requests to more than one server at a time, but each server carries out the client’s requests without invoking operations in other servers.

-In some cases an operation in a server may invoke an operation in another serer and in general the second server may invoke operations with some other servers. To deal with this situation, each client transaction in structured as a Nested DTs. Nested transaction at the same level may run concurrently with one another.

2. Discuss how the concurrency control applied in distributed transaction.

-Each server manages a set of data items and is responsible for ensuring that they remain consistent when accessed by concurrent transactions.

-Therefore each server is responsible for applying concurrency control to its own data items.

-They are performed in a serially equivalent manner:

+Locking in DTs: each server maintains locks for its data items. The local lock manager can decide whether to grant a lock or make the requesting transaction wait. When locking is used for concurrency control, the data items remain locked and are unavailable for other transactions during the atomic commit protocol.

+Timestamp orders concurrency control in DTs: In a single server transaction, the server issues a unique timestamp to each transaction when it starts. When timestamp ordering is used for concurrency control, conflicts are resolved as each operation is performed. Any transaction that reaches the client request to commit should always be able to commit.

+Optimistic concurrency control in DTs: each transaction is validated before it is allowed to commit. Servers assign transaction numbers at the start of validation. A DT is validated by a collection of independent servers each of which validates transactions that access its own data items.

Chapter 9

1. Illustrate the organization of a generic name service.

-A naming service maintains a set of bindings that relate names to objects. All objects in a naming system are named in the same way (the same naming convention). Clients use the naming service to locate objects by name.

-There are a number of existing naming services, a few of which will be described below:

+COS (Common object services) naming

+DNS (Domain name system)

+LDAP (Lightweight Directory Access Protocol)

+NIS (Network Info System) and NIS+

2. Differentiate object naming and object location.

-Object naming:

+Distributed objects can be named in various ways. Object naming based on object identifiers is one extreme.

+When an object is created it is assigned an ID that uniquely IDs that object.

+At the other extreme, objects are addressed by contents or functionality such as object name “printer” can be used to refer to the local printer.

+Many systems offer an intermediate solution: a user-chosen name is used to refer to a single object. One name refers to one object at the same time but can be bound to different objects at different times.

-Object location:

+We use a single distributed location service to keep track of where objects are.

+The location service as a whole stores the location info about all distributed objects.

+Since the number of distributed objects can be extremely large, the complete state of the location service needs to be divided into partitions that are stored in location objects.

+Each location object keeps the location info of some number of distributed objects and can also refer to other location objects.

3. Describe the steps in naming and binding distribute objects.

Algorithm for Naming and Binding Distributed Objects

The naming/ blinding algorithm consists of four steps: Name Lookup, Location Lookup, Destination Selection and Implementation Selection. We will describe each step briefly before going over the details

-          Step 1: Name Lookup

·         In the first step, a name is resolved to an object handle. This object handle consists of two part: an object identifier and a reference to the location of the object

-          Step 2: Location Lookup

·         In the second step, the location reference and the object identifier are resolved to a set of pairs

·         Each element of this set describes the network address, port number, etc. Where the object can be reached, and the protocol stack that has to communicate with that particular destination

-          Step 3: Destination Selection

·         In the third step, one pair is chosen

·         This selection should be made, based on the protocol implementations available to the address space from which binding takes place, security constraints, and locality

-          Step 4: Implementation Selection

·         In the fourth step, a suitable implementation for the selected protocol is chosen

·         We assume that implementations are available on nearby site which acts as an implementation repository

·         Implementations are stored as class objects; new ones can be added at dynamically

·         Once a class object is loaded, it can be used to access multiple distributed objects of the same class

Chapter 14

1. Define and describe DSM

-Is primarily a tool for parallel applications or for any distributed application or group of apps in which individual shared data items can be accessed directly.

-Is in general less appropriate in client-server systems, where clients normally view server-held resources as abstract data and access them by request

-However, servers can provide DSM that is shared between clients.

-In a DS in the absence of physically shared memory, DSM run-time support has to send updates in messages between computers.

-DSM system manages replicated data.

-Each computer has a local copy of recently accessed data items stored in DSM, for speed of access.

-DSM can be persistent.

2. Discuss its different approaches:

There are 3 approaches to the implementation of distributed shared memory (DSM), which respectively involve the use of hardware, virtual memory or library support:

+ Hardware based:

- Some multiprocessor architecture rely on the specialized hardware to handle load and store instructions applied to address in DSM, and to communicate with remote memory modules as necessary in order implement them.

- These hierarchical designs in which clusters of processors and memory modules are connected via a high speed network are aimed at orders of magnitude more processors than the limit of 10 or so that can be accommodated over a common bus.

+ Page based

DSM can be implemented as a region of virtual memory occupying the same address range in the address spaces of every participating process. In each case the kernel maintains the consistency of data within DSM region part of page fault handling

+ Library based

- Some languages or language extensions support forms of DSM. In this type of implementation sharing is not implemented through the virtual memory system but by communication between instance of the language run-time.

- Processes make library calls inserted by a compiler when they access data items in DSM.

- The library access local data items and communicate as necessary to maintain consistency

Chapter 15

1.      Explain the uses of DFS

-A distributed file system in a client/server-based app that allows clients to access and process data stored on the server as if it were on their on computer. When a user accesses a file on the server, the server sends the user a copy of the file, which is cached on the user’s computer while the data is being processed and is then returned to the server.

-Ideally, a DFS organizes file and directory services of individual servers into a global directory in such a way that remote data access is not location-specific but is identical from any client.

-All files are accessible to all users of the global file system and organization is hierarchical and directory-based.

2.      Discuss the advantages of a DFS

-Info: When you need it—where you need it: To keep pace with the daily demands of doing business, you need a DFS that provides security, scalability, availability and Web access for your enterprise, while controlling overall system maintenance costs. Transect’s DFS combines these file sharing capabilities to deliver info whenever and wherever you need it most.

-Technology you can count on: DFS gives users the confidence that business-critical info is not only accessible, but also accurate, up-to-date and protected from unauthorized access.

+Scaleable

+Available: With DFS, files and system apps remain available to users during common operations or temporary system failures.

+Secure: DFS uses multiple security mechanisms to protect data as it travels across the network.

-Easier to Administer: DFS simplifies administration by capabilities for monitoring servers and performing other system functions.

+Shared work groups: DFS is ideal for environments where individuals are performing related tasks with common tools in a wide-area environment.

+Secure, Scaleable Web sites: The performance, administration, scalability and security features of DFS provide a perfect match for growing Web sites struggling to handle increasing amounts of info and users. With DFS Web secure, users have secure access to shared apps from standard desktop browsers for more effective front-end access to apps.

Chapter 16

Discuss how the distributed object system works.

-Once an object has been defined in a generic description language, an interface generator produces language-specific definitions of that object and routines for transmitting that object between programs. Each program becomes a client/server for a specific set of objects.

-So that each program doesn’t have to know details about other programs, each program registers its available object types with an ORB (Object request broker). When a program needs a service, it contacts the ORB, which puts it in contact with the appropriate provider.

Program A                                         Program B

#include genMatrix.h             #include genMatrix.h

                                                            Contact_ORB(anORB);

                                                            Provide_ORB_service(anORB, MatrixClass);

Contact_ORB(anORB);

Request_ORB_service(anORB, MatrixClass);

MatrixClass myMatrix=new(…);

Det=myMatrix.determinant();

+The call to “determinant()” contacts program B, sends the matrix and the method call and waits for the response.

+MatrixClass is define in a generic object language, which specifies its contents and public methods. It is called an Interface description language (IDL).

+As the first step of compilation, the file MatrixClass.idl is translated to each of the required languages. Each program then includes the appropriate language-specific file in its program.

Chapter 17

Give the differences between local and distributed computing.

The major differences between local and distributed computing concern areas of latency, memory access, partial failure and concurrency.

-Latency:

+

Chapter 20

1. Discuss the possible future of DS.

2. Definition of a Mobile Agent

            A mobile agent is not bound to the system where it begins execution. It has the unique ability to transport itself from one system in a network to another. The ability to travel, allows a mobile agent to move to a system that contains an object with which the agent wants to interact, and then to take advantage of being in the same host or network as the object.

3. Seven good reasons for using mobile agents.

They reduce the network load. Distributed systems often rely on communications protocols that involve multiple interactions to accomplish a given task. This is especially true when security measures are enabled. The result is a lot of network traffic. Mobile agents allow you to package a conversation and dispatch it to a destination host where the interactions can take place locally.

They overcome network latency. Critical real-time systems such as robots in manufacturing processes need to respond to changes in their environments in real time. Controlling such systems through a factory network of a substantial size involves significant latencies. For critical real-time systems, such latencies are not acceptable. Mobile agents offer a solution, since they can be dispatched from a central controller to act locally and directly execute the controller’s directions.

They encapsulate protocols. When data are exchanged in a distributed system, each host owns the code that implements the protocols needed to properly code outgoing data and interpret incoming data, respectively. However, as protocols evolve to accommodate new efficiency or security requirements, it is a cumbersome if not possible task to upgrade protocol code properly. The result is often that protocols become a legacy problem. Mobile agents, on the other hand, are able to move to remote hosts in order to establish “channels” based on proprietary protocols.

They execute asynchronously and autonomously. Often mobile devices have to rely on expensive or fragile network connection. That is, tasks that require a continuously open connection between a mobile device and a fixed network will most likely not be economically or technically feasible. Tasks can be embedded into mobile agents, which can then be dispatched into the network. After being dispatched, the mobile agents become independent of the creating process and can operate asynchronously and autonomously.

They adapt dynamically. Mobile agents have the ability to sense their execution environment and react autonomously to changes. Multiple mobile agents possess the unique ability to distribute themselves among the hosts in the network in such a way as to maintain the optimal configuration for solving a particular problem.

They are naturally heterogeneous. Network computing is fundamentally heterogeneous, often from both hardware and software perspectives. As mobile agents are generally computer- and transport-layer-independent, and dependent only on their execution environment, they provide optimal conditions for seamless system integration.

They are robust and fault-tolerant. The ability of mobile agents to react dynamically to unfavorable situations and events makes it easier to build robust and fault tolerant distributed systems. If a host is being shut down, all agents executing on that machine will be warned and given time to dispatch and continue their operation on another host in the network.

4. Mobile agent apps

-Electronic commerce

-Personal assistance

-Secure brokering

-Distributed info retrieval

-Telecommunication networks services

-Workflow apps and groupware

-Monitoring and notification

-Info dissemination

-Parallel processing