The fdcp(1) command can handle data that is not a simple disk-resident byte stream. The fdcp command assumes that both the data and any record, including EOF records, can be copied from one file to another. Record structures can be preserved or removed. EOF records can be preserved either as EOF records in the output file or used to separate the delimited data in the input file into separate files.

The fdcp command does not perform data conversion; the only transformations done are on the record and file structures (fdcp transforms block, record, and file control words from one format to another).

If no assign(1) information is available for a file, the system layer is used. This means that if the file being accessed is on disk and if no assign -F attribute is used, the syscall layer is used; if it is on a tape, the bmx layer is used. Therefore, each tape block is considered a record; user tape marks are mapped to EOF.

The following four examples show some uses of fdcp:

assign -F vms.v.tape tapefile
assign -F text diskfile
fdcp tapefile diskfile

vi diskfile         # process the data

assign -F bmx tapefile

assign -F cos diskfile
fdcp tapefile diskfile

assign -F ibm.fb:240:4800,cos -N ibm diskfile

./a.out diskfile

assign -F ibm.fb:240:4800,bmx -N ibm tapefile

./a.out tapefile

assign -F blankx,cos tapefile
assign -F text diskfile
fdcp diskfile tapefile

assign -F text file1
assign -F text file2
assign -F text file3
assign -F text file4

fdcp file1,file2,file3,file4 tapefile 

assign -F blankx,cos tapefile
assign -F text file1
assign -F text file2
assign -F text file3
assign -F text file4

fdcp tapefile file1,file2,file3,file4

This section describes the following ways to move data between the UNICOS machine and other machines:

The Cray Research Fortran library contains a set of subroutines that convert between Cray Research data formats and the formats of various vendors. These routines are callable from any programming language supported by Cray Research. The explicit conversion routines convert between IBM, VAX/VMS, CDC, NOS/VE, CYBER 205, or IEEE binary data formats and Cray Research binary data formats. For complete details, see the individual man pages for each routine. These subroutines provide an efficient way to convert data that was read into system central memory. These are the recommended routines, and they replace the older explicit routines described in Appendix A.

Table 12-1 lists subroutines that convert Cray Research PVP types. Table 12-2 lists subroutines that convert Cray Research MPP types. Table 12-3 lists subroutines that convert Cray T90/IEEE types. Table 12-4 lists SGI (MIPS) conversion routines.

See the individual man pages for details about the syntax and arguments for each routine.

Implicit data conversion in Fortran requires no explicit action by the program to convert the data in the I/O stream other than using the assign command to instruct the libraries to perform conversion. For details, see the assign(1) man page.

The implicit data conversion process is performed in two steps:

Record format conversion interprets or converts the internal record blocking structures in the data stream to gain record-level access to the data. The data contained in the records can then be converted.

Using implicit conversion, you can select record blocking or deblocking alone, or you can request that the data items be converted automatically. When enabled, record format conversion and data item conversion occur transparently and simultaneously. Changes are usually not required in your Fortran code.

To enable conversion of foreign record formats, specify the appropriate record type with the assign -F command. The -N (numeric conversion) and -C (character conversion) assign options control conversion of data contained in a record. If -F is specified, but -N and -C are not, the libraries interpret the record format, but they do not convert data. You can obtain information about the type of data that will be converted (and, therefore, the type of conversion that will be performed) from the Fortran I/O list.

If -N is used and -C is not, an appropriate character conversion type is selected by default, as shown in the following tables:

Cray Research supports the following implicit data conversion:

Generally, read, write, and rewind are supported for all record formats. Other capabilities, such as backspace and GETPOS/SETPOS are usually not available, but they can be made to work if a blocking type can be used to support it. See the sections on the specific layers for complete details.

If you select the -N option, the libraries perform data conversion for Fortran unformatted statements and BUFFER IN and BUFFER OUT I/O statements. Data is converted between its Cray Research representation and a foreign representation, according to its Fortran data type. Table 12-9 describes the conversion performed for each of the conversion types.

