MainframeMaster

COBOL Tutorial

COBOL MULTIPLE

The MULTIPLE concept represents sophisticated record blocking and I/O optimization mechanisms within COBOL file processing environments, providing comprehensive performance enhancement strategies, advanced buffer management capabilities, and intelligent data transfer optimization that enable efficient file operations, reduced system overhead, and optimized throughput characteristics. This concept embodies enterprise I/O management principles by supporting flexible blocking strategies, enabling efficient data transfer patterns, and facilitating comprehensive performance optimization requirements while maintaining data integrity, ensuring consistent file behavior, and enabling scalable processing architectures across enterprise applications requiring high-performance file operations, optimized resource utilization, and reliable data management throughout intensive business processing scenarios.

MULTIPLE and Blocking Concepts

Record Blocking Specifications
cobol
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
*> File with blocking specification FD file-name BLOCK CONTAINS integer-1 TO integer-2 RECORDS RECORD CONTAINS integer-3 TO integer-4 CHARACTERS DATA RECORD IS record-name. *> Examples of blocking configurations *> Fixed blocking - exactly 10 records per block FD CUSTOMER-FILE BLOCK CONTAINS 10 RECORDS RECORD CONTAINS 100 CHARACTERS DATA RECORD IS CUSTOMER-RECORD. *> Variable blocking - 5 to 20 records per block FD TRANSACTION-FILE BLOCK CONTAINS 5 TO 20 RECORDS RECORD CONTAINS 50 TO 200 CHARACTERS DATA RECORD IS TRANSACTION-RECORD. *> Character-based blocking FD INVENTORY-FILE BLOCK CONTAINS 1000 TO 5000 CHARACTERS RECORD CONTAINS 80 CHARACTERS DATA RECORD IS INVENTORY-RECORD. *> Optimized blocking for performance FD SALES-FILE BLOCK CONTAINS 50 RECORDS RECORD CONTAINS 150 CHARACTERS DATA RECORD IS SALES-RECORD. *> Multiple record types in same block FD MIXED-FILE BLOCK CONTAINS 100 TO 500 CHARACTERS RECORD CONTAINS 20 TO 100 CHARACTERS DATA RECORDS ARE HEADER-RECORD, DETAIL-RECORD, TRAILER-RECORD.
Record Blocking
I/O Optimization
Performance

Comprehensive MULTIPLE Examples

