Misplaced Pages

#312687

73-425: Job processing is divided into several phases to provide parallelism through pipelining . These phases include input processing where jobs are read and interpreted, the execution phase where jobs run, and output processing where job output is printed or stored on DASD . Jobs that are in the same phase of execution are usually said to reside on a particular queue; for example, jobs that are currently executing are on

146-403: A certain point. Amdahl's Law has limitations, including assumptions of fixed workload, neglecting inter-process communication and synchronization overheads, primarily focusing on computational aspect and ignoring extrinsic factors such as data persistence, I/O operations, and memory access overheads. Gustafson's law and Universal Scalability Law give a more realistic assessment of

219-518: A closer integration with Job Management than what RJE had. OS/VS1 went through seven product releases. IBM enhanced OS/VS1 Release 7 with four releases of the IBM OS/VS1 Basic Programming Extensions (BPE), product 5662-257. BPE provides support for new 1980s hardware, such as 3380 Direct Access Storage , and for VM handshaking between VTAM and VM/VTAM Communications Network Application (VCNA). IBM announced

292-555: A combination of both. However, OS/VS1 could, and often did, support interactive applications and users by running IBM's CICS transaction processing monitor as a job within one of its partitions. Installation and modification of OS/VS1 was accomplished via IBM's cumbersome System Generation (SYSGEN) process. OS/VS1 included a replacement for OS/360 RJE. It allowed submission and retrieval of jobs by 2770, 2780 and 3780 terminals and by workstation programs included with OS/VS1 for, e.g., 1130. RES included Remote Terminal Access Method and

365-446: A constant value for large numbers of processing elements. The maximum potential speedup of an overall system can be calculated by Amdahl's law . Amdahl's Law indicates that optimal performance improvement is achieved by balancing enhancements to both parallelizable and non-parallelizable components of a task. Furthermore, it reveals that increasing the number of processors yields diminishing returns, with negligible speedup gains beyond

438-445: A mainstream programming task. In 2012 quad-core processors became standard for desktop computers , while servers have 10+ core processors. From Moore's law it can be predicted that the number of cores per processor will double every 18–24 months. This could mean that after 2020 a typical processor will have dozens or hundreds of cores, however in reality the standard is somewhere in the region of 4 to 16 cores, with some designs having

511-476: A medium-sized work load (for the 1970s) consisting only of batch processing applications, running within a fixed number of operating system partitions via the batch job management system Job Entry Subsystem 1 (JES1) . This was in contrast to OS/VS2 which was intended to handle larger work loads consisting of batch applications, online interactive users (using the Time Sharing Option , or TSO), or

584-574: A mix of performance and efficiency cores (such as ARM's big.LITTLE design) due to thermal and design constraints. An operating system can ensure that different tasks and user programs are run in parallel on the available cores. However, for a serial software program to take full advantage of the multi-core architecture the programmer needs to restructure and parallelize the code. A speed-up of application software runtime will no longer be achieved through frequency scaling, instead programmers will need to parallelize their software code to take advantage of

657-520: A multi-core processor can issue multiple instructions per clock cycle from multiple instruction streams. IBM 's Cell microprocessor , designed for use in the Sony PlayStation 3 , is a prominent multi-core processor. Each core in a multi-core processor can potentially be superscalar as well—that is, on every clock cycle, each core can issue multiple instructions from one thread. Simultaneous multithreading (of which Intel's Hyper-Threading

730-403: A node), or n-dimensional mesh . Parallel computers based on interconnected networks need to have some kind of routing to enable the passing of messages between nodes that are not directly connected. The medium used for communication between the processors is likely to be hierarchical in large multiprocessor machines. Parallel computers can be roughly classified according to the level at which

803-410: A parallel program are often called threads . Some parallel computer architectures use smaller, lightweight versions of threads known as fibers , while others use bigger versions known as processes . However, "threads" is generally accepted as a generic term for subtasks. Threads will often need synchronized access to an object or other resource , for example when they must update a variable that

SECTION 10

#1732772287313

876-543: A pipelined processor is a RISC processor, with five stages: instruction fetch (IF), instruction decode (ID), execute (EX), memory access (MEM), and register write back (WB). The Pentium 4 processor had a 35-stage pipeline. Most modern processors also have multiple execution units . They usually combine this feature with pipelining and thus can issue more than one instruction per clock cycle ( IPC > 1 ). These processors are known as superscalar processors. Superscalar processors differ from multi-core processors in that