For numeric data conversions, most foreign data elements are defined with fewer bits than their corresponding Cray Research data elements. If the value in a Cray Research element is too large to fit in the foreign element, the foreign element is set to the largest or smallest possible value; no error is generated. When converting from a Cray Research element to a smaller foreign element, precision is also lost due to truncation of the floating-point mantissa.

If the assign -N user or assign -N site command is specified, the user or site must provide site numeric data conversion routines. They follow the same calling conventions as the other explicit routines.

For implicit conversion, specify format characteristics on an assign command.

Files can be converted to one of the following:

When a Fortran I/O operation is performed on the file, the appropriate file format and data conversions are performed during the I/O operation. Data conversion is performed on each data item, based on the type of the Fortran variable in the I/O list.

For example, if the first read of a foreign format file is the following, the library interprets any blocking structures in the file that precede the first data record:

READ (10) INT,FLOAT1,FLOAT2

These vary depending on the file type and record format. The first 32 bits of data (in IBM format, for example) are extracted, sign-extended, and stored in the INT Fortran variable. The next 32 bits are extracted, converted to native floating-point format, and stored in the FLOAT1 Fortran variable.

The next 32 bits are extracted, converted, and stored into the FLOAT2 Fortran variable. The library then skips to the end of the foreign logical record. When writing from a native system to a foreign format (for example, if in the previous example WRITE(10) was used), precision is lost when converting from a 64-bit representation to 32-bit representation.

As with any software process, the various options for data conversion have advantages and disadvantages, which are discussed in this section. As a set, various data conversion options provide choices in methods of file processing for front-end systems. No one option is best for all applications.

The subroutines required to handle data conversion must be loaded into absolute binary files. By default, the run-time libraries include references to routines required to support the forms of implicit conversion enabled in the foreign data conversion configuration file, usually named <fdcconfig.h>.

If an application requires the use of a conversion routine that is not loaded by default, it can use the loader directives files to activate the routines that support that type of conversion.

It is possible to activate these conversion types for an entire site by using the UNICOS installation tool. Use the following nested menu options:

Configure system==>
  SEGLDR loader configuration==>
    Define optional SEGLDR HARDREF directives==>

This adds the needed directives in the site-configurable SEGLDR directives file.

Tape formats are physical structures that the operating system superimposes over the user-declared CYBER record manager file structure. The FFIO system supports I-format (internal) and SI -format (system or SCOPE internal) tape formats and files transmitted to the UNICOS operating system from a CYBER disk.

I-format tapes have block sizes that range from 0 to 512 words in exact multiples of 60-bit words. Each block includes a 48-bit block terminator.

SI-format tapes also have block sizes ranging from 0 to 512 words in exact multiples of 60-bit words. Any block smaller than the maximum size (512 words) contains a 48-bit block terminator. This terminator has the same format as that used for I-format tapes.

All CDC sequential tape files are blocked; a block may contain partial records or one or more records. The block structure is intertwined with the physical tape format. Fortran programmers do not use block boundaries. The translation routines construct blocks from records supplied by users and supply users with records as required.

Two CYBER blocking types are supported:

A record is the unit of information that is processed on each call for reading or writing. Therefore, the CDC translation routines on UNICOS systems must be aware of the following record types and their analogous structures. Partial record input and output can be achieved using standard buffer I/O requests.

Several NOS/VE record formats are supported. One noteworthy restriction is that the nosve.v format is not supported on tape.

The UNICOS operating system uses COS blocking primarily for Fortran unformatted sequential files.

The COS operating system uses COS blocking for all blocked files. Because the data formats (floating point, character, logical, and integer) are the same as on UNICOS systems with CRI floating point format, and because COS blocking is the default blocking format on the UNICOS operating system, no conversion is necessary when moving unformatted blocked sequential files between the UNICOS operating system on Cray PVP systems with CRI floating point and the COS operating system. Two common file types on COS require some conversion to make them useful on the UNICOS operating system.

The first of these file types is COS blocked text files. To handle these, a combination of the cos and the blankx layers is necessary. The blankx layer must process the blank compression that is usually done on COS files. The cos layer processes the COS block and record control words that are present in COS text files. To read or write such a file, use the following command:

assign -F blankx,cos cosfile

