Operating Systems Course Research Articles

A study of common pitfalls in simple multi-threaded programs

It is generally acknowledged that developing correct multi-threaded codes is difficult, because threads may interact with each other in unpredictable ways. The goal of this work is to discover common multi-threaded programming pitfalls, the knowledge of which will be useful in instructing new programmers and in developing tools to aid in multi-threaded programming. To this end, we study multi-threaded applications written by students from introductory operating systems courses. Although the applications are simple, careful inspection and the use of an automatic race detection tool reveal a surprising quantity and variety of synchronization errors. We describe and discuss these errors, evaluate the role of automated tools, and propose new tools for use in the instruction of multi-threaded programming.

Discovery learning in introductory operating system courses

Practical experiences are necessary to balance the theory discussed in textbooks and in class meetings. Effective practical experiences must have a clear purpose and must motivate students to become involved as active learners. This paper presents some practical experiences for an introductory operating systems course. The experiences employ short programs with unexpected behaviors and open-ended questions. Students use these as starting points to discover more about the concepts involved. The presented experiences provide effective reinforcement of the underlying theory.

Empirical exploration in undergraduate operating systems

The undergraduate operating systems course can provide students with a valuable introduction to empirical testing and experimentation. We have implemented a process scheduling simulator designed to develop student empirical skills while they are learning part of the standard operating systems curriculum. The simulator is written in Java and available for direct experimentation via the World Wide Web. By accessing the remote URL through an appletviewer, students can permanently save input test data and simulator results generated in HTML format. In one type of assignment, students are given a hypothesis about process scheduling and are asked to develop experiments to support or disprove the hypothesis. In a second type of assignment students are asked to develop their own hypotheses. Not only did these assignments enhance student understanding of process scheduling, but the techniques exposed students to empirical approaches to validation and testing.

Visualizing the CPU scheduler and page replacement algorithms

In this paper, we present two packages that simulate the multilevel feedback queue scheduling algorithm for a single CPU, and five page replacement algorithms that are used in the context of memory management. The paper gives a brief description of the interactive, self-paced packages and explains how we use them in Operating System courses. We also highlight the merits of the packages and the benefits to the students derived from our Java written simulations.

Introducing empirical investigation in undergraduate operating systems

The undergraduate operating systems course can provide students with a valuable introduction to empirical testing and experimentation. This paper announces the availability of a process scheduling simulator designed to develop student empirical skills while they are learning part of the standard operating systems curriculum. The simulator is written in Java and available for direct experimentation via the World Wide Web. By accessing the remote URL through an appletviewer, students can permanently save input test data and simulator results generated in HTML format. Students are asked to test specified hypotheses about process scheduling and to develop their own hypotheses about the influence of different parameters on behavior. In order to devise experiments that make sense, students must understand how factors such as burst time and variability influence behavior. Interested faculty are invited to try the simulator and support materials in their operating systems classes.

Tasking solutions to the Sieve of Eratosthenes

Shapiro and later Bokhari described a multiprocessing view of the Sieve of Eratosthenes, to test load balancing on shared-memory multiprocessors. Shapiro proposed the following parallel version of the sieve:Eratosthenes starts off with a large number of slaves and instructs the first one to write down the integers 2, 3, 4, … on the ground in a field. A second slave is dispatched with instructions to cross out all multiples of 2. Eratosthenes now moves down the "list" of numbers and dispatches a new slave whenever an uncrossed number is encountered. Thus, the third slave is sent off with instructions to cross out the multiples of 3, the fourth crosses out all multiples of 5, and so on. The uncrossed numbers that remain at the end of this process are the primes.It turns out that Ada (especially Ada95) supports multiprocessing well in the Sieve of Eratosthenes. One may make use of static and dynamic tasks, protected types, communication, and synchronization in a relatively small program, making the sieve an excellent choice for instruction. In a graduate course we offer at William & Mary, Theory of Programming Languages, we give students a multiprocessing assignment. At this stage, students have rarely done parallel programming, except for low-level threads and locks in operating systems courses. So a parallel programming assignment in a high level language adds an extra tool to their arsenals and gives them an idea of an important part of computing today.

