Multiprocessor Operating System Research Articles

Comparative Study: Preemptive Shortest Job First and Round Robin Algorithms

Abstract: Operating system is a software acting as an interface between computer hardware and user. Operating system is known as a resource manager. The main responsibility of operating system is to handle resources of computer system. Scheduling is a key concept in computer multitasking and multiprocessing operating system design by switching the CPU among process. Shortest job first (SJF) and round robin are two wellknown algorithms in CPU processing. For shortest job first, this algorithm can be preemptived. In preemptive shortest job first, when a new process coming in, the process can be interupted. Where with round robin algorithm there will be time slices, context switching, or also called quantum, between process. In this journal we wil discuss comparative study between preemptive shortest job first and round robin algorithms. Three comparative studies will be discussed to understand these two algorithms more deeply. For all comparative study, the average waiting time and average turnaround time is more for round robin algorithm. In the first comparative study, we get average waiting time 52% more. For average turnaround time, 30% more. In second comparative analysis, we get 52 % average waiting time more and we get 35 % average turnaround time more. For third comparative analysis, average waiting time we get 50% more and for average turnaround time, we get 28% more. Thus it is concluded in our comparative study for these kind of data the preemptive shortest job first is more efficient then the round robin algorithm.
 
 Keywords: comparative study, premptive shortest job first algorithm, round robin algorithm, turn around time, average waiting time, time slice

CPU Scheduling Visualization

Scheduling is a key concept in computer multitasking and multiprocessing operating system design, and in real-time operating system design. CPU scheduling is the basis of multiprogramming operating systems by switching the CPU among process; the operating system can make the computer more productive, scheduling algorithms are widely used in communications networks and in operating systems to allocate resources to competing tasks. In this paper, visual interfaces for CPU scheduling algorithms were designed by using Visual Basic6 language. They may use to learn users about this algorithms and how they work

Performance innovation in the IBM zEnterprise 196 processor

The IBM zEnterprise® 196 achieves substantial performance gains over prior designs across the full spectrum of workloads being run on today's enterprise information technology systems, ranging from large data-intensive transaction processing workloads to central processing unit-intensive business applications. Each of these required innovations in the design of the hardware, software, and instruction-set architecture (ISA) with performance gains coming from several sources: the out-of-order microprocessor core design, the multilevel cache structure, new ISA facilities, and additional ISA extensions to enable efficient scaling of large multiprocessor operating system images. These enhancements were achieved through collaborative development among hardware, software, compiler, architecture, and performance analysis teams. This paper describes the performance contributions from these sources, with particular focus on the new architectural facilities.

Counter Abstraction in the CSP/FDR setting

In this paper we consider an adaptation of counter abstraction for the CSP/FDR setting. The technique allows us to transform a concurrent system with an unbounded number of agents into a finite-state abstraction. The systems to which the method can be applied are composed of many identical node processes that run in parallel with a controller process. Refinement checks on the abstract state machine can be performed automatically in the traces and stable failures models using the FDR model checker. We illustrate the method on an example based on a multiprocessor operating system.

Service Management: An Interview with Alan Ganek

A new multiprocessor system-on-chip prototyping flow based on the Portable Operating System Interface (Posix) standard and a multiprocessor hardware platform lets you quickly prototype Posix-based applications. Modern MPSoCs (multiprocessor systems on chip) contain a huge amount of software and rely on complex hardware components. As application complexity grows, programmable multiprocessor platforms are becoming more desirable. In fact, chips with several processors (such as general purpose processors and digital signal processors) are emerging in the industry, either for low-end applications such as audio codec or high-end applications such as video encoders. Reconfigurable hardware platforms recently emerged as effective solutions to validate and prototype MPSoC designs early in a design flow. Such prototyping platforms make simultaneous hardware and software development possible and enable early software design and debugging,13 thus allowing for early software and hardware integration - which is the critical step in MPSoC system designs. Applications running on these new multiprocessor platforms usually require sophisticated multitasking operating systems to execute the system parts mapped to software. These operating systems provide a suitable abstraction, allowing easy development of application software.4 Using a standard API at this level makes this process even more effective and enhances software portability and reuse across different operating systems. However, the same portability doesn't apply from a hardware perspective, where changes to the underlying configurable hardware architecture are still seen as a major source of nonportability and usually lead to long, tedious redesign cycles. MPSoC designers have recently introduced the concept of hardware-dependent software (HdS) to tackle such strong coupling between hardware and software within the lower system software layers.1 Here, we describe our experience in MPSoC prototyping using a multiprocessor operating system kernel that implements the Portable Operating System Interface (Posix) API standard on top of a reconfigurable multiprocessor platform using the HdS concept. (We chose Posix as the API owing to its wide acceptance and availability in many runtime environments.5) Investigating the complexity of hardware and software integration in multiprocessor system design, a process still not completely mastered in MPSoC design flows, helped us understand the duality between the low-level software layer (HdS) and the underlying hardware platform in the context of MPSoC design.

