DC/UCF Concepts › Resource Management › Deadlock Detection › DC/UCF System Deadlocks

DC/UCF System Deadlocks

Control blocks

The DC/UCF system uses three control blocks to detect deadlocked tasks:

• Internal event control block (ECB)—Each resource in use by a task is associated with an internal event control block (ECB). The ECB is used when another task must wait for the resource.

  For example, one task may be using a nonconcurrent program. When another task requests the program, the requesting task must wait for the ECB associated with the program to be posted.

• Dispatch control element (DCE)—Each active task is associated with a dispatch control element (DCE). The DCE is used by the dispatcher to determine the status of the task (for example, waiting or ready to run). If the task is waiting for a resource, the DCE points to the ECB associated with the resource.
• Deadlock prevention element (DPE)—When a task must wait for a resource that is in use by one or more other tasks, the system creates one deadlock prevention element (DPE) for each task already using the resource. The DPEs link the DCEs for the tasks to the ECB for the resource.

These structures are used by the deadlock detector to verify that two or more tasks are in a deadlock.

Detecting Deadlocks for DC/UCF System Resources

The following figure illustrates how the system uses control blocks to detect deadlocks.

                                          ┌────────┐                ┌────────┐
Task A is using resource 1.               │  DCE   │                │  DCE   │
                                          │ Task A │                │ Task B │
Task B is using resource 2.               └────────┘                └────────┘
--------------------------------------------------------------------------------

Task A requests resource 2.               ┌────────┐                ┌────────┐
                                          │  DCE   │                │  DCE   │
The system builds an ECB for              │ Task A │                │ Task B │
resource 2 and a DPE linking              └───┬────┘                └───┬────┘
resource 2 to task B.                         │                         │
                                              │                     ┌───▼────┐
Task A waits for resource 2.                  │                     │DPE B-2 │
                                              │                     └───┬────┘
                                              │                         │
                                              │                     ┌───▼────┐
                                              │                     │  ECB   │
                                              └─────────────────────►Resource│
                                                                    │   2    │
                                                                    └────────┘
--------------------------------------------------------------------------------

Task B requests resource 1.               ┌────────┐                ┌────────┐
                                          │  DCE   ├──┐         ┌─ ─┤  DCE   │
The system builds an ECB for              │ Task A │  │         │   │ Task B │
resource 1 and a DPE linking              └───┬────┘  │             └───┬────┘
resource 1 to task A.                         │       │         │       │
                                              │       │                 │
The system checks the ECB for             ┌───▼────┐  │         │   ┌───▼────┐
resource 2 and finds the DPE              │DPE A-1 │  │             │DPE B-2 │
linking resource 2 to task B.             └───┬────┘  │         │   └───┬────┘
                                              │       │                 │
The deadlock detector uses these              │       │         │       │
structures to determine that a            ┌───▼────┐  │             ┌───▼────┐
deadlock has occurred.                    │  ECB   │  │         │   │  ECB   │
                                          │Resource│  └─────────┼───►Resource│
                                          │   1    ◄-- - - - - ─┘   │   2    │
                                          └────────┘                └────────┘

Specifying a DPE Count

The DC/UCF system allocates all DPEs at startup. The number of DPEs is specified by the DPE COUNT parameter of the system generation SYSTEM statement. You can specify an explicit value in this parameter, or you can allow the system generation compiler to calculate the value for you. The compiler calculates the number of DPEs to equal:

• The number of TCEs to be allocated by the system
• Multiplied by 20
• Plus 1 for each physical terminal included in the system definition

Note: For more information about the DPE COUNT parameter, see SYSTEM Statement.

At Runtime

At startup, the system allocates the specified number of DPEs above the 16 Mb line. When an executing CA IDMS system exhausts its primary allocation of DPEs, it creates a secondary allocation in XA storage. The size of the secondary allocation is 25% of the value defined in the SYSTEM statement.

The following considerations apply to specifying the DPE COUNT value:

• For performance, secondary allocations of DPEs should be avoided.
• Specifying too high a value for the DPE COUNT parameter results in wasted space.