949-421: A problem, an algorithm is constructed and implemented as a serial stream of instructions. These instructions are executed on a central processing unit on one computer. Only one instruction may execute at a time—after that instruction is finished, the next one is executed. Parallel computing, on the other hand, uses multiple processing elements simultaneously to solve a problem. This is accomplished by breaking

1022-450: A result from instruction 2. It violates condition 1, and thus introduces a flow dependency. In this example, there are no dependencies between the instructions, so they can all be run in parallel. Bernstein's conditions do not allow memory to be shared between different processes. For that, some means of enforcing an ordering between accesses is necessary, such as semaphores , barriers or some other synchronization method . Subtasks in

1095-471: A result, shared memory computer architectures do not scale as well as distributed memory systems do. Processor–processor and processor–memory communication can be implemented in hardware in several ways, including via shared (either multiported or multiplexed ) memory, a crossbar switch , a shared bus or an interconnect network of a myriad of topologies including star , ring , tree , hypercube , fat hypercube (a hypercube with more than one processor at

1168-512: A separate ASP machine. An uncommon variant, local ASP ( LASP ), was a single large machine with the ASP functions running on the same machine. In the 1970s, a notable installation of ASP was at Princeton University controlling an IBM 360/91 mainframe. In 1973, IBM rewrote ASP and renamed it JES3, supporting MVS only. There was also a JES in OS/VS1 that was often referred to as JES1 . In addition,

1241-412: A single address space ), or distributed memory (in which each processing element has its own local address space). Distributed memory refers to the fact that the memory is logically distributed, but often implies that it is physically distributed as well. Distributed shared memory and memory virtualization combine the two approaches, where the processing element has its own local memory and access to

1314-595: A single machine, while clusters , MPPs , and grids use multiple computers to work on the same task. Specialized parallel computer architectures are sometimes used alongside traditional processors, for accelerating specific tasks. In some cases parallelism is transparent to the programmer, such as in bit-level or instruction-level parallelism, but explicitly parallel algorithms , particularly those that use concurrency, are more difficult to write than sequential ones, because concurrency introduces several new classes of potential software bugs , of which race conditions are

1387-632: A standard part of the system and renamed it Job Entry Subsystem 2 . JES2 was introduced in OS/VS2 in Release 2, also known as MVS , in 1973. It was many years before the HASP labels were removed from the source code, and the messages issued by JES2 are still prefixed with $ HASP . Several JES2 commands continue to support specification of either JES2 or HASP to maintain backwards compatibility . ASP initially stood for Attached Support Processor , and

1460-500: A sufficient amount of memory bandwidth exists. A distributed computer (also known as a distributed memory multiprocessor) is a distributed memory computer system in which the processing elements are connected by a network. Distributed computers are highly scalable. The terms " concurrent computing ", "parallel computing", and "distributed computing" have a lot of overlap, and no clear distinction exists between them. The same system may be characterized both as "parallel" and "distributed";

1533-521: A task independently. On the other hand, concurrency enables a program to deal with multiple tasks even on a single CPU core; the core switches between tasks (i.e. threads ) without necessarily completing each one. A program can have both, neither or a combination of parallelism and concurrency characteristics. Parallel computers can be roughly classified according to the level at which the hardware supports parallelism, with multi-core and multi-processor computers having multiple processing elements within

SECTION 20

#1732772287313

1606-512: A time from multiple threads. A symmetric multiprocessor (SMP) is a computer system with multiple identical processors that share memory and connect via a bus . Bus contention prevents bus architectures from scaling. As a result, SMPs generally do not comprise more than 32 processors. Because of the small size of the processors and the significant reduction in the requirements for bus bandwidth achieved by large caches, such symmetric multiprocessors are extremely cost-effective, provided that

1679-416: Is a programming language construct that allows one thread to take control of a variable and prevent other threads from reading or writing it, until that variable is unlocked. The thread holding the lock is free to execute its critical section (the section of a program that requires exclusive access to some variable), and to unlock the data when it is finished. Therefore, to guarantee correct program execution,

1752-516: Is equivalent to an entirely sequential program. The single-instruction-multiple-data (SIMD) classification is analogous to doing the same operation repeatedly over a large data set. This is commonly done in signal processing applications. Multiple-instruction-single-data (MISD) is a rarely used classification. While computer architectures to deal with this were devised (such as systolic arrays ), few applications that fit this class materialized. Multiple-instruction-multiple-data (MIMD) programs are by far

