Cs 450-1 Operating Systems

Дата канвертавання24.04.2016
Памер44.39 Kb.


CS 450-1 Operating Systems

Fall 2002

Matthew Liberati

Stephanie Engel

Kevin Koo

Kyu Oh

Table of Contents

Introduction 2

OS/2 Command Language 2

Graphical User Interface 3

Process Control Block 4

Hardware Platform 6

Synchronization Mechanisms 7

Scheduling 7

Deadlock 8

Processor Support 8

Single-User, Multitasking, Multithreading 8
Characteristics 9

History of OS/2 9

Today OS/2 11

Conclusion 11

Bibliography 12

OS/2 is a very complex advanced operating system. Many of the original ideas developed in the early versions of OS/2 are still being used by more popular operating systems today. This paper presents an overview of some of the common techniques used by the operating system and a brief history of the operating system.
OS/2 Command Language (Shell Script)

Using OS/2 without the Workplace Shell

To use OS/2 without loading the Workplace Shell, replace the following line in your CONFIG.SYS




where is the letter of the drive on which OS/2 is located.

Note that you can always invoke the Workplace Shell by typing PMSHELL at an OS/2 command line. It can consequently be removed by closing it from the Window List.

Booting OS/2 in full-screen mode

You can boot OS/2 in full-screen mode, and still retain Presentation Manager support for multiple sessions:

  1. Change:


in your CONFIG.SYS file to:


where is the drive on which OS/2 resides.

  1. Create the file STARTUP.CMD in your OS/2 boot drive's root directory. STARTUP.CMD should contain the following lines:




Viewing *.inf files more conveniently

There are two tips to make viewing OS/2 *.inf files more convenient:
1. Put several INF files together using a plus sign. On the command line (or 'Parameters' field of the settings notebook), enter something such as:


The pathnames aren't necessary if the file is in a directory specified by the HELP environmental variable.

2. You can assign the book names to an environmental variable:


and execute VIEW.EXE using the variable name (e.g., VIEW FILE).

Disabling use of the floppy drives

To prevent users from using the floppy drives under OS/2, such as in a workstation situation:

Remove the following line from your CONFIG.SYS:


Where x is 1 for ISA and EISA, or 2 for Microchannel.

Rebooting from the command line

To reboot OS/2 down from the command line, type


Note: the above only works with Boot Manager installed.



where is the letter of the drive or partition to which you wish to boot

Graphical User Interface
OS/2 was originally written for the 286. The 286 had introduced what Intel called "protected" memory and the ability to write programs beyond the 640K barriers, but it did so in a way that sometimes made it incompatible with existing 8088/8086 based software. IBM realized the problems inherent in the real-mode DOS architecture and worked on solutions throughout early and mid-80's. The first version of OS/2 was released in late 1987. From some angles OS/2 strongly resembled DOS and from others it didn't look like DOS at all. The command line interface of OS/2 1.0 looked a lot like DOS. OS/2 1.0 was indeed a radical departure from DOS and had a number of important features that DOS could never have - and which many other operating systems began to support only many years later.

  • Preemptive multitasking.

  • Multithreading.

  • Interprocess communication (IPC) features such as shared memory, pipes, queues and semaphores.

  • Virtual memory support (swapping) - theoretically up to 1GB virtual memory.

  • Fully protected operation.

  • Dynamic linking (DLLs).

  • Support for 16MB physical memory.

Perhaps the worst obstacle that the designers of OS/2 faced was DOS support. This was caused by a combination of several factors:

  • No support for virtualization of real mode on the 286 processor.

  • Seriously incomplete DOS API forcing applications to access hardware directly.

  • Memory constraints of real mode.

