Misplaced Pages

#145854

58-452: OS/360 included spooling routines, called reader/interpreters and output writers . Each reader/interpreter was "responsible for reading one input job stream" – that is one input device. Likewise each output writer was responsible for controlling one printer or punch . Spooled data were stored in OS temporary datasets controlled by standard OS services. Each reader/interpreter or output writer

116-455: A digital preservation strategy states, "the ideal approach would provide a single extensible , long-term solution that can be designed once and for all and applied uniformly, automatically, and in organized synchrony (for example, at every refresh cycle) to all types of documents and media". He further states that this should not only apply to out of date systems, but also be upwardly mobile to future unknown systems. Practically speaking, when

174-479: A [Commodore] 64 to emulate an IBM PC [which uses MS-DOS], in the same sense that it's possible to bail out Lake Michigan with a teaspoon . Most emulators just emulate a hardware architecture—if operating system firmware or software is required for the desired software, it must be provided as well (and may itself be emulated). Both the OS and the software will then be interpreted by the emulator, rather than being run by native hardware. Apart from this interpreter for

232-523: A certain application is released in a new version, rather than address compatibility issues and migration for every digital object created in the previous version of that application , one could create an emulator for the application , allowing access to all of said digital objects. Because of its primary use of digital formats, new media art relies heavily on emulation as a preservation strategy. Artists such as Cory Arcangel specialize in resurrecting obsolete technologies in their artwork and recognize

290-483: A closer connection to the authenticity of the digital object, operating system, or even gaming platform. Emulation addresses the original hardware and software environment of the digital object, and recreates it on a current machine. The emulator allows the user to have access to any kind of application or operating system on a current platform , while the software runs as it did in its original environment. Jeffery Rothenberg, an early proponent of emulation as

348-556: A digital circuit such as a processor. This is done after a digital circuit has been designed in logic equations, but before the circuit is fabricated in hardware. Functional simulation is the use of a computer program to simulate the execution of a second computer program written in symbolic assembly language or compiler language, rather than in binary machine code . By using a functional simulator, programmers can execute and trace selected sections of source code to search for programming errors (bugs), without generating binary code. This

406-406: A hardware or microcode assist, while "simulation" referred to pure software emulation. For example, a computer specially built for running programs designed for another architecture is an emulator. In contrast, a simulator could be a program which runs on a PC, so that old Atari games can be simulated on it. Purists continue to insist on this distinction, but currently the term "emulation" often means

464-401: A problem when emulating computers whose processor speed is on the same order of magnitude as the host machine . Until not many years ago, emulation in such situations was considered completely impractical by many . What allowed breaking through this restriction were the advances in dynamic recompilation techniques . Simple a priori translation of emulated program code into code runnable on

522-433: A real HP printer will also run in the non-HP printer emulation and produce equivalent printing. Since at least the 1990s, many video game enthusiasts and hobbyists have used emulators to play classic arcade games from the 1980s using the games' original 1980s machine code and data, which is interpreted by a current-era system, and to emulate old video game consoles (see video game console emulator ). A hardware emulator

580-403: A software implementation. Even in emulators that treat each device as a special case, there is usually a common basic infrastructure for: Emulation is one strategy in pursuit of digital preservation and combating obsolescence . Emulation focuses on recreating an original computer environment, which can be time-consuming and difficult to achieve, but valuable because of its ability to maintain

638-405: A specific machine. The simplest form of a CPU simulator is an interpreter , which is a computer program that follows the execution flow of the emulated program code and, for every machine code instruction encountered, executes operations on the host processor that are semantically equivalent to the original instructions. This is made possible by assigning a variable to each register and flag of

SECTION 10

#1732780096146

696-471: A standard, unified I/O API can, however, rival such simpler models, if well thought-out, and they have the additional advantage of "automatically" providing a plug-in service through which third-party virtual devices can be used within the emulator. A unified I/O API may not necessarily mirror the structure of the real hardware bus: bus design is limited by several electric constraints and a need for hardware concurrency management that can mostly be ignored in

754-410: A variety of 2770/2780/3780 simulators and Multi-leaving implementations for use with HASP and ASP. Some of these vendors incorrectly referred to their products as HASP emulators , but the products were actually terminals that talked to HASP; they did not perform any of the functions of HASP. The RJE console operator could enter a restricted set of HASP Console Operator Commands. These HASP commands were