1825-465: Is known as burst buffer , which is typically built from arrays of non-volatile memory physically distributed across multiple I/O nodes. Computer architectures in which each element of main memory can be accessed with equal latency and bandwidth are known as uniform memory access (UMA) systems. Typically, that can be achieved only by a shared memory system, in which the memory is not physically distributed. A system that does not have this property

1898-429: Is known as a non-uniform memory access (NUMA) architecture. Distributed memory systems have non-uniform memory access. Computer systems make use of caches —small and fast memories located close to the processor which store temporary copies of memory values (nearby in both the physical and logical sense). Parallel computer systems have difficulties with caches that may store the same value in more than one location, with

1971-419: Is shared between them. Without synchronization, the instructions between the two threads may be interleaved in any order. For example, consider the following program: If instruction 1B is executed between 1A and 3A, or if instruction 1A is executed between 1B and 3B, the program will produce incorrect data. This is known as a race condition . The programmer must use a lock to provide mutual exclusion . A lock

2044-429: Is the best known) was an early form of pseudo-multi-coreism. A processor capable of concurrent multithreading includes multiple execution units in the same processing unit—that is it has a superscalar architecture—and can issue multiple instructions per clock cycle from multiple threads. Temporal multithreading on the other hand includes a single execution unit in the same processing unit and can issue one instruction at

2117-529: Is the characteristic of a parallel program that "entirely different calculations can be performed on either the same or different sets of data". This contrasts with data parallelism, where the same calculation is performed on the same or different sets of data. Task parallelism involves the decomposition of a task into sub-tasks and then allocating each sub-task to a processor for execution. The processors would then execute these sub-tasks concurrently and often cooperatively. Task parallelism does not usually scale with

2190-644: The Attached Support Processor ( ASP ). HASP was developed by IBM Federal Systems Division contractors at the Johnson Space Center in Houston . It originally managed job scheduling and print and punch output for a single OS/360 computer. Multi Access Spool capability was added to let peer computers share a common job queue and print/punch output queues. With the introduction of System/370 in 1972, IBM rewrote HASP to become

2263-568: The master ( MSTR ) subsystem, which is built into MVS, can start jobs that run outside of the control of the primary JES, including the Master Scheduler and the primary JES itself. Originally the JCL for the Master subsystem was in an IBM provided load modules, but in current versions of MVS through z/OS, it can be provided as a member of the system parameter library (PARMLIB). Source code

Job Entry Subsystem 2/3 - Misplaced Pages Continue

2336-426: The "strategic" JES, meaning that all future development efforts will be focused on JES2 rather than JES3. IBM has reassured customers that JES3 will continue to be supported until an end-of-support date is announced. In February 2019, IBM announced that z/OS 2.5 (expected to be released in 2021) will be the last version of z/OS to include JES3. In October 2019, Phoenix Software International announced that it had licensed

2409-423: The 1970s until about 1986, speed-up in computer architecture was driven by doubling computer word size —the amount of information the processor can manipulate per cycle. Increasing the word size reduces the number of instructions the processor must execute to perform an operation on variables whose sizes are greater than the length of the word. For example, where an 8-bit processor must add two 16-bit integers ,

2482-520: The JCL existed before execution or that there was a prior step where the dataset was defined as NEW,CATLG. JES2 did not insist on this, allowing the job to run even though it would fail when the step using it failed to find it. OS/360 's batch job processing had limited operational flexibility and performance, which was addressed by two field-developed packages called the Houston Automatic Spooling Priority ( HASP ) and

2555-625: The JES3 source code from IBM and would be taking over its maintenance and enhancement. Parallelism (computing) Parallel computing is a type of computation in which many calculations or processes are carried out simultaneously. Large problems can often be divided into smaller ones, which can then be solved at the same time. There are several different forms of parallel computing: bit-level , instruction-level , data , and task parallelism . Parallelism has long been employed in high-performance computing , but has gained broader interest due to

2628-484: The above program can be rewritten to use locks: One thread will successfully lock variable V, while the other thread will be locked out —unable to proceed until V is unlocked again. This guarantees correct execution of the program. Locks may be necessary to ensure correct program execution when threads must serialize access to resources, but their use can greatly slow a program and may affect its reliability . Locking multiple variables using non-atomic locks introduces