cobol
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
IDENTIFICATION DIVISION. PROGRAM-ID. MULTIPLE-BLOCKING-DEMO. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. *> High-performance blocked file SELECT BLOCKED-CUSTOMER-FILE ASSIGN TO "BLOCKED-CUST.DAT" ORGANIZATION IS SEQUENTIAL ACCESS MODE IS SEQUENTIAL FILE STATUS IS WS-BLOCKED-STATUS. *> Unblocked file for comparison SELECT UNBLOCKED-CUSTOMER-FILE ASSIGN TO "UNBLOCK-CUST.DAT" ORGANIZATION IS SEQUENTIAL ACCESS MODE IS SEQUENTIAL FILE STATUS IS WS-UNBLOCK-STATUS. *> Variable blocked file SELECT VARIABLE-BLOCKED-FILE ASSIGN TO "VAR-BLOCK.DAT" ORGANIZATION IS SEQUENTIAL ACCESS MODE IS SEQUENTIAL FILE STATUS IS WS-VAR-STATUS. DATA DIVISION. FILE SECTION. *> Blocked file with optimal blocking factor FD BLOCKED-CUSTOMER-FILE BLOCK CONTAINS 25 RECORDS RECORD CONTAINS 200 CHARACTERS DATA RECORD IS BLOCKED-CUSTOMER-RECORD. 01 BLOCKED-CUSTOMER-RECORD. 05 BLOCKED-CUST-ID PIC X(8). 05 BLOCKED-CUST-NAME PIC X(30). 05 BLOCKED-CUST-ADDRESS PIC X(50). 05 BLOCKED-CUST-PHONE PIC X(15). 05 BLOCKED-CUST-EMAIL PIC X(40). 05 BLOCKED-CUST-BALANCE PIC 9(8)V99. 05 BLOCKED-CUST-STATUS PIC X(10). 05 FILLER PIC X(37). *> Unblocked file (blocking factor = 1) FD UNBLOCKED-CUSTOMER-FILE BLOCK CONTAINS 1 RECORD RECORD CONTAINS 200 CHARACTERS DATA RECORD IS UNBLOCKED-CUSTOMER-RECORD. 01 UNBLOCKED-CUSTOMER-RECORD. 05 UNBLOCKED-CUST-ID PIC X(8). 05 UNBLOCKED-CUST-NAME PIC X(30). 05 UNBLOCKED-CUST-ADDRESS PIC X(50). 05 UNBLOCKED-CUST-PHONE PIC X(15). 05 UNBLOCKED-CUST-EMAIL PIC X(40). 05 UNBLOCKED-CUST-BALANCE PIC 9(8)V99. 05 UNBLOCKED-CUST-STATUS PIC X(10). 05 FILLER PIC X(37). *> Variable blocking for different record sizes FD VARIABLE-BLOCKED-FILE BLOCK CONTAINS 10 TO 50 RECORDS RECORD CONTAINS 50 TO 300 CHARACTERS DATA RECORDS ARE SMALL-RECORD, MEDIUM-RECORD, LARGE-RECORD. 01 SMALL-RECORD. 05 SMALL-TYPE PIC X(5) VALUE "SMALL". 05 SMALL-DATA PIC X(45). 01 MEDIUM-RECORD. 05 MEDIUM-TYPE PIC X(6) VALUE "MEDIUM". 05 MEDIUM-DATA PIC X(144). 01 LARGE-RECORD. 05 LARGE-TYPE PIC X(5) VALUE "LARGE". 05 LARGE-DATA PIC X(295). WORKING-STORAGE SECTION. *> File status variables 01 WS-FILE-STATUS. 05 WS-BLOCKED-STATUS PIC X(2). 05 WS-UNBLOCK-STATUS PIC X(2). 05 WS-VAR-STATUS PIC X(2). *> Performance measurement variables 01 WS-PERFORMANCE-METRICS. 05 WS-BLOCKED-START-TIME PIC 9(8). 05 WS-BLOCKED-END-TIME PIC 9(8). 05 WS-UNBLOCK-START-TIME PIC 9(8). 05 WS-UNBLOCK-END-TIME PIC 9(8). 05 WS-BLOCKED-DURATION PIC 9(6). 05 WS-UNBLOCK-DURATION PIC 9(6). 05 WS-PERFORMANCE-RATIO PIC 9(3)V99. *> Processing statistics 01 WS-PROCESSING-STATS. 05 WS-BLOCKED-RECORDS PIC 9(8) VALUE 0. 05 WS-UNBLOCK-RECORDS PIC 9(8) VALUE 0. 05 WS-BLOCKED-IO-OPS PIC 9(6) VALUE 0. 05 WS-UNBLOCK-IO-OPS PIC 9(6) VALUE 0. 05 WS-TOTAL-RECORDS PIC 9(8) VALUE 10000. *> Blocking calculations 01 WS-BLOCKING-ANALYSIS. 05 WS-RECORD-SIZE PIC 9(4) VALUE 200. 05 WS-BLOCK-SIZE PIC 9(6) VALUE 5000. 05 WS-BLOCKING-FACTOR PIC 9(3). 05 WS-WASTE-BYTES PIC 9(4). 05 WS-EFFICIENCY-PCT PIC 9(3)V99. PROCEDURE DIVISION. MAIN-BLOCKING-DEMO. DISPLAY "=== COBOL MULTIPLE BLOCKING DEMONSTRATION ===" DISPLAY SPACES PERFORM CALCULATE-OPTIMAL-BLOCKING PERFORM DEMONSTRATE-BLOCKED-PROCESSING PERFORM DEMONSTRATE-UNBLOCKED-PROCESSING PERFORM COMPARE-PERFORMANCE-RESULTS PERFORM DEMONSTRATE-VARIABLE-BLOCKING DISPLAY "=== BLOCKING DEMO COMPLETE ===" STOP RUN. CALCULATE-OPTIMAL-BLOCKING. DISPLAY "=== OPTIMAL BLOCKING CALCULATION ===" DISPLAY SPACES DISPLAY "Calculating optimal blocking factors..." *> Calculate blocking factor for 5000-byte blocks COMPUTE WS-BLOCKING-FACTOR = WS-BLOCK-SIZE / WS-RECORD-SIZE COMPUTE WS-WASTE-BYTES = WS-BLOCK-SIZE - (WS-BLOCKING-FACTOR * WS-RECORD-SIZE) COMPUTE WS-EFFICIENCY-PCT = ((WS-BLOCKING-FACTOR * WS-RECORD-SIZE) / WS-BLOCK-SIZE) * 100 DISPLAY "Block size analysis:" DISPLAY " Target block size: " WS-BLOCK-SIZE " bytes" DISPLAY " Record size: " WS-RECORD-SIZE " bytes" DISPLAY " Optimal blocking factor: " WS-BLOCKING-FACTOR " records/block" DISPLAY " Wasted bytes per block: " WS-WASTE-BYTES " bytes" DISPLAY " Block efficiency: " WS-EFFICIENCY-PCT "%" DISPLAY "I/O operation reduction:" COMPUTE WS-BLOCKED-IO-OPS = WS-TOTAL-RECORDS / WS-BLOCKING-FACTOR MOVE WS-TOTAL-RECORDS TO WS-UNBLOCK-IO-OPS DISPLAY " Blocked I/O operations: " WS-BLOCKED-IO-OPS DISPLAY " Unblocked I/O operations: " WS-UNBLOCK-IO-OPS COMPUTE WS-PERFORMANCE-RATIO = WS-UNBLOCK-IO-OPS / WS-BLOCKED-IO-OPS DISPLAY " I/O reduction factor: " WS-PERFORMANCE-RATIO "x" DISPLAY SPACES. DEMONSTRATE-BLOCKED-PROCESSING. DISPLAY "=== BLOCKED FILE PROCESSING ===" DISPLAY SPACES DISPLAY "Processing blocked file (25 records per block)..." MOVE FUNCTION CURRENT-DATE(9:6) TO WS-BLOCKED-START-TIME OPEN OUTPUT BLOCKED-CUSTOMER-FILE PERFORM CREATE-BLOCKED-TEST-DATA CLOSE BLOCKED-CUSTOMER-FILE *> Read the blocked file back OPEN INPUT BLOCKED-CUSTOMER-FILE PERFORM READ-BLOCKED-FILE CLOSE BLOCKED-CUSTOMER-FILE MOVE FUNCTION CURRENT-DATE(9:6) TO WS-BLOCKED-END-TIME COMPUTE WS-BLOCKED-DURATION = WS-BLOCKED-END-TIME - WS-BLOCKED-START-TIME DISPLAY "Blocked processing completed:" DISPLAY " Records processed: " WS-BLOCKED-RECORDS DISPLAY " Estimated I/O operations: " WS-BLOCKED-IO-OPS DISPLAY " Processing time: " WS-BLOCKED-DURATION " deciseconds" DISPLAY SPACES. CREATE-BLOCKED-TEST-DATA. 01 WS-RECORD-COUNTER PIC 9(8) VALUE 0. 01 WS-CUSTOMER-ID-NUM PIC 9(6) VALUE 0. PERFORM VARYING WS-RECORD-COUNTER FROM 1 BY 1 UNTIL WS-RECORD-COUNTER > WS-TOTAL-RECORDS ADD 1 TO WS-CUSTOMER-ID-NUM MOVE WS-CUSTOMER-ID-NUM TO BLOCKED-CUST-ID STRING "CUSTOMER-" WS-CUSTOMER-ID-NUM DELIMITED BY SIZE INTO BLOCKED-CUST-NAME MOVE "123 MAIN STREET" TO BLOCKED-CUST-ADDRESS MOVE "555-1234" TO BLOCKED-CUST-PHONE STRING "cust" WS-CUSTOMER-ID-NUM "@email.com" DELIMITED BY SIZE INTO BLOCKED-CUST-EMAIL COMPUTE BLOCKED-CUST-BALANCE = WS-CUSTOMER-ID-NUM * 100.50 MOVE "ACTIVE" TO BLOCKED-CUST-STATUS WRITE BLOCKED-CUSTOMER-RECORD ADD 1 TO WS-BLOCKED-RECORDS IF FUNCTION MOD(WS-RECORD-COUNTER, 1000) = 0 DISPLAY " Created " WS-RECORD-COUNTER " blocked records" END-IF END-PERFORM. READ-BLOCKED-FILE. 01 WS-READ-COUNTER PIC 9(8) VALUE 0. READ BLOCKED-CUSTOMER-FILE AT END CONTINUE END-READ PERFORM UNTIL WS-BLOCKED-STATUS NOT = "00" ADD 1 TO WS-READ-COUNTER IF FUNCTION MOD(WS-READ-COUNTER, 1000) = 0 DISPLAY " Read " WS-READ-COUNTER " blocked records" END-IF READ BLOCKED-CUSTOMER-FILE END-READ END-PERFORM. DEMONSTRATE-UNBLOCKED-PROCESSING. DISPLAY "=== UNBLOCKED FILE PROCESSING ===" DISPLAY SPACES DISPLAY "Processing unblocked file (1 record per block)..." MOVE FUNCTION CURRENT-DATE(9:6) TO WS-UNBLOCK-START-TIME OPEN OUTPUT UNBLOCKED-CUSTOMER-FILE PERFORM CREATE-UNBLOCKED-TEST-DATA CLOSE UNBLOCKED-CUSTOMER-FILE *> Read the unblocked file back OPEN INPUT UNBLOCKED-CUSTOMER-FILE PERFORM READ-UNBLOCKED-FILE CLOSE UNBLOCKED-CUSTOMER-FILE MOVE FUNCTION CURRENT-DATE(9:6) TO WS-UNBLOCK-END-TIME COMPUTE WS-UNBLOCK-DURATION = WS-UNBLOCK-END-TIME - WS-UNBLOCK-START-TIME DISPLAY "Unblocked processing completed:" DISPLAY " Records processed: " WS-UNBLOCK-RECORDS DISPLAY " I/O operations: " WS-UNBLOCK-IO-OPS DISPLAY " Processing time: " WS-UNBLOCK-DURATION " deciseconds" DISPLAY SPACES. CREATE-UNBLOCKED-TEST-DATA. 01 WS-RECORD-COUNTER PIC 9(8) VALUE 0. 01 WS-CUSTOMER-ID-NUM PIC 9(6) VALUE 0. PERFORM VARYING WS-RECORD-COUNTER FROM 1 BY 1 UNTIL WS-RECORD-COUNTER > WS-TOTAL-RECORDS ADD 1 TO WS-CUSTOMER-ID-NUM MOVE WS-CUSTOMER-ID-NUM TO UNBLOCKED-CUST-ID STRING "CUSTOMER-" WS-CUSTOMER-ID-NUM DELIMITED BY SIZE INTO UNBLOCKED-CUST-NAME MOVE "123 MAIN STREET" TO UNBLOCKED-CUST-ADDRESS MOVE "555-1234" TO UNBLOCKED-CUST-PHONE STRING "cust" WS-CUSTOMER-ID-NUM "@email.com" DELIMITED BY SIZE INTO UNBLOCKED-CUST-EMAIL COMPUTE UNBLOCKED-CUST-BALANCE = WS-CUSTOMER-ID-NUM * 100.50 MOVE "ACTIVE" TO UNBLOCKED-CUST-STATUS WRITE UNBLOCKED-CUSTOMER-RECORD ADD 1 TO WS-UNBLOCK-RECORDS IF FUNCTION MOD(WS-RECORD-COUNTER, 1000) = 0 DISPLAY " Created " WS-RECORD-COUNTER " unblocked records" END-IF END-PERFORM. READ-UNBLOCKED-FILE. 01 WS-READ-COUNTER PIC 9(8) VALUE 0. READ UNBLOCKED-CUSTOMER-FILE AT END CONTINUE END-READ PERFORM UNTIL WS-UNBLOCK-STATUS NOT = "00" ADD 1 TO WS-READ-COUNTER IF FUNCTION MOD(WS-READ-COUNTER, 1000) = 0 DISPLAY " Read " WS-READ-COUNTER " unblocked records" END-IF READ UNBLOCKED-CUSTOMER-FILE END-READ END-PERFORM. COMPARE-PERFORMANCE-RESULTS. DISPLAY "=== PERFORMANCE COMPARISON ===" DISPLAY SPACES DISPLAY "Processing time comparison:" DISPLAY " Blocked file time: " WS-BLOCKED-DURATION " deciseconds" DISPLAY " Unblocked file time: " WS-UNBLOCK-DURATION " deciseconds" IF WS-UNBLOCK-DURATION > 0 COMPUTE WS-PERFORMANCE-RATIO = WS-UNBLOCK-DURATION / WS-BLOCKED-DURATION DISPLAY " Performance improvement: " WS-PERFORMANCE-RATIO "x faster" END-IF DISPLAY "I/O operation comparison:" DISPLAY " Blocked I/O operations: " WS-BLOCKED-IO-OPS DISPLAY " Unblocked I/O operations: " WS-UNBLOCK-IO-OPS COMPUTE WS-PERFORMANCE-RATIO = WS-UNBLOCK-IO-OPS / WS-BLOCKED-IO-OPS DISPLAY " I/O reduction: " WS-PERFORMANCE-RATIO "x fewer operations" DISPLAY "Blocking benefits:" DISPLAY " ✓ Reduced system overhead" DISPLAY " ✓ Improved throughput" DISPLAY " ✓ Better resource utilization" DISPLAY " ✓ Enhanced system performance" DISPLAY SPACES. DEMONSTRATE-VARIABLE-BLOCKING. DISPLAY "=== VARIABLE BLOCKING DEMONSTRATION ===" DISPLAY SPACES DISPLAY "Creating variable-blocked file with mixed record sizes..." OPEN OUTPUT VARIABLE-BLOCKED-FILE PERFORM CREATE-VARIABLE-RECORDS CLOSE VARIABLE-BLOCKED-FILE DISPLAY "Variable blocking characteristics:" DISPLAY " • Different record sizes in same file" DISPLAY " • Flexible blocking based on record size" DISPLAY " • Optimized space utilization" DISPLAY " • Efficient for mixed data types" DISPLAY SPACES. CREATE-VARIABLE-RECORDS. 01 WS-VAR-COUNTER PIC 9(4) VALUE 0. 01 WS-RECORD-TYPE PIC 9 VALUE 0. PERFORM VARYING WS-VAR-COUNTER FROM 1 BY 1 UNTIL WS-VAR-COUNTER > 100 COMPUTE WS-RECORD-TYPE = FUNCTION MOD(WS-VAR-COUNTER, 3) + 1 EVALUATE WS-RECORD-TYPE WHEN 1 MOVE "DATA1" TO SMALL-DATA WRITE SMALL-RECORD DISPLAY " Created small record " WS-VAR-COUNTER WHEN 2 MOVE "MEDIUM DATA CONTENT" TO MEDIUM-DATA WRITE MEDIUM-RECORD DISPLAY " Created medium record " WS-VAR-COUNTER WHEN 3 MOVE "LARGE DATA CONTENT WITH MORE INFORMATION" TO LARGE-DATA WRITE LARGE-RECORD DISPLAY " Created large record " WS-VAR-COUNTER END-EVALUATE IF FUNCTION MOD(WS-VAR-COUNTER, 20) = 0 DISPLAY " Progress: " WS-VAR-COUNTER " variable records created" END-IF END-PERFORM.

