Transaction Processing Facility

z/TPF

Developer| IBM
Written in| z/Architecture Assembly language, C, C++
OS family| z/Architecture assembly language (z/TPF), ESA/390 assembly language (TPF4)
Working state| Current
Source model| Closed source (Source code is available to licensed users with restrictions)
Initial release| 1979; 47 years ago (1979)
|Final release|Latest release}}| 1.1.0.2025[1]
Platforms| IBM System z (z/TPF), ESA/390 (TPF4)
Kernel type| Real-time
Default user interface| 3215 3270
License| Proprietary monthly license charge (MLC)
Official website| z/TPF Product Page
History of IBM mainframe operating systems

Early mainframe computer OSs

* GM OS & GM-NAA I/O (1955)
* BESYS (1957)
* UMES (1958)
* SOS (1959)
* IBSYS (1960)
* CTSS (1961)

Miscellaneous S/360 line OSes

* BOS/360 (1965)
* TOS/360 (1965)
* TSS/360 (1967)
* MTS (1967)
* ORVYL (1967)
* MUSIC (1972)
* MUSIC/SP (1985)

DOS/360 and successors (1966)

* DOS/VS (1972)
* DOS/VSE (1979)
* VSE/SP (1983, 1985)
* VSE/ESA (1991)
* z/VSE (2005)

OS/360 and successors (1966)

* MFT (1966)
* MFT II (1968)
* OS/VS1 (1972)
* OS/VS1 BPE
* MVT (1967)
* 65MP
* OS/VS2R1 (SVS) (1972)
* MVS (OS/VS2R2 and later) (1974)
* MVS/SE (1978)
* MVS/SE 2 (1979)
* MVS/SP Version 1 (1980)
* MVS/XA (1983)
* MVS/ESA (1988)
* OS/390 (1995)
* z/OS (2000)

VM line

* CP-40/CMS (1967)
* CP-67/CMS (1967)
* VP/CSS (1968)
* VM/370 (1972)
* VM/BSE (BSEPP)
* VM/SE (SEPP)
* VM/SP (1980)
* VM/XA MA (1984)
* VM/XA SF (1985)
* VM/XA SP (1988)
* VM/ESA (1990)
* z/VM (2000)

TPF line

* ACP (1967)
* TPF (1979)
* z/TPF (2005)

UNIX and Unix-like

* UTS (1981)
* AIX/370 (1990)
* AIX/ESA (1991)
* MVS/ESA OpenEdition (1993)
* OS/390 UNIX System Services (1996)
* Linux (1999)
* z/OS UNIX System Services (2001)
* OpenSolaris (2008)

* v
* t
* e

Transaction Processing Facility (TPF)[2] is an IBM real-time operating system for mainframe computers descended from the IBM System/360 family, including zSeries and System z9.

TPF delivers fast, high-volume, high-throughput transaction processing, handling large, continuous loads of essentially simple transactions across large, geographically dispersed networks.

While there are other industrial-strength transaction processing systems, notably IBM's own CICS and IMS, TPF's specialty is extreme volume, large numbers of concurrent users, and very fast response times. For example, it handles VISA credit card transaction processing during the peak holiday shopping season.[3][2]

The TPF passenger reservation application PARS, or its international version IPARS, is used by many airlines. PARS is an application program; TPF is an operating system.

One of TPF's major optional components is a high performance, specialized database facility called TPF Database Facility (TPFDF).[4]

A close cousin of TPF, the transaction monitor ALCS, was developed by IBM to integrate TPF services into the more common mainframe operating system MVS, now z/OS.

## Contents

* 1 History
* 2 Users
* 3 Operating environment
* 3.1 Tightly coupled
* 3.2 Loosely coupled
* 3.2.1 Processor shared records
* 3.2.2 Processor unique records
* 4 TPF attributes
* 4.1 What TPF is not
* 4.2 What TPF is
* 4.2.1 Data records
* 4.2.2 Programs and residency
* 4.2.3 Memory usage
* 5 References
* 6 Bibliography
* 7 External links

## History

