To appear in: Proceedings of Second International ICSC Symposium on Fuzzy Logic and Applications (ISFL'97), to be held

Transcription

1 To appear in: Proceedings of Second International ICSC Symposium on Fuzzy Logic and Applications (ISFL'97), to be held in Zurich, Switzerland, February 12-14, Fuzzy Control of Load{Balancing for Distributed DB/DC Transaction Processing Reinhard Riedl and Ralf Salomon Department of Computer Science, University of Zurich Winterthurerstrasse 190, 8057 Zurich, Switzerland FAX: Abstract The ecient use of distributed database/data communication (DB/DC) systems requires sophisticated management policies. A good management policy aims at minimizing the (average) response time or a high data throughput. Both goals can be achieved by a balanced load of the incoming transactions requiring for data manipulation over the processing units available. The well-known problem is that no algorithm exists that yields optimal performance for the entire bandwidth of the input. Two other problems are that such a complex real-world application cannot be modeled completely by means of analytical methods, and that the information available at runtime is rather imprecise. In this paper, we suggest a fuzzy switching device, which integrates dierent, simple load balancing algorithms and selects a particular algorithm depending on the actual system state expressed in fuzzy terms. The simple load balancing algorithms are selected on the basis of a cost function model. 1 Introduction Load distribution in distributed database/data communication environments is a very challenging task. Formal mathematical models can cover only particular aspects, since the entire system is too complex, even if one resorts to drastic simplications. Unfortunately, the load balancing problem cannot be decomposed into independent, simpler sub-problems, because the solutions of these sub-problems inuence each other with respect to achieving optimal performance. In this paper, we propose the development of a fuzzy switching device, which, depending on the actual system state expressed in fuzzy terms, selects an algorithm that solves one of the mentioned subproblems. To this end, Section 2 gives a brief overview of the distributed database/data communication environment as is investigated in the LYDIA project. Section 3 discusses dierent level, on which load balancing can be implemented. Section 4 presents the goal and outlines a strategy for solving the problem. The actual fuzzy switching device is outlined in Section 5. Finally, the paper is concluded with a discussion. 2 The distributed DB/DC Environment In this section, we briey describe the database/data communication (DB/DC) environment that is given in the LYDIA project. The hardware under consideration is a distributed system, which consists of a considerably large number of processing nodes. Each node has its own operating system, address space, main memory, and hard disk environment, which may or may not be shared among other nodes. All nodes can communicate with each other via a high speed network, which supplies the node-to-node connections. User terminals are connected via frontend systems, which allow the connection to all nodes in the distributed system. An example of a distributed DB/DC system is shown in Figure 1. The data communication system provides all basic communication functions to remote processing nodes. It treats terminal sessions as well-dened connections between terminals and applications running on arbitrarily chosen nodes of the distributed system. A terminal session is opened and closed from the terminal by suitable commands. A database in general is a huge repository for data items representing information to be maintained and to be made available on demand. Physically, 1

2 the database is stored on several disks of the distributed system. In the database-sharing mode, all disks are shared among all nodes, whereas in the shared-nothing mode, each disk is accessed by only one node. In order to reduce the data access time, the distributed DB/DC environment caches data units in node-specic main memory buers and allows the replication of data units, i.e., several copies of the same data unit may exist in dierent buers. An appropriate coherence protocol preserves the consistency of all replicated data units. The user accesses the database via a database handler, which oers essentially the four basic operations insert, delete, update, and select. From the user's perspective, transactions are the basic database operations. By denition, a transaction is a sequence of basic database operations, which transforms a consistent and integer state of the database into another consistent and integer state. A transaction implies four fundamental (ACID) requirements: atomicity, consistency, isolation, and durability. The transaction monitor provides the user with the basic functionality for the implementation of transactions, namely recovery control and concurrency control. The transaction monitor's recovery component allows for complete rollbacks of any transaction that did not succeed in physically storing all its updated data items on the disk. The transaction monitor's concurrency control component guarantees the correct interleaved or parallel execution of transactions. To handle this task, the given DB/DC environment adopts a (pessimistic) two-phase locking protocol. In any acquisition phase, CPU 1 CPU 2 CPU 3 CPU n Data Storage 1 User Terminals Data Storage n Figure 1: An example of a distributed DB/DC environment. a lock has to be acquired for each data item to be accessed by the transaction. For read-only accesses, a lock may be shared, i.e., granted to more than one transaction simultaneously; otherwise a lock must be exclusive. In the locking-release phase, a transaction releases all its acquired locks. In the following, we shall assume a pessimistic protocol that releases all locks only at the end of the execution of a transaction, since, with respect to load distribution, this case is the more general; Optimistic protocols may be embedded straightforwardly. 3 Levels of Load Distribution In a distributed DB/DC-transaction processing system, the load can be distributed on dierent levels, and the following ve, hierarchically-ordered levels can be identied: Dialog steps: a dialogue step is the time between a user input and the next terminal output. Transactions: as depicted above, a transaction is an atomic unit of work, which is processed on the base of a transaction program (TAP). Conversations: a conversation is a consecutive execution of several transaction programs with additional support and data representation from the transaction monitor. A communication buer and a conversation-specic memory forward all context data from one transaction to the next. Note that in general a conversation is not atomic, i.e., it does not have the ACID-properties. Terminal Sessions: a terminal session lasts for the duration of a connection of a terminal with a node and may enclose various conversations. Application Sessions: during a terminal session, each user of the terminal will be connected to the same transaction monitor application session, where dierent transaction programs are bound together, each of which is identied by a transaction program code (TAC). Obviously, the coarser the load granules to be distributed are, the easier the implementation of the algorithm is. For the identication of the load granules, the following two requirements are essential. First, a transaction in a multi-computer system must not be less reliable (with respect to the ACID-properties) 2

3 than a transaction in a single node system. Second, a load distribution ought to support a higher availability of the distributed system as compared with a single node system. Both requirements suggest that load distribution should be supported on the level of transactions. The choice of a ner load distribution granulation would dramatically increase the costs of implementation, as it leads to conicts with transactions dened by the monitor. The choice of a coarser load distribution granulation would demand the support of partial roll backs of these units by single transactions, which means that load distribution were implemented again on the level of transactions. The chosen level for an actual load distribution algorithm may be higher though. Indeed, in practice, it will depend on the actual workload and the system's situation. Besides the costs for processing the distribution, the main load distribution overhead is generated by the transfer costs, which depend on the amount of context data that are necessary for processing the load unit. As context data are stored in local buers, they have to be transferred from node to node in case of a distribution. The ner the workload is partitioned, the higher these costs are. In this paper, we characterize workload on the level of transactions. Thus in a natural way, there may be assigned two types of observables to each transaction, a priori observables whose knowledge may be used for load distribution, and a posteriori observables, which decide on the relative success of load distribution decisions. The a priori observables are the user identicator (UID), the terminal identicator (TID), the transaction code (TAC), the conversation identicator (CID), and the application identicator (AID). A posteriori observables are a list of pages accessed by write accesses and a list of pages accessed by readonly accesses. For the a posteriori observables, we can ignore the order of accesses, as there is little chance to exploit statistic knowledge about them, and we ignore the number of accesses to the same data object by the same transaction, as this is rather irrelevant for performance issues. Workload analysis of customer traces in the LYDIA-project [2] has provided the following results: apart from hot spots, which have to be dealt with on the level of data partitioning and data distribution, there is some considerable correlation between a priori and a posteriori observables in the customer traces analyzed. Analyses indicate that, according to these correlations, load distribution algorithms preferably perform load assignment primarily on the level of conversation instances in case of load situations similar to those used for drawing the customer traces. 4 Load Balancing The goal of load balancing to distribute the workload such that the system yields optimal performance. In distributed DB/DC systems, load balancing concentrates on the minimization of the response time as the critical performance criterion. Each load unit that is initiated by the user is routed to the node to which the terminal is connected. At that `host node', it has to be decided where the execution of the load unit is to take place. For cost reasons, we shall exclude redistribution except for server breakdowns. Moreover, in order to make the burden of the conceptual framework easier, we shall assume that every load unit can be executed at every node. Note that an appropriate data organization for supporting load balancing is not considered here, since this is an o-line problem. In a general data processing system, the response time of requests depends mainly on the actual throughput; the response time increases with increasing throughput. This phenomenon does not contradict Little's formula at all, since the number of transactions in the system is a superlinear function of the throughput. For a DB/DC system to work properly, it is necessary that the throughput is not less than the input. Thus, the throughput may be considered as an independent variable, and the response time then is considered as the dependent variable. The eectivity of load balancing may be expressed by the response-time throughput graph. Algorithms that yield the lowest response time in the whole bandwidth of throughput are considered optimal. Obviously, for a given set of load balancing algorithms, no complete ordering of the corresponding graphs exist. Instead, graphs will show crossing points as is exemplied in Figure 2. An optimal algorithm can be obtained { at least theoretically { by switching between algorithms at crossing points. In practice, the crossing points heavily depend on workload properties represented by the actual relations between a priori and a posteriori observables. Also, the crossing points dynamically vary in time. 3

4 Response time Algorithm 2 Algorithm 1 Crossing Point Throughput Figure 2: An example of two response time vs. throughput graphs for dierent load balancing algorithms Both properties make it hard to predict appropriate switching points. Related analysis of thrashing phenomena due to lock contentions, as it may already be observed in single node systems, shows that even slightest dierences of otherwise identical inputs can move thrashing borders considerably. Therefore, the only hope for detecting crossing points at runtime is the usage of heuristic dynamical control algorithms. In summary, the main objective of load balancing is the minimization of the response-time throughput graph by dynamically switching between load algorithms that yield good performance in particular sections of the bandwidth of throughput. However, even for subintervals, no simple optimizing algorithms exist, since many dierent phenomena inuence the response time as has been shown in the description of the environment and its workload presented above. 5 Fuzzy Load Balancing In order to proceed toward the development of load balancing algorithms, we adopt an approach in the spirit of classical control theory and then combine it with new design principles as have been developed in fuzzy control theory (see, for example, [6]). We shall rst identify a possible complete set of state variables and then dene a formal framework, in which design principle from fuzzy control may be used. For a more general description of how the concept of state variables can be integrated in fuzzy control, the reader is kindly referred to [6]. In the discussion presented above, we have identied the primary objective of load balancing as the minimization of response time as a function of throughput. In order to obtain a set of state variables, we now have to identify those parts of the response time that are inuenced by the node choice and can be exploited for feedback control of load distribution. As was shown in [2], these parts are the CPU processing time the data access time the costs due to lock contention the waiting time for CPU-processing the costs due to context transfer. In [2], it was also shown that, in order to deal with page access times, the introduction of a workload partition into workload classes is a conditio sine qua non, as data access times may only be reduced by the exploitation of the correlation of a priori and a posteriori observables. Relying on the results presented in [2] and [5], load distribution may be based on a cost function model. The associated cost function is to be minimized and consists of ve terms, which estimate the ve components depicted above as a function of the a priori observables. Unfortunately, these terms are partly positively correlated and partly negatively correlated. These correlations are rather dicult to assess and the order of magnitude is partly unknown. Therefore, in [5] it was suggested that for each of these terms an optimal algorithm is to be found, which minimizes it. Then, these principal algorithms are to be combined to a meta algorithm. As it was pointed out there, one way to combine algorithms is to switch between them according to the actual load state. In this paper, we suggest a fuzzy switching device that is based on design principles similar to those developed in [6]. From the above, we conclude that an appropriate choice for the state variables are functions which represent performance with respect to the various terms of the cost function. These state variables can be used to implement a fuzzy load balancing mechanism, which relies on the implicit feedback of state variables. The main dierence to [6] is that here the objective is optimal control. The state variables can be chosen in two dierent ways. Either, one denes a performance goal for each of the cost terms and measures the relative success in 4

5 achieving the desired goal as the quotient of actual and desired performance. Or, for each cost term, one denes a basic one-theme algorithm, which achieves optimal performance, and derives the state variables from the themes used for achieving the minimization. For a discussion of a transposed version of the rst approach, the reader is referred to [1]. The results given in [1] apply mutatis mutandis to some extent to our situation, because user classes may be interpreted as cost function terms. The second approach relies on the identication of optimal algorithms for individual cost terms, and has been investigated in [5]. Before we present the results obtained there, let us rst discuss the costs due to lock contention. Costs due to lock contention consists of waiting times for locks momentarily assigned to other transactions as well as the overhead resulting from lock misses, e.g., the costs for suspending a transaction. The control of lock contention is a wellknown problem for local scheduling in single node systems. A discussion of this problem can be found, for example, in [3]. Furthermore, industrial experience shows that costs due to lock conicts arise only if the system is already severely overloaded. In such a situation, these costs can be neglected, since the real problems are others. Therefore, we consider costs due to lock conicts as a global `local scheduling' problem. Care has to be taken that the lock conict rate stays below critical values, but this is a problem apart from the load distribution problem. In [5], the one-theme algorithms that minimize the other terms for immediate sender-initiated load distribution (and given connections between terminals and nodes) were identied as follows: JFN = `join the fastest node' for minimizing the CPU processing times JMAN = `join the most data ane node' for minimizing data access times JSQ = `join the shortest queue' for minimizing waiting times `process at the node the terminal is connected to' for minimizing costs of contest transfer The only nontrivial algorithm from a heuristic point of view is JMAN as it relies on the concept of data anity and some specication to grasp data anities dynamically at run time. We shall not discuss these problems here, but refer to the paper mentioned above. Let us just note that the most (data) ane node for a transaction from a given workload class is that node that is expected to have the highest cache hit ratio and the lowest percentage of remote data accesses. Consequently, the state variables resulting from these four algorithms are s 1 (t):= average observed processing speed (for a unit of processing work) in the whole system observed in the recent past s 2 (t):= average observed data anity (for a transaction routing decision) in the whole system observed in the recent past s 3 (t):= current imbalance of waiting queues s 4 (t):= average observed amount of context transfer (for a transaction routing decision) in the whole system observed in the recent past. In order to formally deal with these quantities, we introduce fuzzy anity matrices for each of the four cost terms. Assume that we have got N workload classes and M nodes. Assume further that we perform immediate sender-initiated load distribution at single nodes, and some node is given. Then the aliated anity matrix A i (t) := (a(t) i;j ); i 2 f1; 2; 3; 4g at time t is an N times M matrix with N lines corresponding to the workload classes and M columns corresponding to the executing nodes. Updates of anity matrices take place only upon arrival of new load units. Of course, other formalization are equally possible. A fuzzy entry in that anity matrix is a number from the interval [0; 1], which describes the anity between the workload class and the node with respect to the cost function term i. The higher the entry is the more advisable the choice of the node is. In [5], methods for the calculation of these fuzzy entries are presented. Note that only in case of data anity, lines will differ in general. In case of waiting costs, entries may be dened as the inverses of the queue length increased by one, normalized such that the maximal entry is one. In case of data anity, a possible choice would be the normalized sum of all time points, when an according routing decision was taken, divided by the corresponding sum for all load unit entries. Another 5

6 choice, which is more appropriate for fuzzy algorithm switching, is the average cache miss ratio in the recent past at the corresponding node for the corresponding workload class. A detailed discussion of the appropriate choice is beyond the scope of this small paper. In case of processing times, the processing speed relative to the fastest node may be taken. As background load may be present, actual measurements have to provide these values dynamically at runtime. Before a routing decision is to be taken, the value of the state variable at the node may be calculated as the sum of all routing decisions exponentially weighted according to the time they took place (and possibly with appropriate normalization). More precisely, we sum up over all anity entries aliated with a routing decision, each multiplied by the exponential of the time it was taken (and possibly perform some normalization, respectively). This procedure works well for three state variables, but in case of waiting costs the state variable ought to reect the current imbalance rather than the quality of past decisions. Therefore, we dene s 3 instead as the average of all entries (or alternatively, as the average of the entries in the line aliated with the workload class under consideration). Note that an analogous denition is equally possible for s 2 : we may dene it as the quotient of the average anity for the workload class under consideration and the maximal anity for that class. Having identied the state variables, we may design the fuzzy controller relying on some implicit feedback mechanism as described in detail in [6]. There, it has been shown that independently associating one fuzzy rule set for each state variable is sucient. That is, given n state variables, one has to design n onedimensional fuzzy rule sets. Exploiting this, we introduce four fuzzy rules corresponding to the four state variables: Note that these rules correspond in a one-to-one manner to the single theme algorithms enumerated above. Note further, that contrary to the problem discussed in [6], care has to be taken when choosing the sign in the feedback procedure. We may now design various types of fuzzy controllers: fuzzy superposition of single theme algorithms according to the fuzzy fulllment of the rules above, or fuzzy algorithm switching according to the fuzzy fulllment of the rules above. The rst design approach is applicable, if the algorithms aliated with the above rules are represented by the anity matrices dened above in such a way that they always choose the node with the maximally aliated anity entry. In the second design approach, the resulting fuzzy meta algorithm makes the routing decision according to the algorithm with the maximal aliated state variable. Further performance studies of the load balancing problem are necessary in order to develop the expert knowledge, which is required for any further development of a fuzzy controller. Eventually, this knowledge may help to understand which fuzzy design is to be preferably chosen. Of course, there are alternative approaches to the identication of state variables and the consecutive fuzzy design principle for a load distribution algorithm: for example, even in case of completely distributed load distribution, the global system state as represented by the anity matrices may be considered. If average processing speeds are low, improve them. If data anity routing is prospective, choose it. If the load imbalance is high, decrease it. If context transfer is high, decrease it. The extent to which each of the rules has to be applied, i.e., the relative importance of each of the rules, is given by the value of the aliated state variable. 6 Conclusion In this paper, we have presented a principal design strategy for the design of fuzzy controllers for load balancing in a distributed DB/DC transaction processing system. The resulting algorithms are capable of explicitly dealing with the essential causes for response delays, and in a parallel manner. Due to the systematic approach taken future developments in mathematical modeling may be easily integrated. 6

7 LB 1 TAC, UID, TAP,... Fuzzy Switch Device LB 2 LB 3 LB 4 Decision Figure 3: Depending on the actual system state, the fuzzy switching device chooses the load balancing algorithm (LBx) that is expected to yield the best performance. Fourth Euromicro Workshop on Parallel and Distributed Processing, IEEE Computer Society Press, (1996). [5] Riedl R., Richter L., Born E., Delica T.: Dynamic Adaptive Load Balancing Algorithms for High Performance Processing Deliverable WP3, T3.2, ESPRIT III P8144, URL: LYDIA/year2-deliv.html (1996). [6] Salomon R., Riedl R.: How Fuzzy Control can Benet from Classical Control Theory: The Fuzzy State Controller, accepted for publication in the same proceedings (1997). Acknowledgements This work stems in part from intense discussions and joint work (of the rst author) in the LYDIA Esprit-project grant P8144, in particular with Eike Born, Thomas Delica, Werner Ehrl (all Siemens Nixdorf Information Systems AG, Munich), and Lutz Richter (Computer Systems Architecture and Software Group, University of Zurich). This work was also supported in part by a Human Capital and Mobility fellowship of the European Union, grant ER- BCHBICT Special thanks are due to Rolf Pfeifer (AI Lab, University of Zurich) for his support. References [1] Bhattacharya P., Georgiadis L., Tsoucas P., Viniotis I.: Adaptive Lexicographic Optimization in Multi-class M/G/1 queues, Mathematics of Operations Research (1992) [2] Born E., Delica T., Ehrl W., Richter L., Riedl R.: Characterization of Workload for Distributed Processing { Methodology and Guide, Deliverable WP2/T2.1 ESPRIT III P8144, URL: LYDIA/year2-deliv.html (1996). [3] Moenkberg A., Weikum G.,: Performance Evaluation of an Adaptive and Robust Load Control Method for the Avoidance of Data-Contention Thrashing, Proceedings 18th VLDB Conference, Vancouver, British Columbia, Canada, pp (1993). [4] Riedl R., Richter L.: Classication of Load Distribution Algorithms, Proceedings of the 7