MainframeMaster

COBOL Tutorial

COBOL CHECKPOINT Statement

The CHECKPOINT statement in COBOL provides comprehensive program recovery and restart capabilities for long-running batch processes, critical system operations, and fault-tolerant processing environments. This powerful feature enables automatic program state preservation, sophisticated restart mechanisms, recovery point management, and resilient batch processing architectures that can gracefully handle system failures, power outages, hardware malfunctions, and other unexpected interruptions while maintaining data integrity and processing continuity across complex enterprise computing environments.

Understanding CHECKPOINT Fundamentals

CHECKPOINT creates a recovery point in program execution that captures the current state of program variables, file positions, and processing context. When a program terminates abnormally, the system can use this checkpoint information to restart processing from the last known good state rather than from the beginning.

Core Checkpoint Features:

  • Automatic program state preservation and recovery
  • Configurable checkpoint intervals and triggers
  • File position and data integrity maintenance
  • Resource allocation and memory state capture
  • Transaction boundary coordination and management
  • System-level integration with job control systems
  • Performance optimization for minimal overhead
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
*> Basic CHECKPOINT implementation
DATA DIVISION.
WORKING-STORAGE SECTION.
01  CHECKPOINT-CONTROL.
    05  CHECKPOINT-ID          PIC X(20).
    05  CHECKPOINT-COUNTER     PIC 9(8) VALUE ZERO.
    05  RECORDS-PROCESSED      PIC 9(10) VALUE ZERO.
    05  CHECKPOINT-FREQUENCY   PIC 9(6) VALUE 10000.
    05  LAST-CHECKPOINT-TIME   PIC X(26).
    05  PROCESSING-START-TIME  PIC X(26).
 
01  RESTART-INFORMATION.
    05  RESTART-FLAG           PIC X VALUE 'N'.
        88  RESTARTING         VALUE 'Y'.
    05  RESTART-POINT          PIC 9(10) VALUE ZERO.
    05  RESTART-FILE-POSITION  PIC 9(12) VALUE ZERO.
 
01  FILE-STATUS-TRACKING.
    05  INPUT-FILE-STATUS      PIC XX.
    05  OUTPUT-FILE-STATUS     PIC XX.
    05  CONTROL-FILE-STATUS    PIC XX.
 
PROCEDURE DIVISION.
MAIN-PROCESSING-WITH-CHECKPOINTS.
    PERFORM INITIALIZE-CHECKPOINT-SYSTEM
    PERFORM CHECK-FOR-RESTART-CONDITION
    PERFORM MAIN-PROCESSING-LOOP
    PERFORM FINALIZE-CHECKPOINT-PROCESSING.
 
INITIALIZE-CHECKPOINT-SYSTEM.
    MOVE FUNCTION CURRENT-DATE TO PROCESSING-START-TIME
    MOVE ZERO TO CHECKPOINT-COUNTER RECORDS-PROCESSED
    
    *> Check if this is a restart
    CALL 'CHECK-RESTART-STATUS' USING RESTART-INFORMATION
    
    IF RESTARTING
        DISPLAY "=== RESTART DETECTED ==="
        DISPLAY "Restarting from checkpoint: " RESTART-POINT
        MOVE RESTART-POINT TO RECORDS-PROCESSED
        PERFORM RESTORE-FILE-POSITIONS
    ELSE
        DISPLAY "=== NORMAL START ==="
        DISPLAY "Beginning fresh processing run"
    END-IF.
 
MAIN-PROCESSING-LOOP.
    PERFORM UNTIL END-OF-INPUT-FILE
        PERFORM READ-AND-PROCESS-RECORD
        
        *> Check if checkpoint is needed
        IF FUNCTION MOD(RECORDS-PROCESSED, CHECKPOINT-FREQUENCY) = ZERO
            PERFORM CREATE-CHECKPOINT
        END-IF
    END-PERFORM.
 