TPF evolved from the Airline Control Program (ACP), a free package developed in the mid-1960s by IBM in association with major North American and European airlines. In 1979, IBM introduced TPF as a replacement for ACP -- and as a priced software product. The new name suggests its greater scope and evolution into non-airline related entities.

TPF was traditionally an IBM System/370 assembly language environment for performance reasons, and many TPF assembler applications persist. However, more recent versions of TPF encourage the use of C. Another programming language called SabreTalk was born and died on TPF.

IBM announced the delivery of the current release of TPF, dubbed z/TPF V1.1, in September 2005. Most significantly, z/TPF adds 64-bit addressing and mandates use of the 64-bit GNU development tools.[5][6]

The GCC compiler and the DIGNUS Systems/C++ and Systems/C are the only supported compilers for z/TPF. The Dignus compilers offer reduced source code changes when moving from TPF 4.1 to z/TPF.

## Users

Current users include Sabre (reservations), VISA Inc. (authorizations), American Airlines,[7] American Express (authorizations), DXC Technology SHARES (reservations), Amtrak, Marriott International, Travelport (Galileo, Apollo, Worldspan), Citibank, Trenitalia (reservations), Delta Air Lines (reservations and operations) and Japan Airlines.[8]

## Operating environment

### Tightly coupled

Although IBM's 3083 was aimed at running TPF on a "fast... uniprocessor",[9] TPF is capable of running on a multiprocessor, that is, on systems in which there is more than one CPU. Within the LPAR, the CPUs are referred to as instruction streams or simply I-streams. When running on a LPAR with more than one I-stream, TPF is said to be running tightly coupled. TPF adheres to SMP concepts; no concept of NUMA-based distinctions between memory addresses exist.

The depth of the CPU ready list is measured as any incoming transaction is received, and queued for the I-stream with the lowest demand, thus maintaining continuous load balancing among available processors. In cases where loosely coupled configurations are populated by multiprocessor CPCs (Central Processing Complex, i.e. the physical machine packaged in one system cabinet), SMP takes place within the CPC as described here, whereas sharing of inter-CPC resources takes place as described under Loosely coupled, below.

In the TPF architecture, all memory (except for a 4KB-sized prefix area) is shared among all I-streams. In instances where memory-resident data must or should be kept separated by I-stream, the programmer typically allocates a storage area into a number of subsections equal to the number of I-streams, then accesses the desired I-stream associated area by taking the base address of the allocated area, and adding to it the product of the I-stream relative number times the size of each subsection.

### Loosely coupled

TPF is capable of supporting multiple mainframes (of any size themselves — be it single I-stream to multiple I-stream) connecting to and operating on a common database. Currently, 32 IBM mainframes may share the TPF database; if such a system were in operation, it would be called 32-way loosely coupled. The simplest loosely coupled system would be two IBM mainframes sharing one DASD (Direct Access Storage Device). In this case, the control program would be equally loaded into memory and each program or record on DASD could be potentially accessed by either mainframe.

In order to serialize accesses between data records on a loosely coupled system, a practice known as record locking must be used. This means that when one mainframe processor obtains a hold on a record, the mechanism must prevent all other processors from obtaining the same hold and communicate to the requesting processors that they are waiting. Within any tightly coupled system, this is easy to manage between I-streams via the use of the Record Hold Table. However, when the lock is obtained offboard of the TPF processor in the DASD control unit, an external process must be used. Historically, the record locking was accomplished in the DASD control unit via an RPQ known as LLF (Limited Locking Facility) and later ELLF (extended). LLF and ELLF were both replaced by the Multipathing Lock Facility (MPLF). To run clustered (loosely coupled) z/TPF requires either MPLF in all disk control units or an alternative locking device called a Coupling Facility.[10][11]

#### Processor shared records

Records that absolutely must be managed by a record locking process are those which are processor shared. In TPF, most record accesses are done by using record type and ordinal. Given a record type in the TPF system of 'FRED' with 100 records or ordinals, in a processor shared scheme, record type 'FRED' ordinal '5' would resolve to exactly the same file address on DASD — necessitating the use of a record locking mechanism.

