A Dynamic Load-Balancing Approach for Efficient
Remote Interactive Visualization
Chen-Han Kuo and Damon Shing-Min Liu
Department of Computer Science and Information Engineering
National Chung Cheng University,Chiayi,Taiwan
f
kch90,damon
g@cs.ccu.edu.tw
Abstract
In this paper, we present a dynamic load-balancing scheme in a networked heterogeneous computing environ-ment and apply it to a Web-based scientific visualization system, whose efficiency requires a much stronger support than what is needed for visualizations merely on a single computer. To achieve the overall system resource utiliza-tion and to determine the most cost-effective strategy for such computing applications, we adopt a distributed asyn-chronous pipeline approach and a dynamic load-balancing algorithm at server side to distribute tasks among the whole system. To achieve efficient pipelining, it essentially re-quires a network with high bandwidth and low latency, an efficient interprocess communication mechanism on the net-work, and proper adaptation and partitioning of the visual-ization computations through the pipeline.
By taking each client’s capability into consideration, this dynamic approach can dispatch some stages of the visualization pipeline to client for executing. Besides, we also present a mechanism for selecting a computing unit that best suits for executing a specific visualization computation in the incoming job. We have demonstrated a number of static and dynamic configurations in task allocation and functional partitioning in order to realize the target application.
Keywords: Scientific visualization, load-balancing, Java RMI, visualization pipeline, Visualization Toolkit.
1. Introduction
Over the past several years,visualization in scientific and medical research has become a rapidly emerging disci-pline aimed at developing approaches and tools to facilitate the interpretation of and interaction with large amounts of
data. The overall thrust of visualization science has been to provide researchers with the ability to explore hidden rela-tionships,patterns,or characteristics of data in a new and deeper manner. The field of scientific visualization usu-ally involves the use of high-performance computers (such as supercomputers) to accommodate orders-of-magnitude variations in processing,memory and storage. However, the price of such computers is often far beyond the reach of most researchers and practitioners. Furthermore,even if high-performance computers can be used remotely,these is still a demanding need of flexibility and adaptability in utilizing network bandwidth and data access mechanisms.
The increased capabilities of workstations have been used to dramatically increase the size and complexity of numerical simulations. As the size of the simulations in-creases,the size of the solution data sets also increases and can result in immense data sets representing the physical characteristics of a studied field. Much research seeks to design a novel distributed software architecture that enables the construction of visualizations,despite geographical dis-tribution of both resources and users.
Particularly,the recently widespread popularity of Web technology has created a new visualization paradigm. The ease of Web development enables the implementation of a distributed environment as a visualization system. It indi-cates that the Web and its associated browsers can serve as an easily used and powerful front-end to effective remote interactive visualization. In it,computational resources are extended beyond the machine running the HTTP server by using UNIX interprocess communication mechanism or Java RMI for communication with rendering servers on other machines. Nevertheless,very often the traffic on the Web is very bursty.
In these Web-based,computation intensive applications, we need a dynamic load-balancing algorithm to reduce the overall system response time by selecting the least loaded server and utilizing the whole system’s resource properly. In the Internet environment,there are two common kinds of computational models. The one simply utilizes the
comput-ing resource on the server side and is called server-based. The other one simply performs visualization tasks on the client side and is called client-based. However, a more flex-ible and effective design of a visualization needs to manage more carefully the computing resources on client and server, and also consider the influence of their interconnecting net-works.
To this end,we often need a dynamic system that splits visualization tasks so as to distribute workload among all involved computing units (server and clients) according to the static and dynamic system parameters. Here our aim is to develop an effective load-balancing scheme in such sys-tem. In it,we are mainly concerned with the management of resource allocation and configuration in computing units, storage systems and networks.
2. Previously related work
In this section we review some previously related work in the areas of visualization system models and load-balancing algorithms.
2.1 Visualization system models
In [1],a visualization process is considered as a pipeline consisting of 1) data source; 2) data filter; 3) mapping; 4) rendering of the final results (see Fig. 1). The model is use-ful to analyze a typical Web-based visualization system. A client-server based,distributed scientific visualization sys-tem for medical image analysis and generation was pre-sented by P.W. Liu et al in [2]. They developed the system with several pre-allocated computation servers constituting the processor pool for the client. In the model,the server side provides the communication module,which channels communications among the servers and host PCs and the servers themselves are the processes running in the pro-cessor pool. On the client sides are the GUI and several manager modules. They used command queue,communi-cation module and pre-allocated processor pool to enable the distributed architecture. [3] presents a system architec-ture describing how technology for Web-programming ap-plications can be utilized for supporting interactive visual-izations over the Web. They developed a data visualization system using a set of Java Applets that interface with VTK. It was the first attempt to use hybrid approach to construct Web-based visualization systems. But they only split the renderer’s computing load and distributed it to clients.
2.2 Distributed load-balancing algorithms
In order to execute arriving tasks with unpredictable workload rates,in [2] they built a load-balancing tree (sim-ilar to a Huffman’s coding tree) by combining the static
and the dynamic index,in which every node represents a computing processor. The static index indicates the work-station’s computing power while the dynamic index refers to the workstation’s current workload. On the tree,they can favorably adjust the indices representing the computa-tion servers to minimize the amount of data communicacomputa-tion needed for image generation. This is one of the early refer-ence models for controlling the data transmission overhead. In some load-balancing algorithms,the outdated infor-mation will cause the ”herd effect” which can push the system into a severe performance condition [4][5] because clients always catch the least loaded server. Many algo-rithms have been presented to remedy this problem. In [5], instead of sending a request to the least loaded server among n computing servers,a client randomly selects a size k sub-set of the servers and sends the request to the least loaded one in the subset. As described in [4],the optimal sub-set size varies with the update frequency of load informa-tion. In our system,we keep the transmitted message size between kernel and computing servers as small as possi-ble,aiming to provide the load-balancing algorithm with the most time-critical information.
3
ARCHITECTURAL DESIGN
Our visualization system architecture (see Fig. 2) is based on a client-server framework [6] that enables visu-alization over the Web. It is designed and developed using Java RMI (Remote Method Invocation) and VTK (Visual-ization Toolkit) to achieve portability and modularity. In the following,we will discuss the system components at server and client,respectively. The server is designed to be able to serve multiple requests by integrating several computational components. They include:
1. Kernel: The kernel receives requests when sessions are established and then sends the tasks to the public queue. The kernel decides to which computing unit (CU) the jobs will be dispatched by executing the load-balancing module.
2. Load-Balancing Module: The load-balancing module performs to evaluate the load of each CU and to select the least loaded CU for executing next task.
3. VTK Module: In our system we develop the visual-ization work by use of an existing visualvisual-ization library called VTK [7][8] . VTK is an open source,object-oriented software system for 3D computer graphics, image processing and visualization,and it is freely available. VTK comprises C++ and Java class libraries and several other interfacing utilities. It also supports a wide variety of data structures and visualization al-gorithms.
Raw Data Filter Mapper Renderer
Direction of data flow
stage 1 stage 2 stage 3
Output to client
Fig. 1. Visualization pipeline
Kernel
Public Queue
CU CU ... CU Dataset
preprocess
RMI Server RMI Environment
Request Response server VTK Module client VTK Module client VTK Module . . . . . . . . . . . . GUI GUI RMI Client
4. Computing Unit (CU): Computing units are one or more computers connecting to visualization server by high-bandwidth networks. They will get the required data,exploit appropriate VTK functions to process the data,and generate intermediate or final results. 5. Public Queue: The public queue is where the client job
requests will be placed and sent for further processing. In client,there are two primary components:
1. a Java-based graphical user interface using AWT or Swing.
2. a VTK function module.
Particularly client can also contribute its computing power to the system and acts as a CU.
4
Approaches
In our visualization system we propose a dynamic ap-proach to operate on the Web-based visualization tasks. We aim to decompose,distribute,and execute every individual stage of visualization pipeline on a least loaded CU. Not only the CUs at server but also client itself should be con-sidered as a computational resource in the system. The in-formation needed by the kernel for inserting the requesting tasks into the CU pool is collected from client as passed parameters under the authentication by RMI. Running task codes are written in Java so that the visualization system can be developed on any hardware platform. As soon as the ker-nel receives the request it inserts a job node (including all the information needed for executing the job) into the pub-lic queue. The job node is later removed and dispatched to the least loaded CU selected by the load-balancing module to be executed (here task is always initiated from the first stage of the pipeline). After the CU finishes performing the first stage (including loading data from the data server and filtering) and produces the intermediate output (in our case,a .vtk file),it creates and inserts another job node into the head of the public queue. Then the new job is resched-uled by the load-balancing module again for the rest of the stages. On completing every stage in the pipeline,the result (an image or a VRML file) is sent to the client.
4.1 Load-balancing
In the following,we will elaborate the concepts of load evaluation mechanism,the organization of CUs,updating policy and dispatching strategy.
4.1.1 Load evaluation
In our system,before the kernel can select one or more least loaded CUs to dispatch jobs,it has to estimate each CU’s static system parameters and dynamic workload. The static information includes the computing power expressed in term of MIPS in the processor,MB in memory size, and so on. The static information is gathered while CUs or clients connecting to the server. For a better estimation, dynamic information is evaluated with respect to some pre-measured amounts. For instance,we can sample with dif-ferent data sizes and operational parameters beforehand,run and measure each pipeline stage’s operation time on a sin-gle CU. If the actual request value (i.e. isovalue) at run-time is not in sample values,we can utilize linear interpolation techniques to compute the data. Or we can simply use the nearest value if the sampling precision is considered high enough.
4.1.2 Updating policy
The load information will be updated whenever a CU fin-ishes executing the current stage and sends a new job node of next stage to the head of the public queue. We always keep the most recent information possible to avoid the ”herd effect” and ensure that the transmitted message overhead is small compared to the job request. Owing to the frequent updates,we search for CU using hash table so as to increase the efficiency. When a job is accepted or completed,the CU will adjust its load parameter by appropriate amounts (i.e. workload of the job).
4.1.3 Organization of CUs
Aggregation of the static and dynamic load index can re-sult in a single load parameter for each CU. To choose a least loaded CU,instead of sorting CUs by traditional sort-ing mechanisms,we present a ”Rangsort-ing Buckets” approach to increase the search efficiency and simplify the sorting steps. Firstly,we classify CUs into several levels and each one is associated with a weighted value,the more powerful ones get larger values. Furthermore,we separate the load parameter extent into several buckets and each represents a ranging segment. In the initial phase,we place all CUs into ranging buckets depending on which bucket their static load parameter is in the range of. In the updating state,a CU will change its load parameter and shift among the buckets. A CU will move back to a higher range number bucket when it regains computing resource because of completing tasks. Since we constantly shift the CUs’ positions in those buck-ets when updating the load information at run time,we can perform the search in the order of high to low range number bucket for the first nonempty bucket,and further explore
in that bucket for the most efficient CU to execute the next task.
4.1.4 Dispatching strategy
Due to data migration overhead,we prefer to continue pro-cessing data on the same CU if possible. To this end,we raise the priority of the CU which performs the previous stage and favor it when selecting the next CU candidate. We do so by multiplying a factor to the load of the original CU and the factor is determined by the size of the intermediate output.
5
Conclusions and future work
In this project,we have presented an effective load-balancing scheme and applied it to our visualization sys-tem,which involves great computational and memory de-mands. Our system divides each visualization tasks into several subtasks and assumes clients can contribute their computing resources too. We evaluate using the static and dynamic load information of all computing units,and parti-tion them into several ordered intervals so as to dynamically select a least loaded computing unit for executing each sub-task. We aim to achieve overall system effectiveness by ex-ploring different computational techniques in a remote real time visualization environment. In the future,we wish to port our system on Grid infrastructure. By exploring tech-niques in Grid,we hope to get more precise information such as free memory size and processor utilization ratio, more globally and uniformly under authorization.
References
[1] C. Upson,T. Faulhauber,D. Kamins,D. Laidlaw, D. Schlegel,J. Vroom,R. Gurwitz,and A. van Dam, “The application visualization system: a computational environment for scientific visualization,” IEEE Com-puter Graphics and Applications,vol. 9,no. 4,pp. 30– 42,July 1989.
[2] P.-W. Liu,“Distributed computing: new power for sci-entific visualization,” IEEE Computer Graphics and Applications,vol. 16,no. 3,pp. 42–51,1996.
[3] A. Alves,M. Ferreira de Oliveira,R. Minghim,and L. Nonato,“Interactive visualization over theWWW,” IEEE Computer Graphics and Image Processing,pp. 259–266,Oct. 2000.
[4] M. Dahlin,“Interpreting stale load information,” in Proceedings of the 19th IEEE International Confer-ence,1999,pp. 285– 296.
[5] M. Mitzenmacher,“How useful is old information?” in Proceedings of the Sixteenth Annual ACM Symposium on Principles of Distributed Computing. ACM Press, 1997,pp. 83–91.
[6] C.-H. Kuo,C.-J. Shiu,and D. S.-M. Liu,“A framework forWeb-based scientific visualization,” in Proceedings of the 2002 Computer Graphics Workshop,Tainan,Tai-wan,2002,p. 52.
[7] W. Schroeder,K. Martin,and B. Lorensen,The Visual-ization Toolkit, 2nd Edition,Prentice Hall,Upper Sad-dle River,New Jersey,1998.
[8] W. Schroeder, The VTK User’s Guide Version 4.0. Kitware,Inc.,2001.