2701-418: The average time per instruction. Maintaining everything else constant, increasing the clock frequency decreases the average time it takes to execute an instruction. An increase in frequency thus decreases runtime for all compute-bound programs. However, power consumption P by a chip is given by the equation P = C × V × F , where C is the capacitance being switched per clock cycle (proportional to

2774-508: The cost of the byte multiplexor channel, and offloading the job scheduling, print, and card handling also offloaded those functions from the larger machines. Increased reliability was another advantage to offset the added hardware cost. One or more main systems could fail or be taken offline for maintenance without taking down the whole complex. ASP was primarily targeted at large government agencies and defense contractors that might have as many as six 360/65s all being scheduled and managed by

2847-444: The costs associated with merging data from multiple processes. Specifically, inter-process communication and synchronization can lead to overheads that are substantially higher—often by two or more orders of magnitude—compared to processing the same data on a single thread. Therefore, the overall improvement should be carefully evaluated. From the advent of very-large-scale integration (VLSI) computer-chip fabrication technology in

2920-560: The design of the 7094 / 7040 Direct Coupled System, using data channel to data channel communication. By attaching an IBM 7040 as a peripheral, processor throughput was more than doubled. In a typical ASP configuration, a small mainframe such as a 360/40 called the support system controlled one or more 360/65 or larger processors called main systems. The computers were connected through selector channels on each host attached to channel-to-channel adapters in an early form of short distance, point-to-point computer networking. ASP required

2993-457: The easiest to parallelize. Michael J. Flynn created one of the earliest classification systems for parallel (and sequential) computers and programs, now known as Flynn's taxonomy . Flynn classified programs and computers by whether they were operating using a single set or multiple sets of instructions, and whether or not those instructions were using a single set or multiple sets of data. The single-instruction-single-data (SISD) classification

Job Entry Subsystem 2/3 - Misplaced Pages Continue

3066-427: The execution queue. To improve I/O efficiency, JES performs spooling , which provides multiple jobs with simultaneous access to a common storage volume. JES uses a structure called a checkpoint to backup information about currently executing jobs and their associated output. The checkpoint can be used to restore jobs and output in the event of unexpected hardware or software failures. Although JES2 and JES3 provide

3139-547: The hardware supports parallelism. This classification is broadly analogous to the distance between basic computing nodes. These are not mutually exclusive; for example, clusters of symmetric multiprocessors are relatively common. A multi-core processor is a processor that includes multiple processing units (called "cores") on the same chip. This processor differs from a superscalar processor, which includes multiple execution units and can issue multiple instructions per clock cycle from one instruction stream (thread); in contrast,

3212-454: The increasing computing power of multicore architectures. Main article: Amdahl's law Optimally, the speedup from parallelization would be linear—doubling the number of processing elements should halve the runtime, and doubling it a second time should again halve the runtime. However, very few parallel algorithms achieve optimal speedup. Most of them have a near-linear speedup for small numbers of processing elements, which flattens out into

3285-608: The introduction of 32-bit processors, which has been a standard in general-purpose computing for two decades. Not until the early 2000s, with the advent of x86-64 architectures, did 64-bit processors become commonplace. A computer program is, in essence, a stream of instructions executed by a processor. Without instruction-level parallelism, a processor can only issue less than one instruction per clock cycle ( IPC < 1 ). These processors are known as subscalar processors. These instructions can be re-ordered and combined into groups which are then executed in parallel without changing

3358-549: The last BPE release, OS/VS1 Basic Programming Extensions Release 4, on September 15, 1983, with planned general availability in March 1984. IBM announced the end of functional enhancements to OS/VS1 in 1984. IBM recommended OS/VS1 installations migrate to MVS/370 or MVS/XA . To assist with the migration to MVS/XA , IBM made the VM/XA Migration Aid. It allowed installations to run OS/VS1 and MVS/XA simultaneously on

3431-511: The memory on non-local processors. Accesses to local memory are typically faster than accesses to non-local memory. On the supercomputers , distributed shared memory space can be implemented using the programming model such as PGAS . This model allows processes on one compute node to transparently access the remote memory of another compute node. All compute nodes are also connected to an external shared memory system via high-speed interconnect, such as Infiniband , this external shared memory system

3504-442: The most common type of parallel programs. According to David A. Patterson and John L. Hennessy , "Some machines are hybrids of these categories, of course, but this classic model has survived because it is simple, easy to understand, and gives a good first approximation. It is also—perhaps because of its understandability—the most widely used scheme." Parallel computing can incur significant overhead in practice, primarily due to

3577-498: The most common. Communication and synchronization between the different subtasks are typically some of the greatest obstacles to getting optimal parallel program performance. A theoretical upper bound on the speed-up of a single program as a result of parallelization is given by Amdahl's law , which states that it is limited by the fraction of time for which the parallelization can be utilised. Traditionally, computer software has been written for serial computation . To solve

3650-447: The number of transistors whose inputs change), V is voltage , and F is the processor frequency (cycles per second). Increases in frequency increase the amount of power used in a processor. Increasing processor power consumption led ultimately to Intel 's May 8, 2004 cancellation of its Tejas and Jayhawk processors, which is generally cited as the end of frequency scaling as the dominant computer architecture paradigm. To deal with