Blocking Benefits and Considerations

Performance Benefits
  • • Reduced I/O operations
  • • Improved throughput
  • • Lower system overhead
  • • Better resource utilization
Design Considerations
  • • Memory buffer requirements
  • • Record size vs block size
  • • Access pattern impact
  • • Storage device characteristics

Interactive Tutorial

Hands-On Exercise: Optimizing File Blocking
Practice calculating and implementing optimal blocking factors

Exercise 1: Calculating Optimal Block Size

cobol
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
*> Given: Record size = 150 bytes, Target block size = 4096 bytes 01 WS-BLOCKING-CALC. 05 WS-RECORD-SIZE PIC 9(4) VALUE 150. 05 WS-TARGET-BLOCK-SIZE PIC 9(6) VALUE 4096. 05 WS-CALCULATED-FACTOR PIC 9(3). 05 WS-ACTUAL-BLOCK-SIZE PIC 9(6). 05 WS-WASTED-SPACE PIC 9(4). 05 WS-EFFICIENCY PIC 9(3)V99. PROCEDURE DIVISION. CALCULATE-BLOCKING. *> Calculate optimal blocking factor COMPUTE WS-CALCULATED-FACTOR = WS-TARGET-BLOCK-SIZE / WS-RECORD-SIZE *> Calculate actual block size COMPUTE WS-ACTUAL-BLOCK-SIZE = WS-CALCULATED-FACTOR * WS-RECORD-SIZE *> Calculate wasted space COMPUTE WS-WASTED-SPACE = WS-TARGET-BLOCK-SIZE - WS-ACTUAL-BLOCK-SIZE *> Calculate efficiency COMPUTE WS-EFFICIENCY = (WS-ACTUAL-BLOCK-SIZE / WS-TARGET-BLOCK-SIZE) * 100 DISPLAY "Blocking Analysis Results:" DISPLAY " Records per block: " WS-CALCULATED-FACTOR DISPLAY " Actual block size: " WS-ACTUAL-BLOCK-SIZE " bytes" DISPLAY " Wasted space: " WS-WASTED-SPACE " bytes" DISPLAY " Efficiency: " WS-EFFICIENCY "%".