All processor shared records on a TPF system will be accessed via the same file address which will resolve to the same location.

#### Processor unique records

A processor unique record is one that is defined such that each processor expected to be in the loosely coupled complex has a record type of 'FRED' and perhaps 100 ordinals. However, if a user on any 2 or more processors examines the file address that record type 'FRED', ordinal '5' resolves to, they will note a different physical address is used.

## TPF attributes

### What TPF is not

TPF is not a general-purpose operating system. TPF's specialized role is to process transaction input messages, then return output messages on a 1:1 basis at extremely high volume with short maximum elapsed time limits.

TPF has no built-in graphical user interface functionality, and TPF has never offered direct graphical display facilities: to implement it on the host would be considered an unnecessary and potentially harmful diversion of real-time system resources. TPF's user interface is command-line driven with simple text display terminals that scroll upward, and there are no mouse-driven cursors, windows, or icons on a TPF Prime CRAS[12] (Computer room agent set -- which is best thought of as the "operator's console"). Character messages are intended to be the mode of communications with human users. All work is accomplished via the use of the command line, similar to UNIX without X. There are several products available which connect to Prime CRAS and provide graphical interface functions to the TPF operator, such as TPF Operations Server.[13] Graphical interfaces for end users, if desired, must be provided by external systems. Such systems perform analysis on character content (see Screen scrape) and convert the message to/from the desired graphical form, depending on its context.

Being a specialized purpose operating system, TPF does not host a compiler/assembler, text editor, nor implement the concept of a desktop as one might expect to find in a general-purpose operating system. TPF application source code is commonly stored in external systems, and likewise built "offline". Starting with z/TPF 1.1, Linux is the supported build platform; executable programs intended for z/TPF operation must observe the ELF format for s390x-ibm-linux.

Using TPF requires a knowledge of its Command Guide[14] since there is no support for an online command "directory" or "man"/help facility to which users might be accustomed. Commands created and shipped by IBM for the system administration of TPF are called "functional messages"—commonly referred to as "Z-messages", as they are all prefixed with the letter "Z". Other letters are reserved so that customers may write their own commands.

TPF implements debugging in a distributed client-server mode, which is necessary because of the system's headless, multi-processing nature: pausing the entire system in order to trap a single task would be highly counterproductive. Debugger packages have been developed by third party vendors who took very different approaches to the "break/continue" operations required at the TPF host, implementing unique communications protocols used in traffic between the human developer running the debugger client and the server-side debug controller, as well as the form and function of debugger program operations at the client side. Two examples of third party debugger packages are Step by Step Trace from Bedford Associates[15] and CMSTPF, TPF/GI, and zTPFGI, all from TPF Software, Inc.[16] Neither package is wholly compatible with the other, nor with IBM's own offering. IBM's debugging client offering is packaged in an IDE called IBM TPF Toolkit.[17]

### What TPF is

TPF is highly optimized to permit messages from the supported network to either be switched out to another location, routed to an application (specific set of programs) or to permit extremely efficient accesses to database records.

#### Data records

Historically, all data on the TPF system had to fit in fixed record (and memory block) sizes of 381, 1055 and 4K bytes. This was due in part to the physical record sizes of blocks located on DASD. Much overhead was saved by freeing up any part of the operating system from breaking large data entities into smaller ones during file operations, and reassembling the same during read operations. Since IBM hardware does I/O via the use of channels and channel programs, TPF would generate very small and efficient channel programs to do its I/O — all in the name of speed. Since the early days also placed a premium on the size of storage media — be it memory or disk, TPF applications evolved into doing very powerful things while using very little resource.

Today, much of these limitations are removed. In fact, only because of legacy support are smaller-than-4K DASD records still used. With the advances made in DASD technology, a read/write of a 4K record is just as efficient as a 1055 byte record. The same advances have increased the capacity of each device so that there is no longer a premium placed on the ability to pack data into the smallest model as possible.

#### Programs and residency