OS/2 Warp 4.0 (codename "Merlin") was released in August, 1996. Its new features included a "beautified" GUI; an ex-Apple programmer designed the new graphical icons and “widgets”. The beauty was much more than skin deep, however. Also included were OpenGL support, OpenDoc support, and a full Java Development Kit, which included a Java Virtual Machine, which allows Java applications to be run independent of a browser. For high-end systems, the included VoiceType Dictation system allowed users to navigate their computer and dictate text to their computer without ever touching a keyboard or mouse. OS/2 Warp 4 is fully Object Oriented via SOM and the base concept of Object Orientness is that everything is built on the same code. This means that all of the objects resemble the way the other objects function too. In OS/2 this also translates into drag and drop. OS/2 Warp 4 is faster than WinNT, more stable than Win95, easier to use than both WinNT and Win95, it is safe proven technology, it runs practically all of your DOS and Windows 3.1 programs, including most games, and it is based on the best open (i.e.: non-proprietary) standards and some not found out-of-the-box in any other Operating Systems yet (VoiceType, Java Virtual Machine, OpenDOC, OpenGL, MPEG, QuickTime and SOM). OS/2 also pre-emptively multitasks all sessions (including DOS/Win), and is also one of the best multitasker in general. It can take quite a high load without slowing down.

Detailed structure of Process Control Block

  • Portability: run not just on Intel machines but on a variety

of hardware platforms

  • Layered approach:

  • HAL: maps between generic hardware commands and responses and those unique to a specific platform. It isolates the OS from platform specific hardware differences.

  • Microkernel: consists of the most used and most fundamental components of the OS. The kernel manages thread scheduling, process switching, exception and interrupt handling, and multiprocessor synchronization.

  • Device drivers: include both file system and hardware device drivers that translate user I/O functions into hardware specific device I/O requests.

  • W2K Executive: includes modules for specific system functions and provides an API for user-mode software.

  • Some of the modules:

    • I/O manager: provides a framework through which I/O devices are accessible to applications, and is responsible for dispatching to the appropriate device drivers.

    • Object manager: creates, manages and deletes W2K Executive objects and abstract data types that are used to represent resources such as processes, threads, and synchronization objects.

    • Security reference monitor: enforces access-validation and audit-generation rules.

    • Process/thread manager: creates and deletes objects and track process and threads.

    • LPC facility: enforces a client server relationship between applications and executive subsystems within a single system.

  • User Processes

    • Special system support processes: include services not provided as part of the W2K OS, such as the logon process and the session manager.

    • Server processes: Other W2K services such as the event logger.

    • Environment subsystems: expose the native W2K services to user applications and thus provide an OS environment.

    • User applications: Win32, Posix, OS/2, Windows 3.1 or MSDOS.

  • Client/server model: the Executive, the subsystems and the applications are structured using this model.

  • Each environment subsystem and executive service subsystem is implemented as one or more processes.

  • Each process waits for a request from a client for one of its services. Clients, which can be an application program or another OS module, request a service by sending a message.

  • The message is routed through the Executive to the appropriate server. The server performs the requested operation and returns the results or status information by means of another message, which is routed back to the client.

  • Threads and SMP:

  • OS routines can run on any available processor, and different routines can execute simultaneously on different processors.

  • W2k supports the use of multiple threads execution within a single process. Multiple threads within the same process may execute on different processors simultaneously.

  • Server processes may use multiple threads to process requests from more than one client simultaneously.

  • Mechanisms for sharing data and resources between processes.

  • Object-oriented design: facilitates the sharing of resources and data among processes and the protection of resources from unauthorized access.

Hardware Platform

OS/2 is a hybrid system containing internal components that run in both 16-bit and 32-bit modes. Applications can run in either mode. Requests are translated between 16 and 32 bit forms as needed.

A native OS/2 program runs without privileges in its own address space. It requests services by calling routines supplied in DLL modules. System and I/O requests are passed to the kernel and device drivers, while database and communication requests are often passed through a "pipe" to other programs running in the background.

