COBOL Record Blocking

Record blocking is a fundamental concept in COBOL file processing that significantly impacts I/O performance and storage efficiency. Understanding the difference between physical records (blocks) and logical records, and how to specify blocking factors, is essential for optimizing file operations in mainframe environments. This guide covers physical and logical records, the BLOCK CONTAINS clause, blocking factors, and performance considerations.

What is Record Blocking?

Record blocking is the process of grouping multiple logical records into a single physical record (block) for storage and I/O operations. This technique:

• Reduces I/O Operations: Reading or writing one block transfers multiple logical records at once
• Improves Performance: Fewer I/O operations mean faster file processing
• Optimizes Storage: More efficient use of storage media, especially for tape drives
• Reduces Overhead: Less system overhead per logical record processed

Physical Records vs Logical Records

Understanding the distinction between physical and logical records is crucial for effective file processing:

Logical Records

A logical record is the unit of data that your COBOL program processes:

• Program View: What your COBOL program sees and works with
• One at a Time: Your program processes one logical record per READ or WRITE statement
• Defined in FD: Described in the File Description (FD) entry
• Variable or Fixed Length: Can be fixed-length or variable-length depending on your definition

1
2
3
4
5
6
7
01 CUSTOMER-RECORD.
   05 CUSTOMER-ID       PIC X(8).
   05 CUSTOMER-NAME     PIC X(30).
   05 CUSTOMER-ADDRESS  PIC X(50).
   05 CUSTOMER-PHONE    PIC X(12).
 
*> This is a logical record - what your program processes

Physical Records (Blocks)

A physical record, also called a block, is what is actually stored on the storage device:

• Storage View: What is physically written to disk, tape, or other storage media
• Contains Multiple Logical Records: One physical block can contain many logical records
• I/O Unit: The unit of data transferred in a single I/O operation
• Block Size: Determined by the blocking factor and logical record size

Visual Example

Consider a file with logical records of 80 characters each, blocked at 10 records per block:

When your program reads Record 1, the system actually reads the entire first block (containing Records 1-10) into memory. Subsequent READ statements for Records 2-10 use the data already in memory, avoiding additional I/O operations.

The BLOCK CONTAINS Clause

The BLOCK CONTAINS clause in the File Description (FD) entry specifies how logical records are grouped into physical blocks. This clause is essential for optimizing I/O performance.

Syntax

1
2
3
4
5
FD  file-name
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS [integer-1] [TO integer-2] 
                  {RECORDS | CHARACTERS | WORDS}
    RECORD CONTAINS [integer-3] [TO integer-4] CHARACTERS.

Blocking by Records

The most common approach is to specify the number of logical records per physical block:

1
2
3
4
5
6
7
8
9
10
11
12
13
FD  CUSTOMER-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 20 RECORDS
    RECORD CONTAINS 100 CHARACTERS.
01  CUSTOMER-RECORD.
    05  CUSTOMER-ID       PIC 9(5).
    05  CUSTOMER-NAME     PIC X(30).
    05  CUSTOMER-ADDRESS  PIC X(50).
    05  CUSTOMER-SALARY   PIC 9(7)V99.
    05  FILLER            PIC X(5).
 
*> This creates blocks of 2,000 characters (20 × 100)
*> Each physical I/O operation transfers 20 logical records

Blocking by Characters

You can also specify blocking by the total number of characters:

1
2
3
4
5
6
7
8
FD  DATA-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 1600 CHARACTERS
    RECORD CONTAINS 80 CHARACTERS.
 
*> This creates blocks of 1,600 characters
*> With 80-character records, this equals 20 records per block
*> (1600 ÷ 80 = 20)

Variable Blocking

For variable-length records, you can specify a range:

1
2
3
4
5
6
7
8
FD  VARIABLE-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 100 TO 200 CHARACTERS
    RECORD CONTAINS 50 TO 100 CHARACTERS
    DEPENDING ON RECORD-LENGTH.
 
*> Blocks can vary in size from 100 to 200 characters
*> Each block contains one or more variable-length records

Unblocked Records

If you don't specify BLOCK CONTAINS, or specify BLOCK CONTAINS 0 RECORDS, each logical record becomes its own physical block:

1
2
3
4
5
6
7
8
FD  UNBLOCKED-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 0 RECORDS
    RECORD CONTAINS 80 CHARACTERS.
 
*> Each logical record is a separate physical block
*> Maximum I/O operations (one per record)
*> Used when random access is more important than sequential performance

Blocking Factor

The blocking factor is the number of logical records contained in each physical block. Choosing the right blocking factor is crucial for optimal performance.

Factors to Consider

• File Size: Larger files benefit from larger blocking factors
• Access Pattern: Sequential access benefits more from blocking than random access
• Storage Medium: Tape drives benefit more from large blocks than disk drives
• Memory Constraints: Larger blocks require more buffer memory
• Record Size: Smaller records can use larger blocking factors

Typical Blocking Factors