With this command, a Fortran program can perform list-directed, formatted, and namelist I/O on cosfile as though it were in UNICOS text format.

On UNICOS systems, you can also use the fdcp command to convert such a file to UNICOS text format.

assign -F blankx,cos cosfile
assign -F text textfile
fdcp cosfile textfile

To create a COS blocked, blank compressed text file, use the following:

assign -F blankx,cos cosfile
assign -F text textfile
fdcp textfile cosfile

If the COS file contains more than one EOF, specify the textfile with assign -F text.eof. This directs the text layer to use the ~e marker in the text file to signify an EOF.

The second of these file types is the COS blocked direct-access file. Direct-access files on the UNICOS operating system do not contain any blocking information; they are fixed-length record files and rely on the record length for the record boundaries.

On the COS operating system, direct-access files are COS blocked. Unformatted direct-access files are indistinguishable from sequential files. Formatted direct-access files are distinguishable from sequential files only because they are not blank compressed.

Because the FFIO system does not support random positioning on COS blocked files, it is not possible to directly read and write COS direct-access files. You can use fdcp to convert the files to a format that can be directly used on the UNICOS operating system. The simplest way to do this is to remove the blocking control words (BCW) from the file. This results in a file that contains all of the fixed-length records in a directly usable format. An example of this follows:

assign -F cos cosfile
fdcp cosfile dafile

The converse operation requires one more command. You must borrow one of the fixed-length record types because generic fixed-length record type do not exist. An example of this follows:

assign -F cosfile
assign -F vms.f.t:800 dafile
fdcp dafile cosfile

The CYBER 205 layer is limited to the support of the W-type record. These records are not supported directly on tape; however, if tape files are copied to disk (preferably using fdcp), W-type records can be handled there.

A peculiar feature of the CYBER 205 conversion is the conversion of half-precision floating-point numbers, which are mapped to short integers in the numeric conversion routines. Therefore, if you do this conversion, a short integer array must be an equivalence of a real array to do the I/O.

Example:

    integer*2 ioarray(100)
    real fltnum(100)
    equivalence (fltnum,ioarray)
    read(1) ioarray
    do 10 i= 1,100
      call calc(fltnum(i))
C     deal with converted half-precision values
10  continue
    end

The FFIO system includes two features that are embedded in the blankx and text layers to process CTSS files. CTSS uses its own text file format and uses blank compression on these files. To read and write most CTSS text files, use the following specification:

blankx.ctss,text.ctss

Because unformatted Fortran files (binary records) are in COS blocked format at CTSS sites running a UNICOS system, conversion is not necessary.

To convert and transfer data between UNICOS systems and an IBM/MVS or VM system, you must understand the differences between the UNICOS file system and file formats, and those on the IBM system(s). On both VM and MVS, the file system is record oriented.

The most obvious form of data conversion is between the IBM EBCDIC character set and the ASCII character set used on UNICOS systems. Most of the utilities that transfer files to and from the IBM systems automatically convert both the record structures and character set to the UNICOS text format and to ASCII. For example, ftp performs these conversions and does not require any further conversion on UNICOS systems.

Binary data, however, is more complicated. You must first find a way to transfer the file and to preserve the record boundaries. If stations are available, this is simple (some examples are shown in the following sections). Few problems are caused by using tapes in transferring the file and preserving record boundaries.

Cray Research supports the following IBM record formats:

For all IBM record formats, the data formats are the same whether you are processing a disk file or processing a tape file.

    INTEGER IARR(10)
    REAL RARR(15)

    DO 10 I=1,10
      WRITE(1) IARR,RARR
10  CONTINUE
    STOP
    END

EOF
f90 test.f                  # compile and load program
segldr test.o               # load program
assign -R                   # reset assign
assign -F cos -N ibm fort.1 # select COS blocking (normal default)
                            # and IBM numeric data conversion
./a.out                     # execute
dispose fort.1 -f bb -t 'dsn=array.test,disp=shr'
                            # dispose file to MVS system

     INTEGER IARR(10)
     REAL RARR(15)
     DO 10 I=1,10
       READ(1) IARR,RARR
 10  CONTINUE
     STOP
     END