Exercise 2: Implementing Variable Blocking

cobol
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
*> Variable blocking for different record types FD MULTI-TYPE-FILE BLOCK CONTAINS 20 TO 100 RECORDS RECORD CONTAINS 50 TO 500 CHARACTERS DATA RECORDS ARE TRANSACTION-RECORD, SUMMARY-RECORD, DETAIL-RECORD. 01 TRANSACTION-RECORD. 05 TRANS-TYPE PIC X(5) VALUE "TRANS". 05 TRANS-DATA PIC X(45). 01 SUMMARY-RECORD. 05 SUMM-TYPE PIC X(7) VALUE "SUMMARY". 05 SUMM-DATA PIC X(143). 01 DETAIL-RECORD. 05 DETAIL-TYPE PIC X(6) VALUE "DETAIL". 05 DETAIL-DATA PIC X(494). PROCEDURE DIVISION. CREATE-OPTIMIZED-FILE. OPEN OUTPUT MULTI-TYPE-FILE *> Write small records first (more per block) PERFORM 50 TIMES MOVE "TRANS DATA" TO TRANS-DATA WRITE TRANSACTION-RECORD END-PERFORM *> Write medium records PERFORM 30 TIMES MOVE "SUMMARY INFORMATION" TO SUMM-DATA WRITE SUMMARY-RECORD END-PERFORM *> Write large records (fewer per block) PERFORM 10 TIMES MOVE "DETAILED INFORMATION" TO DETAIL-DATA WRITE DETAIL-RECORD END-PERFORM CLOSE MULTI-TYPE-FILE.

Best Practices

Knowledge Check

Test Your Understanding

Question 1: Blocking Benefits

How does record blocking improve file I/O performance?

Answer: Record blocking improves performance by reducing the number of physical I/O operations. Instead of one I/O per record, multiple records are transferred in a single operation, reducing system overhead, improving throughput, and better utilizing storage device capabilities.

Question 2: Optimal Blocking Factor

How do you calculate the optimal blocking factor for a file?

Answer: Calculate blocking factor by dividing the target block size by the record size. Consider factors like available memory, I/O device characteristics, access patterns, and efficiency requirements. Aim for high block utilization while staying within memory constraints.

Question 3: Variable Blocking

When should you use variable blocking instead of fixed blocking?

Answer: Use variable blocking when you have multiple record types with different sizes in the same file, or when record sizes vary significantly. It provides better space utilization and can accommodate different record sizes efficiently within the same blocking scheme.

Related Pages