READ-AND-PROCESS-RECORD.
    READ INPUT-FILE INTO WS-INPUT-RECORD
    AT END
        SET END-OF-INPUT-FILE TO TRUE
    NOT AT END
        PERFORM VALIDATE-INPUT-RECORD
        PERFORM TRANSFORM-RECORD-DATA
        PERFORM WRITE-OUTPUT-RECORD
        ADD 1 TO RECORDS-PROCESSED
        
        *> Display progress every 1000 records
        IF FUNCTION MOD(RECORDS-PROCESSED, 1000) = ZERO
            DISPLAY "Processed " RECORDS-PROCESSED " records"
        END-IF
    END-READ.
 
CREATE-CHECKPOINT.
    ADD 1 TO CHECKPOINT-COUNTER
    MOVE FUNCTION CURRENT-DATE TO LAST-CHECKPOINT-TIME
    
    *> Create unique checkpoint identifier
    STRING "CKPT-" FUNCTION CURRENT-DATE(1:8) "-" 
           FUNCTION CURRENT-DATE(9:6) "-" CHECKPOINT-COUNTER
        DELIMITED BY SIZE INTO CHECKPOINT-ID
    END-STRING
    
    DISPLAY "Creating checkpoint: " CHECKPOINT-ID
    DISPLAY "Records processed: " RECORDS-PROCESSED
    DISPLAY "Checkpoint time: " LAST-CHECKPOINT-TIME
    
    *> Issue the CHECKPOINT statement
    CHECKPOINT CHECKPOINT-ID
    
    *> Log checkpoint creation
    PERFORM LOG-CHECKPOINT-CREATION.
 
LOG-CHECKPOINT-CREATION.
    DISPLAY "=== CHECKPOINT CREATED ==="
    DISPLAY "Checkpoint ID: " CHECKPOINT-ID
    DISPLAY "Checkpoint Number: " CHECKPOINT-COUNTER
    DISPLAY "Records Processed: " RECORDS-PROCESSED
    DISPLAY "Timestamp: " LAST-CHECKPOINT-TIME
    DISPLAY "Processing Rate: " 
        FUNCTION NUMVAL(RECORDS-PROCESSED) / CHECKPOINT-COUNTER
        " records per checkpoint"
    DISPLAY "==============================".

Advanced Checkpoint Strategies

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
*> Advanced checkpoint management with multiple recovery levels
DATA DIVISION.
WORKING-STORAGE SECTION.
01  ADVANCED-CHECKPOINT-CONTROL.
    05  MAJOR-CHECKPOINT-ID    PIC X(30).
    05  MINOR-CHECKPOINT-ID    PIC X(30).
    05  CHECKPOINT-LEVEL       PIC 9 VALUE 1.
        88  MINOR-CHECKPOINT   VALUE 1.
        88  MAJOR-CHECKPOINT   VALUE 2.
        88  CRITICAL-CHECKPOINT VALUE 3.
    05  CHECKPOINT-STRATEGY    PIC X(10) VALUE "ADAPTIVE".
        88  FIXED-INTERVAL     VALUE "FIXED".
        88  ADAPTIVE-INTERVAL  VALUE "ADAPTIVE".
        88  ERROR-TRIGGERED    VALUE "ERROR".
 
01  CHECKPOINT-METRICS.
    05  TOTAL-CHECKPOINTS      PIC 9(6) VALUE ZERO.
    05  MAJOR-CHECKPOINTS      PIC 9(6) VALUE ZERO.
    05  MINOR-CHECKPOINTS      PIC 9(6) VALUE ZERO.
    05  FAILED-CHECKPOINTS     PIC 9(4) VALUE ZERO.
    05  CHECKPOINT-OVERHEAD    PIC 9(5)V99 VALUE ZERO.
    05  RECOVERY-TIME          PIC 9(5)V99 VALUE ZERO.
 
01  DYNAMIC-CHECKPOINT-CONFIG.
    05  BASE-INTERVAL          PIC 9(6) VALUE 5000.
    05  CURRENT-INTERVAL       PIC 9(6) VALUE 5000.
    05  MAX-INTERVAL           PIC 9(6) VALUE 50000.
    05  MIN-INTERVAL           PIC 9(6) VALUE 1000.
    05  ADJUSTMENT-FACTOR      PIC 9V99 VALUE 1.20.
    05  ERROR-COUNT            PIC 9(4) VALUE ZERO.
    05  PERFORMANCE-THRESHOLD  PIC 9(3)V99 VALUE 95.00.
 
