Accessing MVS data sets

Consider the use of the file when choosing DCB parameters:
- Specify largest possible BLKSIZE (blocked files).
- Use recfm = FBS or F over FB unless dealing with a PDS. The use of standard (S) blocks optimizes the sequential processing of a file on a direct-access device.
- fseek() on sequential files is most efficient when using recfm = F or recfm = FBS.
- If you are accessing an existing sequential file created as FB, and you know that there are no short blocks in the file, specify FBS on the call to fopen() or freopen() to enable the library to perform faster repositions.
The proper choice of file attributes is important for efficient I/O.
When you do not need to reposition within a file, take advantage of NOSEEK for more efficient reading and writing to a data set. You can also specify NCP or BUFNO on the DD statement for MVS DASD data sets, thereby reducing the clock time of the application. See Multiple buffering for more information.
If possible, read or write a block at a time to minimize the I/O overhead and elapsed time.
Using text I/O for writing can be slower than using binary or record I/O. When you use binary or record I/O, the application must ensure that the data is written to the file in the correct format.
If you are using FB or FBS files, use binary I/O instead of record I/O. This way, you can read or write more than one record at a time.
Use fread() instead of fgets(), and fwrite() in place of fputs(), wherever possible.
Use putc() instead of fputc(), and getc() instead of fgetc(), if you must read or write a character.
The fputc() function, as defined by ANSI, puts a single character to the text stream. Special action occurs when writing a control character. On the other hand, the putc() macro buffers characters in storage and invokes fputc() only when encountering a control character. This reduces call overhead when you are writing one character at a time.
If you are using hiperspace memory files, you can use setvbuf() to set the buffer size.
The default buffer size for memory files in hiperspace is 16K. You can override this by calling setvbuf() after fopen(), but before performing any I/O operations on the file. The minimum buffer size is 4K. If you specify a smaller size, it is ignored, and the default is used instead.
If your file will be large, you can improve execution time by increasing the buffer size. This will result in less frequent flushing of the buffer to the hiperspace, but will cost you memory in the user address space for the larger buffers. For example,
```
      rc = setvbuf(fp, NULL, _IOFBF, 32768);
```
Alternatively, if your memory is constrained, you can reduce requirements for memory in the user address space by reducing the buffer size. This will result in more frequent flushing of the buffer to the hiperspace. For example,
```
      rc = setvbuf(fp, NULL, _IOFBF, 4096);
```
For more information on hiperspace memory files, refer to Performing memory file and hiperspace I/O operations.
When writing to text files that do not use DBCS characters, ensure that MB_CUR_MAX is set to 1 for the current locale. This will prevent internal I/O checks for DBCS strings.
Avoid using fscanf() or fprintf() if you can use other I/O routines instead. For example, use fwrite() rather than fprintf() to write out a format string with no substitution variables.
When using fflush() beware of NULL file pointers; fflush(NULL) flushes all open streams.
Specify DCB parameters on fopen() only when you are creating the file. When you are appending, updating or reading a file, these attributes are retrieved from the existing file.
Many file attributes (DCB parameters) are possible when you open a file with z/OS® XL C/C++. DCB parameters specified on fopen() must be compatible with those of the file or the ddname. This checking may cause unwanted overhead.
Use fgetpos() and fsetpos() instead of ftell() and fseek() when you are saving a position you will return to later. fgetpos() saves more information about the position than ftell().
Where possible, use striped data sets. These data sets improve overall I/O throughput.
For temporary files, use memory files rather than files created with tmpfile().
You can use MVS memory files from z/OS UNIX C++ application programs. However, use of the fork() function from the program clears a memory file and removes access from a hiperspace memory file for the child process. Use of an exec function from the program clears a memory file when the process address space is cleared.
For large memory files (1MB or larger) in which you perform random seeking, use hiperspace memory files, if they are available.
When your library is below the 16MB line, use hiperspace memory files.
The non-hiperspace files use up your storage from below the line. Hiperspace memory files do not reside in user virtual storage. Changing a memory file to a hiperspace memory file saves user virtual storage only if the file is larger than one hiperspace memory file buffer.
For VSAM I/O use VSAM buffers appropriately and use flocate() instead of ftell() and fseek().