Multithreaded programming in an introduction to operating systems course

This paper presents a way of teaching multithreaded programming as a component in an introduction to operating systems course. Topics include programming assignments, term projects, and experiences. This paper also suggests future work for overcoming a bottleneck that occurs in the current version of this course.

Development of a Business Operating Systems Course

Curriculum 95 is a collaborative effort between the Association for Computing Machinery (ACM), the Data Processing Management Association (DPMA), the Academy for Information Systems (AIS), and other professional societies to develop a new model curriculum for undergraduate programs in Information Systems. One of the five curriculum areas defined in Curriculum 95, “Information Technology,” proposes learning units in hardware, software, telecommunications, and programming.This paper discusses the development of a Business Operating Systems course which satisfies the hardware and software components of the Information Technology area in the new model. It describes the results of a survey of Management Information Systems (MIS) faculty who teach technical courses. The survey investigates the delivery of technical courses in general and specific topics and platforms taught in MIS operating systems courses.

System calls and interrupt vectors in an operating systems course

The introductory operating systems course has a tendency to appear to the student as a disparate collection of topics such as synchronization primitives, process scheduling algorithms, and page replacement policies. We describe a sequence of material to cover early in the operating systems course that prevents this tendency by clarifying the goal of the course and by providing a framework for understanding how the later course material is used in kernel design. The material centers around two concepts. First is the importance of the abstraction provided by the system call interface, that the kernel is the implementation of that interface, and the analogy with the instruction set interface the student has already encountered. Second is how the interrupt vector mechanism in a broad sense is central to how the kernel functions and underpins the actual implementation of many of the other topics in the course. Illustration through code from a real operating system kernel is a key feature of how this sequence makes clear the workings of an operating system.

The EOS laboratory environment for a course in operating systems

This paper describes a laboratory environment for teaching operating systems. The EOS (Exploratory Operating Systems) lab was developed with a National Science Foundation ILI grant to be used in conjunction with a traditional operating systems (OS) course. The main goal of the EOS project was to improve the teaching of operating system principles without the necessity of a special purpose laboratory and the addition to the curriculum of a second course in OS. The EOS labs are summarized and a CPU scheduling lab is described in some detail. A standardized testing instrument was used to compare class performance before and after adding the lab to the OS course. Preliminary results show an improvement attributable to the EOS laboratory. The author's experience in building a workstation laboratory from an externally funded grant is described.

CALOS

This paper describes CALOS, our application of computer-aided learning to a third-year Computer Science course in Operating Systems. The delivery tool we choose is the World Wide Web. The course material consists of interactive exercises, interactive simulations and demonstrations, on-line notes, student - instructor communication mechanisms, student - student communication mechanisms, progress tracking, navigational aids, student evaluations, a glossary and a bibliography. We make use of text, images, animations and voice. We plan to offer the course experimentally in several modes in order to determine the best use of the hypermedia presentation.

XINU—an easy to use prototype for an operating system course

XINU—an easy to use prototype for an operating system course

O.S. bridge between academia and reality

This paper presents a different approach to solving the dilemma of balancing the theory and the practice in an undergraduate operating systems course. We are in the process of implementing a laboratory that allows students to experiment with a copy of the 386BSD Unix System. Students are guided through exercises with increasing complexity, from a single exercise of initializing a new file system to more complicated team projects. The laboratory does not require a set of machines dedicated to the Operating Systems Class which is the reason many instructors choose to use simulators or small academic operating systems. This is accomplished through the use of recent removable disk technology that provides enough speed and capacity to load the source code of a real system. This approach provides a more in-depth study of a system students are more likely to encounter when they leave school. It also allows students to work in teams in an environment closer to the real world and provides a strong foundation for students wishing to enter graduate school with intentions to specialize in the area of operating systems development.

An undergraduate course in concurrent programming using Ada