01  CHECKPOINT-STATE-DATA.
    05  BUSINESS-TRANSACTION-ID PIC X(20).
    05  BATCH-NUMBER           PIC 9(8).
    05  PROCESSING-PHASE       PIC X(20).
    05  ERROR-RECOVERY-LEVEL   PIC 9.
    05  DATA-CONSISTENCY-FLAG  PIC X VALUE 'Y'.
        88  DATA-CONSISTENT    VALUE 'Y'.
    05  RESOURCE-LOCKS         OCCURS 10 TIMES PIC X(20).
 
PROCEDURE DIVISION.
ADVANCED-CHECKPOINT-PROCESSING.
    PERFORM INITIALIZE-ADVANCED-CHECKPOINTS
    PERFORM DETERMINE-CHECKPOINT-STRATEGY
    PERFORM EXECUTE-ADAPTIVE-PROCESSING
    PERFORM ANALYZE-CHECKPOINT-PERFORMANCE.
 
INITIALIZE-ADVANCED-CHECKPOINTS.
    MOVE ZERO TO TOTAL-CHECKPOINTS MAJOR-CHECKPOINTS
                 MINOR-CHECKPOINTS FAILED-CHECKPOINTS
                 ERROR-COUNT
    
    MOVE "ADAPTIVE" TO CHECKPOINT-STRATEGY
    MOVE 5000 TO CURRENT-INTERVAL
    
    *> Initialize state tracking
    MOVE FUNCTION CURRENT-DATE(9:8) TO BATCH-NUMBER
    MOVE "INITIALIZATION" TO PROCESSING-PHASE
    MOVE 1 TO ERROR-RECOVERY-LEVEL
    MOVE 'Y' TO DATA-CONSISTENCY-FLAG.
 
DETERMINE-CHECKPOINT-STRATEGY.
    *> Analyze system conditions to optimize checkpoint frequency
    PERFORM EVALUATE-SYSTEM-LOAD
    PERFORM ASSESS-ERROR-RATE
    PERFORM CALCULATE-OPTIMAL-INTERVAL
    
    EVALUATE TRUE
        WHEN SYSTEM-LOAD-HIGH
            MOVE "FIXED" TO CHECKPOINT-STRATEGY
            COMPUTE CURRENT-INTERVAL = BASE-INTERVAL * 2
        WHEN ERROR-RATE-HIGH
            MOVE "ERROR" TO CHECKPOINT-STRATEGY
            COMPUTE CURRENT-INTERVAL = MIN-INTERVAL
        WHEN SYSTEM-STABLE
            MOVE "ADAPTIVE" TO CHECKPOINT-STRATEGY
            MOVE BASE-INTERVAL TO CURRENT-INTERVAL
    END-EVALUATE.
 
EXECUTE-ADAPTIVE-PROCESSING.
    PERFORM VARYING WS-RECORD-NUM FROM 1 BY 1
        UNTIL END-OF-PROCESSING
        
        PERFORM PROCESS-BUSINESS-RECORD
        
        *> Dynamic checkpoint decision
        PERFORM EVALUATE-CHECKPOINT-NEED
        
        IF CHECKPOINT-REQUIRED
            PERFORM DETERMINE-CHECKPOINT-LEVEL
            PERFORM EXECUTE-APPROPRIATE-CHECKPOINT
            PERFORM ADJUST-CHECKPOINT-INTERVAL
        END-IF
        
        *> Monitor for error conditions
        PERFORM MONITOR-ERROR-CONDITIONS
    END-PERFORM.
 