A softerware monitor for shared‐memory multiprocessor computers

AbstractANIX is a multiprocessor operating system to be used in the backbone Asynchronous Transfer Mode (ATM) switches. In ANIX, memory contention by processes running on different CPUs is managed with a protocol called WWWH (when to sleep, who to sleep, where to sleep, and how to sleep). Tools are needed to test, debug, and tune the system running WWWH. This paper describes the experience and practice in design of SHMON, a performance tool that monitors the dynamic behavior of the running system. Copyright © 2004 John Wiley & Sons, Ltd.

Embedding Linux

The author explains the whys and hows of fitting a software quart into a pint pot-with room to spare. Linux is an open-source Unix-like kernel, that can be freely distributed under the terms of the GNU General Public License. Right from the beginning, as is the case today, distributions of the Linux kernel have been accompanied by GNU-developed utility programs to form a complete operating system. Strictly speaking, the correct name for such distributions is GNU/Linux, although the GNU prefix is generally dropped in the interests of brevity. Since its initial release the communications infrastructure provided by the Internet has enabled large numbers of developers to enhance and extend Linux, to the point where it can now be seen as a mature alternative to operating environments such as Windows and Unix. Linux is a multi-tasking, multi-user, multiprocessor operating system supporting a wide range of hardware platforms, such as x86, Alpha, Sparc, MIPS, SuperH, PowerPC and ARM. Where hardware support is provided, the kernel makes use of protected-mode memory management, increasing system reliability as one failing application is unlikely to cause the kernel, or other application to fail.

A Fast and Efficient Processor Management Scheme fork-aryn-cubes

Job scheduling and processor allocation are two key components of processor management technique in a multiprocessor operating system. We propose a fast and efficient processor management technique, called virtual cube (VC), fork-aryn-cubes in this paper. The proposed scheme supports spatial allocation of jobs to the virtual cubes of the system and multiprograms the virtual cubes in a round-robin fashion. The objective here is to reduce job waiting time and fragmentation. The VC scheme uses a fast subcube allocation algorithm called enhancedk-ary buddy. A novel approach, called paging, is proposed for fast submesh allocation. When used with the first fit algorithm, the paging scheme is shown to be extremely fast and efficient compared to other contemporary submesh allocation algorithms fork-aryn-cubes. We also study the impact of page size on performance and illustrate a methodology to compute optimal page size. Simulation results show that the VC scheme with its multiprogramming capability can boost system performance considerably and outperforms all existing policies while incurring minimal run-time overhead.

MultiSync: a synchronization model for multimedia systems

Synchronization among various media sources is one of the most important issues in multimedia communications and various audio/video (A/V) applications. For continuous playback (such as lip synchronization) under a time-sharing multiprocessing operating system (such as UNIX), the synchronization quality of traditional synchronization mechanisms employed on single processes may vary according to the workload of the system. When the system encounters an overload situation, the synchronization usually fails and, even worse, results in two fatal defects in human perception: the audio discontinuity (audio break) and the out-of-synchronization (synchronization anomaly). In order to overcome these problems, a novel media synchronization model employed on multiple processes (or threads) in a multiprocessing environment is proposed. The problem of asynchronism due to system overload is solved by assigning a higher priority to more important media and adopting a delay-or-drop policy to treat the lower priority ones. Some experimental results are presented to show the effectiveness of the proposed model and the implementation mechanisms under a UNIX, X-Windows environment. On the basis of the proposed model, a continuous media playback (CMP) module, which acted as the key component of some popular multimedia systems such as multimedia authoring system, multimedia E-mail system, multimedia bulletin board system (BBS), and video-on-demand (VoD) System, was implemented.

Hierarchical clustering: A structure for scalable multiprocessor operating system design

We introduce the concept ofhierarchical clustering as a way to structure shared-memory multiprocessor operating systems for scalability. The concept is based on clustering and hierarchical system design. Hierarchical clustering leads to a modular system, composed of easy-to-design and efficient building blocks. The resulting structure is scalable because it 1) maximizes locality, which is key to good performance in NUMA (non-uniform memory access) systems and 2) provides for concurrency that increases linearly with the number of processors. At the same time, there is tight coupling within a cluster, so the system performs well for local interactions that are expected to constitute the common case. A clustered system can easily be adapted to different hardware configurations and architectures by changing the size of the clusters. We show how this structuring technique is applied to the design of a microkernel-based operating system calledHurricane. This prototype system is the first complete and running implementation of its kind and demonstrates the feasibility of a hierarchically clustered system. We present performance results based on the prototype, demonstrating the characteristics and behavior of a clustered system. In particular, we show how clustering trades off the efficiencies of tight coupling for the advantages of replication, increased locality, and decreased lock contention.

