Mario Tokoro 3. Keio University Hiyoshi, Yokohama 223 JAPAN. Abstract

Transcription

1 Toward a New Computing Model/Methodology for Open Distributed Environment Mario Tokoro 3 Department of Computer Science Keio University Hiyoshi, Yokohama 223 JAPAN Tel: Telefax: mario@keioacjp October 18, 1989 Abstract This paper proposes a new computing model/methodology called Mass/Distancebased computing (MD-based computing for short) for solving a problem in an objectoriented open distributed environment It introduces the notions of distance between objects and the mass of an object, and envisages solving a problem as a mutual eect between the computational eld and the problem 3 also with Sony Computer Science Laboratory Inc, Takanawa Muse Building, Higashi Gotanda, Shinagawa-ku, Tokyo, 141 JAPAN Tel: , Telefax: , mario@cslsonycojp 1

2 1 Introduction Recent demands on computer systems can be summarized as: 1 to solve larger and more complex problems, 2 to realize more reliable real time processing, and 3 to provide better user interfaces We have realized the necessity of following software-related items to answer these demands based on the advancement of hardware technology: raising the level of abstraction in describing problems, employing inherent parallelism of problems, accepting the notion of Open Systems [Hewitt 84], and introducing the notion of atomic transaction, time, and so forth In this paper, we pick up the rst demand as our primary concern and propose a new computing model/methodology called Mass/Distance-based computing (MD-based computing for short) MD-based computing is a computing model/methodology for solving a large complex problem on an object-oriented open-ended distributed environment We introduce the notions of distance between objects and the mass of an object to the model/methodology We envisage an open-ended distributed environment as a computational eld Thus, solving a problem can be modeled as mutual eects between the computational eld and the problem 2 Object-oriented Computing The adjective object-oriented emerged in early 1970's at almost the same time in the elds of programming languages, operating systems, articial intelligence, databases, and graphics The commonness and dierence in the usages were realized in 1980's The most common and important feature in those is that object-orientation is a technique of modularization or abstraction in programming and knowledge representation, where modularization is performed in analogy to objects in the real world, so that computation is modeled as a simulation of the world We dene object and object-oriented computing as follows: An object is a physical or logical entity that is self-contained and provided with a unied communication protocol Object-oriented computing is a method of computing in which objects request computation and receive answers from each other in terms of the unied communication protocol A unied communication protocol means that an object can communicate with any other objects through the communication protocol when it knows the addresses (or id's) of the objects 2

3 An object possesses a set of procedures which correspond to computable requests and a local storage to keep its state Object-oriented computing can be understood as the departure from the microscopic view of computing where computation proceeds by executing an algorithm of a procedure to the macroscopic view where computation proceeds as mutual eects among objects 3 Concurrent Objects A concurrent object [Tokoro 88] possesses a (virtual) processor in addition to its local storage and a set of procedures By incorporating a processor in an object, we can eliminate the notion of the locus of execution or allocation of a processor to an object from object-oriented computing Thus, we can employ concurrent objects as a simpler unit for concurrent and distributed computing Hewitt has been advocating this notion as the theory of Actor [Hewitt 73] Orient84/K [Tokoro 84], ConcurrentSmalltalk [Yokote 86] [Yokote 87], also employ this notion As a result, those languages have the following very important advantages: Objects in the real world exist in parallel and execute in parallel By using concurrent objects, it becomes very easy and natural to model computation in analogy to the real world The allocation of processors to objects becomes an implementation issue rather than language issue Therefore, a program becomes independent from the executing system architecture (ie, shared/distributed memory system, the number of processors in the system, and so forth) Most concurrent object-oriented programming languages provide a special object, usually called a future object, to receive an answer for an asynchronous request The notion of future object can easily be extended so that a future object receive more than one answer Thus, we can incorporate stream in object-oriented computing On the other hand, assignment in conventional languages is to generate a future object and to request the destination object to return the answer to the future object 4 Parallel Computing Parallel computing is one of the important methods for high-speed computing Parallel computation of a program is achieved in the following two steps taking balancing of load and reducing overhead for sharing information into account: 1 decomposing a problem into subproblems 2 allocating subproblems to parallel hardware 3

4 Sharing of information is achieved in either of the following schemes: 1 sharing a memory region, or 2 sending messages Sharing a memory region is advantageous when the amount of information shared among subproblems is large However, there is a possibility of processors being idle due to mutual exclusion among subproblems Using messages is advantageous when the amount of information shared among subproblems is small However, there is the overhead of message transmission and reception That is, sharing a memory region has no overhead of message transmission and reception, while it may suer from performance degradation due to processors being idle Using messages has a lower probability of processors being idle, while it may suer from the overhead of message transmission and reception It is dicult in general to determine the allocation of subproblems to processors/computers in advance of execution so that the load of each processor/computer balances for the entire course of execution Thus, we need dynamic allocation of subproblems to processors/computers In case of sharing a memory region for sharing information, it is dicult to allocate subproblems to processors/computers beyond their directly accessible regions It becomes dicult even to write a correct program and maintain it which uses a memory region for sharing information, when the problem becomes large and complex This is because we need a lower level of synchronization among subproblems than the object level Thus, sharing by message is advantageous when we need wide-range load averaging for a large problem If we have a large amount of information to share, we make it one or more objects so that we can share the information by messages We can employ the notion of composite object [Watari 89] to decompose shared information into a structure of objects, where atomic transactions can be applied to preserve consistency without loosing parallelism 5 Shared Virtual Object Space Let us envisage an object on the main memory of a processor in an open distributed environment as a copy of the object in a shared virtual object space (Figure 1) This resembles a block of a distributed shared memory being copied on the cache memory of a processor in a distributed shared memory multiprocessor We can also liken this to a page of distributed secondary storage copied on the main memory of a computer in a shared virtual memory system [Li 86] Copyon-write and map-on-reference [Tevanian 87] are also based on the same idea It is possible that more than one copy of an object exits in the shared virtual object space In such a case, we keep the consistency of the state of an object using a cache consistency protocol The largest dierence between the scheme of shared virtual object space and the shared memory multiprocessor cache or shared virtual memory system is that the shared virtual object 4

5 caching Shared Virtual Object Space objid intra-object displacement PU cache Figure 1: Shared Virtual Object Space space has two-dimensional address, object id and intra-object displacement, whereas the other schemes have one-dimensional linear addresses We can implement the shared virtual object space on a shared segmented virtual memory with object id's (ie, segment numbers) being uniquely created A shared segmented virtual memory can be realized by extending Li's method Unique object id's can be realized by having a long segment number eld By employing the notion of shared virtual object space, object migration becomes transparent from programming level and is handled by an object management facility If we can assume that a program has locality in space 1 as well as locality in time, (the author believes it has) we can achieve ease of programming without causing any performance degradation Kono is extending the notion of shared virtual object space to the concept of paraexistence to treat various problems in a unied way [Kono 89] In order to eectively utilize the notion and mechanism of the shared virtual object space, we need to introduce the notion of distance and mass as described later 6 Distributed Computing In order to perform parallel computing, we decompose a problem into subproblems and allocate them to parallel hardware This in fact yields distance between subproblems Distance manifests in communication delay And, this prevents an object from knowing the current status of other objects This is an essential characteristic of distributed systems 1 Dierent sections of a program can be executed in parallel 5

6 If all the objects concerned with a computation have to have the unique view of an object, we need synchronization among all the objects for every event when the object changes its state We call this complete sharing of an object Instead, the objects concerned with a computation can give up having the unique view of an object, so that we can reduce the frequency of synchronization We call this incomplete sharing of an object In a distributed system, it is impractical to do complete sharing, especially when distance among objects is long and the amount of shared information is large And it is not always necessary in spite of [Carriero 89][Birman 85] 7 Open Systems We started parallel computing by decomposing a problem into subproblems However, our recent programming utilizes existing servers (ie, objects) instead of writing the whole program Thus, programming style is changing from an algorithmic/synthetic way to \try to use them" way That is, a program is written to make maximal use of existing services at each step in the computation In such a programming style, it is impossible to know in advance of execution what kinds of services are available at a certain time In addition, in order to know the available services in the course of executing a program, an object has to use time and computational power Nevertheless, the result returned to the object might not be correct, since the state of the system could change before it takes the planned action This is the signicance of Open Systems[Hewitt 84] Although this is an unavoidable drawback from the conventional viewpoint of programming methodology, we should armatively utilize this characteristic for eciency and robustness of a system 8 Distance In distributed computing, especially in open environments, it is very important to keep the communication delay between objects short Communication delay is a function of geographical distance, communication bandwidth, and other communication overhead Let us dene distance between objects as communication delay between the objects 2 In open systems where computation proceeds utilizing existing objects (servers), we should use closer objects if the same services are provided, and we should ask objects to move closer for higher performance However, an open system is a multiuser system Thus, an object which is used by n users (or n objects) should be placed at (or migrated to) a location where those users can eciently use 2 This denition is reasonable since ultimate communication delay between objects is determined by geographical distance 6

7 it In order to decide such an ideal location, it is rational to dene gravitational force between objects i and j by the frequency of communication between the two objects If we want to dene the locations of objects only by gravitational forces, all of the objects get together at one single point Or, objects are gathered into a few points (assuming users do not move) This means that many objects are executed by one computer In such a case, although communication delay is minimum, the execution speed of each object is slowed This is because all the loads are gathered into one computer Thus, we should introduce repulsive force, which can be dened by the load of a processor More precisely, it can be dened by the dierence between the loads of a processor before and after an additional object is allocated to the processor By knowing the processing speed of each computer comprising a distributed system, topology of connection among computers, required computing power for each object, and communication frequency between objects, it is possible to determine the optimum position of objects for each event in the course of execution However, it should also be noted that observing distance requires time and computing power, and the measured distance may already incorrect when we take action to the object 9 Mass Assume that at a certain time in the course of computing the objects are all placed at their optimum locations Also assume that we can know their optimum locations at the next time It is not always true that migration should take place This is because we have to pay a cost for migration The cost for migration is a function of the distance and the mass of the migrating object The mass can be dened by the size of the object We may also have to take the inertia of an object into consideration, which is interpreted as the overhead for migration According to the above consideration, the location of the objects at the next time should be determined by the cost and the eect of migration 10 MD-based Computing What we want for computation in an open distributed environment is to eciently utilize existing objects through relocating them to their optimal locations taking cost and eect of migration into account Determination of the optimal locations is performed by using the notions of distance, mass, gravitation force and repulsive force, where distance is a function of communication delay between objects, mass is the size of an object, gravitation force is a function of frequency of communication between objects, and repulsive force is a function of additional load to a computer In an open distributed system, however, processing capacity of each computer and con- 7

8 nection topology among computing elements change frequently Users of an open distributed system also change frequently Therefore, it is almost impossible to estimate the processing capacity and usage of computational resources Even if we can estimate those parameters, it might not be possible to calculate the optimal locations of objects in a practical cost and time In addition, an open distributed system is a multi-user system, and conict may arise among users Thus, we now dene MD-based computing as a computational method in which each user (or each object) does locally a best eort to achieve satisfactory allocation of objects using the notion of distance and mass Conict between users for their satisfactory object allocations should be solved by negotiation between users to nd sub-satisfactory object allocations for them This is viewing an open distributed system as the computational eld, and viewing computation as transforming a part of the huge computational eld into its adequate shape That is to say, in MD-based computing, solving a problem is considered as mutual eects between the computational eld and the problem Figure 2 illustrates MD-based computing There is an open distributed computational eld where two tasks (Task A and Task B) are being carried out If you want to start a new task, you will put the task to the eld through your interface computer The load of the computer becomes very high so that repulsive forces appear among the objects consisting the task At the same time, gravitational forces appear between these objects and some existing objects on the computational eld, as these objects communicate with the existing objects Thus, the task starts to diuse, that is, ojbects consisting the task migrate Some of the existing objects may move to their new locations, being attracted by the new task Negotiations among objects may be necessary for nding stisfactory locations Please note that all the existing computations in the computational eld form the environment for the new task, and the new task changes the environment 11 Conclusion In this paper, we proposed the notion of MD-based computing as an attempt to establish computing model/methodology in open distributed environment We introduced the notions of distance and mass in this model/methodology, and we envisage solving a problem as mutual eects between the computational eld and the problem This may lead us to viewing a computing system as a continuous computational eld, as opposed to conventional view of a computing system being a discrete computational eld 8

9 New Task Task A Task B Open Ended Gravitational Force Repulsive Force Figure 2: MD-based computing Acknowledgement The author is indebted to Professor Carl E Hewitt, who is currently an IBM Chair Visiting Adjunct Professor at Keio University, for giving him an insight of Open Systems The author wishes to thank Shinji Kono, Chisato Numaoka, Eiichi Osawa, Rik Smoody, Shigeru Watari, and Yasuhiko Yokote for their critical comments and discussion References [Birman 85] Kenneth P Birman Replication and Fault-Tolerance in the ISIS System In Proceedings of the 10th ACM Symposium on Operating System Principles, ACM, December 1985 [Carriero 89] Nicholas Carriero and David Gelernter Linda in context Communications of the ACM, Vol32, No4, 1989 [Hewitt 73] C Hewitt, P Bishop, and R Steiger A Universal Modular ACTOR Formalism for Articial Intelligence In Proceedings of the 3rd International Joint Conference on Articial Intelligence, August 1973 [Hewitt 84] Carl Hewitt and Peter de Jong Open Systems In J Mylopoulos and J W Schmidt M L Brodie, editors, On Conceptual Modeling, Springer-Verlag, 1984 [Kono 89] Shinji Kono, Shigeru Watari, and Mario Tokoro Object Storage System and Programming Transparency Technical Report 89-SF-30-2, Information Processing Society of 9

10 Japan, September 1989 also appeared in SCSL-TR of Sony Computer Science Laboratory Inc (in Japanese) [Li 86] Kai Li Shared Virtual Memory on Loosely Coupled Multiprocessors Technical Report, Yale University, December 1986 [Tevanian 87] Avadis Tevanian, Jr Architecture Independent Virtual Memory Management for Parallel and Distributed Environment: The Mach Approach Technical Report CMU-CS , Department of Computer Science, Carnegie-Mellon University, December 1987 [Tokoro 84] Mario Tokoro and Yutaka Ishikawa Object-Oriented Approach to Knowledge Systems In Proceedings of the International Conference on Fifth Generation Computer Systems 1984, November 1984 [Tokoro 88] Mario Tokoro Issues in Object-Oriented Concurrent Computing In Proceedings of 4th Conference of Japan Society for Software Science and Technology, September 1988 (in Japanese) [Watari 89] Shigeru Watari, Shinji Kono, Ei-ichi Osawa, Rik Smoody, and Mario Tokoro Extending Object-Oriented Systems to Support Dialectic Worldviews Technical Report SCSL- TM , Sony Computer Science Laboratory Inc, September 1989 [Yokote 86] Yasuhiko Yokote and Mario Tokoro Design and Implementation of Concurrent- Smalltalk In Proceedings of Object-Oriented Programming Systems, Languages and Applications in 1986, ACM, September{October 1986 [Yokote 87] Yasuhiko Yokote and Mario Tokoro Concurrent Programming in Concurrent- Smalltalk In Akinori Yonezawa and Mario Tokoro, editors, Object-Oriented Concurrent Programming, pp129{158, The MIT Press,