EVALUATE-CHECKPOINT-NEED.
    SET CHECKPOINT-NOT-REQUIRED TO TRUE
    
    *> Check various checkpoint triggers
    IF FUNCTION MOD(WS-RECORD-NUM, CURRENT-INTERVAL) = ZERO
        SET CHECKPOINT-REQUIRED TO TRUE
        SET MINOR-CHECKPOINT TO TRUE
    END-IF
    
    *> Major checkpoint at phase boundaries
    IF PROCESSING-PHASE-CHANGED
        SET CHECKPOINT-REQUIRED TO TRUE
        SET MAJOR-CHECKPOINT TO TRUE
    END-IF
    
    *> Critical checkpoint on error conditions
    IF ERROR-COUNT > 5
        SET CHECKPOINT-REQUIRED TO TRUE
        SET CRITICAL-CHECKPOINT TO TRUE
    END-IF
    
    *> Resource-based checkpoint
    IF MEMORY-USAGE-HIGH OR TRANSACTION-BOUNDARY
        SET CHECKPOINT-REQUIRED TO TRUE
        SET MAJOR-CHECKPOINT TO TRUE
    END-IF.
 
EXECUTE-APPROPRIATE-CHECKPOINT.
    MOVE FUNCTION CURRENT-DATE TO WS-CHECKPOINT-START-TIME
    
    EVALUATE CHECKPOINT-LEVEL
        WHEN 1  *> Minor checkpoint
            PERFORM CREATE-MINOR-CHECKPOINT
        WHEN 2  *> Major checkpoint
            PERFORM CREATE-MAJOR-CHECKPOINT
        WHEN 3  *> Critical checkpoint
            PERFORM CREATE-CRITICAL-CHECKPOINT
    END-EVALUATE
    
    PERFORM MEASURE-CHECKPOINT-OVERHEAD
    ADD 1 TO TOTAL-CHECKPOINTS.
 
CREATE-MINOR-CHECKPOINT.
    STRING "MINOR-" BATCH-NUMBER "-" TOTAL-CHECKPOINTS
        DELIMITED BY SIZE INTO MINOR-CHECKPOINT-ID
    END-STRING
    
    *> Quick checkpoint with minimal state
    CHECKPOINT MINOR-CHECKPOINT-ID
    
    ADD 1 TO MINOR-CHECKPOINTS
    DISPLAY "Minor checkpoint: " MINOR-CHECKPOINT-ID.
 
CREATE-MAJOR-CHECKPOINT.
    STRING "MAJOR-" BATCH-NUMBER "-" TOTAL-CHECKPOINTS
        DELIMITED BY SIZE INTO MAJOR-CHECKPOINT-ID
    END-STRING
    
    *> Comprehensive checkpoint with full state
    PERFORM SAVE-COMPLETE-STATE
    CHECKPOINT MAJOR-CHECKPOINT-ID
    PERFORM VERIFY-CHECKPOINT-INTEGRITY
    
    ADD 1 TO MAJOR-CHECKPOINTS
    DISPLAY "Major checkpoint: " MAJOR-CHECKPOINT-ID.
 
CREATE-CRITICAL-CHECKPOINT.
    STRING "CRITICAL-" BATCH-NUMBER "-" TOTAL-CHECKPOINTS
        DELIMITED BY SIZE INTO MAJOR-CHECKPOINT-ID
    END-STRING
    
    *> Emergency checkpoint with maximum recovery information
    PERFORM SAVE-CRITICAL-STATE
    PERFORM FLUSH-ALL-BUFFERS
    CHECKPOINT MAJOR-CHECKPOINT-ID
    PERFORM VERIFY-CHECKPOINT-INTEGRITY
    PERFORM LOG-CRITICAL-CHECKPOINT
    
    DISPLAY "CRITICAL checkpoint created: " MAJOR-CHECKPOINT-ID.
 
ADJUST-CHECKPOINT-INTERVAL.
    *> Adaptive interval adjustment based on performance
    IF CHECKPOINT-OVERHEAD > PERFORMANCE-THRESHOLD
        *> Increase interval if overhead is too high
        COMPUTE CURRENT-INTERVAL = 
            CURRENT-INTERVAL * ADJUSTMENT-FACTOR
        IF CURRENT-INTERVAL > MAX-INTERVAL
            MOVE MAX-INTERVAL TO CURRENT-INTERVAL
        END-IF
    ELSE
        *> Decrease interval if system can handle more frequent checkpoints
        COMPUTE CURRENT-INTERVAL = 
            CURRENT-INTERVAL / ADJUSTMENT-FACTOR
        IF CURRENT-INTERVAL < MIN-INTERVAL
            MOVE MIN-INTERVAL TO CURRENT-INTERVAL
        END-IF
    END-IF.
 
