CICS uses in-memory resource tables (also called control tables) to know which programs, transactions, files, terminals, and other resources exist and how to use them. The main tables are the PPT (Processing Program Table) for programs and mapsets, the PCT (Program Control Table) for transaction-to-program mapping, the FCT (File Control Table) for files and datasets, the TCT (Terminal Control Table) for terminals and sessions, and the DCT (Destination Control Table) for destinations such as queues. These tables are built from resource definitions (e.g. RDO definitions in the CSD) at CICS startup or when resources are installed online. This page summarizes what each table holds and how it is used.
Think of CICS as an office. The resource tables are like the office directory and filing cabinets. One list (PCT) says "when someone asks for CUST, use the CUSTPGM program." Another list (PPT) says "here is where CUSTPGM lives and how big it is." Another (FCT) says "here are the files we can use and where they are." When you ask CICS to do something, it looks in these lists to find the right program, file, or terminal. The lists are filled from the definitions that the administrator wrote (RDO).
| Table | Purpose |
|---|---|
| PPT (Processing Program Table) | Program and mapset definitions; load address, language, size, use count |
| PCT (Program Control Table) | Transaction ID to program mapping; transaction attributes |
| FCT (File Control Table) | File and dataset definitions; dataset name, record format, open options |
| TCT (Terminal Control Table) | Terminal and session definitions; terminal ID, type, connection |
| DCT (Destination Control Table) | Destination definitions (e.g. queues, transient data); where to send output |
The PPT holds one entry per program (and per mapset) known to the region. Each entry includes the program name, load library and load address (when loaded), language, size, task use count, and attributes such as whether the program is resident or reloadable. When a transaction runs and requests a program (e.g. via LINK or EXEC CICS LOAD), CICS looks up the program in the PPT to load it (if not already loaded) and to manage its lifecycle. Application programs do not reference the PPT directly; CICS APIs use it internally.
The PCT (in CICS documentation often called the transaction definition table) maps each transaction ID to the program that runs when that transaction is invoked. It also stores transaction attributes such as task class, priority, and security. When a user enters a transaction ID (e.g. from a terminal or via an API), CICS looks up the ID in the PCT to find the program to run and the attributes to use. So the PCT is the table that answers "what runs when transaction X is requested?"
The FCT contains entries for each file (and associated dataset) that CICS can access. Each entry defines the logical file name used by the application, the physical dataset name, record format (e.g. fixed, variable), open mode (e.g. input, output, update), and other file attributes. Before an application can OPEN, READ, WRITE, or REWRITE a file, that file must be defined in the FCT. CICS uses the FCT to open datasets and to manage file resources.
The TCT holds entries for terminals (and logical units) connected to or known by the region. Each entry identifies the terminal, its type, and connection information. The Terminal Control Program uses the TCT to route input from terminals to the right task and to manage terminal sessions. In modern setups, "terminals" may be logical (e.g. web or API sessions) rather than physical devices, but the idea is the same: the TCT describes the endpoints that can invoke transactions.
The DCT defines destinations for output: transient data queues, temporary storage, and other destinations. When an application writes to a queue or destination, CICS uses the DCT to resolve the destination name to the actual resource (e.g. a transient data queue or a TS queue). So the DCT is the table that tells CICS where to send data when a destination name is used.
Resource tables are not hand-coded; they are built from resource definitions. With RDO (Resource Definition Online), definitions are stored in the CSD (CICS System Definition) dataset. At CICS initialization, the region can load a set of groups (e.g. from GRPLIST) from the CSD and build the PPT, PCT, FCT, TCT, DCT, and other tables. Alternatively, definitions can be installed into a running region (e.g. CEDA INSTALL) so that new or changed resources appear without a restart. So the persistent configuration is in the CSD; the in-memory tables are the runtime representation used by CICS control programs.
1. Which table maps a transaction ID to the program to run?
2. Where does CICS find the load address of a program?
3. How are resource tables built in a running CICS region?