812-432: A virtual power source, this would be a highly unusual solution. Emulators typically stop at a simulation of the documented hardware specifications and digital logic. Sufficient emulation of some hardware platforms requires extreme accuracy, down to the level of individual clock cycles, undocumented features, unpredictable analog elements, and implementation bugs. This is particularly the case with classic home computers such as

870-679: Is an emulator which takes the form of a hardware device. Examples include the DOS-compatible card installed in some 1990s-era Macintosh computers, such as the Centris 610 or Performa 630 , that allowed them to run personal computer (PC) software programs and field-programmable gate array -based hardware emulators . The Church-Turing thesis implies that theoretically, any operating environment can be emulated within any other environment, assuming memory limitations are ignored. However, in practice, it can be quite difficult, particularly when

928-469: Is distinct from simulating execution of binary code, which is software emulation. The first functional simulator was written by Autonetics about 1960 for testing assembly language programs for later execution in military computer D-17B . This made it possible for flight programs to be written, executed, and tested before D-17B computer hardware had been built. Autonetics also programmed a functional simulator for testing flight programs for later execution in

986-565: Is divided into modules that correspond roughly to the emulated computer's subsystems. Most often, an emulator will be composed of the following modules: Buses are often not emulated, either for reasons of performance or simplicity, and virtual peripherals communicate directly with the CPU or the memory subsystem. It is possible for the memory subsystem emulation to be reduced to simply an array of elements each sized like an emulated word; however, this model fails very quickly as soon as any location in

1044-405: Is important for such applications to be properly emulated. Most emulators do not, as mentioned earlier, emulate the main system bus ; each I/O device is thus often treated as a special case, and no consistent interface for virtual peripherals is provided. This can result in a performance advantage, since each I/O module can be tailored to the characteristics of the emulated device; designs based on

1102-414: Is kept in a code cache , and the original code is not lost or affected; this way, even data segments can be (meaninglessly) translated by the recompiler, resulting in no more than a waste of translation time. Speed may not be desirable as some older games were not designed with the speed of faster computers in mind. A game designed for a 30 MHz PC with a level timer of 300 game seconds might only give

1160-445: Is rare in real emulators for performance reasons (it is generally faster to use a subroutine to do the work of an interrupt). Interpreters are very popular as computer simulators, as they are much simpler to implement than more time-efficient alternative solutions, and their speed is more than adequate for emulating computers of more than roughly a decade ago on modern machines. However, the speed penalty inherent in interpretation can be

1218-406: Is the virtualization of computers as complete hardware platforms, certain logical abstractions of their components, or only the functionality required to run various operating systems . Virtualization hides the physical characteristics of a computing platform from the users, presenting instead an abstract computing platform. At its origins, the software that controlled virtualization was called

SECTION 20

#1732780096146

1276-492: Is these procedures' duty to map every access to the correct location of the correct object. On a base-limit addressing system where memory from address 0 to address ROMSIZE-1 is read-only memory, while the rest is RAM, something along the line of the following procedures would be typical: The CPU simulator is often the most complicated part of an emulator. Many emulators are written using "pre-packaged" CPU simulators, in order to concentrate on good and efficient emulation of

1334-503: The 650 on the 705 . In addition to simulators, IBM had compatibility features on the 709 and 7090 , for which it provided the IBM 709 computer with a program to run legacy programs written for the IBM 704 on the 709 and later on the IBM 7090. This program used the instructions added by the compatibility feature to trap instructions requiring special handling; all other 704 instructions ran

1392-693: The Binary Synchronous Communications (BSC) protocol. HASP II supported IBM terminals such as 2770 , 2780 , 3770 , 3780 , but additionally provided support for multi-leaving communication with intelligent workstations such as the IBM 1130 , IBM System/3 and the System/360 Model 20 . Multi-leaving is "fully synchronous, pseudo-simultaneous, bi-directional transmission of a variable number of data streams between two or more computers utilizing binary-synchronous communications facilities." Third party vendors developed