SAVE-COMPLETE-STATE.
    *> Save all critical program state for major checkpoints
    MOVE BUSINESS-TRANSACTION-ID TO WS-STATE-BUFFER
    MOVE BATCH-NUMBER TO WS-STATE-BUFFER(21:8)
    MOVE PROCESSING-PHASE TO WS-STATE-BUFFER(29:20)
    MOVE ERROR-RECOVERY-LEVEL TO WS-STATE-BUFFER(49:1)
    
    *> Save file positions
    PERFORM SAVE-FILE-POSITIONS
    
    *> Save resource locks
    PERFORM SAVE-RESOURCE-LOCKS.
 
SAVE-CRITICAL-STATE.
    *> Save maximum state information for critical situations
    PERFORM SAVE-COMPLETE-STATE
    PERFORM SAVE-MEMORY-IMAGE
    PERFORM SAVE-TRANSACTION-LOG
    PERFORM SAVE-ERROR-CONTEXT.
 
MEASURE-CHECKPOINT-OVERHEAD.
    MOVE FUNCTION CURRENT-DATE TO WS-CHECKPOINT-END-TIME
    COMPUTE CHECKPOINT-OVERHEAD = 
        WS-CHECKPOINT-END-TIME - WS-CHECKPOINT-START-TIME.
 
ANALYZE-CHECKPOINT-PERFORMANCE.
    DISPLAY "=== CHECKPOINT PERFORMANCE ANALYSIS ==="
    DISPLAY "Total Checkpoints: " TOTAL-CHECKPOINTS
    DISPLAY "Major Checkpoints: " MAJOR-CHECKPOINTS
    DISPLAY "Minor Checkpoints: " MINOR-CHECKPOINTS
    DISPLAY "Failed Checkpoints: " FAILED-CHECKPOINTS
    DISPLAY "Average Overhead: " CHECKPOINT-OVERHEAD "%"
    DISPLAY "Current Interval: " CURRENT-INTERVAL " records"
    
    IF TOTAL-CHECKPOINTS > ZERO
        COMPUTE WS-SUCCESS-RATE = 
            ((TOTAL-CHECKPOINTS - FAILED-CHECKPOINTS) / 
             TOTAL-CHECKPOINTS) * 100
        DISPLAY "Success Rate: " WS-SUCCESS-RATE "%"
    END-IF.

Restart and Recovery Mechanisms

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
*> Comprehensive restart and recovery system
DATA DIVISION.
WORKING-STORAGE SECTION.
01  RESTART-CONTROL-SYSTEM.
    05  RESTART-MODE           PIC X(15) VALUE "AUTOMATIC".
        88  AUTOMATIC-RESTART  VALUE "AUTOMATIC".
        88  MANUAL-RESTART     VALUE "MANUAL".
        88  SELECTIVE-RESTART  VALUE "SELECTIVE".
    05  RESTART-REASON         PIC X(30).
    05  RESTART-TIMESTAMP      PIC X(26).
    05  RECOVERY-LEVEL         PIC 9 VALUE 1.
        88  BASIC-RECOVERY     VALUE 1.
        88  FULL-RECOVERY      VALUE 2.
        88  EMERGENCY-RECOVERY VALUE 3.
 
01  RECOVERY-INFORMATION.
    05  LAST-GOOD-CHECKPOINT   PIC X(30).
    05  RECOVERY-POINT         PIC 9(12).
    05  DATA-INTEGRITY-STATUS  PIC X VALUE 'U'.
        88  DATA-VERIFIED      VALUE 'V'.
        88  DATA-SUSPECT       VALUE 'S'.
        88  DATA-CORRUPTED     VALUE 'C'.
        88  DATA-UNKNOWN       VALUE 'U'.
    05  ROLLBACK-REQUIRED      PIC X VALUE 'N'.
        88  NEEDS-ROLLBACK     VALUE 'Y'.
 