EOF
f90 test.f -o test.o        # compile and load program
assign -R                   # reset assign
assign -F cos -N ibm fort.1 # select cos blocking (normal default)
                            # and IBM numeric data conversion
fetch fort.1 -f BB -t 'dsname=array.test, disp-shr'
                            # fetch file from MVS system, and
                            # convert blocking from what is on
                            # MVS to COS blocked.
./a.out                     # run the program

assign -R                      # reset assign
assign -F ibm.vbs -N ibm fort.1# select IBM VBS record format
                               # and IBM numeric data conversion

fetch fort.1 -f TR -t 'dsn=array.test, disp=shr'
                               # fetch file from MVS system in
                               # 'transparent' mode.
./a.out                        # run the program

assign -R               # reset assign
assign -F ibm.vbs,cos -N ibm fort.1
                        # select IBM VBS record format with blocks
                        # delimited as COS blocked records. Also
                        # specify IBM numeric data conversion
./a.out                 # run the program
dispose fort.1 -f BB -t 'DCB=(RECFM=U),dsname=array.test,disp=shr'
                        # dispose file from MVS system

assign -F ibm.v:3280 fort.1    # V format, recsize 3280 bytes
assign -F ibm.vb::16000 fort.1 # VB format,
                               # max block size 16,000 bytes
assign -F ibm.f:1600 fort.1    # F format fixed-length records
                               # of 1600 bytes each.
assign -F ibm.fb:1600:32000 fort.1
                               # Fixed-length records 1600 bytes
                               # each, 20 records per block
assign -F ibm.vbs::1800 fort.1 # VBS format, block size 1800 bytes

IRIX systems use 32-bit IEEE standard floating point, as do many workstations and personal computers. These workstations often use a dialect of UNIX software as the operating system, with twos-complement arithmetic and the ASCII character set. The logical values in these implementations are usually the same for Fortran and C. They use zero for false and nonzero for true. It is also common to see the f77 record blocking used by the Fortran run-time library on unformatted sequential files.

No IEEE record format exists, but the IEEE implicit and explicit data conversion routine facilities are provided with the assumption that many of these things are true.

Most computer systems that use the IEEE data formats run operating systems based on UNIX software and use f77 record blocking. You can use the rcp or ftp commands to transfer files. In most cases, the following command should work for implicit conversion:

assign -F f77 -N ieee fort.1

When writing files in the f77 format, remember that you can gain a large performance boost by ensuring that the records being written fit in the working buffer of the f77 layer.

Silicon Graphics MIPS systems use IEEE floating-point representation, so IEEE conversion is usually unnecessary when reading or writing IEEE data on these systems.

The Cray T90/IEEE and Cray MPP systems both use IEEE floating-point representations. However, they differ from most workstations in that the default data size is 64-bits instead of 32-bits.

On Cray T90/IEEE systems there are no 32-bit native data types, so any and all 32-bit IEEE data types must be read or written with an IEEE data conversion layer (for example, assign -N ieee, or assign -N ieee_dp).

On Cray MPP systems, data types can be declared as 32-bits in size and can then be read or written directly. This is the most direct and efficient method to read or write data files for IEEE workstations. The user can either alter the declarations of the variables used in the Fortran I/O list to declare then as KIND=4 or as REAL*4 (or INTEGER*4), or all the variables in the program can be resized by compiling with the -s default32 compiler option.

For example, to read a file on a Cray MPP system which has 32-bit integers and 64-bit IEEE floating-point numbers, consider the following code fragments. Existing program:

REAL         RVAL      ! Default size (64-bits)
INTEGER      IVAL      ! Default size (64-bits)
...
READ (1) IVAL, RVAL