A program written to run in the 32-bit mode of OS/2 will be portable to the PowerPC, where the operating system will supply a set of DLL's that duplicate OS/2 services. Even so, there are relatively few programs written as native OS/2 applications. A DOS or Windows program runs under OS/2 in a virtual machine. It requests services by making standard DOS or BIOS calls or by directly manipulating virtual devices. Loading VDD modules during OS/2 initialization can extend the set of virtual devices. Some OS/2 VDDs mediate between many users and a shared display, sound card, or print spool. Some acquire exclusive use of a device and pass through all the DOS operations to the real hardware. Some VDDs emulate no real hardware, but provide a conduit for DOS program requests to more complex database, communication, or file services supplied by the external OS/2 system.

Synchronization Mechanisms
A semaphore is a flag variable that displays whether a resource is being used or not. If the resource is being used by another process the semaphore alerts other processes that the resource is currently occupied. The two settings the semaphore has are wait and signal. However, sometimes processes must wait for long periods of time. This occurs when another process is in its critical section and cannot give control to another process. Another name for this phenomena is called spinlock.
In OS/2, this problem is fixed by having processes that are waiting block themselves. This allows the CPU scheduler to select another process instead of waiting which increases the overall efficiency of the computer system. After being blocked, a process is eventually changed to the ready state and placed back in the CPU queue for another attempt at execution.
In OS/2 There are three main types of semaphores. Each type of semaphore has the same general type of commands. These commands include creation, addition, deletion, open, release, reset and query. The three types of semaphores are called event, mutex, and muxwait semaphores respectively. Event semaphores only contain links to a single thread. Mutex semaphores are linked to multiple threads. Using mutex, several threads can be given an order of execution. For example, a piece of code can be written to not allow a second thread to execute until the first thread is done executing. Muxwait semaphores are linked to several threads and are only released when the mutex semaphores are no longer connected to threads. This is an attempt to prevent deadlocking by not allowing new semaphores to connect to threads until the original threads are done processing.
Scheduling on OS/2 allows for the seamless completion of multiple tasks. This is done by switching the CPU to different processes when the current process is idle or waiting for I/O or hardware. Whenever a process becomes idle, a new process is selected for execution by the short term CPU scheduler. It is very interesting to note that OS/2 was the first operating system to provide any support for multitasking at all. The original operating system of OS/2 was 16 bit and a more recent version of OS/2 was the first operating system to support 32 bit.
OS/2 uses preemptive scheduling that is priority based to provide run time to the most critical thread. The threads are stored in a queue while waiting to be processed. If no threads are ready in the queue, the idle process executes. The idle process typically runs anywhere from 80-99% of the time on most machines running the OS/2 operating system.
Threads have their priority changed based on the length of their wait and what they are waiting for. An I/O wait would get a large priority boost while a CPU wait would get a lower priority boost. Threads and processes involved in the current window selected by the user also would receive a priority boost.
The potential for deadlock is directly related to the complexity of the operating system. As more and more threads and semaphores are created, the possibility of deadlock increases exponentially. Deadlock occurs in OS/2 whenever a thread is operating in its critical section related to a kernel process. Because the thread is in its critical process, resources are kept to keep the process running and since the thread is located in the kernel, the resource cannot be shared. This is because multiple copies of the kernel cannot be created since the kernel runs the operating system. Because of these idiosyncrasies OS/2, like most other operating systems does nothing about deadlock.

Processor Support

OS/2 Warp provides support for both uniprocessor systems with the ability to upgrade for Symmetric Multiprocessor support. This upgrade creates an operating system capable of running high-speed networks and able to use multiprocessor motherboards to run large servers.

Single-User, Multi-tasking, and Multithreading

OS/2 is a single-user operating system, able to run in text mode, DOS mode, and its GUI interface Presentation Manager (PM).

OS/2 is a step up from DOS, using pre-emptive multi-tasking to schedule CPU time. DOS uses co-operative multi-tasking when switching back and forth between programs that does not prevent programs from possibly hogging the CPU. Many varieties of OS/2 handle symmetric multi-processing (SMP) given multiple CPUs. OS/2 was the first Personal Computer to provide intrinsic multi-tasking, originally designed for the 286 Intel chips and passed on to the 386’s and on. It is the multi-tasking successor to DOS.

Native applications can utilize multi-threading capability, but not legacy applications from DOS or Windows 3.1 unless it is an internal feature to those programs.