TPF also had its program segments allocated as 381, 1055 and 4K byte-sized records at different points in its history. Each segment consisted of a single record; with a typically comprehensive application requiring perhaps tens or even hundreds of segments. For the first forty years of TPF's history, these segments were never link-edited. Instead, the relocatable object code (direct output from the assembler) was laid out in memory, had its internally (self-referential) relocatable symbols resolved, then the entire image was written to file for later loading into the system. This created a challenging programming environment in which segments related to one another could not directly address each other, with control transfer between them implemented as the ENTER/BACK system service.

In ACP/TPF's earliest days (circa 1965), memory space was severely limited, which gave rise to a distinction between file-resident and core-resident programs—only the most frequently used application programs were written into memory and never removed (core-residency); the rest were stored on file and read in on demand, with their backing memory buffers released post-execution.

The introduction of C language to TPF at version 3.0 was first implemented conformant to segment conventions, including the absence of linkage editing. This scheme quickly demonstrated itself to be impractical for anything other than the simplest of C programs. At TPF 4.1, truly and fully linked load modules were introduced to TPF. These were compiled with the z/OS C/C++ compiler using TPF-specific header files and linked with IEWL, resulting in a z/OS-conformant load module, which in no manner could be considered a traditional TPF segment. The TPF loader was extended to read the z/OS-unique load module file format, then lay out file-resident load modules' sections into memory; meanwhile, assembly language programs remained confined to TPF's segment model, creating an obvious disparity between applications written in assembler and those written in higher level languages (HLL).

At z/TPF 1.1, all source language types were conceptually unified and fully link-edited to conform to the ELF specification. The segment concept became obsolete, meaning that any program written in any source language—including Assembler—may now be of any size. Furthermore, external references became possible, and separate source code programs that had once been segments could now be directly linked together into a shared object. A value point is that critical legacy applications can benefit from improved efficiency through simple repackaging—calls made between members of a single shared object module now have a much shorter pathlength at run time as compared to calling the system's ENTER/BACK service. Members of the same shared object may now share writeable data regions directly thanks to copy-on-write functionality also introduced at z/TPF 1.1; which coincidentally reinforces TPF's reentrancy requirements.

The concepts of file- and memory- residency were also made obsolete, due to a z/TPF design point which sought to have all programs resident in memory at all times.

Since z/TPF had to maintain a call stack for high-level language programs, which gave HLL programs the ability to benefit from stack-based memory allocation, it was deemed beneficial to extend the call stack to assembly language programs on an optional basis, which can ease memory pressure and ease recursive programming.

All z/TPF executable programs are now packaged as ELF shared objects.

#### Memory usage

Historically and in step with the previous, core blocks— memory— were also 381, 1055 and 4 K bytes in size. Since ALL memory blocks had to be of this size, most of the overhead for obtaining memory found in other systems was discarded. The programmer merely needed to decide what size block would fit the need and ask for it. TPF would maintain a list of blocks in use and simply hand out the first block on the available list.

Physical memory was divided into sections reserved for each size so a 1055 byte block always came from a section and returned there, the only overhead needed was to add its address to the appropriate physical block table's list. No compaction or data collection was required.

As applications got more advanced demands for memory increased, and once C became available memory chunks of indeterminate or large size were required. This gave rise to the use of heap storage and some memory management routines. To ease the overhead, TPF memory was broken into frames— 4 KB in size (1 MB with z/TPF). If an application needs a certain number of bytes, the number of contiguous frames required to fill that need are granted.

## References