1450-539: The Commodore 64 , whose software often depends on highly sophisticated low-level programming tricks invented by game programmers and the " demoscene ". In contrast, some other platforms have had very little use of direct hardware addressing, such as an emulator for the PlayStation 4. In these cases, a simple compatibility layer may suffice. This translates system calls for the foreign system into system calls for

1508-486: The Game Boy Advance , saw significant progress toward emulation during their production. This led to an effort by console manufacturers to stop unofficial emulation, but consistent failures such as Sega v. Accolade 977 F.2d 1510 (9th Cir. 1992), Sony Computer Entertainment, Inc. v. Connectix Corporation 203 F.3d 596 (2000), and Sony Computer Entertainment America v. Bleem 214 F.3d 1022 (2000), have had

1566-511: The IBM 3270 or VT100 and many others are no longer produced as physical devices. Instead, software running on modern operating systems simulates a "dumb" terminal and is able to render the graphical and text elements of the host application, send keystrokes and process commands using the appropriate terminal protocol. Some terminal emulation applications include Attachmate Reflection , IBM Personal Communications , and Micro Focus Rumba. Other types of emulators include: Typically, an emulator

1624-601: The IBM Type-III Library . It had a competitor, ASP (Attached Support Processor), which ran on one mainframe and controlled scheduling of other attached mainframes. ASP later became JES3 . In MVS , HASP became JES2, one of two Job Entry Subsystems . It was many years before the HASP labels were removed from the JES2 source, and the messages issued by JES2 are still prefixed with "$ HASP". A modified version of HASP

1682-546: The spool files, communicating with the system operator, and driving multiple communication lines for remote job entry. Hasp was written entirely in System/360 assembler and a typical HASP system might require 86KB of memory, which could be virtual memory on OS/VS systems. Much of what would become JES2 's JECL was a part of HASP. Hasp originally supported IBM Synchronous Transmit-Receive (STR) batch terminals; however, HASP II dropped support for STR and only supported

1740-409: The CPU may slow the system down. If a math coprocessor is not installed or present on the CPU, when the CPU executes any co-processor instruction it will make a determined interrupt (coprocessor not available), calling the math emulator routines. When the instruction is successfully emulated, the program continues executing. Logic simulation is the use of a computer program to simulate the operation of

1798-551: The HASP II V4 shared spool mods were distributed around the world by Mellon Bank. The shared spool Mellon Mods were added to the SHARE distribution process so they could be more widely accessed. The "Mellon Mods" were the base for Jes/2 Multi Access Spool. The program was sometimes referred to under various other names, but there is no indication of IBM ever using them in official documents. The program became classified as part of

Houston Automatic Spooling Priority - Misplaced Pages Continue

1856-572: The Xbox 360, Xbox One, Nintendo 3DS, etc. Generally such emulators make currently impossible claims such as being able to run Xbox One and Xbox 360 games in a single program. As computers and global computer networks continued to advance and emulator developers grew more skilled in their work, the length of time between the commercial release of a console and its successful emulation began to shrink. Fifth generation consoles such as Nintendo 64 , PlayStation and sixth generation handhelds, such as

1914-402: The commands received from the CPU as the original program would. Developers of software for embedded systems or video game consoles often design their software on especially accurate emulators called simulators before trying it on the real hardware. This is so that software can be produced and tested before the final hardware exists in large quantities, so that it can be tested without taking

1972-497: The complete imitation of a machine executing binary code while "simulation" often refers to computer simulation , where a computer program is used to simulate an abstract model. Computer simulation is used in virtually every scientific and engineering domain and Computer Science is no exception, with several projects simulating abstract models of computer systems, such as network simulation , which both practically and semantically differs from network emulation. Hardware virtualization

2030-458: The computer's logical memory does not match physical memory . This clearly is the case whenever the emulated hardware allows for advanced memory management (in which case, the MMU logic can be embedded in the memory emulator, made a module of its own, or sometimes integrated into the CPU simulator). Even if the emulated computer does not feature an MMU, though, there are usually other factors that break

2088-511: The current deck of cards being read. This might have been of use if a card jam made it more sensible to let other jobs go ahead while one or more cards were replaced at a nearby keypunch. HASP job log output provided a summary of the resources used for the job (output appeared in all caps): Punched card input Too Many Requests If you report this error to the Wikimedia System Administrators, please include