OS/2 has interesting features that date from IBMs collaboration with Microsoft in the beginning of its lifecycle.

When running DOS programs OS/2 allows for different AUTOEXEC.BAT files to be set for different DOS windows open. It is then possible to run applications with contradictory requirements and settings.

Lower end versions either require for Windows 3.1 to already be installed on the computer or it includes in itself a re-compiled version.

History of OS/2

Originally IBM and Microsoft worked together to produce OS/2 operating system. In 1987, OS/2 version 1.0 was released for computer with 286 processor or better. It was the first operating system for the personal computer to provide intrinsic multitasking based on hardware support. Version 1.0 was text mode and allowed only one program to be on the screen at a time, but also allowed other programs to be running in the background.

Version 1.1 was released in 1988. In this new version, the graphical user interface called Presentation Manager (PM) was added, which was more user friendly. The GUI allowed users to click on icons with their mouse instead of typing commands.
In 1989 version 1.2 was released. The system’s graphical user interface was significantly improved. After the release of version 1.2 two new versions were underway. One of the two was version 2.0 of OS/2 that IBM was producing. Version 2.0 was to be the first 32-bit operating system for the personal computers requiring 386 processor. Microsoft was developing the second version, which was version 3.0. This version was intended for network server, allowing it to be platform independent due to the user of microkernel.
In 1990, IBM and Microsoft separated and worked independently in their own versions of OS/2. In 1991, IBM released version 1.3 of OS/2. This version was smaller, faster, and more stable than previous versions.
In 1992, OS/2 version 2.0 was released. It was the first 32 bit operating system for personal computers. This version used Virtual DOS Machines (VDMs) allowing OS/2 to run many DOS and Windows programs at the same time. Version 2.0 was also the first operating system to introduce Workplace Shell (WPS), an object oriented user interface (OOUI). OS/2 version 2.1 was released in 1993. This system introduced new 32-bit graphics subsystems. Version 2.1 allowed more CD-ROM and SCSI drivers.
In 1995, OS/2 Warp 3.0 was released only requiring 4MB of RAM to run. Warp 3.0 improved Workplace Shell in performance and functionality. It also added TCP/IP and Internet communications, which allowed peer-to-peer networking and access to network servers.
In 1996, Warp 4.0 was released. The system introduced new features including Java, VoiceType Navigation and Dictation. IBM calls Warp 4.0 the “Universal Client” because of its unparalleled network connectivity.
Screen shot of OS/2 Warp 4

Screen Shot of OS/2 Warp 4

Today OS/2
Today, OS/2 is not common operating systems that are used in personal computer. However OS/2 is still consider one of the most high performance and high end operating system. OS/2 are produced by IBM, which runs on Intel, Cyrix, AMD pentium, and Intel. The current version of OS/2 is version 4.51. The system requires 32 bits and costs around $250. The warp for small to medium scale servers is supported by 80486 pentium hardware.
OS/2 has a rich and vibrant history. Many of the original concepts of OS/2 are still being used by many operating systems today. It is a shame that OS/2 has gone unnoticed by a large segment of the computer-owning population.


Both, David. URL: http://www.os2bbs.com/os2news/OS2History.html

“History of OS/2.” URL: http://www-132.ibm.com/webapp/wcs/stores/
ibm.com United States URL: http://www-132.ibm.com/webapp/wcs/stores/
Masterson, Mark (2000). “Paging Under OS/2.” URL:

“The OS-2 API Project.” URL: http://www.edm2.com/os2api/index.html
“The OS-2 Factbook” URL: http://www.edm2.com//0509/sp2.html
Silberschatz, Abraham, Peter Galvin, Greg Gagne (2002). Operating System Concepts:

Sixth Edition. New York, NY: John Wiley & Sons, Inc.
Smith, Rod URL: http://www.rodsbooks.com/buy-os2/buy-os2.txt

База данных защищена авторским правом ©shkola.of.by 2016
звярнуцца да адміністрацыі

    Галоўная старонка