1. ↑ "z/TPF, z/TPFDF, TPF Operations Server, and TPF Toolkit 4.6 for 2025". IBM. https://www.ibm.com/docs/en/ztpf/2025.
2. ↑ 2.0 2.1 Steve Lohr (October 4, 2004). "IBM Updates Old Workhorse to Use Linux". The New York Times. https://www.nytimes.com/2004/10/04/technology/ibm-updates-old-workhorse-to-use-linux.html.
3. ↑ Michelle Louzoun (August 24, 1987). "Visa Is Everywhere It Wants To Be". InformationWeek: 19.
4. ↑ IBM Corporation. "TPF Database Facility (TPFDF)". https://www-01.ibm.com/software/htp/tpf/pages/prod_df.htm.
5. ↑ "IBM bolsters its mainframe platform". Computerworld. https://www.computerworld.com/article/2326123/ibm-bolsters-its-mainframe-platform.html.
6. ↑ Jennifer Mears. "IBM pumps up Linux virtual machines on mainframe OS". Computerworld. https://www.computerworld.com/article/2543201/ibm-pumps-up-linux-virtual-machines-on-mainframe-os.html.
7. ↑ "TPF Users Group, Job Corner". http://tpfug.org/JobCorner/jobs.htm.
8. ↑ "IBM News room - 2008-04-14 Japan Airlines International to Upgrade Reservation and Ticketing System With IBM Mainframe - United States". 2008-04-14. http://www-03.ibm.com/press/us/en/pressrelease/23914.wss.
9. ↑ Anne & Lynn Wheeler. "IBM 9020 computers used by FAA (was Re: EPO stories (was: HELP IT'S HOT!!!!!))". Newsgroup: alt.folklore.computers.
10. ↑ "IBM Knowledge Center". 2014-10-24. http://publib.boulder.ibm.com/infocenter/zvm/v5r4/index.jsp?topic=/com.ibm.zvm.v54.hcpf2/hcsf9b3153.htm.
11. ↑ "IBM z/Transaction Processing Facility Enterprise Edition V1.1 hardware requirements - United States". http://www-01.ibm.com/support/docview.wss?uid=swg27007957.
12. ↑ IBM Corporation (19 Apr 2018). "z/TPF Glossary". https://www.ibm.com/support/knowledgecenter/SSB23S_1.1.0.15/gtpg3/gtpg3p.html?pos=2.
13. ↑ IBM Corporation (19 April 2018). "IBM TPF Operations Server". https://www.ibm.com/support/knowledgecenter/SSB23S_1.1.0.15/com.ibm.tpfops.doc/kc_tos_welcome.html.
14. ↑ IBM Corporation (29 January 2019). "z/TPF Operations Command Guide". https://www.ibm.com/support/knowledgecenter/SSB23S_1.1.0.15/gtpo1/hfmsgs.html.
15. ↑ Bedford Associates. "Bedford Associates, Inc.". http://www.bedfordit.com/.
16. ↑ TPF Software. "TPF Software, Inc.". http://www.tpfsoftware.com/.
17. ↑ IBM Corporation (Dec 2017). "IBM TPF Toolkit Overview". https://www.ibm.com/us-en/marketplace/ibm-tpf-toolkit.

## Bibliography

* Transaction Processing Facility: A Guide for Application Programmers (Yourdon Press Computing Series) by R. Jason Martin (Hardcover - April 1990), ISBN 978-0139281105

## External links

* z/TPF (IBM)
* TPF User Group (TPF User Group)

* v
* t
* e

Operating systems by IBM

Desktop, workstation|

* PC DOS
* DOS/V
* PC/IX
* AIX
* OS/2
* AOS

Server, mainframe|

* IBSYS
* BOS/360
* TOS/360
* TSS/360
* DOS/360 and successors
* VSE
* OS/360 and successors
* OS/VS1
* SVS
* MVS
* OS/390
* z/OS
* VM line
* ACP
* TPF
* CPF
* System/88 OS
* IBM i
* AIX
* zLinux
* DPCX
* DPPX
* SSP
* SRTOS

Point of sale|

* 4680 OS
* 4690 OS

Projects|

* Taligent
* Workplace OS
* Monterey
* Trillian
* K42

* v
* t
* e

Real-time operating systems (RTOS)

* Comparison of real-time operating systems

Open-source|

* BeRTOS
* ChibiOS/RT
* Contiki
* eCos
* ERIKA Enterprise
* FreeRTOS
* Fuchsia
* FunkOS
* Mynewt OS
* Nano-RK
* NuttX
* RIOT
* RTAI
* RTEMS
* RTLinux
* RT-Thread
* seL4
* TI-RTOS
* TRON
* Wombat OS
* Xenomai
* Zephyr