2146-411: The design and development of new systems. It eases the development process by providing the ability to detect, recreate and repair flaws in the design even before the system is actually built. It is particularly useful in the design of multi-core systems, where concurrency errors can be very difficult to detect and correct without the controlled environment provided by virtual hardware. This also allows

2204-411: The details below. Request from 172.68.168.150 via cp1114 cp1114, Varnish XID 920738830 Upstream caches: cp1114 int Error: 429, Too Many Requests at Thu, 28 Nov 2024 07:48:16 GMT Emulator In computing , an emulator is hardware or software that enables one computer system (called the host ) to behave like another computer system (called the guest ). An emulator typically enables

2262-582: The development process of "home brew" DIY demos and in the creation of new games for older systems. The Internet has helped in the spread of console emulators, as most - if not all - would be unavailable for sale in retail outlets. Examples of console emulators that have been released in the last few decades are: RPCS3 , Dolphin , Cemu , PCSX2 , PPSSPP , ZSNES , Citra , ePSXe , Project64 , Visual Boy Advance , Nestopia , and Yuzu . Due to their popularity, emulators have been impersonated by malware. Most of these emulators are for video game consoles like

2320-418: The emulated binary machine's language , some other hardware (such as input or output devices) must be provided in virtual form as well; for example, if writing to a specific memory location should influence what is displayed on the screen, then this would need to be emulated. While emulation could, if taken to the extreme, go down to the atomic level, basing its output on a simulation of the actual circuitry from

2378-505: The equivalence between logical and physical memory: many (if not most) architectures offer memory-mapped I/O ; even those that do not often have a block of logical memory mapped to ROM , which means that the memory-array module must be discarded if the read-only nature of ROM is to be emulated. Features such as bank switching or segmentation may also complicate memory emulation. As a result, most emulators implement at least two procedures for writing to and reading from logical memory, and it

Houston Automatic Spooling Priority - Misplaced Pages Continue

2436-433: The exact behavior of the system to be emulated is not documented and has to be deduced through reverse engineering . It also says nothing about timing constraints; if the emulator does not perform as quickly as it did using the original hardware, the software inside the emulation may run much more slowly (possibly triggering timer interrupts that alter behavior). "Can a Commodore 64 emulate MS-DOS ?" Yes, it's possible for

2494-424: The host architecture is usually impossible because of several reasons: Various forms of dynamic recompilation, including the popular Just In Time compiler (JIT) technique, try to circumvent these problems by waiting until the processor control flow jumps into a location containing untranslated code, and only then ("just in time") translates a block of the code into host code that can be executed. The translated code

2552-537: The host system e.g., the Linux compatibility layer used on *BSD to run closed source Linux native software on FreeBSD and NetBSD . For example, while the Nintendo 64 graphic processor was fully programmable, most games used one of a few pre-made programs, which were mostly self-contained and communicated with the game via FIFO ; therefore, many emulators do not emulate the graphic processor at all, but simply interpret

2610-422: The host system to run software or use peripheral devices designed for the guest system. Emulation refers to the ability of a computer program in an electronic device to emulate (or imitate) another program or device. Many printers , for example, are designed to emulate HP LaserJet printers because so much software is written for HP printers. If a non-HP printer emulates an HP printer, any software written for

2668-479: The importance of a decentralized and deinstitutionalized process for the preservation of digital culture. In many cases, the goal of emulation in new media art is to preserve a digital medium so that it can be saved indefinitely and reproduced without error, so that there is no reliance on hardware that ages and becomes obsolete. The paradox is that the emulation and the emulator have to be made to work on future computers. Emulation techniques are commonly used during

2726-401: The military computer D-37C . Video game console emulators are programs that allow a personal computer or video game console to emulate another video game console. They are most often used to play older 1980s to 2000s-era video games on modern personal computers and more contemporary video game consoles. They are also used to translate games into other languages, to modify existing games, and in