01  RESTART-VALIDATION.
    05  CHECKPOINT-VALIDATION  PIC X VALUE 'N'.
        88  CHECKPOINT-VALID   VALUE 'Y'.
    05  FILE-CONSISTENCY       PIC X VALUE 'N'.
        88  FILES-CONSISTENT   VALUE 'Y'.
    05  RESOURCE-AVAILABILITY  PIC X VALUE 'N'.
        88  RESOURCES-AVAILABLE VALUE 'Y'.
 
01  RECOVERY-STATISTICS.
    05  RESTART-COUNT          PIC 9(4) VALUE ZERO.
    05  SUCCESSFUL-RESTARTS    PIC 9(4) VALUE ZERO.
    05  FAILED-RESTARTS        PIC 9(4) VALUE ZERO.
    05  TOTAL-RECOVERY-TIME    PIC 9(6)V99 VALUE ZERO.
    05  RECORDS-REPROCESSED    PIC 9(10) VALUE ZERO.
 
PROCEDURE DIVISION.
RESTART-AND-RECOVERY-SYSTEM.
    PERFORM DETECT-RESTART-CONDITION
    PERFORM VALIDATE-RESTART-FEASIBILITY
    PERFORM EXECUTE-RECOVERY-PROCESS
    PERFORM RESUME-NORMAL-PROCESSING.
 
DETECT-RESTART-CONDITION.
    *> Check for various restart indicators
    CALL 'CHECK-ABNORMAL-TERMINATION' USING WS-TERMINATION-FLAG
    
    IF ABNORMAL-TERMINATION
        MOVE "ABNORMAL TERMINATION" TO RESTART-REASON
        MOVE "AUTOMATIC" TO RESTART-MODE
        MOVE 2 TO RECOVERY-LEVEL
        DISPLAY "Abnormal termination detected - initiating restart"
    ELSE
        CALL 'CHECK-OPERATOR-RESTART' USING WS-OPERATOR-REQUEST
        IF OPERATOR-RESTART-REQUESTED
            MOVE "OPERATOR REQUEST" TO RESTART-REASON
            MOVE "MANUAL" TO RESTART-MODE
            MOVE 1 TO RECOVERY-LEVEL
            DISPLAY "Operator restart requested"
        END-IF
    END-IF.
 
VALIDATE-RESTART-FEASIBILITY.
    MOVE 'N' TO CHECKPOINT-VALIDATION
                FILE-CONSISTENCY
                RESOURCE-AVAILABILITY
    
    *> Validate last checkpoint
    PERFORM VALIDATE-CHECKPOINT-INTEGRITY
    
    IF CHECKPOINT-VALID
        DISPLAY "Checkpoint validation: PASSED"
        PERFORM VALIDATE-FILE-CONSISTENCY
        
        IF FILES-CONSISTENT
            DISPLAY "File consistency check: PASSED"
            PERFORM CHECK-RESOURCE-AVAILABILITY
            
            IF RESOURCES-AVAILABLE
                DISPLAY "Resource availability: CONFIRMED"
                DISPLAY "Restart validation: COMPLETE"
            ELSE
                DISPLAY "Resource availability: FAILED"
                PERFORM HANDLE-RESOURCE-CONFLICTS
            END-IF
        ELSE
            DISPLAY "File consistency check: FAILED"
            PERFORM HANDLE-FILE-INCONSISTENCY
        END-IF
    ELSE
        DISPLAY "Checkpoint validation: FAILED"
        PERFORM HANDLE-INVALID-CHECKPOINT
    END-IF.
 
EXECUTE-RECOVERY-PROCESS.
    MOVE FUNCTION CURRENT-DATE TO RESTART-TIMESTAMP
    ADD 1 TO RESTART-COUNT
    
    DISPLAY "=== RECOVERY PROCESS INITIATED ==="
    DISPLAY "Restart Mode: " RESTART-MODE
    DISPLAY "Recovery Level: " RECOVERY-LEVEL
    DISPLAY "Restart Reason: " RESTART-REASON
    DISPLAY "Restart Time: " RESTART-TIMESTAMP
    
    EVALUATE RECOVERY-LEVEL
        WHEN 1
            PERFORM BASIC-RECOVERY-PROCESS
        WHEN 2
            PERFORM FULL-RECOVERY-PROCESS
        WHEN 3
            PERFORM EMERGENCY-RECOVERY-PROCESS
    END-EVALUATE.
 