Proprietary|

* 4690 OS
* DioneOS
* embOS
* Integrity
* Junos OS
* LynxOS
* µC/OS-II
* MQX
* Nucleus RTOS
* OpenComRTOS
* OSE
* OS-9
* OS2000
* PikeOS
* QNX
* REAL/32
* REX OS
* ScreenOS
* ThreadX
* TPF
* VRTX
* VxWorks
* Windows Embedded Compact

Historic|

* 4680 OS
* Concurrent DOS
* DNIX
* DSOS
* EROS
* FlexOS
* MERT/UNIX-RT
* Multiuser DOS
* pSOS
* RMX
* RSX-11
* RT-11
* Sintran III
* Symbian
* THEOS
* UNOS

* Category

* v
* t
* e

Operating systems

General|

* Advocacy
* Comparison
* Forensic engineering
* History
* Hobbyist development
* List
* Timeline
* Usage share

Kernel|

| Architectures|

* Exokernel
* Hybrid
* Microkernel
* Monolithic
* vkernel
* Rump kernel
* Unikernel

|

Components|

* Device driver
* Loadable kernel module
* Microkernel
* User space

Process management|

| Concepts|

* Context switch
* Interrupt
* IPC
* Process
* Process control block
* Real-time
* Thread
* Time-sharing

|

Scheduling
algorithms|

* Computer multitasking
* Fixed-priority preemptive
* Multilevel feedback queue
* Preemptive
* Round-robin
* Shortest job next

Memory management and
resource protection|

* Bus error
* General protection fault
* Memory protection
* Paging
* Protection ring
* Segmentation fault
* Virtual memory

Storage access and
file systems|

* Boot loader
* Defragmentation
* Device file
* File attribute
* Inode
* Journal
* Partition
* Virtual file system
* Virtual tape library

List|