Parallel processing of incremental ray tracing on a shared-memory multiprocessor

This paper presents a novel parallel-processing method for image synthesis using incremental ray tracing on a shared-memory multiprocessor workstation. The most efficient technique for image synthesis is ray tracing, proposed by Whitted in 1980. Ray-tracing algorithms are simple and can generate realistic images. However, they are time-consuming, since calculations of the intersections between objects and ray increase exponentially as the complexity of scenes increases. Fast image synthesis for animation is one of the most important topics in computer graphics. As the area of computer applications has broadened, the complexity of images to be synthesized has increased. Parallel processing of computer graphics is one way of achieving fast image synthesis. This paper describes a parallel processing technique for incremental ray tracing, which recalculates only the rays changed by moving objects in successive scenes of continuous image synthesis. The performance of parallel ray tracing was evaluated on the multiprocessor workstation TOP-1. Strategies for allocating pixels to processes under a multiprocess operating system on this workstation are discussed.

Kernel‐Kernel communication in a shared‐memory multiprocessor

AbstractIn the standard kernel organization on a bus‐based multiprocessor, all processors share the code and data of the operating system; explicit synchronization is used to control access to kernel data structures. Distributed‐memory multicomputers use an alternative approach, in which each instance of the kernel performs local operations directly and uses remote invocation to perform remote operations. Either approach to interkernel communication can be used in a large‐scale shared‐memory multiprocessor.In the paper we discuss the issues and architectural features that must be considered when choosing between remote memory access and remote invocation. We focus in particular on experience with the Psyche multiprocessor operating system on the BBN Butterfly Plus. We find that the Butterfly architecture is biased towards the use of remote invocation for kernel operations that perform a significant number of memory references, and that current architectural trends are likely to increase this bias in future machines. This conclusion suggests that straightforward parallelization of existing kernels (e.g. by using semaphores to protect shared data) is unlikely in the future to yield acceptable performance. We note, however, that remote memory access is useful for small, frequently‐executed operations, and is likely to remain so.

CHAOS arc : kernel support for multiweight objects, invocations, and atomicity in real-time multiprocessor applications

CHAOS arc is an object-based multiprocessor operating system kernel that provides primitives with which programmers may easily construct objects of differing types and object invocations of differing semantics, targeting multiprocessor systems, and real-time applications. The CHAOS arc can guarantee desired performance and functionality levels of selected computations in real-time applications. Such guarantees can be made despite possible uncertainty in execution environments by allowing programs to adapt in performance and functionality to varying operating conditions. This paper reviews the primitives offered by CHAOS arc and demonstrates how the required elements of the CHAOS arc real-time kernel are constructed with those primitives.

Prediction of performance and processor requirements in real-time data flow architectures

Presents a new data flow graph model for describing the real-time execution of iterative control and signal processing algorithms on multiprocessor data flow architectures. Identified by the acronym ATAMM, for Algorithm to Architecture Mapping Model, the model is important because it specifies criteria for a multiprocessor operating system to achieve predictable and reliable performance. Algorithm performance is characterized by execution time and iteration period. For a given data flow graph representation, the model facilitates calculation of greatest lower bounds for these performance measures. When sufficient processors are available, the system executes algorithms with minimum execution time and minimum iteration period, and the number of processors required is calculated. When only limited processors are available or when processors fail, performance is made to degrade gracefully and predictably. The user off-line is able to specify tradeoffs between increasing execution time or increasing iteration period. The approach to achieving predictable performance is to control the injection rate of input data and to modify the data flow graph precedence relations so that a processor is always available to execute an enabled graph node. An implementation of the ATAMM model in a four-processor architecture based on Westinghouse's VHSIC 1750A Instruction Set Processor is described.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The design of an object-oriented operating system (abstract)

This tutorial describes the object-oriented design of a complete operating system, written to be object-oriented, with a user and application interface that is object-oriented. The main objective is to illustrate object-oriented design trade-offs by studying a large object-oriented system, the Choices operating system. Choices is an object-oriented multiprocessor operating system that runs native on SPARC stations, Encore Multimaxes, and IBM PCs. The system is built from a number of frameworks that implement a general file system, persistent store for persistent objects, process switching, parallel processing, distributed processing, interrupt handling, virtual memory, networking, and interprocess communication. If you bring an IBM/PC 386-based portable computer running MS-DOS to the course then you may experiment by writing application programs for PC-Choices. All participants will receive a copy of PC-Choices on a floppy. Participants should have experience with building object-oriented systems and have a basic understanding of operating systems design. Reading knowledge of C++ is helpful, but not necessary.

Characterizing the caching and synchronization performance of a multiprocessor operating system

Characterizing the caching and synchronization performance of a multiprocessor operating system

Operating system support for animate vision