This program will expect both the integer and floating-point data to be the same size (64-bits). However, it can be modified to declare the variables to be the same size as the expected data. Modified program (#1):

REAL    (KIND=8) RVAL      ! Explicit 64-bits
INTEGER (KIND=4) IVAL      ! Explicit 32-bits
...
READ (1) IVAL, RVAL

This program will correctly read the the expected data. However, if this type of modification is too extensive, only the variables used in the I/O statement list need be modified. Modified program (#2):

REAL             RVAL      ! Default size (64-bits)
INTEGER          IVAL      ! Default size (64-bits)
REAL    (KIND=8) RTMP      ! Explicit 64-bits
INTEGER (KIND=4) ITMP      ! Explicit 32-bits
...
READ (1) ITMP, RTMP  !

Change explicitly sized data to default sized data:

RVAL = RTMP
IVAL = ITMP

On MIPS systems, data types can be declared as 64-bits in size and can then be read or written directly. This is the most direct and efficient method to read or write data files for Cray IEEE systems. The user can either alter the declarations of the variables used in the Fortran I/O list to declare them as KIND=8 or as REAL*8 (or INTEGER*8), or all the variables in the program can be resized by compiling with the -r8 (or -i8) compiler option.

The following are other IEEE data conversion variants; not all variants are available on all systems:

Nine record types are supported for VAX/VMS record conversion. This includes a combination of three record types and the three types of storage medium, as defined in the following list:

Segmented records are mainly used by VAX/VMS Fortran. The following are examples of some combinations of segmented records in different types of storage media:

The VAX/VMS system stores its data as a stream of bytes on various devices. UNICOS systems number their bytes from the most-significant bits to the least-significant bits, while the VAX system numbers the bytes from lowest-significance up. The station and a UNICOS system make this byte-ordering transparent when you use text files. When data conversion is used, byte swapping sometimes must be done.

Character conversion is not necessary for text files transferred using the station because the VAX/VMS system uses the same ASCII character set as UNICOS systems. The station software correctly handles byte-ordering machines for text files.

The process is similar for binary data. You can use the fetch and dispose commands to move data between the UNICOS system and the VAX. You can move data in several ways.

You can use the -f bb transfer format, which places the burden of blocking and unblocking the data to be transferred to the VAX. The VAX station must convert VMS blocking to COS blocking and the opposite is true.

You can also use the -f tr transfer option, which results in record formats on UNICOS systems that use the tr subfield in the vms layer specification.

When using -f bb transfers, you must know the format of the file on the VAX side and specify the proper record format when reading/writing the data.

Most VAX/VMS users are aware of only two basic record types, which are V and F (variable length and fixed length). F format on the VAX maps directly to the vms.f record types on UNICOS systems.

fetch testin -f bb -t 'CRAYMH"USER PASSWD"::SEG.DAT'
assign -a TESTIN -F vms.s.bb::10000,cos -N vms fort.1
assign -a TESTOUT -F vms.s.bb::10000,cos -N vms fort.22
f90 test.f test.o../a.out
dispose TESTOUT -f BB -t 'CRAYMH"USER PASSWD"::[]SEG2.DAT'

    PROGRAM FRED
    REAL
    INTEGER*2 SHORT(50)
C
C   NOTE THAT BECAUSE -N VMS IS IN USE, THE SHORT INTEGERS
C   BECOME 64 BITS ON THE CRAY RESEARCH SYSTEM
C
10  READ (1,END=99) SHORT, REAL
    CALL PROCESS (STAT,SHORT,REAL)C
C   ...AND ARE CONVERTED BACK ON OUTPUT
C
    WRITE(22) SHORT, REAL
    GOTO 10
99  STOP
    END
    SUBROUTINE PROCESS (STAT,SHORT,REAL)
    REAL REAL(100)
    INTEGER SHORT(50)
C
C   PROCESS THE DATA
C
    RETURN
    END

Because the default record type produced on UNICOS systems is v, special work is not required to dispose vms.s.bb or vms.v.bb records. It is also easy to fetch data from the station because the station reads the data properly without user intervention. When using fixed-length record format, you must add the following information to the TEXT field on the dispose command:

-t 'CRAYMH"USER PASSWD"::SEG.DAT/RFM=FIX/MRS=256/NORAT'

This dispose command works properly for a file created with the vms.f.tr:256 specification.

The RFM, MRS, and NORAT parameters specify a fixed-length record format file, a maximum record size of 256 bytes, and no record attributes.