* Acorn
* Arthur
* ARX
* MOS
* RISC iX
* RISC OS
* Amiga Inc.
* AmigaOS
* AmigaOS 1.0-3.9 (Motorola 68000)
* AmigaOS 4 (PowerPC)
* Amiga Unix, a.k.a. Amix
* Amstrad
* AMSDOS
* Contiki
* SymbOS
* Android
* Apple Inc.
* Apple II family
* Apple III
* Apple DOS
* Apple Lisa
* Apple SOS
* Apple Pascal
* ProDOS
* GS/OS
* GNO/ME
* Contiki
* Apple Macintosh
* Classic Mac OS
* A/UX
* Copland
* MkLinux
* Pink
* Rhapsody
* macOS (formerly Mac OS X and OS X)
* macOS Server (formerly Mac OS X Server and OS X Server)
* Apple Network Server
* Apple MessagePad
* Newton OS
* iPhone and iPod Touch
* iOS (formerly iPhone OS)
* iPad
* iPadOS
* Apple Watch
* watchOS
* Apple TV
* tvOS
* Darwin
* iPod
* iPod software (unnamed embedded OS)
* A/ROSE
* Apollo Computer
* Domain/OS
* Atari
* Atari DOS
* Atari TOS
* Atari MultiTOS
* BAE Systems XTS-400
* Be Inc.
* BeOS
* BeIA
* BeOS r5.1d0
* Bell Labs Non-Unix
* BESYS
* Plan 9 from Bell Labs
* Inferno)
* Burroughs Corporation
* Burroughs MCP
* BSD
* Control Data Corporation
* Chippewa Operating System
* Kronos
* NOS (Network Operating System)
* SCOPE)
* Convergent Technologies Operating System
* Cosmos
* Cromemco
* Cromemco DOS
* Cromix
* Data General
* AOS (for 16-bit)
* DG/UX
* RDOS (Real-time DOS)
* Datapoint (CTOS for Z-80)
* DDC-I Inc.
* HeartOS
* Digital Research, Inc.
* CP/M
* CP/M Plus
* CP/M-68K
* CP/M-8000
* CP/M-86
* CP/M-86 Plus
* Concurrent CP/M
* Concurrent CP/M-86
* Concurrent CP/M 8-16
* Concurrent CP/M-68K
* Concurrent DOS
* Concurrent PC DOS
* Concurrent DOS 8-16
* Concurrent DOS 286
* Concurrent DOS XM
* Concurrent DOS 386
* Concurrent DOS 386/MGE
* Concurrent DOS 68K
* DR-DOS
* FlexOS
* FlexOS 186
* FlexOS 286
* FlexOS 68K
* Multiuser DOS
* Datapac Multiuser DOS
* Datapac System Manager, a derivative of Datapac Multiuser DOS
* IMS Multiuser DOS
* MP/M
* MP/M II
* MP/M-86
* MP/M 8-16
* PalmDOS 1.0
* Personal CP/M
* Digital Equipment Corporation
* Batch-11/DOS-11
* OS/8
* RSTS/E
* RSX-11
* RT-11
* TOPS-10
* TOPS-20
* TENEX
* Digital UNIX
* Ultrix
* VMS
* WAITS
* DOS
* ENEA AB OSE
* Fujitsu Towns OS
* General Electric, Honeywell, Bull
* Real-Time Multiprogramming Operating System
* GCOS
* Multics
* Genode
* GNU
* Google
* Android
* Chromium OS
* Chrome OS
* Goobuntu
* Fuchsia)
* Green Hills Software
* INTEGRITY
* INTEGRITY-178B
* µ-velOSity
* Haiku
* Harmony
* Heathkit, Zenith Data Systems
* HDOS
* HT-11
* Hewlett-Packare
* HP-UX
* Multi-Programming Executive
* Honeywell CP-6
* Huawei Harmony OS
* Intel Corporation
* ISIS
* IBM
* Pre-360
* BESYS
* CTSS
* GM OS & GM-NAA I/O
* IBSYS
* SHARE Operating System
* University of Michigan Executive System (UMES)
* OS/360 and successors
* OS/360 and successors
* MVS
* OS/390
* Phoenix/MVS
* z/OS)
* DOS
* DOS/360 and successors on IBM S/360, S/370, and successor mainframes
* BOS/360
* TOS/360
* DOS/VS
* DOS/VSE
* VSE/SP
* VSE/ESA
* z/VSE)
* VM/CMS
* CP/CMS
* CP-40
* CP-67
* VM/370
* VM/XA
* VM/ESA Virtual Machine
* z/VM)
* TPF line
* Airline Control Program ACP
* Transaction Processing Facility)
* Unix-like
* AIX
* UTS (Mainframe UNIX)
* Linux on z Systems
* Others on IBM S/360, S/370, and successor mainframes
* TSS/360
* MUSIC/SP
* ORVYL and WYLBUR
* IBM PC
* PC DOS
* OS/2
* OS/2 Warp
* eComStation)
* Other hardware
* IBM Series 1
* EDX
* RPS
* CPS
* IBM 1130 DM2
* IBM 1800 MPX & TSX
* IBM 8100
* DPCX
* DPPX)
* System 3 DMS
* IBM System 34, 36, 38
* OS/400
* illumos
* IncludeOS
* iOS
* audioOS
* iPadOS
* tvOS
* Linux
* MINIX
* MorphOS
* MUSIC/SP
* Nemesis
* NeXTSTEP
* NOS
* ORVYL
* OS/2
* OS-9
* OSv
* Pick
* QNX
* ReactOS
* RISC OS
* Solaris
* Tandem
* NonStop
* TPF
* TRIPOS
* Unix
* Visi On
* VS/9
* webOS
* Windows
* Xerox 500 series (530 RTB, 560)
* Xinu
* z/OS

Miscellaneous concepts|

* API
* Computer network
* HAL
* Live CD
* Live USB
* OS shell
* CLI
* GUI
* NUI
* TUI
* VUI
* ZUI
* PXE

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Transaction Processing Facility. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Organization:Transaction_Processing_Facility&oldid=4348326"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template