Animate vision systems couple computer vision and robotics to achieve robust and accurate vision, as well as other complex behavior. These systems combine low-level sensory processing and effector output with high-level cognitive planning—all computationally intensive tasks that can benefit from parallel processing. A typical animate vision application will likely consist of many tasks, each of which may require a different parallel programming model, and all of which must cooperate to achieve the desired behavior. These multi-model programs require an underlying software system that not only supports several different models of parallel computation simultaneously, but which also allows tasks implemented in different models to interact. This paper describes the Psyche multiprocessor operating system, which was designed to support multi-model programming, and the Rochester Checkers Player, a multi-model robotics program that plays checkers against a human opponent. Psyche supports a variety of parallel programming models within a single operating system by according first-class status to processes implemented in user space. It also supports interactions between programming models using model-independent communication, wherein different types of processes communicate and synchronize without relying on the semantics or implementation of a particular programming model. The implementation of the Checkers Player, in which different parallel programming models are used for vision, robot motion planning, and strategy, illustrates the use of the Psyche mechanisms in an application program, and demonstrates many of the advantages of multi-model programming for animate vision systems.

Toward Dynamic. Multiprocessor Real-Time Threads

Publisher Summary This chapter describes some of the research issues and solutions surrounding the development of a real-time threads package for multiprocessor systems. The package involved is based on Mach threads and has been implemented on standard UNIX platforms and on 32-node BBN Butterfly multiprocessor. It has also been used as a portable basis for the construction of parallel real-time applications and multiprocessor operating system kernels. The essential idea underlying real-time threads is that the schedulability of a thread should be guaranteed before it is actually run, not only at the time of program compilation but also at the time of thread creation. Specifically, the real-time threads package guarantees the schedulability of threads being created prior to their execution, assuming that thread deadlines, start times, and maximum execution times are known. The second main idea underlying real-time threads is that minimum functionality should be offered by the threads package itself. Specifically, when scheduling, guarantees cannot be made by the package's underlying algorithms.

Dynamic scheduling of hard real-time tasks and real-time threads

The authors investigate the dynamic scheduling of tasks with well-defined timing constraints. They present a dynamic uniprocessor scheduling algorithm with an O(n log n) worst-case complexity. The preemptive scheduling performed by the algorithm is shown to be of higher efficiency than that of other known algorithms. Furthermore, tasks may be related by precedence constraints, and they may have arbitrary deadlines and start times (which need not equal their arrival times). An experimental evaluation of the algorithm compares its average case behavior to the worst case. An analytic model used for explanation of the experimental results is validated with actual system measurements. The dynamic scheduling algorithm is the basis of a real-time multiprocessor operating system kernel developed in conjunction with this research. Specifically, this algorithm is used at the lowest, threads-based layer of the kernel whenever threads are created. >

The EMMA2 multiprocessor operating system

AbstractThe EMMA2EMMA is a registered trademark of Elsag—Elettronica San Giorgio. parallel architecture is a network of nodes, named 'Regions': each region is based on two shared‐memory hierarchical bus levels, on which a large series of monocpu, multicpu and specialized I/O boards can be inserted, grouped in 'Families'.Its typical applications are Image processing, pattern recognition and artificial intelligence, characterized by intensive computation requirements, real‐time constraints and good price‐performance ratio for building large industrial systems. This paper presents the main characteristics of the EMMA2 parallel operating system, highlighting the internal organization and mechanisms offering the parallel co‐operation model for user programs.Section 1 briefly introduces the overall hardware architecture. It allows application partitioning into parallel independent subsystems, on two levels of computation: the lower level (family) is dedicated to massive number crunching, while the upper (region) permits the interaction of these lower machines.Section 2 deals with the system software environment, based on a host‐target configuration: the host is mainly devoted to machine control, system monitoring, program development and debugging in a multi‐user environment.Sections 3, 4 and 5 describe respectively the fundamental concepts of the operating system internal organization and the basic mechanisms with respect to the machine architecture; the basic functions that constitute the internal layers and services; the resulting parallel programming and co‐operation model and the typical mapping rules of algorithms to this architecture, completed with some examples of their functionalities.The most important aspect of the EMMA2 operating system is the fact that it offers a uniform interface to user tasks, independently of their allocation on the target machine. Objects managed by system services can be referred to via logical names. Code for system services is distributed among processors and resides on a private read‐only memory. The operating system's data reside in shared memory only for system functions that need to be distributed, while private functions are based on different copies of data in private memories.Section 6 gives more details on the most relevant EMMA2 industrial applications, also showing their mapping to the parallel architecture and some performance‐related information. Section 7 contains a brief outline of the novel architecture currently in development and of the subsequent OS Improvements.In conclusion, we report some considerations about the present status of the EMMA2 system, compared with some other well‐known architectures, and about research efforts for its future evolution.