BASIC-RECOVERY-PROCESS.
    DISPLAY "Executing basic recovery process..."
    
    *> Restore from last checkpoint
    PERFORM RESTORE-CHECKPOINT-STATE
    PERFORM REPOSITION-FILES
    PERFORM VERIFY-DATA-INTEGRITY
    
    IF DATA-VERIFIED
        PERFORM RESUME-FROM-CHECKPOINT
        ADD 1 TO SUCCESSFUL-RESTARTS
        DISPLAY "Basic recovery completed successfully"
    ELSE
        DISPLAY "Basic recovery failed - escalating to full recovery"
        MOVE 2 TO RECOVERY-LEVEL
        PERFORM FULL-RECOVERY-PROCESS
    END-IF.
 
FULL-RECOVERY-PROCESS.
    DISPLAY "Executing full recovery process..."
    
    *> Comprehensive recovery with validation
    PERFORM RESTORE-COMPLETE-STATE
    PERFORM REBUILD-INDEXES
    PERFORM VERIFY-TRANSACTION-INTEGRITY
    PERFORM RECONCILE-DATA-SOURCES
    
    IF DATA-VERIFIED AND FILES-CONSISTENT
        PERFORM RESUME-FROM-CHECKPOINT
        ADD 1 TO SUCCESSFUL-RESTARTS
        DISPLAY "Full recovery completed successfully"
    ELSE
        DISPLAY "Full recovery failed - emergency recovery required"
        MOVE 3 TO RECOVERY-LEVEL
        PERFORM EMERGENCY-RECOVERY-PROCESS
    END-IF.
 
EMERGENCY-RECOVERY-PROCESS.
    DISPLAY "Executing emergency recovery process..."
    
    *> Last resort recovery procedures
    PERFORM ASSESS-DATA-DAMAGE
    PERFORM RESTORE-FROM-BACKUP
    PERFORM RECONSTRUCT-MISSING-DATA
    PERFORM MANUAL-INTERVENTION-REQUIRED
    
    IF DATA-INTEGRITY-RESTORED
        PERFORM RESUME-WITH-VALIDATION
        ADD 1 TO SUCCESSFUL-RESTARTS
        DISPLAY "Emergency recovery completed"
    ELSE
        ADD 1 TO FAILED-RESTARTS
        DISPLAY "Emergency recovery failed - manual intervention required"
        PERFORM ESCALATE-TO-OPERATIONS
    END-IF.
 
RESTORE-CHECKPOINT-STATE.
    DISPLAY "Restoring state from checkpoint: " LAST-GOOD-CHECKPOINT
    
    *> Restore program variables
    CALL 'RESTORE-PROGRAM-STATE' USING LAST-GOOD-CHECKPOINT
                                       WS-STATE-BUFFER
    
    *> Restore processing counters
    MOVE WS-STATE-BUFFER(1:10) TO RECOVERY-POINT
    DISPLAY "Recovery point: " RECOVERY-POINT
    
    *> Restore business context
    MOVE WS-STATE-BUFFER(11:20) TO BUSINESS-TRANSACTION-ID
    MOVE WS-STATE-BUFFER(31:8) TO BATCH-NUMBER.
 
REPOSITION-FILES.
    DISPLAY "Repositioning files to checkpoint state..."
    
    *> Reposition input files
    PERFORM RESTORE-INPUT-FILE-POSITION
    PERFORM RESTORE-OUTPUT-FILE-POSITION
    PERFORM RESTORE-CONTROL-FILE-POSITION
    
    *> Verify file positions
    PERFORM VERIFY-FILE-POSITIONS.
 
