System Information

Stallion (stallion.tacc.utexas.edu) is a Dell Linux/Windows visualization cluster and large high-resolution tiled display. The system consists of a Dell Precision 690 head node, 23 Dell XPS 720 rendering nodes, and 75 Dell 30 inch LCD monitors arranged in a 15 x 5 configuration. Altogether, Stallion provides users with 47 graphics processing units (GPUs), over 36 GB of graphics memory, and a 307 megapixel display--currently the highest resolution display in the world. Stallion is an ideal resource for users wishing to explore terascale datasets / geometries or ultra high-resolution imagery. Its resolution allows users to, in the same view, examine large-scale global features of their data from a distance and fine-scale local features close up. Users can also examine multiple views of their data (for example, different timesteps) simultaneously.

For a Stallion allocation, users should visit the TACC User Portal. Stallion is available for local use in the ACES Visualization Lab.

Stallion's architecture and technical specifications are shown in the following tables:

User Environment

Environment

TACC provides several rendering environments that allow users to render to the tiled display. Before you can use the display, however, you must power on the screens:

user@stallion~: screens_on
user@stallion~: screens_wake

If you would like the screens to remain awake during your entire session:

user@stallion~: watch -n 300 "screens_on; screens_wake"

Users are provided with a home directory which is limited to 500 MB. This home directory is routinely backed up. In addition, users are provided with a directory on the 4.5 TB /work filesystem. There are no quotas on /work; however, it may be purged when it becomes full, and is not backed up. The environment variables $HOME and $WORK point to these directories. Both /home and /work are shared between the head node and all of the render nodes.

Usage

Several common visualization applications are available over a shared file system on Stallion and other machines in the Vislab. These applications have graphics engines based on OpenGL, and are therefore able to be run on the tiled display via Chromium. Visualization applications that are available are listed below:

VisIt is a scientific visualization application developed at Lawrence Livermore National Labs and based on VTK. VisIt can work with most types of structured and unstructured data. It supports any VTK formatted data set, as well as several other commonly used formats such as NetCDF and GIS formats. VisIt features a rich set of 2D and 3D visualization methods. Both single threaded and distributed versions are available. To run VisIt, run the following in a terminal:

user@stallion:~$ module load visit
user@stallion:~$ visit

ParaView is an open source advanced visualization tool from Kitware, the developers of VTK. ParaView can visualize extremely large datasets and was designed to be run in parallel environments. ParaView supports structured and unstructured grids. It can visualize any VTK formatted data set, as well as image, and AMR datasets. Both single threaded and distributed versions are available. To run ParaView, run the following in the terminal:

user@stallion:~$ module load paraview
user@stallion:~$ paraview

SAGE (http://www.evl.uic.edu/cavern/sage/) is a graphics streaming architecture for collaborative scientific visualization environments developed at the Electronic Visualization Laboratory at the University of Illinois at Chicago. SAGE applications stream pixel data to the rendering nodes driving the tiled display. SAGE then renders the content to the display with a user-specified position and size, scaling the content if necessary. SAGE is ideal for displaying imagery and video content. Users can run an arbitrary number of SAGE applications, dynamically positioning them on the tiled display using the SAGE user interface.

Starting SAGE

1. Login to the Stallion head node console
2. In a terminal, run the following:

   user@stallion:~$ module load sage
   user@stallion:~$ startsage
   

3. When the GUI appears, hit the 'Start' button. The screens will one-by-one turn black as SAGE processes are started.
4. Open the SAGE user interface by connecting to Stallion (shown in a list of tiled displays). This interface allows you to position and scale your content on the tiled display.
5. You can now run your SAGE applications.

Viewing images with SAGE

The SAGE image viewer is ideal for viewing medium- to high-resolution static imagery. For extremely large images (those greater than 100 megapixels), see the Magic Carpet section. To use the image viewer, run the following in a terminal:

user@stallion:~$ module load sage
user@stallion:~$ imageviewer

Playing animations with SAGE

MPlayer has been compiled with SAGE support. Users can thus play most kinds of video content to the tiled display. To use the SAGE-enabled MPlayer, run the following in a terminal:

user@stallion:~$ module load sage
user@stallion:~$ mplayer

Chromium (http://chromium.sourceforge.net) is a system for interactive OpenGL rendering on graphics clusters. Chromium behaves as an OpenGL library to a graphics application. It intercepts OpenGL commands and distributes them in parallel to the cluster. With Chromium, users can run unmodified OpenGL applications on the tiled display using all of the render nodes. This approach allows for the rendering of large geometries at extremely high resolutions. To run an OpenGL application using Chromium, follow these steps:

1. Load the Chromium environment:

   user@stallion:~$ module load chromium

2. Use the 'startchromium' script to run your application through Chromium. This script allows you to select which screens on the tiled display you wish to use. The syntax is:

   user@stallion:~$ startchromium -g WxH+x+y

   where WxH+x+y is the tiled display geometry you wish to use.

   For example, to run the application 'glxgears' on a 5x5 section at the right of the tiled display, run:

   user@stallion:~$ startchromium -g 5x5+9+0 glxgears

Magic Carpet (http://www.evl.uic.edu/cavern/mc/) is a cluster-based image viewer for tiled displays developed at the Electronic Visualization Laboratory at the University of Illinois at Chicago. With Magic Carpet, users can interactively explore images up to several gigapixels in resolution. It uses pre-processed multi-resolution tiled images to achieve full interactivity. During viewing, it loads appropriate image data at a suitable level of detail to the graphics card in a view-dependent manner.

Processing images for Magic Carpet

Magic Carpet requires that images be pre-processed prior to viewing. Note that for extremely large images the processing time can be significant. To process images, do the following:

1. Load the Magic Carpet module:

   user@stallion:~$ module load magicarpet

2. Run the pgen1 utility to generate configuration and layout files. The syntax for pgen1 is:

   user@stallion:~$ pgen1

   For example, for a 10,000 x 5,000 resolution JPEG image, run the following command:

   user@stallion:~$ pgen1 example.jpg 10000 5000 3

   This will generate the example.jpg.conf and example.jpg.layout files.

3. Use the pyramidmaker utility to process your image. At a terminal, run 'pyramidmaker'. In the interface select your image input format and previously generated configuration file. Then, select a directory where the processed data should go. You may adjust the default block size if you wish. Finally, hit the 'Run' button. Pyramidmaker will take some time to complete.

Viewing images with Magic Carpet

After processing your images as described above, you can view your images on the tiled display by following these steps:

1. Load the Magic Carpet environment:

   user@stallion:~$ module load magicarpet

2. Run the magicarpet_view script. This script will modify the necessary configuration files for you and launch Magic Carpet on the tiled display. The syntax is:

   user@stallion:~$ magicarpet_view

   For example:

   user@stallion:~$ magicarpet_view /home/user/example.jpg

   For more detailed instructions and information about Magic Carpet, please see the Magic Carpet How-to at http://www.evl.uic.edu/cavern/mc/howto.html.

To run these applications on the tiled display, Chromium must first be run. The example below shows how to run a 5x5 VisIt session on the left side of the tiled display wall:

user@stallion:~$ module load chromium visit
user@stallion:~$ startchromium -g 5x5+0+0 visit

Command not found error

user@stallion:~$ visit
bash: visit: command not found

If you get a command not found error, make sure you have loaded the corresponding module:

user@stallion:~$ module load visit/1.11.0
user@stallion:~$ visit

Loading the VisIt module modifies the PATH variable to include the location of the VisIt executable, and modifies the library path variables.

If you have any issues that are not listed above, please create a consulting ticket at the TACC User Portal.