Spring 2007 CSCI653 Final Project

Sijie Zhang

1849862576

Critical review of

“High-Performance Dynamic Graphics Streaming for

 Scalable Adaptive Graphics Environment”

This paper [1] is one of the proceedings in the Super Computing conference held at Tampa Florida, 2006. It was written by Jeong, B. etc, from the Electronic Visualization Laboratory (noted as EVL) of University of Illinois at Chicago. This lab has been famous for inventing the CAVE® virtual reality theater in 1992, the ImmersaDesk® in 1995, and the “PARIS” system (collaborative augmented reality environment with haptic feedback) in 1998. These display environments have been used globally for scientific and medical discovery, art exhibition and industrial prototyping. EVL also has a long history of researching in tools and techniques to share and visualize multiple-standard applications in real-time among collaborators over high-speed, experimental networks: from earlier tele-immersion experiments to SAGE: Scalable Adaptive Graphics Environment. This work becomes more and more important now days in the sense of increasing the utilization of distributed computing resources, enforcing the interconnectivity and facilitating the collaboration between remotely located groups. To explain the architecture of this framework and show its performance with benchmarks and a real application test between Chicago and San Diego is the main purpose of this paper. They have done a good job in presenting a clear picture of the architecture of SAGE and explaining why SAGE outperforms several peer systems. Some improvements can be considered for presenting the experimental results. 

            As a specialized network middleware, SAGE “enables data, high-definition video and extremely high-resolution graphics to be streamed in real-time from remotely distributed rendering and storage clusters to scalable display walls over ultrahigh-speed networks”. They have come up with a specific reconfiguration procedure to realize such a dynamic implementation. This procedure consists of three phases: the initial phase (a SAGE application is started on a rendering cluster and network connections to the display cluster are established), the configuration phase (rendering and display nodes, plus the active connections are dynamically reconfigured based on user-defined application layout) and the streaming phase (pixel streaming is started or resumed with the configuration done in the second phase, synchronizations among rendering nodes and display nodes being applied respectively). The whole procedure is controlled by the heart component in SAGE, called the Free Space Manager (FSManager). It is similar to a regular desktop manager in an ordinary operation system. Users send commands through the SAGE user interface (UI client) to FSManager, then control messages are sent out to other SAGE components, including SAGE Application Interface Library (SAIL), which is a very simple API to the SAGE framework, allowing the programmers to “describe pixel buffers and the position of the buffers in the application output image”; SAGE Receiver, which “receives multiple pixel streams from SAIL nodes to drive the screens attached to each display node”; and synchronization channel (one synchronization channel among display nodes, i.e. SAGE receivers and the other among rendering nodes, i.e. SAIL nodes). The following figure is taken from the paper to show the structure of the SAGE system.

Four experiments are done to test the performance of SAGE. First is to investigate which network streaming protocol should be used for which scenario. TCP is good for local area networks but performs badly over wide area networks, which is intuitive to understand; UDP is as good as TCP over LAN, but has much better results over WAN with modified packet (the frame number and the position information of the pixel data are stored in the packet) has very good performance, however, this casts an upper bound of the data transfer rate for the sender (SAIL node). Benchmarks are done in the second experiment. SAGE shows high throughput and scalability over both LAN and WAN, as well as over 90% bandwidth utilization. Third experiment shows a successful SAGE demonstration between San Diego and Chicago, with four different applications shown on the tile display wall, i.e. MagicCarpet streamed from San Diego to Chicago using UDP, a high-resolution image viewer from local using TCP, Bitplayer showing an animation from downtown Chicago to EVL using UDP, and locally streamed HD camera live image using TCP. The last experiment shows that SAGE has low remote pixel streaming latency.

Compared to some peer systems, SAGE is unique in its high-speed graphics streaming capability over WAN. Furthermore, SAGE outperforms Access Grid [3] by focusing on visualizing and dynamic reconfiguration, other than simple distributed meetings and collaborative work-sessions. SAGE is better than SGE [4][5] (Scalable Graphics Engine, developed by IBM), due to its natural high flexibility and scalability: SGE is limited by a number of factors such as special hardware requirement, adapting to new network technology, network bandwidth, number of inputs and memory capacity. XDMX (Distributed Multi-head X11) [6] is almost as powerful as SAGE, but it can not support parallel applications as SAGE can. As the predecessor of SAGE, EVL developed TeraVision [2], which, however, is suitable for “streaming a single desktop to a high-resolution tiled display, but unsuitable for supporting parallel applications or multiple instances of applications”, that is exactly the strength of SAGE. 

            This paper elaborately addressed the main contributions mentioned in the introduction, with self-explaining schematic illustrations, fragments of pseudo-codes, tables and plots from the experiments, which give the conclusions very solid foundation. As to the future work, they point out the direction of the next step, how “to support distant collaboration with multiple end-points by streaming the same visualization at the same time and see each other via the streaming of HD camera live feeds”, several approaches to solve this challenge being proposed afterwards. This advancement is somehow like the opposite of the current functionality of SAGE, which has a many(input)-to-one(output) communication model, and they want the second generation SAGE to include a one(input)-to-many(simultaneous output) model. This is as important as the current functionality by nature. As a comment, there are a few points that need to be discussed more. First, the data transfer rate from the rendering node to the network is limited by the network protocol, in order to keep the packet loss rate low. This may become a critical bottleneck of this framework as the application and visualization data grows. It deserves further investigation in the future. Secondly, one important feature of SAGE, which is claimed by the authors to be the reason to develop a new system based on TeraVision, is the ability to support parallel applications, seems not to receive enough attention in this paper. Maybe more details and elaborated experiments will address this issue in the future papers.

Reference:

1. Jeong, B., Renambot, L., Jagodic, R., Singh, R., Aguilera, J., Johnson, A., Leigh, J.

High-Performance Dynamic Graphics Streaming for Scalable Adaptive Graphics Environment Proceedings of SC06, Tampa, FL.

2. R. Singh, B. Jeong, L. Renambot, A. Johnson, and J. Leigh, “TeraVision: a distributed, scalable, high resolution graphics streaming system,” in Proceedings of IEEE Cluster, 2004.

3. L. Childers, T. Disz, R. Olson, M. E. Papka, R.Stevens, and T. Udeshi, “Access Grid: immersive group-to-group collaborative visualization,” in Proceedings of Fourth International Immersive Projection Technology Workshop, 2000.

4. K. A. Perrine, D. R. Jones, and W. R. Wiley, “Parallel graphics and interactivity with the scaleable graphics engine,” in Proceedings of ACM/IEEE Conference on Supercomputing, 2001.

5. J. T. Klosowski, P. Kirchner, J. Valuyeva, G. Abram, C. Morris, R. Wolfe, and T. Jackman, “Deep view: high-resolution reality,” IEEE Computer Graphics and Applications, volume 22, issue 3, pp. 12–15, May/June 2002.

6. “Distributed multi-head X project,” http://dmx.sourceforge.net/.