3723-461: The operating system. To improve maintainability and serviceability of user-written enhancements, JES provides a set of exit points that pass control from the JES to user programs at key points of processing. These extensions can provide custom functionality such as special commands, custom print page headings, and non-standard job processing. In 2017, IBM released a statement of direction for JES2 to be

SECTION 50

#1732772287313

3796-824: The overhead from resource contention or communication dominates the time spent on other computation, further parallelization (that is, splitting the workload over even more threads) increases rather than decreases the amount of time required to finish. This problem, known as parallel slowdown , can be improved in some cases by software analysis and redesign. Applications are often classified according to how often their subtasks need to synchronize or communicate with each other. An application exhibits fine-grained parallelism if its subtasks must communicate many times per second; it exhibits coarse-grained parallelism if they do not communicate many times per second, and it exhibits embarrassing parallelism if they rarely or never have to communicate. Embarrassingly parallel applications are considered

3869-589: The parallel performance. Understanding data dependencies is fundamental in implementing parallel algorithms . No program can run more quickly than the longest chain of dependent calculations (known as the critical path ), since calculations that depend upon prior calculations in the chain must be executed in order. However, most algorithms do not consist of just a long chain of dependent calculations; there are usually opportunities to execute independent calculations in parallel. Let P i and P j be two program segments. Bernstein's conditions describe when

3942-441: The physical constraints preventing frequency scaling . As power consumption (and consequently heat generation) by computers has become a concern in recent years, parallel computing has become the dominant paradigm in computer architecture , mainly in the form of multi-core processors . In computer science , parallelism and concurrency are two different things: a parallel program uses multiple CPU cores , each core performing

4015-452: The possibility of incorrect program execution. These computers require a cache coherency system, which keeps track of cached values and strategically purges them, thus ensuring correct program execution. Bus snooping is one of the most common methods for keeping track of which values are being accessed (and thus should be purged). Designing large, high-performance cache coherence systems is a very difficult problem in computer architecture. As

4088-495: The possibility of program deadlock . An atomic lock locks multiple variables all at once. If it cannot lock all of them, it does not lock any of them. If two threads each need to lock the same two variables using non-atomic locks, it is possible that one thread will lock one of them and the second thread will lock the second variable. In such a case, neither thread can complete, and deadlock results. Many parallel programs require that their subtasks act in synchrony . This requires

4161-404: The problem into independent parts so that each processing element can execute its part of the algorithm simultaneously with the others. The processing elements can be diverse and include resources such as a single computer with multiple processors, several networked computers, specialized hardware, or any combination of the above. Historically parallel computing was used for scientific computing and

4234-462: The problem of power consumption and overheating the major central processing unit (CPU or processor) manufacturers started to produce power efficient processors with multiple cores. The core is the computing unit of the processor and in multi-core processors each core is independent and can access the same memory concurrently. Multi-core processors have brought parallel computing to desktop computers . Thus parallelization of serial programs has become

4307-564: The processor must first add the 8 lower-order bits from each integer using the standard addition instruction, then add the 8 higher-order bits using an add-with-carry instruction and the carry bit from the lower order addition; thus, an 8-bit processor requires two instructions to complete a single operation, where a 16-bit processor would be able to complete the operation with a single instruction. Historically, 4-bit microprocessors were replaced with 8-bit, then 16-bit, then 32-bit microprocessors. This trend generally came to an end with

4380-568: The processors in a typical distributed system run concurrently in parallel. OS/VS1 Operating System/Virtual Storage 1 , or OS/VS1 , is a discontinued IBM mainframe computer operating system designed to be run on IBM System/370 hardware. It was the successor to the Multiprogramming with a Fixed number of Tasks (MFT) option of System/360 's operating system OS/360 . OS/VS1, in comparison to its predecessor, supported virtual memory (then called virtual storage ). OS/VS1

4453-456: The purchase of an additional computer to manage input and output of the hosts running the job workload, which was economically justified by the high cost of standalone byte-multiplexor channels needed to drive printers and punched card reader devices; the 360/50 and smaller systems had a built-in byte multiplexor channel, whereas the faster 360/65 and larger systems required a relatively expensive standalone unit. Using ASP made it possible to avoid

