Performance Control in Very Large Collaborative Information Systems Reinhard RIEDL Department of Computer Science, University of Zurich, Winterthurerstr. 190 CH-8057 Zurich, Switzerland
[email protected] http://www.ifi.unizh.ch/ riedl
Abstract. Collaboration of different information systems with partially redundant database contents may help to decrease response times and to increase availability of the system for query activities. For this purpose these query activities have to be performed redundantly in parallel on databases in different information systems. However, as collaborations are scaling up in the number of participating customers, uncontrolled parallel querying will finally lead to the opposite effect, namely longer and longer waiting time, until the whole collaborating system undergoes thrashing. In this paper we present a novel, natural, analytic pricing scheme for query services which may be used to control the degree of effective redundancy in query activities by way of self-regulation. The pricing scheme is based on the calculation of tailback effects and it binds the prices to actual performance, thus ruling out any deviations of prices from real behavior due to speculative system usage by customers.
1 Introduction Cooperating information systems arise in various different business cases, each presenting its particular engineering and management difficulties. Different companies or institutions may decide to found an information extranet company, which supports a controlled exchange of data and knowledge. So far such federated systems are either central ones, though, or their usage is subject to serious constraints. Anyhow, it is usually based on the assumption of a shared cultural background of both users and system creators. The merging of companies may raise the demand to merge the corresponding information systems. The marriages of big companies, which took place in the recent past, have yielded numerous such examples. Hereby, one encounters primarily problems of heritage, that is both system heritage and cultural heritage.
For historical reasons, some companies have developed various different and independent information intranets. Increasing interdisciplinarity of activities now faces them with the problem of how to bring these information systems together. In science and research this seems to be a rather natural process. However, also in industry different business paradigms have yielded the demand for an increased interdisciplanarity - for example the stressing of clerk-to-customer relationship in assurance industry. Psychological reasoning or knowledge engineering may suggest that an organization or enterprise builds various locally managed databases instead of a single central database. First, in many hierarchically organized associations, there is often considerable resistance to deliver private information goods to a central control instance, even though people are very much willing to share these information goods among equals. Second, a local administration of data may be preferable to a global one as long as the know-how in a particular area is only locally available. Numerous examples indicate that chances may be higher to bridge heterogeneous technical systems than the chances are to successfully transform a decentralized human expert knowledge (as it may be needed for an efficient administration of databases) into a central one. Thus, there are lots of different business cases where a system of independent information subsystems arises quite naturally. Obviously, collaboration of these subsystems is desirable and offers new performance perspectives for users.
2 Collaboration In this paper we shall analyze the interplay of information redundancy on the one hand, and of performance and reliability on the other hand, as it takes place in collaborative information systems, where accesses to data are primarily READ accesses. Redundancy of data and computing resources may be used to improve the quality of service (as perceived by the users of the system) in a twofold way. First, failures of some system parts may be compensated for by performing the same activities in parallel. Only if all those services instances among those requested drop out, which are able to supply the demanded reply, then the user will observe a system failure. Therefore, the higher the ‘available redundancy’ is, the higher is the reliability of the system (with respect to the availability of its functionalities). Second, if the same activity is carried out in parallel on different service instances, which are able to supply the demanded reply, the average observed response time distributions will be dominated by the distribution in case of non-redundant activities. (This is true as long as we do not consider conditioned expectation values ruling out system failures, but calculate cases with ‘no sufficient response’ properly as response time equal to plus infinity). Thus, both in case of the absence and in case of the presence of failures, it is generally valid that the higher the used redundancies in the system is, the better is the observed
performance. We apply this consideration to the situation, where different information systems collaborate. As an illustrative example consider the case of a federated library system, where copies of the same document may reside at various places. If a search for a document is performed, this may be done in parallel in the databases of various or all libraries in the system (assuming that each library has its own database). Good performance clearly means low response time in this situation, while high reliability means high likelihood that indeed one copy of the document is found in reasonable time. Note that the term ‘available redundancy’ has a special meaning in this example. It may well happen that a particular document only exists in one library. In that case, the available redundancy is only one (or zero according to the chosen definition of the term redundancy). Generally speaking ‘available redundancy’ means the number of services which are able to deliver the demanded reply. By wrong folklore, short response times contradict high throughput and vice versa. In case that there is no redundancy of activities, this is well known to be false as simple queueing theory tells us. Strategies to reduce response times increase the maximal throughput and vice versa. (The wrong folklore seems to stem from Little’s formula, which relates average response time, average throughput and average number of tasks in the system, but does NOT relate performance goals, obviously.) However, in case of a parallel performing of identical activities this folklore indeed describes the trade-off between the goal to reduce response time and the goal to increase the throughput. Too much concurrency of redundant activities may finally cause thrashing. Or, in other words, if we pursue the goal of maximal availability, we may end up with no availability at all as the tailbacks at the various nodes get longer and longer and finally parts of the system will crash. Summarizing the above, there is a trade-off between the redundancy of activities and the performance as it is observed by the user, which is neither nonlinear, nor completely predictable. Low redundancy causes bad performance for a single user. High redundancy will eventually lead to the crashing of the system or some of its parts. Thus the situation is somewhat similar with the interplay between multiprogramming level and performance, wher a low level leads to low throughput whereas a high level creates the danger of thrashing. Or rather, both problems are dual problems: In multiprogramming many tasks are run in pseudoparallel at one node, while in our system each tasks is run in parallel on many nodes. Whereas this duality does not help to solve our problem, as we shall explain below, it gives an intuitive insight into the nature of our problem. It has been effectively demonstrated that a dynamic control of the multipramming level leads to optimal performance, see e.g. [2] . The same is true for our problem. There, we have to control the blocking of processes by other processes. We have to control the lenghths of tailbacks, which may be considered to be same type of problem as seen from an abstract perspective.
As many tasks run in parallel in our problem, we might indeed try to reformulate it as a ‘multiprogramming level’ problem (MLP) for distributed systems. And we might then try to transform the corresponding solutions in order to obtain solutions for our problem. Fortunately, the techniques developed for single node MLP, apply to multiple node MLP, too. Unfortunately, they address a different phenomenon, thrashing due to a lock overload, i.e. when thrashing is caused by tailbacks of transactions waiting for the grant of a lock to a particulare database page. In case of READ only accesses such type of thrashing does not occur. While in case of WRITE accesses and locks performance is limited by the conflict rate (see [2] ), which must not be too high, in case of READ only accesses, a higher multiprogramming level is achievable, but finally pure overload will bring down the system, too. This implies that some sort of concurrency control or (used) redundancy control has to be introduced as well. In this paper we shall discuss how this may be done.
3 The Models Activities performed in a collaborative information system are most diverse. Documents may be shipped or even traded, any kind of read or write statements on databases may be carried out, similar activities may be carried out on file systems, see e.g. Web-SQL, (or look at the real world in business, where databases are not always state of the art yet), whole transaction programs may be run, possibly on distributed, heterogeneous database systems, etc. In this paper we shall discuss the collaborative, parallel search for and exchange of information products, i.e. documents. Hereby, we shall restrict our considerations to pure performance aspects related to the collaboration of individual information systems (thus analyzing performance and availability aspects in federated database universes). By abuse of terminology, in the following we shall use the terms document, information product, soft-goods, and products synonymously. The term query will always indicate an information retrieval activity. We shall first discuss search for documents.
3.1 The Market Metaphor We shall consider a collaborative information system as a three-tier market place for information goods: In the consumer tier customers access the market via graphical user interfaces; in the broker tier demand for and supply of information are matched; and in the provider tier information goods are supplied by a document database plus possibly an information retrieval system. Due to the transparency paradigm for distributed systems 3-tier market architectures - see e.g. [3] - such architectures are usually supposed
to provide transparency between the first and the third tier and vice versa. For reasons which will become clear later complete transparency would get in the way of optimal customer service. Therefore, we assume that the customers are admitted partial insight into the middle-tier, or rather, that they may actively contribute to the control of the matching procedure, while the details of the matching procedures remain transparent to the customers. Customers request information products via the definition of a formal profile of their information need. That profile is generated and launched with the help of the GUI. In order to improve the quality of service, the profile is optionally enriched by additional, statistically relevant information on the customer and/or by a rating of search areas, i.e. information subsystems, which reflects the opinion of the customer about the likelihoods that the document might be found in one of these subsystems. Moreover, the customer defines the price she is willing to spend on the retrieval procedure. The collaborative information system replies either a selected set of products or an ordered list of product descriptions, according to the specification given in the request. And in addition it bills the customer. In order to avoid misunderstanding let us stress the point that customers are not billed for the reply or its quality, but they are billed for the request. Pricing and billing is NOT used to make money, but only in order to control the performance of the system and to balance the requests. Prices will be low if the load of the system is low, and they will be high if the load of the system is high. In other words, the quality of the matching service does not only depend on the price, but on the ratio of the price and the load state, where load is measured locally at the various subsystems. In order to make the control work customers or groups of customers are attributed budgets, and at the end of a billing period cumulated expenses may indeed be translated into real money. Furthermore, let us point out clearly, that despite of our definition, by its very nature the matching of supply and demand necessarily has to take place both in the consumer tier and the broker tier, and in many cases part of the matching will take place in the provider tier as well. The consumer tier as part of the matching may be referred to as expert system GUI and the better this expert GUI works, the more satisfactory the results obtained by the customer will be. Namely, it is the support for the formulation of information needs which has to take place in the consumer tier and there is no way to deal without that. If different cultures of information systems are to be merged for collaboration, the careful design of this prematching is of particular importance, because differences in ontologies have to be overcome. For a discussion on ontology based customer support systems see e.g. [7] . The matching in the middle-tier is performed by way of IR-queries, which are generated from the information needs as formulated by a consumer via the GUI to the market. These formulations are translated by some mediator instance in the broker tier into one or various queries. Hereby, information on the consumer may be used in order to improve the relevance of the queries on a particular database or retrieval system to the
information need. This process does not necessarily rely on explicit feedback, which will be omitted in our model in order to keep it simple. Above we have emphasized the pre-matching in the consumer-tier and we have pointed to the problem on ontology translations. In most cases, though, the GUI will only supply some broker instance with the information relevant for this task, which will then be carried out by various agents. Hereby, the mediator proceeds as follows. It attributes the consumer to some consumer class, about which it holds statistical information, to be called a consumer profile. And based on this consumer profile it invokes an agent for this class which translates the original query into a prime query. Then the mediator delivers this prime query to a selected set of subsystem specific agents, which translate the query into subsystem specific local queries to be carried out in the corresponding information subsystem. In order to make the description easier we shall assume that agents and subsystems are selected such that each subsystem consists only of one single retrieval base. Thus different agents may perform the same translations, but the invocation of agents depends only on the selection of a subsystems where the search for the document is to be carried out. As usual, the term agent is only used as a metaphor in order to isolate activities of the broker instance and it does not (necessarily) relate to any kind of mobility. For various mobility aspects and another discussion of the use of agents for the management of information markets see e.g. [4]. The various aspects of query translation will not be subject of this paper either. We have integrated a short description only in order to give the reader a more consistent image of the market and its problems. In addition, the specification of user preferences for search in subsystems becomes more transparent, if the nature of the affiliated activities in the middle-tier is known.
3.2 Central versus distributed information systems
There are various different ways how to organize such a broker-based 3-tier market. All data may be brought together at the huge broker database, which is represented by an IR-system that may be the searched by a single query. All meta-data usable for queries, that is all IR-information, may be put into a single IR-catalogue database in the broker tier. Or part of the query may delegated to IR-systems in subsystems. The above model does not rule out any solution, but we are primarily interested in the third type of architecture. There are two important soft-reasons for the choice of distributed solutions: people’s discomfort with centralized solutions and the superlinear growth of the burden of administration of contents with the size of field, from which contents are provided for administration. In addition, transfer and merging of contents into a single content base causes high expenses in manpower. Thus, there is a lot of reason to keep the information there where it is created and to access it remotely. The situation might be different if
we were able to perform content management completely automatically, but still psychological and political resistances would prevent centralized solutions in many cases. Thus if we want to turn single information systems into collaborative ones we have to deal with distributed, heterogeneous systems anyhow.
4 The Interplay of Used Redundancy and System Performance For each single customer best results will be obtained if she is served with maximal redundancy, that is, if the search for documents satisfying her information needs is performed on any information subsystem available. Unfortunately, if all customers are guaranteed optimal service, this may finally lead to unacceptable response times: all get the worst service as we offer the best service to each individual customer. Therefore, control of service qualities has to be performed. The redundancy of service activities has to be controlled as a function of the current system state. This is by far a non-trivial dynamic optimization problem. In order to obtain approximative solutions we suggest a self-governed, distributed control policy, which is able to consider local load states and changes. For this purpose we introduce the following ‘control framework’ as an auxiliary construction.
4.1 The Control Framework We now define a generic, ‘egocentric’ model for collaborative information systems. Hereby, the principal idea is, that collaboration takes place on the basis of a selfless attitude which agrees to serve ‘foreigners’ as long as its own drawback caused by a single collaborative transaction is not too severe. We assume that all customers belong to some information system which they are allowed to use freely, and they want to use other, remote information systems, which are part of the collaboration, too. The collaborating information systems are assumed to be independent and they are focused on serving their own customers (belonging to the system), but they are willing to supply services to all remote customers, as long as the quality of service for their own customers is only gracefully degraded. Thus, the billing takes place only to prevent systems from getting overloaded and the price billed for carrying out some request does not depend on the quality of the results but on the degradation of service quality for the local customers. Various control scenarios have been suggested for similar scenarios, see e.g. [5] . In this paper we provide a novel analytic modeling of prices. Once a customer request for information goods has arrived at some broker instance in the middle-tier the request is immediately carried out in the customer’s home information system. Moreover, the broker chooses as many of the cheapest offers for carrying
out a retrieval as possible, that is: the broker makes its selective choive such that the sum of the prices of all consumed offers is below the budget specified for the retrieval activity. For this purpose it either takes the prices defined by the information subsystems directly into consideration/calculation, or it modifies them according to the expected likelihood that the system will be able to fit the information needs of the customer. The latter is done in one of the following way: The requests of customers are allocated to request classes, which reflect the a priori knowledge on their information needs. This allocation is done based on a priori observables affiliated with customers or their requests, such as profession, membership in special interest groups, etc. Further, it is also based on user preferences, as they are explicitely declared by the customer. Hereby, in the general case query formulations will not be considered as a priori observables, but as request parameters. And user preferences may either be abstract categories of information needs (setting the context for the semantic interpretation of the query as formulated by the customer) or they may be concrete information subsystems known to the customer. In the course of time statistical experience is obtained for each class. This may be used to generate estimates on how good an information subsystem will serve a customer. Moreover, the statistical information may be used for a reordering of classes leading to ne class allocation strategies. Finally, the estimates on the quality of service with respect to content delivery are used as multiplicative weightings of prices. Finally, when the systems have been chosen, and the individual queries for the systems have been generated, they are carried out there and the obtained results are merged by the broker and delivered to the user. In the following we shall draw up a model, which enables us to calculate the pure unweighted prices.
4.2 The Theoretical Model
We start our calculations by first modeling each information system performing local requests as an M/G/1 queue. Modeling requests by a Poisson process is a standard technique which is supported by considerable empirical evidence. There may occur some deviations from Poisson behavior if pre-queueing is performed, but we ignore such effects in order to keep the model analytically tractable. And we assume that service times are independent and identically distributed, but we do NOT assume that they are exponentially distributed, as this contradicts empirical observations, e.g. fat distribution tails. The main difference between our model and real world systems is that the queueing model assumes batch processing while (pseudo-parallel) concurrent processing takes place in real world systems. This alters results in low load states but still yields good approximations in middle-high and high load states. Moreover, in order to keep the
calculations straightforward we consider only one type of workload, that is, we do not distinguish between different types of queries. Now we consider the situation when a sporadic remote request ‘asks’ for execution, whereby we do assume that the service time distribution for the remote request coincides with the distribution for the local requests. The subsystems first have to respond with the current price for the service. Then the broker decides whether it wants the service to be performed or not - based on the knowledge of the price and its budget. In order to make calculations easier, we make the approximative assumption, that all requests in the system have not yet started processing. In the case that M =G, i.e. in the case of an M/M/1 queue, this assumption is indeed no loss of generality, in other situations it modifies the results only to some minor extent. As we intend to price the service with respect to its effects on the local system, we have to calculate the damage done to its own customers, when the system processes a remote request. We estimate this damage by the sum of local customers which have to wait for service because the remote request is carried out. In other words we calculate the tailback effect of performing the service for a remote customer and we define the expected value of the tailback to be the price to be billed. This tailback effect will obviously depend on the service discipline, which we assume to be of FIFO nature. Thus we have to calculate the expected number of customers which will arrive between the time when the remote request enters the system and the first time afterwards, when the system becomes idle again (since an idle period cuts off the tailback). This time interval will be addressed as ‘remaining busy period’ in the following. In order to do this we use and old but still brilliant trick of Takacs [6], following for this purpose the lines of Kleinrock - see [1], chapter 5.8. We permute the order of customers served during the period. First we ignore all tasks except the first task C1 and observe a ‘fictious’ busy period for that task, but with a LCFS strategy. Thus this fictious busy period may be modeled as the sum of 1 + random variables, the first of which is the service time for C1 and the remainder of which are random variables describing the duration of the fictious sub-busy periods, which are distributed as a busy period itself, and is the number of tasks arriving during the execution of C1 . As it is known, this yields the relation Y1 = x + X +1 + X + ::: + X3 + X2 ;
where Y1 denotes the duration of the fictious busy period for C1 , Xj denotes the subbusy period related to the j-th customer, which arrives during the service of C1 , and all Xj and Y are identically distributed. In the following we carry out the same considerations for the other tasks C2 , C3 , ... in the system, which is possible due to the independence assumptions in our model. In this way we can express the duration of the
remaining busy period as the busy period which we would observe if the remote task arrived at an idle time, plus the sum of the busy periods we would observe if each of tasks present in the system would arrive at an idle time. Consequently, we can model N +1 the remaining busy period as n + i=1 i random variable, where n is the number of tasks already present in the system, when the remote task arrives (we do not have to carry about whether these tasks are local or remote ones), the n refers to the service times for the tasks in the queue right now, and the i are random variables equal to the number of customers arriving during the service interval for task i in the system.
P
Thus, if Y denotes the remaining busy period, and xj is the service time for the j-th task in the system, including the newly arrived remote task as task n + 1, and Xl;m denotes the m-th task arriving during the l-th fictious busy period, we get the relation
X Y nX x X X
n+1 Y =
j =1
+1
j
=
j =1
j
(
j
+
1
i=0
j;j +1 i );
where all Xl;m are identically distributed. This relation simply tells us that the remaining busy period is the sum of n + 1 identically distributed and independent busy periods for an M/G/1 system. Consequently, the number of local requests which suffer from the tailback caused by a remote request is n times the number of customers serviced in an M/G/1 system during a busy period. We conclude that the price has to be a linear function of the number of tasks in the system, as long as the input is constant. Assume that we have Poisson input of requests with parameter and the average service time is x. As it is known - see [1], chapter 5.9 E (Yi ) =
1 1
x
. Thus we may conclude that E (Y ) =
n+1 : 1 x
Now, will vary during the course of the day, but in many cases we may assume that it varies only slowly. Thus, we finally arrive at a ‘nearly’ analytically calculated price for the service to the remote customer. Let P (t) denote the price at time t, n(t) the length of the waiting queue at time t, and (t) denote the average number of local requests in the time interval [t; t [, where is chosen by experience. Then the price may be calculated as P (t) =
n(t) + 1 : 1 x(t)
Note that both x and may vary for different subsystems, i.e. they are subsystem specific.
4.3 The General View As we have indicated above, the control framework is only an auxiliary construction, which is introduced in order to make the pricing easier to understand. There is nothing special about local or remote accesses and we may drop this construction completely. (This means then, though, that there is no free querying in a home system.) If all accesses to the information subsystems are carried out across the middle-tier, there is no need to perform the pricing in a subsystem at all. Indeed, if there is one only broker instance it has all data necessary for pricing and no communication overhead is caused. If this is not the case, still regular polling may yield appropriately precise information about the system states in order to provide good estimates of prices. Thus our pricing introduces a self-regulation for collaborative information systems, which balances the desire for high redundancy and the need to control the overall system load. However, what we indeed want to balance is the effective redundancy and the overall load. In the following we describe one way how to achieve this goal: We base the decision which subsystems to choose for service both on the load dependent prices introduced above and on preference matrices (prefi;j )
, which define the preferences of customers from class i for the system j . We have shortly indicated above, how such classes may be formed, and we shall assume now that a grouping is given. For example in an enterprise with different departments classes may correspond to departments. Once the classes are defined, the preference matrix may be defined in various ways. If first abstracts are returned instead of complete articles, we may apply an implicit, automatic feedback procedure to obtain such a preference matrix: We simply define prefi;j as the likelihood that a document ordered by a customer of class i was suggested by system j . When the choice of systems to be requested for service is performed the inverse of each price Pj (t) in subsystem j at the the present time t is now multiplied by prefi;j , where i is the customer the requesting customer belongs to, yielding a temporary value vector (value)i (t). The resulting optimization problem for the broker is to solve the optimization problem maxSET
X
i2SET
valuei (t);
X
i2SET
Pi (t)
K;
where K is the budget available, and SET varies over all sets of eligible subsystems. In this way we can indeed balance the need for effective redundancy against the need for a control of the system load and we obtain a self-regulation of the system. The main feature of our control framework is that it does not only look after the interests of the system by protecting subsystems from becoming overloaded, but it equally
presents the interests of the customer by supporting optimal choices of subsystems for the provision of services as shown above. This fits with the intuitive understanding that a good control strategy must serve both masters, the users and the system.
4.4 The Budgets
We have calculated prices on an analytic basis. Why can such a pricing scheme control the system? The answer is as follows: Load can only be increased if the budgets do allow that. if budgets are set to infinity, no control may be exercised. If budgets are set to zero, no activities will take place. If the overall budget spent in the system at a particular moment is finite but nonzero, this defines an upper bound on the number of queries executed in parallel. Now market mechanisms come into play and turn the system into a self-regulating one. Hereby, our analytic pricing scheme helps to avoid all kinds of unpleasant phenomenons arising from inadequate pricing in incomplete markets. Our pricing scheme binds prices to observable performance effects. Thus the market trades exactly, what it is supposed to trade, namely the importances of demands, which leads to a balancing of requests in the system. We shall not discuss the question here, how budgets ought to be chosen. The experience in the market and the market mechanisms themselves will teach customers and system administrators to choose appropriate budgets. Instead we pose the following rather modest question: What does it mean that we are able to purchase querying in a single subsystem? Well, this question still contains too many implicit parameters. We have to rewrite it as follows: How does the budget relate with the average load and the likelihood, that we will not be able to purchase one single query transaction in a subsystem? We may model this question approximatively with the equilibrium states of a birthdeath queueing system, if we know the distribution FB of budgets. As the complete complex system is much too difficult for analytic, closed form solutions we do assume that there is one preferable subsystem for all requests and we calculate the answer to the above question with respect to a querying price for this preferable subsystem. Moreover we do assume, that in most cases each customer has got enough budget for a query in the preferred subsystem. Let x and be defined as above. Then we define the birth coefficients k and the death coefficients k as follows: k = (1
FB (
n+1 )) 1 x
k = 1=x
This yields that if the budget is K and if
b
n(K ) := K (1
x) + 1 ;
then the probability of getting no service with the budget K is
P1k n K xk Qik k P1k Qik xk = (
1+
1 =0
)
1 =0
=1
+ (1 + (1
FB ( 1n+1 x )) : FB ( 1n+1 x ))
Obviously, there is no closed form for this formula in the general case, but it mat well be approximated numerically for a given distribution of budget sizes. In case that all budgets have the size K , i.e. the distribution function is equal to 1 (x K ), a closed formula for the above likelihood L of staying without service may be calculated explicitly, as this situation corresponds to a M/M/1/K-queueing system: L=
1
1
x
(x)n(K )+1
(x)
n(K )
These calculations seem to be rather tiresome, but at least they indicate how to proceed heuristically in order to choose appropriate budgets. First, agree upon the desired redundancy r and some desired availability likelihood 1 L, second estimate the average load, and third calculate the budget as rn 1 (L).
4.5 Real Pricing for World-Wide Information Markets
The main idea in behind the introduction of our tailback-based pricing scheme is the wish to obtain a self-managing control of the system usage. Thus, so far we have not cared very much about the implementation of charging and billing. But what about really huge federated information markets on the internet, which may be accessed via a web-interface from Mrs. Anybody? These information markets do not exist, but they are most likely to come. Well, the situation is not severly different from dedicated collaborative systems. Prices may equally be used to control the system. However, it is unlikely that it worth implementing some micro-payment which bills the customer per transaction - the more since in case of a single transaction it is difficult to make customers pay explicitely for the expenses of the suppliers rather than for the goods they get. Instead, extranet-like structures may be imposed, which allow customers to spend a fixed budget per month of year of subscription. One of the reasons why electronic commerce is less successful than originally predicted is the smallness of available market places. If electronic information markets want to be successful the have grow large, even in case they are trading most specialized expert knowledge. Very large markets offer the possibility of highly redundant search for information goods, and they offer the possibility of most spectacular thrashing. Thus control is again the magic word here, the more self-managing, the better!
5 Future Work A lot of work still has to be done. Future work ought to concern among others the following aspects – the modeling of user preferences based on the query translation schemes – the design of algorithms for budgeting – a microeconomic analysis of the market mechanisms arising from the tailback pricing
6 Conclusions and Outlook We have presented a natural pricing scheme for service in collaborative information markets which relies on the play of market mechanisms but binds prices to real, observable performance effects. The scheme is based on the analytic modeling of tailback effects. Its analytic binding of prices to performance prevents unwanted deviations of prices from real world performance phenomenons and it enforces market mechanisms which supply the system with a control of the degree of redundancy in retrieval activities. If one combines this pricing scheme with a user group specific value scheme similar to the one we have presented one obtains a balancing of effective redundancy (which is desired by the users) against the need to limit the load of the system. The pricing technique developed may also serve as a basic technique for load balancing in general distributed systems. Since prices are calculated individually for each subsystem, they do not only control the redundancy on a system-wide level, but they help to choose the optimal servers as well. This may be exploited for load balancing in enviroments without redundant service execution, too. We have restricted our considerations to homogeneous load (and homogeneous servers) in order to keep notations simple. However, our pricing technique may equally be applied to inhomogenous load, as long as we are able to identify load classes sufficiently well. For example, it may be used to model the trade-off between JSQ (‘Join the Shortest Queue’) algorithms and data-affinity based routing algorithms in distributed highperformance DB/DC transaction processing systems.
References 1. Kleinrock, L.: Queueing Systems: Volume 1: Theory, John Wiley Sons, 1975; 2. Moenkeberg A., Weikum G.: Performance Evaluation of an Adaptive and Robust Load Control Method for the Avoidance of Data-Contention Thrashing. VLDB 1992: 432-443;
3. OSM, http://www.osm.org 4. Riedl R. and Suezawa T.: Management of Information Markets with Mobile Agents, EMMSEC99, Stockhol 1999, to appear; 5. Sairamesh J., Nikolaou C., Ferguson D.F., Yemini Y.: Economic Framework for Pricing and Charging in Digital Libraries, D-Lib Magazine, Feb 1996; 6. Takacs, L.: to the Theory of Queues, Oxford University Press, 1962; 7. TAMBIS, http://img.cs.man.ac.uk/tambis/index.html
