cfly(3pf)

NAME
     cfly - OpenGL Performer scene viewer for PC clusters

SYNOPSIS
     cfly [ options ] file ...

     run_all_cfly [ options ] file ...

     run_cfly daemon_hostname [ options ] file ...

DESCRIPTION
     cfly is one of the sample programs distributed with the OpenGL Performer
     high-performance graphics library.  cfly is an implementation of perfly
     for SGI PC-clusters.  cfly treats each PC screen in the cluster as a
     graphic pipe on a multi-pipe SGI workstation.

     cfly brings up a window (or full screen) on each cluster console. By
     default, it breaks the field of view horizontally starting the leftmost
     portion on the first cluster host and advancing towards the right.  All
     program events are read on the first host. In other words, you can only
     control cfly (GUI, mouse events, keyboard events) from the leftmost
     console.

     cfly is a sample implementation demonstrating how to use the DataSync API
     for writing multi-screen cluster applications.  The DataSync daemon
     dsyncd must be running on one of the cluster nodes before starting cfly.


   Starting cfly
     For the sake of the discussion, we assume the master node of the cluster
     is master-channel.

     Each one of the cluster nodes runs an identical copy of the program cfly.
     You can either run cfly manually on each node, or use a script that runs
     them from a single node. The following section demonstrates each one of
     these operation modes using the data file: town_ogl.pfb.

     If you wish to run each node separately, enter (on each node):


              % setenv PFSERVER master-channel
              % cfly town_ogl.pfb



     Start at the leftmost node and advance to the right. As new nodes start,
     cfly breaks the viewer field of view among all the available nodes from
     left to right in the order that they were activated.

     If you wish to start cfly from a single node, first make sure all nodes
     have logged in and executed

              % xhost +



     Start cfly using the provided script on the node master-channel:


              % run_all_cfly town_ogl.pfb



     run_all_cfly start up ImageSync video synchronization, brings up a remote
     shell on each on each cluster node and runs a script for setting
     environment variables and running cfly.  Here is the contents of the
     script run_all_cfly:


              #!/bin/csh

              # start ImageSync.
              /usr/share/ImageSync/bin/imagesync -v

              # Start cfly application on all channels listed in /etc/channel_list
              # Channels should be listed from left to right to ensure correct
              # breakup of the cfly field of view.
              set list=`cat /etc/channel_list`

              # assume DataSync server runs on master node (this host)
              set server=`hostname`

              set c=0
              set i=2

              while ( $c <  $list[1] )
                rsh $list[$i] /usr/bin/X11/run_cfly $server $* &

                @ c = ($c + 1)
                @ i = ($i + 1)
                sleep 3
              end



     The script run_cfly reads:


              #!/bin/csh

              setenv PFSERVER $1
              setenv DISPLAY :0
              setenv __GL_SYNC_TO_VBLANK 1

              shift
              /usr/bin/X11/cfly $*



     Note that run_all_cfly uses /etc/channel_list for a list of channels
     ordered from left to right. If you change the host names of your cluster
     nodes, you have to update /etc/channel_list.

     You can also use the script run_cfly in order to start cfly on a single
     node. run_cfly expects the DataSync daemon node hostname as its first
     parameter. In addition to running cfly, run_cfly also makes OpenGL
     Performer synchronize its rendering frames to the graphic hardware video
     frames.


   User controls, command line options
     cfly is an adaptation of the perfly source code. Almost all user control
     is identical to that of perfly. See manual page for perfly for details.

     cfly has one new parameter to the perfly command line flag -H.  This flag
     now takes four parameters (instead of three):
     horiz_fov,vert_fov,h_offset,v_offset.  They set custom field-of-view and
     viewing offset in the horizontal and vertical directions.  This option is
     useful for overriding the automatic projection parameter setting of cfly.


   Package dependencies
     cfly uses DataSync (libds).


   Trouble Shooting
     Channels come up with wrong horizontal offsets.

     The channels listed in /etc/channel_list may be out of order. They should
     be ordered from left to right.

     Channels do not start at all

     Verify that the DataSync daemon (dsyncd) is running on the same node
     where you started run_all_cfly (for best load-balancing, dsyncd should
     run on the master channel).

     Verify that all channel nodes have xhost enabled.


NOTES
   Learning More
     Once you've seen OpenGL Performer in action, you will want to learn more
     about it.  The OpenGL Performer Programming Guide and the OpenGL
     Performer Release Notes are the primary sources of information, but the a
     number of information sources are available to give you a good start in
     your learning process. The origin of this quest is the Performer man
     page. Just type "man performer" and just about everything you might want
     to know will be there or in one of the on-line resources listed there.


SEE ALSO
     perfly, performer, dsServer, dsSession, xhost