2784-634: The opposite effect. According to all legal precedents, emulation is legal within the United States. However, unauthorized distribution of copyrighted code remains illegal, according to both country-specific copyright and international copyright law under the Berne Convention . Under United States law, obtaining a dumped copy of the original machine's BIOS is legal under the ruling Lewis Galoob Toys, Inc. v. Nintendo of America, Inc. , 964 F.2d 965 (9th Cir. 1992) as fair use as long as

2842-416: The player 30 seconds on a 300 MHz PC. Other programs, such as some DOS programs, may not even run on faster computers. Particularly when emulating computers which were "closed-box", in which changes to the core of the system were not typical, software may use techniques that depend on specific characteristics of the computer it ran on (e.g. its CPU's speed) and thus precise control of the speed of emulation

2900-495: The precursor of JES2 's Job Entry Control Language ( JES2 JECL ). Operands were restricted to those from this remote site, hence DJ1-999 (below) would only display typically a few, those still outstanding from the operator's remote site. Some of the HASP RJE Console commands, which could be entered in short (single letter) form, or spelled out, are: A command line "C rm1.rdr" was meant to cancel rather than submit

2958-429: The same on a 7090. The compatibility feature on the 1410 only required setting a console toggle switch, not a support program. In 1963, when microcode was first used to speed up this simulation process, IBM engineers coined the term "emulator" to describe the concept. In the 2000s, it has become common to use the word "emulate" in the context of software. However, before 1980, "emulation" referred only to emulation with

SECTION 50

#1732780096146

3016-488: The shared spool capability for HASP that was used by many mainframe sites. It allowed each HASP system to share a common spool and checkpoint. This enabled workload balancing in a multi-mainframe environment. In HASP II V4, Don Greb and Dave Miko of Mellon Bank moved HASP shared spool to this version. Don Greb of Mellon Bank carried it forward into JES2 multi-access spool (IBM's formal support of HASP in MVS ). Over 350 copies of

3074-410: The simulated CPU. The logic of the simulated CPU can then more or less be directly translated into software algorithms, creating a software re-implementation that basically mirrors the original hardware implementation. The following example illustrates how CPU simulation can be accomplished by an interpreter. In this case, interrupts are checked-for before every instruction executed, though this behavior

3132-686: The software development to take place before the hardware is ready, thus helping to validate design decisions and give a little more control. The word "emulator" was coined in 1963 at IBM during development of the NPL ( IBM System/360 ) product line, using a "new combination of software , microcode , and hardware ". They discovered that simulation using additional instructions implemented in microcode and hardware, instead of software simulation using only standard instructions, to execute programs written for earlier IBM computers dramatically increased simulation speed. Earlier, IBM provided simulators for, e.g.,

3190-415: The time to copy the program to be debugged at a low level and without introducing the side effects of a debugger . In many cases, the simulator is actually produced by the company providing the hardware, which theoretically increases its accuracy. Math co-processor emulators allow programs compiled with math instructions to run on machines that do not have the co-processor installed, but the extra work done by

3248-525: The user obtained a legally purchased copy of the machine. To mitigate this however, several emulators for platforms such as Game Boy Advance are capable of running without a BIOS file, using high-level emulation to simulate BIOS subroutines at a slight cost in emulation accuracy. Terminal emulators are software programs that provide modern computers and devices interactive access to applications running on mainframe computer operating systems or other host systems such as HP-UX or OpenVMS . Terminals such as

3306-824: Was a separate operating system task in its own partition or region. A system with a large number of readers, printers, and punches might have a large number of spooling tasks. HASP was developed by IBM Federal Systems Division contractors at the Lyndon B. Johnson Space Center in Houston . The developers were Tom Simpson and Bob Crabtree. HASP was a program that ran on a mainframe, and performed functions such as: scheduling , control of job flow, spooling and printing/punching. HASP had no support for IBM System/360 Operating System Remote Job Entry , 360S-RC-536, but provided roughly equivalent facilities of its own. In HASP II V3, Roger Fajman, Bill Jones, and Jim Oberthaler of NIH created

3364-505: Was used to provide batch spooling and remote job entry services for the Michigan Terminal System during the late 1960s, 1970s, and 1980s. HASP bypassed most operating system services with code specially tailored for efficiency. HASP operated as a single operating system task and used cooperative multitasking internally to run processors to perform tasks such as running card readers, printers, and punches, managing

#145854