SECTION 60

#1732772287313

4526-629: The result of the program. This is known as instruction-level parallelism. Advances in instruction-level parallelism dominated computer architecture from the mid-1980s until the mid-1990s. All modern processors have multi-stage instruction pipelines . Each stage in the pipeline corresponds to a different action the processor performs on that instruction in that stage; a processor with an N -stage pipeline can have up to N different instructions at different stages of completion and thus can issue one instruction per clock cycle ( IPC = 1 ). These processors are known as scalar processors. The canonical example of

4599-434: The same core functionality, there are certain features that may be present in one JES but not the other. Because of these differences, one JES may be favored over the other in certain customer installations. JCL is used to define jobs to both JES2 and JES3, but small changes usually need to be made to the JCL to get a job written for one JES to run on the other. A common issue was that JES3 checked that all datasets listed in

4672-434: The same machine, as guests of a third system – VM/XA . This way, the new MVS/XA system could be tested while the old production OS/VS1 system was still in use. On January 24, 1989, IBM announced the intention to withdraw OS/VS1 and OS/VS1 BPE from marketing effective April 24, 1989, and to discontinue service effective February 28, 1990. Although IBM's Time Sharing Option (TSO) required VS2, customers with

4745-449: The second segment produces a variable needed by the first segment. The third and final condition represents an output dependency: when two segments write to the same location, the result comes from the logically last executed segment. Consider the following functions, which demonstrate several kinds of dependencies: In this example, instruction 3 cannot be executed before (or even in parallel with) instruction 2, because instruction 3 uses

4818-473: The several execution units are not entire processors (i.e. processing units). Instructions can be grouped together only if there is no data dependency between them. Scoreboarding and the Tomasulo algorithm (which is similar to scoreboarding but makes use of register renaming ) are two of the most common techniques for implementing out-of-order execution and instruction-level parallelism. Task parallelisms

4891-417: The simulation of scientific problems, particularly in the natural and engineering sciences , such as meteorology . This led to the design of parallel hardware and software, as well as high performance computing . Frequency scaling was the dominant reason for improvements in computer performance from the mid-1980s until 2004. The runtime of a program is equal to the number of instructions multiplied by

4964-432: The size of a problem. Superword level parallelism is a vectorization technique based on loop unrolling and basic block vectorization. It is distinct from loop vectorization algorithms in that it can exploit parallelism of inline code , such as manipulating coordinates, color channels or in loops unrolled by hand. Main memory in a parallel computer is either shared memory (shared between all processing elements in

5037-445: The two are independent and can be executed in parallel. For P i , let I i be all of the input variables and O i the output variables, and likewise for P j . P i and P j are independent if they satisfy Violation of the first condition introduces a flow dependency, corresponding to the first segment producing a result used by the second segment. The second condition represents an anti-dependency, when

5110-576: The use of a barrier . Barriers are typically implemented using a lock or a semaphore . One class of algorithms, known as lock-free and wait-free algorithms , altogether avoids the use of locks and barriers. However, this approach is generally difficult to implement and requires correctly designed data structures. Not all parallelization results in speed-up. Generally, as a task is split up into more and more threads, those threads spend an ever-increasing portion of their time communicating with each other or waiting on each other for access to resources. Once

5183-418: Was developed to provide efficient use of multiple systems with a shared workload. It allowed one central system to distribute jobs to multiple connected systems; ASP could run a mixture of OS/360 , SVS and 7090 emulation on a 360/65 main processor, but only OS/360 and SVS on other S/360 and S/370 models.. ASP was announced in March 1967, and that year was reported to be "running very stably". ASP evolved from

5256-470: Was generally available during the 1970s and 1980s, and it is no longer supported by IBM. OS/VS1 was OS/360 MFT II with a single virtual address space; by comparison, OS/VS2 SVS was OS/360 MVT with a single virtual address space. OS/VS1 was often installed on mid-range IBM mainframe systems, such as the System/370 Model 145 and, later, the System/370 Model 148. OS/VS1 was intended to manage

5329-450: Was provided to IBM customers for both ASP and HASP, and many customers made substantial enhancements to these programs, some of which were incorporated into the official product. Far more installations made use of HASP than ASP, and in contemporary z/OS systems, there are many more JES2 installations than JES3. Because of their unique history, IBM continues to ship JES2 and JES3 source code instead of object code , unlike most components of

#312687