This paper describes a senior level course in concurrent programming using Ada. Unlike other similar courses in the subject area, it is not part of an operating systems course, nor is it tied to a particular hardware architecture. The course is software oriented and it discusses in depth a concurrent programming language, Ada, so that students are able to actually develop effective concurrent programs to solve problems in a wide range of applications. Ada is selected because of its popularity, superb portability, numerous hardware platforms, and rich concurrent constructs. Classical issues in concurrent programming are presented in the context of Ada. General issues in designing concurrent programming languages are elaborated using Ada, together with other concurrent programming languages such as CSP, Occam, and Linda. Finally, general principles of designing parallel programs are also discussed. Therefore, the course provides both the depth in a concurrent programming language for program development and the breadth in concurrent programming theory for insight. Using Ada throughout the course strengthens student's expertise in Ada and provides an useful reference point for understanding concurrent programming theory. The course is heavily based on handouts, examples, homework and programming assignments. A rich set of instructional materials are available from the author.

Animating operating systems algorithms with XTANGO

In operating systems courses, students study the major algorithms used in operating systems to manage the various objects and resources in a computing system: processes, files, buffer space, processors, messages, main memory, semaphores, and disk storage. Various classical synchronization problems such as the dining philosophers, the readers and writers, and the producers and consumers with bounded buffer are also analyzed. Even though the computing systems being studied are getting more and more powerful, these algorithms and classical problems are usually analyzed using blackboard, chalk, pencil, and paper. This paper describes an X-windows based package called xtango that was used to animate some of the algorithms and classical problems studied in operating systems. One animation typical of those that have been developed is presented. Students can use these animations during study outside the classroom for a better understanding of the algorithms. Instructors can use the animations to facilitate the presentation of the algorithms in the classroom.

A Simulated Hardware for an Operating System Course Project

A simulated hardware, called Alchemy, was used for the laboratory programming project in an introductory operating system (OS) course at the senior/graduate level. Students developed an OS for the hardware from scratch to support time‐sharing, virtual memory, and asynchronous I/O. The hardware simulation and the outline of the OS written by students are reported. The effectiveness of this teaching method on students' learning of OS concepts is also evaluated.

A multitasking executive for operating systems courses

This paper presents the design of a multitasking executive for a course on computer operating systems. The system described here allows us to illustrate some fundamental concepts of multiprocessing and to experiment parallel programming.The system built is a preempt multitask one, which implements semaphore as a synchronisation tool of concurrent programs. A software layer called SESSION MANAGER is built above the basic kernel which is hence isolated from user's processes.The whole system is thus conceived to be written and tested by students during their courses on basic systems.

Using a model railroad system in an artificial intelligence and operating systems course

article Using a model railroad system in an artificial intelligence and operating systems course Share on Author: Rodney S. Tosten Gettysburg College, Gettysburg, PA Gettysburg College, Gettysburg, PAView Profile Authors Info & Claims ACM SIGCSE BulletinVolume 25Issue 1March 1993 pp 30–32https://doi.org/10.1145/169073.169096Online:01 March 1993Publication History 4citation236DownloadsMetricsTotal Citations4Total Downloads236Last 12 Months10Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

The acquisition of operating systems concepts by computer science students

Students following an operating systems course often experience difficulties in mastering complex abstract concepts, such as concurrency, scheduling of processes and deadlock. The dining philosophers problem served as an example in demystifying many such difficulties. An experiment was designed in which students were tested on their knowledge of the dining philosophers problem after being exposed to a treatment program in which traditional textbook study methods in comparison to computer-assisted instructional methods were used. The results indicated that CAI techniques in this application do not guarantee an easier acquisition of knowledge than with conventional texts, particularly in relation to abstract concepts.

Experience with the language SR in an undergraduate operating systems course

In undergraduate operating systems classes, students learn about concurrent process synchronization, including such things as shared data, race conditions, critical sections, mutual exclusion, semaphores, monitors, and the test-and-set hardware instruction. They also study interprocess communication, message passing, rendezvous, and remote procedure calls. Solutions to classical problems, such as the dining philosophers, producers and consumers, bounded buffers, and readers and writers, are presented using the above concepts. However, students need to write programs in a language that provides facilities for concurrent programming in order to appreciate fully the above concepts. This paper describes the SR language and discusses its successful use as an environment for concurrent programming in an undergraduate operating systems class.