VERIFY-DATA-INTEGRITY.
    DISPLAY "Verifying data integrity..."
    
    MOVE 'U' TO DATA-INTEGRITY-STATUS
    
    *> Check record counts
    PERFORM VERIFY-RECORD-COUNTS
    
    *> Check data consistency
    PERFORM VERIFY-BUSINESS-RULES
    
    *> Check referential integrity
    PERFORM VERIFY-REFERENTIAL-INTEGRITY
    
    IF ALL-INTEGRITY-CHECKS-PASSED
        MOVE 'V' TO DATA-INTEGRITY-STATUS
        DISPLAY "Data integrity verification: PASSED"
    ELSE
        MOVE 'S' TO DATA-INTEGRITY-STATUS
        DISPLAY "Data integrity verification: SUSPECT"
    END-IF.
 
RESUME-FROM-CHECKPOINT.
    DISPLAY "Resuming processing from checkpoint..."
    
    *> Resume normal processing loop
    MOVE RECOVERY-POINT TO RECORDS-PROCESSED
    DISPLAY "Resuming from record: " RECORDS-PROCESSED
    
    *> Log recovery completion
    PERFORM LOG-SUCCESSFUL-RECOVERY.
 
LOG-SUCCESSFUL-RECOVERY.
    DISPLAY "=== RECOVERY COMPLETED SUCCESSFULLY ==="
    DISPLAY "Restart Count: " RESTART-COUNT
    DISPLAY "Recovery Level: " RECOVERY-LEVEL
    DISPLAY "Recovery Point: " RECOVERY-POINT
    DISPLAY "Records to Reprocess: " RECORDS-REPROCESSED
    DISPLAY "Total Recovery Time: " TOTAL-RECOVERY-TIME " seconds"
    DISPLAY "Success Rate: " 
        (SUCCESSFUL-RESTARTS / RESTART-COUNT) * 100 "%"
    DISPLAY "========================================".

Best Practices and Guidelines

CHECKPOINT Implementation Guidelines:

  • Implement checkpoints for long-running batch processes that process large volumes of data
  • Set checkpoint intervals based on processing time rather than just record counts
  • Include sufficient state information to enable meaningful restart capabilities
  • Test restart scenarios thoroughly in development and staging environments
  • Document checkpoint and restart procedures for operations teams
  • Monitor checkpoint overhead and adjust frequency based on system performance
  • Implement multiple checkpoint levels for different recovery scenarios
  • Coordinate checkpoints with transaction boundaries for data consistency
  • Use adaptive checkpoint strategies based on system conditions and error rates
  • Validate checkpoint integrity before relying on restart capabilities

Comprehensive FAQ

Q: When should I use CHECKPOINT in my COBOL programs?

Use CHECKPOINT in long-running batch programs that process large amounts of data and would be expensive to restart from the beginning. This includes data migration jobs, report generation processes, file conversion utilities, and any process that runs for more than 30 minutes or processes millions of records.

Q: How do I determine the optimal checkpoint frequency?

The optimal frequency depends on several factors: processing time per record, system reliability, recovery time requirements, and checkpoint overhead. Start with checkpoints every 10,000-50,000 records or every 5-10 minutes of processing time, then adjust based on actual performance metrics and recovery requirements.

Q: What information should I include in checkpoint state?

Include record counts, file positions, business transaction identifiers, processing phase indicators, error counts, and any program variables necessary to resume processing. Avoid including large data structures that don't affect restart logic.

Q: How does CHECKPOINT interact with database transactions?

CHECKPOINT should be coordinated with database transaction boundaries. Typically, you would commit database transactions before creating a checkpoint to ensure data consistency. The checkpoint captures the program state after successful transaction commits.

Q: Can I have multiple checkpoint levels?

Yes, many organizations implement minor checkpoints for frequent state saves and major checkpoints with more comprehensive state information. This provides flexibility in recovery scenarios and helps balance performance with recovery capabilities.

Q: What happens if a checkpoint operation fails?

If a checkpoint fails, the program should continue processing while logging the failure. Implement retry logic for transient errors and consider reducing checkpoint frequency if failures persist. Monitor checkpoint success rates and investigate systematic failures.

Interactive Quiz

Test Your CHECKPOINT Knowledge

1. What is the primary purpose of the CHECKPOINT statement?

2. When is the best time to create checkpoints?

3. What factors should influence checkpoint frequency?

Answers: 1-B, 2-B, 3-B