Performance Impact

Record blocking has a significant impact on file processing performance:

I/O Operations Reduction

Consider a file with 10,000 records of 100 characters each:

As you can see, increasing the blocking factor dramatically reduces the number of I/O operations, which directly improves performance.

Memory Considerations

While larger blocks reduce I/O operations, they also require more memory:

• I/O Buffers: Each open file needs buffer space equal to at least one block size
• Multiple Files: If your program opens multiple files, each needs its own buffer
• System Limits: Total buffer memory must fit within available system memory
• Virtual Memory: Very large blocks may cause paging, which can hurt performance

Practical Examples

Example 1: Customer Master File

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
IDENTIFICATION DIVISION.
PROGRAM-ID. CUSTOMER-PROCESS.
 
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT CUSTOMER-FILE ASSIGN TO "CUSTMAST.DAT"
        ORGANIZATION IS SEQUENTIAL
        ACCESS MODE IS SEQUENTIAL
        FILE STATUS IS WS-CUST-STATUS.
 
DATA DIVISION.
FILE SECTION.
FD  CUSTOMER-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 25 RECORDS
    RECORD CONTAINS 100 CHARACTERS.
01  CUSTOMER-RECORD.
    05  CUSTOMER-ID       PIC 9(5).
    05  CUSTOMER-NAME     PIC X(30).
    05  CUSTOMER-ADDRESS  PIC X(50).
    05  CUSTOMER-STATUS   PIC X.
    05  FILLER            PIC X(14).
 
WORKING-STORAGE SECTION.
01  WS-CUST-STATUS       PIC XX.
01  RECORD-COUNT          PIC 9(6) VALUE ZERO.
01  EOF-FLAG              PIC X VALUE 'N'.
    88  END-OF-FILE         VALUE 'Y'.
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    OPEN INPUT CUSTOMER-FILE
    PERFORM READ-CUSTOMERS UNTIL END-OF-FILE
    CLOSE CUSTOMER-FILE
    DISPLAY "Total records processed: " RECORD-COUNT
    STOP RUN.
 
READ-CUSTOMERS.
    READ CUSTOMER-FILE
       AT END
          MOVE 'Y' TO EOF-FLAG
       NOT AT END
          ADD 1 TO RECORD-COUNT
          PERFORM PROCESS-CUSTOMER
    END-READ.
 
*> This example uses BLOCK CONTAINS 25 RECORDS
*> Each physical block contains 25 logical records (2,500 characters)
*> Reading 25 records requires only 1 I/O operation instead of 25

Example 2: High-Volume Transaction File

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FD  TRANSACTION-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 50 RECORDS
    RECORD CONTAINS 80 CHARACTERS.
01  TRANSACTION-RECORD.
    05  TRANS-DATE        PIC 9(8).
    05  TRANS-TIME        PIC 9(6).
    05  TRANS-TYPE        PIC X.
    05  TRANS-AMOUNT      PIC 9(7)V99.
    05  ACCOUNT-NUMBER    PIC 9(10).
    05  TRANS-DESCRIPTION PIC X(40).
    05  FILLER            PIC X(6).
 
*> High-volume transaction processing benefits from larger blocking
*> 50 records per block optimizes I/O for bulk processing
*> Each block contains 4,000 characters (50 × 80)
*> Reduces I/O operations by 98% compared to unblocked records

Example 3: Report Output File

1
2
3
4
5
6
7
8
9
10
11
FD  REPORT-FILE
    LABEL RECORDS ARE STANDARD
    BLOCK CONTAINS 10 RECORDS
    RECORD CONTAINS 132 CHARACTERS.
01  REPORT-RECORD.
    05  REPORT-LINE       PIC X(132).
 
*> Report files use smaller blocking for flexibility
*> 10 records per block allows for efficient line-by-line processing
*> Each block contains 1,320 characters (10 × 132)
*> Suitable for both sequential and random access patterns

Best Practices

1. Choose Appropriate Blocking Factors

• Test different blocking factors to find the optimal value for your environment
• Consider your access pattern: sequential benefits more than random access
• Account for memory constraints: ensure buffer memory is available
• Match blocking to storage medium characteristics

2. Consider File Characteristics

• Larger files benefit from larger blocking factors
• Smaller record sizes allow larger blocking factors
• Tape files should use larger blocks (20-100 records)
• Disk files can use moderate blocking (10-50 records)

3. Monitor Performance

• Track I/O statistics to measure the impact of blocking
• Monitor memory usage to ensure buffers don't cause issues
• Test with production-like data volumes
• Compare performance with different blocking factors

4. Common Pitfalls to Avoid

• Too Small: Blocking factor of 1 (unblocked) wastes I/O operations
• Too Large: Very large blocks may cause memory pressure or poor random access
• Ignoring Storage Medium: Not optimizing for tape vs. disk characteristics
• No Testing: Assuming a blocking factor without performance testing

Explain It Like I'm 5 Years Old

Exercises

Quiz