MCS572 UIC HP-Convex SPP1200/XA-16
Scalable Parallel Processor
User's Local Guide


version 2.13
30 October 1997

Professor Floyd B. Hanson

Mail address:

Office address:

Hanson World Wide WEB Home Page:

UIC Fall 1997 Course:

MCS 572 Class World Wide WEB Home Page:

Table of Contents
  • Introduction: SPP1200 Overview.
  • Guide Notation.

  • Background References.

  • Annotated UIC HP-Convex Exemplar SPP1200 Sample Session

  • ftp File Transfers with UIC/Convex/SPP-UX.
  • Execution of Convex Fortran (fc) or Convex C.
  • UNIX Command Dictionary.  
  • SPP-UX Specific Unix Commands.
  • Interrupts Dictionaries CMS, IBM Telnet and UNIX.
  • fc Fortran Extensions.
  • CXpa Performance Analyzer

  • fc Timing Utility Functions.

    Introduction: SPP1200 Overview.

    This User's Local Guide is intended to be a sufficient, hands-on introduction to the UIC Computer Center (CC) HP-Convex SPP1200/XA-16 scalable parallel processor (SPP).

    Click for Figure 1: Picture of HP-Convex Exemplar SPP1200/XA System.  

    The SPP1200/XA-16 has 16 parallel processors, collected into two subunits of 8 processors called hypernodes, i.e., there is only hypernode 0 and hypernode 1 at UIC. The local machine name is the `borg' and its full internet address is `borg.cc.uic.edu'. The XA model denotes the multiple hypernode eXtended Architecture (XA) SPP system. Normally, program execution is restricted to at most 8 nodes of a hypernode, while special permission is needed to use more than 8 nodes and using processors from both hypernodes requires the use of message passing programming.

    Within Hypernode Connections.

    Within the hypernode, eight processors are collected in four processor pairs called Function Blocks such that the processor pairs along with associated local memory bank pairs and Input/Output Subsystem are connected by a 5X5 Cross-Bar switch (i.e., each processor pair and memory bank pair in the hypernode are interconnected). The cross-bar bandwidth is 1.25 GigaBytes/second. Within the hypernode, the computer model is much like a Shared-Memory Processor (SMP) or Symmetric Multi-Processor (SMP too).

    Between Hypernode Connections.

    The two hypernodes and their memories are interconnected as well as connected to Input/Output (I/O) devices by four Coherent Toroidal Interconnect (CTI) rings, with the toroidal qualifier denoting that the ring connects corresponding processor pairs in each hypernode and that the first boundary pair is also directly connected to the last pair (for the UIC two hypernode machine, this only means that the ith processor pair of hypernode 0 is doubly connected to the ith processor pair of hypernode 1 as a ring. When there are more than n hypernodes, with n>2, then hypernode j is connected to hypernode j+1, while the boundary hypernodes 0 and n are also connected, completing the torodal loop interconnection that permit a extra path fault tolerance. Simply viewed, the cross-bars from the horizontal, intra-hypernode mesh connections between processor pairs on the same hypernode, while the CTI rings form the vertical, inter-hypernode mesh connections in two ways between the same numbered processor pairs on different hypernodes. The bandwidth of the CTI rings are 600 MegaBytes/second.

    Click for Figure 2: HP-Convex SPP1200/XA Architectural Overview for n Hypernodes.  

    Memory Organization.

    The SPP1200 is a hybrid distributed-shared memory (DSMP) and message passing processor, when viewed with all the processors on two or more hypernodes.

    Physical Memory: The physical memory of each hypernode is called Globally Shared Memory (GSM) but is distributed as local memory to each processor pair in 2 banks per processor pair. This memory is where the actual computations are performed and is also called the physical or main memory, implemented by fast RAM (Random Access Memory) memory chips. There is a total of 0.5GB physical memory per hypernode or 1GB total or 64MB per processor bank. A single hypernode is also called a Symmetric Multi-Processor (SMP), but could also be called a Shared Memory Processor. GSM is accessed via the cross-bar interconnect within a hypernode, while the CTI rings are used to access the GSM of other hypernodes.

    Virtual Memory: Up to 3GB in virtual memory is available through the exchange of memory units called pages, permitting the execution of much larger programs than can fit in physical memory. The compiler generates the addresses of the much larger virtual memory, but only those pages currently executing are translated into physical memory.

    Cache: In addition, each processor has a 256KB (KB = kilobytes) of fast data cache memory, a 256KB (KB = kilobytes) of fast instruction cache memory, and each processor pair also has the inter-hypernode ring cache call CTIcache. Cache memory is generally smaller, faster and closer to the CPU than physical memory.

    Click for Figure 3: HP-Convex SPP1200/XA More Detailed View of One Hypernode.  

    Hard Disk Memory: Hard disk memory consists of 20 4GB SCSI-2 disks, 10 on each of the hypernodes, and on these disks your user directories, operating system, other system software, and application software are stored. Hard disk memory is generally bigger, slower and furthest away from the CPU than hard disk memory. Hence, the memory hierarchy is the order from cache to physical to hard disk memory.

    Input-Output Connections.

    The
    5X5 Cross-Bar also connects the processors and physical memory to the Exemplar I/O (Input/Ouput) Subsystem. This I/O Subsystem is connected to an ATM (Asynchronous Transfer Mode, not Automatic Teller Machine) network switch which makes a high speed connection at 155 Megabits per second to the UIC ADNii (Academic Network 2) into which a user would typically logon to the UIC Exemplar.

    Explicit Message Passing.

    Message passing systems such as Parallel Virtual Machine (PVM) or Message Passing Interface (MPI; actually the dialect called MPICH is used at UIC) are used for inter-hypernode communication.

    Caution: Message passing must be done using the batch Network Queueing System (NQS), and is not practically feasible, especially on student accounts.

    Processing Units.

    The SPP1200 parallel processor uses Hewlett-Packard PA-RISC 7200 processor chips at a 120MHz clock rate (8.33 nanosecond clock time) with a vendor promised 240 MegaFlops (MF; million floating point operations per second) peak performance. The `200' in the SPP1200 model number corresponds to the `200' in the 7200 chip number. The term RISC denotes `Reduced Instruction Set Computer', in contrast to the formally widely used CISC or `Complex Instruction Set Computer'. See

    Machine Benchmark Performance.

    The SPP1200 has a aggregate peak performance of about 1900 MF for linear algebra or about 1.9 GigaFlops (GF; billion (10^9) floating point operations per second or 1000 MF) according to the Top500 Computer Report (this report is big, yet no SPP1200/XA is powerful enough to appear on the current Top500 list, although two SPP1600/XAs appear, so we have given an estimated scaled value from 64, 48 and 32 processor results from old top500 lists): Note that units of the Hockney asymptotic performance rates, actual maximum Rmax and vendor peak Rpeak, are in MegaFlops (MF, not the GF used in class), while Nmax is the maximum solved matrix corresponding to Rmax and N1/2 is the matrix size corresponding to half Rmax. On the other hand, the asymptotic peek value of 3.8GF.

    This is consistent with another benchmark using the NASA NAS BT Simulated Computational Fluid Dynamics Application which again gives an scaled estimate of about 5.5 old Cray YMP/1 or 1.3 GigaFlops from taking a quarter of performance of the SPP1200/XA-64 formally at NCSA in Urbana using old data. No SPP1200 appears on the current Gunter's benchmark site:

    The SPP1200 would be classified as a mini-supercomputer, not quite a supercomputer which denotes the class of the most powerful machines. However, it offers local access and many of the parallel constructs found on massively parallel machines.

    Operating System.

    The SPP1200 operating system is called SPP-UX, which is a parallel extension of the Hewlett-Packard version of Unix called UX or HP-UX. The current version (7 August 1997) is Convex Exemplar SPP-UX 4.2 Operating System. It is binary compatible with the scalar HP-UX Unix used on Hewlett-Packard workstations. In fact, the SPP-UX scalable Unix microkernel resides in a portion of GSM along side HP-UX. The important extra attribute of SPP-UX is that it allows the management of subsets of the parallel processors in a hypernode or across hypernodes (Caution: must be used in pairs of processors in the batch NQS) called Subcomplexes.

    Login and File Transfer.

    TELNET: Access to the `borg' is by either the universal TCP/IP Internet Protocol:

    command, suggested by the Computer Center, or by the Unix command: which carries your accessing terminal emulation through much better but is restricted to Unix to Unix connections.

    FTP: File transfer to the `borg' is best accomplished by the universal TCP/IP Internet Protocol command:

    or from the `borg' to your home or lab computer.

    Caution: If CMS is your home computer system, then you are restricted to file transfers only from CMS to the `borg' while you are logged onto CMS while accessing the `borg'. This is because CMS accounts are single user accounts restricted to single access only. That is, FTP to and Telnet from CMS would count as a double access so is not permitted in CMS. This is very different from Unix which is a multiuser system allowing multiple access, i.e., you can even log into the `borg' several times simultaneous, but you also degrade your own performance.

    Programming Languages and Compilers.

    The usual optimizing or parallelizing compilers on the Exemplar are the Convex Fortran compiler fc and the Convex optimizing C compiler cc, both in the `borg' directory `/usr/convex/bin'. The option `-O0' enables scalar optimization; `-O1' enables global register optimization as well; `-O2' enables global instruction scheduling, software pipes and data localization too; and `-O3' enables maximal parallel optimizations.

    FORTRAN: A typical format for compiling and linking a Convex Fortran program named `[program].f' with parallel optimizations {`-O3'} in the background {last `&'} is

    where both compiler information listings {`-LST'} and error messages {`>&'} are redirected into the file `[program].LIST', while the executable module is renamed `[executable-file]'. It is assumed that the user replaces the square brackets and their contents by actual legal names.

    Fortran-Version Caution: The full path name of the Convex Fortran is `/usr/convex/bin/fc' (link to /usr/convex/fc/fc). Also, if you are using the system programmer's default Korn-Shell (ksh), then you must use the linked alias name `fcc', instead of `fc' which is reserved for the Korn-Shell. The `fcc' command is identical to the `fc' Convex Fortran Compiler. The standard Unix Fortran is `f77' stored as `/usr/bin/f77', but this compiler does note have any parallel code optimization features.

    There is also the VAST Fortran 90 compiler `f90' of Pacific Sierra Research in `/usr/convex/vast90//f90', but is not licensed on the `borg', except for Fortran 90 extensions used in `fc'. The primary work of `f90' when available is done by the `vf90' precompiler translator that converts `f90' to `f77' usable code. {CAUTION: If you try to compile with `f90', you get the message "Unable to obtain license for vf90: No such feature exists", since `f90' is unlicensed.}

    In summary, the Fortran-Compilers are

    Another caution is that if you have trouble with the above `fc' compiler command line syntax and you are using the Korn-Shell, then see the note below the C-language description for using the user standard C-Shell.

    C: Similar format is used to compile and link C code.

    where where both compiler information listings {`-or all'} and error messages {`>&'} are redirected into the file `[program].LIST', while the executable module is renamed `[executable-file]'.

    C-Version Caution: There are multiple versions of the C-compiler. The `cc' Convex C Compiler is the one in `/usr/convex/bin/cc' (linked to /usr/convex/cc/cc). However, the HP-UX Standard C Compiler is the one in `/bin/cc', so the parallel processing user must make sure that the `set path' line in the user's `.cshrc' has /usr/convex/bin/cc' before `/bin/cc', so that the parallelizing `cc' version is found first (Korn-Shell users need take similar precautions, but normally this path problem should be taken care of by the new user template). There also the GNU (Glad its Not Unix public domain) Project version `gcc' in `/usr/local/bin/gcc'. In summary, the C-Compilers are

    In addition, there are the C++ compilers:

    Shell Caution: If you have trouble with the above compiler command syntax, it may be that you have your borg account shell set as the Korn shell (ksh) rather than the user standard C-shell (csh). You can change you shell for the current session by the command

    or you can change the shell permanently to a C-shell for which this guide is written by the command: where `[borg_user_name]' must be replaced by your actual borg account name, but you must also logout and logback in again to activate the shell change. Using a C-shell should make your access must easier, while the Korn shell or generic shell (ksh) would be more powerful if you were doing computer systems work rather than scientific computing.

    Caution: the Unix Fortran 77 compiler `/usr/bin/f77' and the Unix C compiler `/usr/bin/cc' are non-optimizing, i. e., non-parallelizing. Also, the Fortran 90 command is not fully supported.

    Editors and Emulations.

    There are several editors on the Exemplar (borg.cc.uic.edu), but their ease of use depends on the particular terminal emulation used to access the Exemplar.

    XTERM: The default terminal emulation is MIT's X-Windows systems which is typically used with access from Sun Unix or IBM AIX workstations permitting the windowing interface of these workstations to pass through to the remote Exemplar.

    TERM VT100: However, if you are not using X-Windows to access the `borg', then it is suggested that you use the DEC `vt100' terminal emulation by entering the Unix command

    on the `borg' command line, or better replace your `set xterm' line in your Login resource configuration files `.login' and `.profile' on the `borg'.

    VI: If your are also going to be using the usual Unix visual editor `vi', see the following manual (man) pages:

    along with the vt100 emulation then you will want to replace your Edit Resource Configuration file `.exrc', which by default template is for the `emacs' {"Ensures Maximally, Almost, Carpal-tunnel Syndrome" {%>)}; an editor favored by computer systems people}, by the following version: In fact, since certain execution commands force the vt100 emulation to be revert back to `xterm', a better fix would be to redefine the `vi' editor command in your C-SHell Resource Configuration file `.cshrc', by trying the command : by adding the following line among the aliases: Using the write and quit command: within vi and activating the change by entering on the `borg' command line the source execution command: Then the editing command: should work as usual.

    THE: There is also The Hesseling Editor `the', which is like the CMS xedit command, so use the manual command:

    for more information.

    PICO?: In addition, there is also the `pico' editor from the `pine' mail program, but `pine' itself is not on the `borg' since you are permitted only to send mail from the `borg' but not to it. There is a man (manual) page accessible by the command:

    Program Execution.

    RUN: On the `borg' at UIC, a custom environment command called `run' greatly simplifies the execution of programs (the full path is `/usr/local/bin/run', so the directory `/usr/local/bin/' should be added to the `set path' line in your `.cshrc' C shell file, say). The Computer Center strongly advises use of `run'. A typical format for executing a module named `[executable-file]' in the background {last `&'} is

    where both calculated output and error messages {`>&'} are redirected into the file `[output-file]'.

    UIC borg SPP1200 Accounts.

    A personal account on `borg' is available to any faculty member who requests one and to any student who has obtained a faculty member's sponsorship permission. Note that the UIC Convex is not intended to be used for general needs such as email, news reading, or Web browsing; its resources should be used only for computationally intensive needs. If you wish to obtain an account please send email to with the Subject: Include your netid, your telephone number, and a brief description of your intended usage. Students must also provide the name and email address of the faculty member who is sponsoring the account, i.e., students should send in the message the following items:

    (For MCS 572 students, the Intended Usage is MCS 572 Introduction to Supercomputing, with Faculty Sponsor Prof. F. Hanson)

  • Return to TABLE OF CONTENTS?

    • This mini-local-guide is meant to indicate ``what works'' and what is ``useful'' for beginning users. The guide also gives alternate methods for access from UNIX systems.

    HP, Convex, Exemplar, and UX are trademarks of Hewlett-Packard Company and its CONVEX Computer Corporation division. UNIX is a trademark of Unix System Laboratories, Inc.

    Background References

    This guide is intended t be self contained, but users who want further information, can consult the following sources (you can just click on the highlighted topics to access if you are surfing the world Wide Web):

    1. Professor F. B. Hanson, MCS 572 Introduction to Supercomputing Home Page, {provides a large variety of links to useful supercomputing information}.

    2. UIC Computer Center(ADN), UIC HP-Convex Exemplar SPP1200/XA, {UIC Computer Center's guide to the "borg" Exemplar SPP1200/XA-16}.

    3. NCSA (UI, Urbana) Exemplar SPP1200 Information:

    4. Convex Division of Hewlett-Packard,

    5. James F. Kerrigan, Migrating to Fortran 90, O'Reilly & Associates, Inc., Sebastopol, CA, 1993.

    6. man [command] (CR), when invoked in a UNIX-like system such as SPP-UX UNIX, produces an on-line listing of the manual pages on the command [command], or similar function.

    7. Consultation concerning problems related to using the Convex Exemplar can be obtained from Professor Hanson {718 SEO, X3-2142, hanson@uic.edu}. For those in the MCS572 Class, they should contact Professor Hanson first, but in an emergency they should contact the Computer Center Consultants at systems@uic.edu with Subject: `Borg Problem'.

    Annotated UIC HP-Convex Exemplar SPP1200 Sample Session

    The login procedure depends on your local method of accessing the Convex from UIC, but the best access is from a Unix type system since the UIC HP-Convex Exemplar SPP1200 operating system is SPP-UX, which is substantially Unix and it is to the user's advantage to use Unix to Unix communication. If you do not now have a Unix account you should try to get one from your department's Unix system or from the UIC Computer Center graduate student Unix (IBM RS6000 AIX) server called `icarus'. Unix workstations are available in many science and engineering departments. Communication using the IBM mainframe suffers from horrible terminal emulation problems, so that you should avoid it if you can. If that does not work out or is not practical see Professor Hanson about other alternatives.

    UNIX Access: The preferred remote login command:

    is best since it passes your local terminal emulation from the local session through to the remote UIC one and you do not have to enter your login name as with `telnet' and can proceed directly to the `password' step below.

    PCLAB Access: Access by `telnet' TCP/IP command also works for PCLab PCs, or CMS, as well as in Unix, with the format:

    {Caution: From a UNIX operating system, it is essential to use lower case; borg.cc.uic.edu is the full Internet name for the UIC Convex SPP1200, but the shortened name borg.cc.uic.edu also works; the corresponding Internet Number of the `borg' is `128.248.100.55' and is more basic since the Internet Name is derived from the number and the number may work when the UIC computer domain name server (DNS) is down; the `borg' should respond with:}

    Logging Out: You can end this session at any time you have a `borg: ' prompt by entering:

    or pressing the `Ctrl' control key and 'd' key simultaneously (i.e., `ctrl-d').

    File Commands: You can check what the name of your `borg' home directory (file system) is by the Unix ``print working directory'' command:}

     

    VI SETUP: If you are going to be using the Unix `vi' visual editor rather than the `emacs' editor or an X-Windows editor via `xterm', then you might want to set your terminal environment to the standard `vt100' terminal emulation by the command:

    Along with this change to `vt100', you should first save your old Unix edit (`EX') resource configuration file `.exrc' using the Unix copy `cp' command :

    to a `vt100' friendly one (if permissions permit from Professor Hanson's account) by

    or by using the web link with a web browser at your accessing computer to get a copy:

    although you might have to use the File Transfer Protocol `ftp' to get it to the `borg', for example by Anonymous FTP:

    FTP will be described below in Section on FTP.

     

    FORTRAN SESSION: For a sample session for compiling and executing a Fortran Program, you can get a copy of the MCS572 `borg' starter problem via the web and transfer it to the borg:

    or by `cp' copy command:

    or by Anonymous FTP:

    {Note: if this Anonymous FTP method is used than the getting of `.exrc' above and `start.f' here can be combined.}

     

    For an example of compiling and linking the MCS572 Fortran based `borg' starter problem (assuming `start.f' has been transferred to your `borg' account), enter:

    C SESSION:

    Caution: Borg has had some license problems, but seem to be solved. If you try to run Convex `cc' in `/usr/convex/bin/cc' you may get the message:

    Please contact systems@uic.edu with the "Subject: Borg CC License Problem" and say what compiler that you are using and what the path (file) name of your source is called.

    You can run a sample Convex C program by transferring to the `borg' a starter C code version:

    or by `cp' copy command:

    or by Anonymous FTP:

    {In order to compile and link this C code, enter:}

    ftp File Transfers with UIC/Convex/SPP-UX

    The FTP file transfer protocol is the fastest method of file transfer between UIC and UIC Convex SPP-UX, because it uses a fast internet communication link.

    {Caution: FTP involving UIC CMS should be initiated from CMS, because you can not have multiple write links to the same CMS disk (multiple read links should be OK. There are no similar problems using UNIX system, because UNIX is a multi-user system.}

    ftp File Transfers at the UIC Convex

    At the UIC Convex you can transfer file between the Convex and UICVM or UNIX, even the PSC C90, PSC T3D or NCSA Power Challenge Array if you have an account there. The `ftp' command on UNIX is very much like the `ftp' command in SPP-UX.

    In order to transfer a file from SPP-UX and to UIC, enter the commands:

    For Transfer to UIC Unix:

    For Transfer to UIC CMS:

    ``borg: '' ftp uicvm.cc.uic.edu (CR)

    or

    ``borg: '' ftp 128.248.2.50 (CR)

    {This command allows you to enter the FTP communication system that uses the same lines and protocol as Telnet, but essentially only allows file transfer. The Internet numbers are more reliable. In the SPP-UX to UICVM FTP connection, you will be prompted for your CMS user-id and your CMS password:}

    ``Connected to uicvm.uic.edu'' {If you do not get connected but end up in FTP you can try 'open 128.248.2.50' without restarting in SPP-UX again.}

    ``Name(uicvm.cc.uic.edu:u[default-id]):'' [CMS-user-id like `[userid]'] (CR)

    ``Password(uicvm.cc.uic.edu:[CMS-user-id]):'' [CMS password] (CR) {If successful, then:} {If you make a mistake with either your password or username, you can enter `user (CR)' after the ``ftp>'' prompt to restart. At the SPP-UX FTP ``ftp>'' prompt (it differs from the IBM FTP prompt), you can issue FTP commands:}

    ``ftp >'' help [FTP-command] (CR) {This `help' command gives a short information or definition of the command `[FTP-command]'; `help', alone, will display a list of FTP commands; `?' is an brief alias for `help'.}

    ``ftp >'' ls (CR) {Either `ls' or `dir' list the current contents of the remote directory if you need more information. `pwd' displays the remote (SPP-UX here) working directory.}

    ``ftp>'' ls *.fortran (CR) {This example causes the listing of Fortran files on your CMS disk, with the wild-card `*' standing for any filename. Similarly, use `ls *.f (CR)' in UNIX.}

    ``ftp>'' cd u12688.192.r (CR) {This UICVM example show how to change CMS disks for reading, where `u12688.192' denotes Hanson`s public CMS disk and the `.r' suffix denotes read only access, which is all anyone else would have. Note that you can not use the FTP `put' command to place a SPP-UX file on a CMS disk you currently have CMS links to, because if you try to `put' to such a disk you will get a message like:}

    ``550 Write access unavailable for ... due to other links''

    ``550 Writing is not allowed: .... is Read Only'' {However, if you have a disk that you are not currently linked to, such as a friend`s disk and you are FTPing onto the friend`s account, you may use the command:}

    ``ftp>'' cd [CMS-user-id].[cuu-number].w (CR) {This version of the change directory command permits writing on a disk that is not an `A' or `191' disk, where the `.w' suffix requests write access and the `[cuu-number]' is the disk number (a regular `A' disk has a CUU number of `191'). If this or the prior access requests are successful then you can transfer a file from SPP-UX to UIC using:}

    ``ftp >'' put [SPP-UX-fn.ext] [UICVM-fn.ft.fm] (CR)

    or {The put command stores the local (SPP-UX) file on the remote (UICVM or UNIX) system in an FTP session started from SPP-UX. `send' is an alias for `put', while `mput [SPP-UX-files] (CR) is used to send multiple files to UIC with the similar names.}

    ``ftp >'' get [UICVM-fn.ft.fm] [SPP-UX-fn.ext] (CR) {The GET command transfers a file from UIC to SPP-UX If successful, you should get messages like this:} {`recv' is an alias of `get'.and `mget [UIC-files] (CR)' is used to receive multiple files quickly with wild-cards, but the file names will be the same as they are on the remote machine. Caution: `mget' stores the CMS file into SPP-UX with an upper case name, unlike `get' which stores into SPP-UX properly with a lower case name. You can transfer some more files if you want, changing the directory if needed, or you can quit FTP by using the command:}

    ``ftp >'' quit (CR) {You can also use `bye' to exit FTP, except in IBM FTP. Either will get you back to the SPP-UX (UNIX+) shell with prompt ``u* *%''.}

    ``borg: ''

    ftp File Transfers from UIC UNIX

    The file transfer protocol program from a UNIX session is a similar to file transfers from the UIC SPP-UX sessions, because both have UNIX or extended UNIX operating systems, as discussed in the last section.

    ftp File Transfers from the UIC PC Labs

    File transfer protocol (ftp) on a PC Lab PC may not be practical for must users, due to lack of permanent storage. Transfer between CMS or UNIX and the Convex may be more practical when you are accessing them using `telnet' from the PCs. The nearest Xerox PostScript printer to 2249f is SEL2263, while others are SEL2265, SEL2058, SEO308 and elsewhere. However, if the PC is your favorite medium, then use it as in the above Convex or Unix subsections.

    ftp File Transfers at UIC/CMS

    At UIC the IBMNET version of FTP is used on CMS and it uses the following commands:

    An alternate method of sending files is to use the CMS NOTE command and reading in the CMS file using the CMS GET command. This BITNET file transfer method can produce variable results, because CMS SENDFILE does not work for this purpose, BITNET expects a blank first line in the message and it depends on all the computer links between here and there.

    Execution of Convex Fortran (fc) or Convex C (cc)

    Compilation:

     

    Linking/Loading Step Only:

     

    Execution Step:

    Example 1: Execution using the Terminal for Input and Output

    As practice, you can run any source program that you have transported to SPP-UX. {If available, the simple code `convert.f' 

          program convert 
code: convert from debug fortran  cogs, slightly modified.  
change:  input & output is to & from terminal, input at prompt.  
Caution: compile, load, and execute in SPP-UX using the three commands:  
command:   fc -o convert convert.f
command:   convert
      real a(999) 
      write(*,*) 'input any integer less than 1000:'
      read(*,*) i 
      a(i) = float(i) 
      write(*,6000) a(i) 
6000  format(' floating point representation: ',e13.5)
      write(*,*) 'What happens when you exceed array bound of 999?'
      stop
      end

    Can also be obtained on UICVM CMS using}

    and

    {Since this simple-minded `convert.f' program uses the terminal as undeclared input and output units, corresponding respectively to `read(*,*)' and 'write(*,[n])' statements, without specifying an the FC `open' statement. Be sure to do this in your temporary directory which you can change to by using `cd $TMP'. The source `convert.f' is executed with the 3 commands:}

    {To rerun the same code without recompiling, merely enter `convert' again:}

    Example 2: Execution using Input and Output with Files

    The second example uses data files for both input unit 5 and output unit 6, as well as the UNIX Fortran seconds timer `second()'

    {The source is a modified version of the old USER'S GUIDE craytest code. A copy can be obtained via a web browser:

    or a copy can be obtained by Anonymous FTP:

    or

    An old Cray copy also resides in Hanson`s public CMS disk. Use your own copy or get Hanson`s CMS copy by using SPP-UX `ftp' to your own UICVM CMS account and when in FTP, enter

    {Your output will be in `tempt.output' and you can list is by the command:}

    ``borg:'' cat tempt.output (CR) {Your output should look something like:}

    {If you wish to re-run the program again with a different number, the enter}

    ``borg: '' ex tempt.data (CR) {again, or}

    ``borg: '' !ex (CR) {and enter within EX the subcommand}

    ``:'' 1c (CR)

    5000 (CR)

    . {to change `500' to `5000' and to end the change subcommand, while to end `ex' enter after the ``:'' prompt:}

    ``:'' wq (CR) {after the ``:'' prompt, and then enter}

    ``borg: '' run tempt (CR) {and}

    ``borg: '' cat tempt.output (CR) {again. When you are done with `tempt.f', remove all the files from SPP-UX that you do not need, using:}

    ``borg: '' rm tempt (CR) {for example, but especially the big executables like `tempt'.}

    Modifications for C: Compile and Execution with C

    For information on C language programs use the SPP-UX commands:

    SPP-UX Specific UNIX Commands.

    SPP-UX fc Combined Fortran Compile and Load Command

    See `man fc' for more information.

    Note: It is much better to use makefiles for such commands.

    SPP-UX cc Combined C Compile and Load Command

    The current optimizing SPP-UX C compiler is `/usr/convex/cc6.5/cc'.

    SPP-UX ld Load Command

    See `man ld' for more information. Note that the linker or loader `ld' works for both Fortran and C code object files.

    SPP-UX Parallel Information Functions

    The HP Convex Exemplar SPP1200 has several Parallel Information Functions that permit finding the number of processors with threads (parallel execution streams running on paralllel processors), the number of threads, the number of hypernodes and similar information. The type declarations and usage of these functions is best illustrated by the following Convex Fortran `fc' code fragments:

    Fortran Example: 

    c............  deleted nonrelevant code
Check:  Parallel Information Functions 
Caution:  Avoid "()" args in declaration statements as in Programmer's Guide.
Check:  Output (write) statements for function name meanings.
Code:  Typical Parallel Information Function Declaration Statements:
      integer num_procs
      integer num_threads
      integer num_nodes
      integer num_node_threads
      integer my_thread
      integer my_node
      integer level_of_parallelism
Code:  Typical Parallel Information Output Variable Declaration Statements:
      integer nproc,nth,nnode,nnodeth,myth,mynode,levpar,vlevpar(n)
c............ deleted nonrelevant code 
Code:  Typical Parallel Information Function Output Statements: 
      write(6,*) 'Parallel Information Function Output:'
606   format(1x,a,' = ',i3)
Caution: Deadlock could result if num_procs, etc., are used in I/O operations,
continued: i.e., do not use Parallel Information Functions directly in writes.
      nproc=num_procs()
      write(6,606) 'Number Processors with Threads',nproc
      nth=num_threads()
      write(6,606) 'Number Threads',nth
      nnode=num_nodes()
      write(6,606) 'Number HyperNodes',nnode
      nnodeth=num_node_threads()
      write(6,606) 'Number Threads on HyperNodes',nnodeth
      myth=my_thread()
      write(6,606) 'My Thread ID',myth
      mynode=my_node()
      write(6,606) 'My Hypernode ID',mynode
      levpar=level_of_parallelism()
      write(6,606) 'Level of Parallelism',levpar
Code:  Output Table Explanation of Allowed Levels of Parallelism 0 to 9:
      write(6,*) 'where level 0 means Not Parallel'
      write(6,*) 'where level 1 means Asymmetric Thread Parallelism'
      write(6,*) 'where level 2 means Node Parallelism'
      write(6,*) 'where level 3 means Node Parallelism plus level 1'
      write(6,*) 'where level 4 means Thread Parallelism'
      write(6,*) 'where level 5 means Thread Parallelism plus level 1'
      write(6,*) 'where level 6 means Thread and Node Parallelism'
      write(6,*) 'where level 7 means Thread Parallelism plus levels',
     &           '1 & 2'
      write(6,*) 'where level 8 means Single Dim. Thread Parallelism'
      write(6,*) 'where level 9 means Single Dim. Thread Parallelism',
     &           'plus level 1'
c........ deleted nonrelevant code:
Code:  Example of Use of "level_of_parallelism()" in a loop:
      do 5 i=1,n
      .........     
CodeTechnique: vector form is used to be less likely to hinder loop parallelism:
      vlevpar(i)=level_of_parallelism()
      .........     
 5    continue            
      write(6,606) 'Level of Parallelism: do 5',vlevpar(n)
c.............
      .......

    C Example (untested): 

    /* Include Parallel Information Required Header File: */
#include 

/* Parallel Information Functions: */
    int num_procs(void);
    int num_threads(void);
    int num_nodes(void);
    int num_node_threads(void);
    int my_thread(void);
    int my_node(void);
    int level_of_parallelism(void);

/* Parallel Information Output Variables (can't use directly in printf): */
    int nproc,nth,nnode,nnodeth,myth,mynode,levpar,vlevpar[n];

/* Parallel Information Function Output: */
    printf("\n Parallel Information Function Output:\n");
    nproc=num_procs();
    printf("\n Number Processors with Threads =%3d\n",nproc);
    nth=num_threads();
    printf("\n Number Threads =%3d\n",nth);
    nnode=num_nodes();
    printf("\n Number HyperNodes =%3d\n",nnode);
    nnodeth=num_node_threads();
    printf("\n Number Threads on HyperNodes =%3d\n",nnodeth);
    myth=my_thread();
    printf("\n My Thread ID =%8d\n",myth);
    mynode=my_node();
    printf("\n My Hypernode ID =%8d\n",mynode);
    levpar=level_of_parallelism();
    printf("\n Level of Parallelism =%3d\n",levpar);
    printf("\n where level 0 means Not Parallel,\n");
    printf("\n where level 1 means Asymmetric Thread Parallelism,\n");
    printf("\n where level 2 means Node Parallelism,\n");
    printf("\n where level 3 means Node Parallelism plus level 1,\n");
    printf("\n where level 4 means Thread Parallelism,\n");
    printf("\n where level 5 means Thread Parallelism plus level 1,\n");
    printf("\n where level 6 means Thread and Node Parallelism,\n");
    printf("\n where level 7 means Thread Parallelism plus levels 1 & 2,\n");
    printf("\n where level 8 means Single Dim. Thread Parallelism,\n");
    printf("\n where level 9 means Single Dim. Thread Parallelism +level 1,\n");
/* ....deleted nonrelevant code .... */
    /* do 5 i loop */
    for (i = 1; i <= n; ++i) {
/* ....deleted nonrelevant code .... */
        vlevpar[i]=level_of_parallelism();
        /* do 5 j loop */
	for (j = 1; j <= 3; ++j) {
/* L5: */   box[i-1][j-1] = j * (float)1.5 * i / ((float)n+1.);
        }
}
    printf("\n Level of Parallelism =%3d\n",vlevpar[n]);
/* ....deleted nonrelevant code .... */

    SPP-UX mpa Execution Attribute Modifying Command

    Some command options can not be directly entered in compiler, load or execution commands, but the `mpa' modifying attribute commands permits specifying such things as the number of processors or threads for an executable module file.

    SPP-UX Debugging and Performance Commands

    SPP-UX Network Queueing System (NQS)

    For more information about batch processing with NQS, check the man pages for

    fc Fortran Extensions

    Convex Fortran (fc) contains Fortran90 extensions beyond `f77' Fortran. Fortran90 is best used from within the Convex Fortran optimizing compiler `fc' (Although you can not put the `-f90' option on the `fc' command, the optimization report for `fc -O3 -LST' shows that `f90' is indeed the implicit default even if not requestion, although it may be turned off with the `-nof90' option.

    The `f90' compiler is part of the Pacific-Sierra Research Corporation VAST optimizing compiler that is used by most optimizing compilers and is used along with the `vf90' translator, both being found in the directory `/usr/convex/vast90/' {CAUTION: There is no `vf90' license on the `borg' now and `f90' needs `vf90'}.

    For optimization, it is recommended that your fc program aid the fc parallel optimization model, i.e.,

    fc Compiler Options

    See also Section

    and Subsection

    Also see the appropriate sections, `man cc' for items on Convex Standard C.

    fc Miscellaneous Extensions

    Fortran 90 Array Notation and Array Sections: Convex Fortran fc allows most Fortran90 extensions for arrays, making array statements like

    Array Constructors: Fortran 90 array constructors permit initialization of vectors and arrays by enclosing data separated by commas with all data enclosed between `(/' and `/)' delimiters. For example (assuming proper dimensioning):

    Caution: Constructors can not be currently used in print statement arguments.}

    Fortran90 Array Construction Functions

    Many of the Fortran90 Array Functions that have been available on the Connection Machine are now available for the `fc' compiler version 9.5. However, a few functions take their arguments in a different order on the Convex than on the Connection Machine.

    Fortran90 Array Reduction Functions

    The reduction functions reduce the input to a scalar output.

    Fortran90 Array Manipulation Functions

    The manipulation functions rearrange the elements of the target matrix. See `cm-guide.tex' on `CMS getdisk hanson' for examples. However, the arguments may be in a different order on the Connection Machine.

    Fortran90 Array Location Functions

    The location functions find the location of elements of the target matrix. See `cm-guide.tex' on `CMS getdisk hanson' for examples. However, the arguments may be in a different order on the Connection Machine and the Connection Machine also has the location functions `firstloc', `lastloc' and `project'.

    Fortran90 Array Matrix Multiply Functions

    The matrix multiply functions compute the matrix products of the target matrices. See `cm-guide.tex' on `CMS getdisk hanson' for examples.

    Fortran90 Array Functions TEST CODE

    The following fc code contains examples of use of many of the Fortran90 array intrinsic functions mentioned above. Having array intrinsic more or less like those in CMFortran is helpful for portability. There are some subtle differences:

    1. Intrinsic statement is needed for all f90 intrinsics within fc codes.
    2. Constructors of the form b=(/1 2 3/) will now work with the fc compiler.
    3. cshift and eoshift have arg order somewhat different for fc that for cmf.
    4. Fortran90 array intrinsics used within fc will take no auxiliary markers or keywords like "dim=" or "mask=".
    5. fc version 9.5 (Fall 1996) is the default fc and the command is in `/bin/convex/fc9.5/fc'. (Note the unix command `which fc' displays the link `/usr/convex/bin/fc' which should be in your C-Shell path, but this eventually links to `/bin/convex/fc9.5/fc')
    6. Similarly, cc version 6.5 (Fall 1996) is the default cc and the command is in `/bin/convex/cc6.5/cc'. (Note the unix command `which cc' displays the link `/usr/convex/bin/cc', which should be in your C-Shell path, but this eventually links to `/bin/convex/fc9.5/fc')
    7. array sections can not be used in print statements: NOT print*,b(1:3)
    8. How do you sum an entire array only subject to a mask, but with no dimension restrictions? 
      If  b =  1  3  5            logical mask=b.gt.3
         2  4  6

then   s3=sum(b,1,mask)  or  s2=sum(b,2,mask) work when 

real s3(3),s2(2)

but   isum=sum(b,mask)  or  isum=sum(b,,mask) or isum=sum(b,:,mask) do NOT work.

That is, how do you enter a scalar dim for the whole array?
    Here is a sample code with many examples, heavily commented and followed by the actual output run on borg.cc.uic.edu using the commands 

    borg:    fc -LST -o f90test f90test.f >& f90test.LIST&
borg:    f90test >& f90test.output&

%%%%%%%%%%% f90test.f %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

     program f90test
code97:  update by removing old comments to cmfortran
code96:  retest=f90test.f redone on borg = convex spp1200/xa-16
code95:  retest=cf6testre.f redone 2y later, 01oct95, changes over 93 test
code93:  test if cm Fort90 array functions work for cf77 v6.0
cf90er: => convex fc9.5 flagged for error.
cf6er: => cray cf77v6.0 flagged for error and stilled flagged on convex fc9.5
      integer b(2,3),s2(2),s3(3)
      integer c(2,2),ct(3,2),cs(3,4),as(4),at(3),ctr1(2),ctr2(2),ctr3(2)
      integer a(2,3),cu(2,3),ar1(3),ar2(3),cst(4,3)
      integer bi(2,2),br1(3),br2(3),b2(2),cr1(2),cr2(2)
      logical test(2,3),inmask(64,64)
      real u(64,64),du(64,64),us(8,8),diffav
      intrinsic sum,maxval,minval,product,dot_product,matmul,transpose
     & ,cshift,eoshift,spread
      data b/1,2,3,4,5,6/     !replace constructors initialization
      data as/2,3,4,5/
      data at/2,3,4/
c --------------------
       b(1,1:3) = (/1, 3, 5/)  ! initialize first row, along dimension 2.
       b(2,1:3) = (/2, 4, 6/)  ! initialize second row, along dimension 2.
      print*,'Note: constructors like "(/1,2/)" allowed in fc9.5'
      br1 = b(1,:)
      br2 = b(2,:)
      print60,br1,br2
60    format(' b(2,3)'/(3i3))
c --------------------
      isum = sum(b) ! => isum = 21; i.e., Front-End scalar.
      print61,' isum=sum(b)=',isum
61    format(1x,a36,i4)
      isum = sum(b(:,1:3:2)) ! => isum = 14; sole ':' means all values '1:2'.
      print61,' isum = sum("b(:,1:3:2)")=',isum
      bi=b(:,1:3:2)
      isum=sum(bi)
      print61,' isum = sum("b(:,1:3:2)")=',isum
cf6er:s2 = sum(b,dim=2) ! declared with the correct array section shape.
      print*,'CAUTION: "dim=", etc., markers= NOT allowed in intrinsics'
      s2 = sum(b,2) ! redeclared with the correct array section shape.
      print62,' s2 = sum(b,2)=',s2  ! => s2 = (/9,12/), row sums
62    format(1x,a32,2i3)
      s3 = sum(b,1)  ! => s3 = (/3,7,11/); column sums.
      print63,' s3 = sum(b,1)=',s3
63    format(1x,a32,3i3)
cf6er:isum = sum(b,mask=b.gt.3) ! =>isum = 18; i.e., add only elements
      print*,'CAUTION:  "mask=" marker= STILL not allowed either.'
      s3 = sum(b,1,b.gt.3) ! => s3 = (/0,4,11/); i.e., conditional col sum
      print63,' s3 = sum(b,1,"b.gt.3") =',s3  
      test=b.gt.3
      s3 = sum(b,1,test) ! => s3 = (/0,4,11/); i.e., conditional col sum
      print63,' s3 = sum(b,1,"b.gt.3") =',s3  
      s2 = sum(b,2,test) ! => s2 = (/5,10/); i.e., conditional row sum
      print62,' s2 = sum(b,2,b.gt.3) =',s2  
cf6er:isum = sum(b,,test) ! => isum = 18; i.e., add only elements
cf6er:print61,' isum = sum(b,,b.gt.3) =',isum ! that are greater than three.
      isum = sum(b,0,test) ! => isum = 18; i.e., add only elements
      print61,' isum = sum(b,0,b.gt.3) =',isum ! that are greater than three.
      print*,' CAUTION:  If "sum(array[dim[,mask]])", use zero (0)'
     &      ,' for [dim] for whole array when there is a mask.'
c --------------------
      imax = maxval(b) ! => imax = 6; array maximum value.
      print61,' imax = maxval(b)=',imax
      s3 = maxval(b,1) ! => s3 = (/2,4,6/); column maximums.
      print63,' s3 = maxval(b,1)=',s3
      s2 = maxval(b,2) ! => s2 = (/5,6/); row maximums.
      print62,' s2 = maxval(b,2)=',s2
c --------------------
      imin = minval(b) ! => imin = 1; array minimum value.
      print61,' imin = minval(b)=',imin
c --------------------
      s2 = product(b,2) ! => s2 = (/15,48/); products of column elements.
      print62,' s2 = product(b,2)=',s2
c --------------------
      idot = dot_product(br1,br2) ! => idot = 44; dot product of row
      print61,' idot = dot_product(b(1,:),b(2,:))=',idot ! vectors of b.
      print*,' CAUTION:  Array syntax not allowed in actual arguments.'
c --------------------
      ! assuming array b of the previous section.
      ![Ans] = matmul([Array_1],[Array_2]) ! computes matrix multiplication
                                           ! of two rank two matrices.
      c = matmul(b(:,1:2),b(:,2:3)) ! => c(1,:)=(/15,23/);c(2,:)=(/22,34/).
      c=transpose(c)
      print623,'c=matmul(b(:,1:2),b(:,2:3))=',c
623   format(1x,a36/(2i3))
      ![Ans] = transpose([Array]) ! transforms an array to its transpose.
      ct = transpose(b) ! => ct(1,:)=(/1,2/);ct(2,:)=(/3,4/);ct(3,:)=(/5,6/).
      ctr1 = ct(1,:)
      ctr2 = ct(2,:)
      ctr3 = ct(3,:)
      print623,'ct = transpose(b)=',ctr1,ctr2,ctr3
c --------------------
        ! assume b is again initialized as
        !        b =  1 3 5
        !             2 4 6
      a = cshift(b,1,2)  ! => a = 3 5 1
                         !        4 6 2
      ar1 = a(1,:)
      ar2 = a(2,:)
      print633,'a = cshift(a,1,2)=',ar1,ar2
633   format(1x,a36/(3i3))
    ! i.e., b(i,j+shift) -> a(i,j) for j=1:2, etc.;
    ! i.e., the result is computed from shifting subscript in specified
        ! dimension of the source array by the specified shift.
      a = cshift(b,-1,2)  ! => a = 5 1 3
                          !        6 2 4
      ar1 = a(1,:)
      ar2 = a(2,:)
      print633,'a = cshift(b,-1,2)=',ar1,ar2
        ! i.e., b(i,j+shift) -> a(i,j) for j=2:3, etc.
      s2(1) = 1
      s2(2) = 2
      a = cshift(b,s2,2)  ! a = 3 5 1
                          !     6 2 4
        ! i.e., an array-valued shift, or shift per row.
      ar1 = a(1,:)
      ar2 = a(2,:)
      print633,'a = cshift(b,(/1,2/),2)=',ar1,ar2
c --------------------
        ! Jacobi Iteration for a 5-star discretization of 
        !        2D Laplace's equation:
      u = 0
      u(1,:)=2
      u(64,:)=2
      u(:,1)=2
      u(:,64)=1
      inmask = .FALSE.
      inmask(2:63,2:63) = .TRUE.
      diffav = 1
      iter=0
      do while (diffav.gt.5.e-3.and.iter.lt.100)
         iter=iter+1
         du = 0
         where(inmask)
            du = 0.25*(cshift(u,1,1)+cshift(u,-1,1)+cshift(u,1,2)
     &          +cshift(u,-1,2)) - u
            u = u + du
         end where
         du = du*du
         diffav = sqrt(sum(du)/(62*62))
      end do 
        ! which is the main program fragment of laplace.fcm.
cf90er:print66,'u = laplace-shift(u)=',u(1:64:16,1:64:16)
cf90er:     &   ,' array section like "u(1:64:16,1:64:16)".'
      print*,'CAUTION: array sections not allowed in print'
      us = u(1:64:9,1:64:9)
      us=transpose(us)
      print66,'u = laplace-shift(u)= ; iter=',iter,'; av-diff ='
     &       ,diffav,us
66    format(1x,a36,i3,a7,e10.3/(8f7.3))
c --------------------
      a = eoshift(b,-1,0,1) ! a = 0 0 0 note default boundary value is 0.
                            !     1 3 5
      ar1 = a(1,:)
      ar2 = a(2,:)
      print633,'a = eoshift(b,-1,0,1)=',ar1,ar2
      s2=(/-1,0/)
      b2=(/7,8/)
      a = eoshift(b,s2,b2,2) ! => a = 7 1 3
                             !        2 4 6
      ar1 = a(1,:)
      ar2 = a(2,:)
      print633,'a = eoshift(b,(/-1,0/),(/7,8/),2)=',ar1,ar2
      a = eoshift(b,2,0,2) ! => a = 5 0 0
                           ! =>     6 0 0
      ar1 = a(1,:)
      ar2 = a(2,:)
      print623,'a = eoshift(b,2,2)=',ar1,ar2
c --------------------
      cs = spread(as,1,3)
         ! contents of cs:
         !        2 3 4 5
         !        2 3 4 5
         !        2 3 4 5
      cst = transpose(cs)
      print64,'as =',as
64    format(1x,a32,4i3)
      print643,'cs = spread(as,1,3)=',cst
643   format(1x,a36/(4i3))
c --------------------
      cs = spread(at,2,4)
         ! contents of c:
         !        2 2 2 2
         !        3 3 3 3
         !        4 4 4 4
      cst = transpose(cs)
      print63,'at =',at
      print643,'cs = spread(at,2,4)=',cst
c --------------------
      print*,'F90 random_number does not work, even with intrinsic stmt'
C     call random_number(uniform)
      uniform=rand(1)
      print660,'seed=',1,', uniform random variate =',uniform
C     call random_number(uniform)
      uniform=rand(0)
      print660,'seed=',0,', uniform random variate =',uniform
C     call random_number(uniform)
      uniform=rand(0)
      print660,'seed=',0,', uniform random variate =',uniform
660   format(1x,a,i2,1x,a,f10.6)
c ---------------------------------------------------------------------------
! i.e., b=spread(a,d,c)  =>
! a(n_1,n_2,...,n_(d-1),n_d,...,n_r) -> b(n_1,n_2,...,n_(d-1),c,n_d,...,n_r)
! where r is the rank of source array a and n_i is the size of dimension i;
! noting that a new dimension of size c is added before dimension d.
c ---------------------------------------------------------------  
      stop
      end

%%%%%%%%%%% end f90test.f %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    fc and cc Compiler Optimization Directives

    Compiler directives can be used to force optimization or stop optimization for both `fc' and `cc' compilers. These statements are placed in the Fortran or C source just before the loop or other entity they are to effect. However, some come in single statements, while others come in pairs with one beginning directives and another ending directive. The compiler directives have different formats, i.e., for `fc' they have the form:

    while for `cc' they are called pragmas and have the form:

    If several compatible directives are used on the same code fragment like a loop, then they may be combined, for example in the case of two directives, as

    Caution: for `fc', the leading `C' of `C$DIR' must be in column 1 and a blank must be in column 6. The `#pragma' statement keyword must be in lower case for `cc', but the directives themselves as well as `C$DIR' can be in upper or lower case. Also, it is not wise to force optimization where inappropriate and risk synchronization errors.

    fc and cc Compiler Scalar Directives

    These directives effect scalar optimization or nonoptimization at the point at which the directive appears and only affects the local program unit, such as the loop it appears in.

    Return to TABLE OF CONTENTS?

    fc and cc Compiler Loop Directives

    These compiler directives hold only for the loop immediately following the directive.

    Return to TABLE OF CONTENTS?

    cxpa Performance Analyzer

    The Convex performance analyzer CXpa permits analyzing the performance of both Fortran and C programs. It can be used in both X-Windows and line edit mode, but only the line edit example for Fortran code will be given here, otherwise consult the `man cxpa' command. The `cxpa' analyzer also servers as a coarse CPU timer.