Comparative analysis of operating systems of the Windows and Mac OS families. Brief summary of the project. New operating systems

Published: 01/06/2006
Text version: 1.0

1. General description of real-time operating systems

The basis of any hardware and software complex, including those operating in real time, is the operating system (OS). An operating system is a set of programs that provides management of the resources of a hardware-software complex (computer system) and processes that use these resources in calculations. A resource in this context is any logical or physical (and in totality) component of a computing system or hardware and software complex and the capabilities it provides.

The main resources are the processor (processing time), RAM and peripheral devices.

Resource management comes down to performing the following tasks: simplifying access to resources, distributing them between processes.

Solving the first problem allows you to “hide” the hardware features of the computing system, and thereby provide the user or programmer with a virtual machine with significantly easier management.

Thus, the OS supports the following interfaces: user ( command language to manage the functioning of the system and a set of services); software (a set of services that frees the programmer from coding routine operations).

The resource distribution function is one of the most important tasks solved by the operating system, but it is not inherent in all operating systems, but only in those that ensure the simultaneous execution of several programs (processes).

A process is a sequence of actions prescribed by a program or its logically complete part, as well as data used in calculations. A process is the minimum unit of work for which resources are allocated.

Currently, there is a wide variety of operating systems, which are classified according to the following criteria:

number of users simultaneously served by the system;

the number of processes that can simultaneously run under OS control;

type of user access to the system;

type of hardware and software complex.

In accordance with the first sign, single- and multi-user operating systems are distinguished. The second feature divides the OS into single- and multi-tasking.

In accordance with the third feature, operating systems are divided into:

batch processing systems. In this case, a package is formed from the programs to be executed and presented to the system for processing. In this case, users do not directly interact with the OS;

time sharing systems, providing simultaneous interactive access to the computer system of several users through terminals. In this case, system resources are allocated to each user “in turn”, in accordance with one or another service discipline;

real time systems, which should provide a guaranteed response time to external events (see below for more details).

The fourth feature divides the OS into single- and multiprocessor, network and distributed. For multi-user and multi-tasking operating systems, maintenance discipline is an important indicator. In accordance with this, a distinction is made between preemptive and coordinating modes of multitasking work. In a preemptive organization, only the OS is responsible for allocating processor time to tasks (for example, for each task, a processor is allocated in turn, and for a strictly fixed period of time, but priority servicing is also possible). In the case of a matching organization, each task, having received control, itself determines when to “give” the processor to another task.

In general, coordination is more efficient and reliable than preemption, but the determining factor when implementing programs is the fact that a given program should not exclusively use processor time.

Currently, there are a huge number of types of OS, but in the following only RT OS will be considered.

First we need to define a real-time system.

Real time system(SRV) is a system, the correct functioning of which depends not only on the logical correctness of the calculations, but also on the time during which these calculations are made.

For events occurring in such a system, the time at which these events occur and their logical correctness are important.

The system operates in real time if its performance is adequate to the speed of physical processes at monitoring or control objects (meaning processes directly related to the functions performed by a specific real-time system). The control system must collect data, process it according to specified algorithms and issue a control action in a period of time that ensures the successful completion of the assigned tasks.

1.1 What is a real-time system

Recently, more and more often we are faced with tasks that require the management of complex processes or equipment using a computer. Moreover, all events in these processes occur when they occur. A computer can only perform a finite number of operations in a finite time, so the question arises: will the computer have time to calculate the situation at the required speed and issue specific control actions that would be adequate at a certain point in time. In my opinion the problems this kind of arose from the use of very high speeds in modern production. It is clear that signals in nature propagate at a finite speed, the speed of operation is also finite, therefore it is fundamentally impossible to expect instant actions (caused by a certain event) from a computer. After all, no matter how modern (read - powerful in performance, i.e. high speed processing commands and operations), no matter what the computer is, it physically needs at least a fraction of a second to execute a small simple group of commands, and sometimes this time is too much. Thus, the system's reaction time to some event is strictly greater than zero. Real tasks allow for some delay in actions, and if the system has a reaction time less than this acceptable delay, then it is fair to call it a real-time system. Since in nature different processes occur at different speeds, the same system can fit within the given framework for one process and not fit for another. Thus, it makes sense to talk about a real-time system in relation to a specific task. For example, to plot the dependence of the average air temperature for a day on the day of the week, almost any computer with almost any software will work as a real-time system. If we are controlling the landing of an aircraft, where milliseconds play a significant role, it would be more appropriate to carefully choose hardware and software.

In addition to the considered task of responding to a certain event, there are other classes of real-time tasks. One of the frequently encountered ones is the task of constant monitoring or control of a dynamic process, i.e. when you need to continuously exchange signals with the outside world. A computer is a discrete system, so it is necessary to carry out some actions with certain finite periods of time, assuming that during these short periods of time the outside world remains unchanged. If our system is capable of processing information and producing control signals at the required frequency, then it can be called a real-time system. It is not difficult to understand that this problem can be easily reduced to the previous one, using the beginning of the next time interval as an event. The reaction time must be less than the sampling time of the process. Thus, the task described earlier is the most important one when it comes to real-time systems. It should be noted that unsatisfactory system operation in terms of latency in some tasks can lead to fatal consequences, and in others no abnormal or undesirable situations will occur. For example: if the temperature measurement system from the example described above accidentally arrives late by an unacceptable amount of time, then this means that we simply changed the selection of temperature reading points, and we will still get the correct result, but if the automatic approach on a passenger plane is accidentally delayed for a second at a sudden gust of wind, the plane may not reach the runway and dozens of people will die. Thus, systems should be divided into hard and soft real-time systems.

Hard real time system is a system where the inability to provide a response to any events at a given time is a failure and leads to the impossibility of solving the task. Reaction time in hard real-time systems should be minimal. Most hard real-time systems are monitoring and control systems. Such RTS are difficult to implement, since they are subject to special security requirements.

Accurate definition soft real time does not exist, so we can include here all SRVs that do not fall into the category of hard ones. Thus, a soft real-time system may not be able to do everything in a given time, so the problem arises of determining the criteria for the success (normality) of its functioning.

In addition, RTS can be divided into specialized and universal systems.

Specialized SRV is a system where specific time requirements are initially determined. Such a system must be specifically designed to meet these requirements.

Universal The SRV must be able to perform arbitrary (predetermined in advance) temporary tasks without the use of special equipment. The development of such systems is the most difficult task, although usually the requirements for such systems are milder than the requirements for specialized systems.

1.2 Basic requirements for the SRV

the ability to perform multiple tasks in parallel;

predictability;

the maximum (not average) response time to an event is important;

special requirements in matters of safety;

Possibility of trouble-free operation for a long time.

1.3 General characteristics of the SRV

large and complex systems;

distributed systems;

rigid interaction with equipment;

completing tasks depends on time;

complexity of testing.

RTS must respond to various types of internal and external events (periodic and non-periodic). It should be noted that whether a system belongs to the SRV class has nothing to do with its performance. The initial requirements for the system's response time and other time parameters are determined either by the technical specifications for the system, or simply by the logic of its operation. It is intuitively clear that the speed of the processes at the control and management facility should be greater, the greater the speed of processes at the monitoring and control facility.

1.4 Ways to use the OS

5 types operating systems:

Classic OS. Win NT, Linux and Unix.

Classic OS with RT extension (Win NT - RTX, RT Linux, RT Unix)

Own RV OS. Any programmer can create his own RTOS using several existing methods at the time of writing: create an OS based on an existing platform suitable for this purpose or write it from scratch. Many books have been published on this topic, both in paper and electronic form, which describe the principles of developing such systems, the main steps, provisions, fundamental points, etc. An example of such literature could be book number 2 in the list of references at the end of the abstract.

Commercial OS. An example would be systems such as VxWorks, OS9, etc. It should be noted that such systems are very expensive. For example, the cost of a complete VxWorks OS package (Tornado 1.0) in 2002 was about $15,000. However, over the years, such a system has become significantly cheaper - today its cost is about $10,000 (Tornado version 2.0 and higher - the total cost depends on the selected components).

For more detailed consideration RTOS capabilities are given indicative figures, giving an idea of ​​the order of response time and suitable operating systems. This table is formed on the basis of experimental data obtained on the basis of computing systems built on Intel 80486DX processors. Undoubtedly, this processor today is outdated, but conclusions can be drawn about the level of response to external events of various RT systems.

The table shows that the RTOS time frame is quite strict. Among modern operating systems there is a class of products designed specifically for building hard real-time systems - VxWorks, OS9, QNX, LynxOS, OSE and others. These systems contain the necessary set of tools, and in some cases they are the only choice - you have to go for it, regardless of the costs. However, quite often the requirements for real time (complete predictability of response time) become less stringent, for example, it is necessary to achieve only the desired average performance.

Sometimes it is enough to strictly control only one of the events, while allowing delayed reactions to the others. In such cases, the choice options expand, and the desired results can be achieved using such widespread operating systems as LINUX, Windows NT, Windows CE, supplementing them with real-time extensions (RTAI, RT LINUX, RTX).

1.5 Requirements for the OS when designing an RTOS

1.5.1 Requirement 1. The OS must be multi-threaded and interruptible

As stated above, an RTOS must be predictable, which means the maximum time to complete an activity must be known in advance and must be consistent with the requirements of the application.

The first requirement is that the OS must be multi-threaded according to the principle of absolute priority (interruptible). The scheduler must be able to interrupt any thread and provide the resource to the thread that needs it most. The OS (and hardware) must also provide interrupts at the interrupt handling level.

1.5.2 Requirement 2: There must be a concept of thread priority

The problem is to determine which task requires the resource. In an ideal situation, the RTOS allocates the resource to the thread or driver with the closest deadline (so-called deadline driven OS).

To implement this, the OS must know the time required by each of the running threads to complete (there is still no OS built on this principle, since it is too complex to implement), so OS developers take a different point of view: the concept of priority level is introduced tasks and time constraints boil down to priorities. Since speculative decisions are fraught with errors, SRV indicators are reduced. To more effectively carry out this transformation of constraints, the designer can use schedule theory or simulation modeling, although this may not be useful. There is currently no other solution, so the concept of thread priority is necessary.

1.5.3 Requirement 3: The OS must provide predictable task synchronization mechanisms

Tasks share data (resources) and must communicate with each other, therefore blocking and communication mechanisms must exist.

1.5.4 Requirement 4: There must be a system of priority inheritance

In fact, it is this synchronization mechanism and the fact that different threads share the same memory space that distinguishes threads from processes. Processes do not share the same memory space. For example, older versions of UNIX were not multi-threaded. Old UNIX is a multitasking OS, where tasks are processes that communicate through threads (pipes) and shared memory. Both of these mechanisms use the file system, and its behavior is unpredictable.

The combination of thread priority and resource sharing between them leads to another phenomenon: the classic priority inversion problem. This can be illustrated with an example where there are at least three threads. When a lower-priority thread has occupied a resource shared with a higher-priority thread, and a middle-priority thread is executing first, the highest-priority thread will be suspended until the resource is freed and the middle-priority thread can execute. In this situation, the time required to complete the highest priority thread depends on the lower priority levels - this is priority inversion. It is clear that in such a situation it is difficult to maintain the execution time limit.

To eliminate such inversions, the RTOS must allow priority inheritance, that is, priority promotion to the level of the calling thread. Inheritance means that a thread blocking a resource inherits the priority of the thread it is blocking (only true if the thread it is blocking has a higher priority).

It is sometimes argued that in a well-designed system this problem does not arise. In the case of complex systems, this cannot be agreed. The only way to solve this problem is to manually increase the thread's priority before the resource becomes locked - this is possible in the case where two threads of different priorities are vying for the same resource. In general, there is no solution.

1.5.5 Requirement 5: OS behavior must be known

Finally, time constraints should be considered. The execution time of system calls and the timing of system behavior under various circumstances must be known to the developer, so the RTOS manufacturer must provide the following characteristics:

Interrupt latency (i.e., the time from the moment of interruption to the moment the task starts): it must be predictable and consistent with the requirements of the application. This value depends on the number of simultaneously hanging interrupts;

the maximum execution time of each system call (must be predictable and independent of the number of objects in the system);

maximum interrupt masking time by drivers and OS.

system interrupt levels;

interrupt levels of device drivers, their timing characteristics, etc.

When all the specified characteristics of the OS are known, it is possible to imagine the development of an RTOS based on this OS, taking into account the capabilities of the selected RTOS and hardware.

2. Overview of real-time operating systems

Today there are more than 100 commercial RTOSes. There are many free (or shareware) software systems and systems that have the status of research or university projects. Let's first consider short description some real-time systems, and then we will dwell in more detail on the Win NT RTX RTS, as the most promising system.

2.1 QNX

The QNX operating system is developed by the Canadian company QNX Software System Ltd (1981).

The QNX operating system is a hybrid 16/32-bit operating system that can be configured by the user as desired. It is most often used to create systems that operate in real time. The time required for complete installation of the system, including network tools, is only 10-15 minutes, after which you can begin work. The system's low demands on resources is already evident in the fact that the system with the necessary and sufficient development environment in the form of the Watcom C/C++ compiler (the main compiler for QNX) fits into 10 MB.

QNX is the first commercial OS built on the principles of a microkernel and messaging. The system is implemented as a set of independent (but interacting through message exchange) processes various levels(managers and drivers), each of whom implements certain type service.

These ideas allowed us to achieve several important advantages:

predictability, meaning its applicability to hard real-time problems. No version of UNIX can achieve this quality because the kernel code is too large. Any system call from an interrupt handler in UNIX can result in unpredictable latency (as in Windows NT);

scalability and efficiency achieved by optimal use of resources and meaning its applicability for embedded systems. The dev directory contains only the files necessary for the tasks assigned, corresponding to the necessary drivers. Drivers and managers can be launched and deleted (except for the file system) dynamically, simply from the command line. It is also possible to purchase only those modules that are actually necessary to provide the required functions;

extensibility and reliability at the same time, since the written driver does not need to be compiled into the kernel, risking causing system instability.

The system is built using FLEET technology, which is characterized by the following. QNX is a microkernel-based RTOS (about 10 KB in size). The system uses message passing as the main means of interaction between processes. Thanks to this, in a 32-bit environment, it is possible for processes with 32 and 16-bit codes to interact, and messages are transmitted between any processes, regardless of whether the processes are on the same computer or on different network nodes.

A user working on one of the network nodes can have access to any resources of other nodes, including ports, file system and tasks. The user does not need to delve into the network protocol, which, by the way, is not a secret, right down to its structure. It contains packages that are also used to transmit messages. The network administrator recognizes these packets and forwards them to the microkernel, which in turn forwards them to the local message bus. QNX recognizes more than just message packets from QNX processes. You can also easily contact your network administrator to transfer packet protocols such as TCP/IP, 8MB, etc. You can contact multiple network administrators through a single cable.

The QNX operating system unites the entire PC network into a single set of resources with absolute transparency of access to them. Nodes can be added and removed from the network without affecting the integrity of the system. QNX's networking is so flexible that it can network any heterogeneous set of Intel-compatible computers connected via Arcnet, Ethernet, Token Ring, or a serial port that can also be connected to a modem. In addition, it is possible for a computer to participate in several networks simultaneously, and if one of them becomes overloaded or fails, QNX will automatically use other available networks without losing information.

QNX has some limitations due to the system's focus on the embedded real-time market:

no SMP support;

missing entry virtual memory to disk;

inefficient and non-standard thread support;

incomplete implementation of displaying files in memory;

no support for UNIX-domain sockets;

weak security measures within its own network protocol.

Despite its inherent disadvantages, QNX has many user programs, such as databases, that often outperform their counterparts running other operating systems.

In Russian industry, QNX is found quite often. This is due to the availability of a sufficient amount of software for QNX (drivers, etc.) for various equipment presented on the Russian market.

2.2 VxWorks/Tornado

The VxWorks real-time operating system and the Tornado tool environment from Wind River Systems are designed for developing software for embedded computers operating in hard real-time systems. The VxWorks operating system is a cross-tool application software development system. Development is carried out on an instrumental computer (host) in the Tornado environment for subsequent execution on a target machine (target) running VxWorks.

VxWorks supports target architectures:

Motorola 680x0 and CPU32, PowerPC;

Intel 386/486/Pentium, Intel 960;

Spare, Mips R3000/4000;

AMD 29K, Motorola 88110;

• Tool platforms supported for Tornado (hosts):

  Sun SPARCstation (SunOS and Solaris);

  HP 9000/400,700 (HP-UX);

  IBM RS6000 (AIX);

  Silicon Graphics (IRIX);

  DEC Alpha (OSF/1);

• Supported host-target interfaces:

  host-target Ethernet;

  in-circuit emulator ICE (In-Circuit Emulator);

  cross bus (backplane).

The VxWorks operating system is built as an OS should be hard real time, using microkernel technology, i.e., at the lower, uninterrupted kernel level, only the basic functions of task scheduling and their communication/synchronization management are performed. All other higher-level operating system functions (memory management, I/O management, networking, etc.) are based on simple functions lower level, which makes it possible to ensure the performance and predictability of the kernel, as well as to easily build the necessary operating system configuration.

The multitasking wind kernel uses a task scheduling algorithm that takes into account priorities and is triggered by interrupts. As the primary means of task synchronization and mutually exclusive access to shared resources The wind core uses semaphores. There are several types of semaphores aimed at different application tasks: binary, integer, mutual exclusion and POSIX.

All hardware-dependent parts of VxWorks are located in individual modules so that the embedded system developer can port VxWorks himself to his custom target machine. This set of configuration and initialization modules is called BSP (Board Support Package) and is supplied for standard computers (VME processor, PC or Sparcstation) in source code. A custom machine developer can take a BSP that is closest in architecture to a standard computer as a reference and port VxWorks to his machine by developing his own BSP using the BSP Porting Kit.

2.2.1 Basic networking tools of VxWorks: UNIX-networking, SNMP and STREAMS.

VxWorks was the first real-time operating system to implement the TCP/IP protocol with real-time requirements in mind. Since then, VxWorks supports all network tools standard for UNIX: TCP/UDP/ICMP/IP/ARP, Sockets, SLIP/CSLIP/PPP, telnet/rlogin/rpc/rsh, ftp/tftp/bootp, NFS (client and server) ).

Wind River Systems announced (1994) the WindNet program, under which leading manufacturers software in the field of communications have integrated their software products with VxWorks.

Today these are network protocols X.25, ISDN, ATM, SS7, Frame Relay and OSI; CASE tools for developing distributed systems based on the ROOM (Real-Time Object Oriented Modeling) and CORBA (Common Object Request Broker Architecture) standards; network management using MBD (Management By Delegation) and CMIP/GDMO (Common Management Information Protocol/Guidelines for Definition of Managed Objects) technologies.

2.2.2 Real-time monitoring and debugging: WindView.

Conventional debuggers, which allow you to examine the state of programs and data at breakpoints, are static debugging tools. Opportunities for studying the dynamics of program execution and data changes are provided by special means real-time debugging that traces events of interest to the user and accumulates them in a buffer for subsequent analysis.

Tracing of system events (task switches, writing to the message queue, setting a semaphore, etc.) is possible using the WindView dynamic analyzer, which displays the events accumulated in the buffer on a time diagram.

Recently, high-performance microprocessors, and with them real-time operating systems, are increasingly used in so-called “deeply embedded” applications (automotive electronics, office and household appliances, measuring and medical devices and etc.). There are two main requirements for such computer systems: small size and low cost, therefore deeply embedded microprocessor systems pose two problems in the way of using serial RTOS: small amounts of memory used and the absence of “extra” interfaces through which the target and instrumental machines could be connected at the stage of embedded software development.

Especially for systems with very limited memory, Wind River Systems has developed a reduced WindStream kernel, which requires no more than 8 KB of ROM and 2 KB of RAM to operate. At the same time, the entire range of VxWorks tools, including WindView, is applicable to WindStream.

The Tornado toolchain has an open architecture, which allows other real-time software development tool companies to integrate their software products with Tornado. The user can connect their own specialized development tools to Tornado, as well as expand the capabilities of Wind River Systems tools.

The standard Tornado configuration includes the VxWorks kernel and system libraries, GNU C/C++ Toolkit, CrossWind source language level remote debugger, WindSh shell, BSP WindConfig configurator, etc.

There are many software products integrated with Tornado, produced by other companies.

2.3 RTLinux

2.3.1 The main difficulties when implementing real-time systems in the LINUX environment

As mentioned above, the main task is to respond to some external event in a given period of time. External event usually, from a programmer's point of view, it looks like a hardware interrupt. In modern multitasking operating systems, the kernel is the first to respond to a hardware interrupt. Then this interruption can somehow reach the application task through device drivers. But in a multitasking system, several tasks must be running simultaneously and in order to deliver an interrupt, the kernel must put the process currently running into a sleep state, wake up the desired process and pass the interrupt to it. To do this, you need to switch contexts, which takes a lot of time, so the interrupt will be delivered to the process with a significant delay. In addition, after a process receives an interrupt, one cannot be sure that information processing will be completed in the shortest possible time, because If the computer is equipped with only one processor, and more than one task is running in the system, then a task switch with another context switch can occur at any time. As a result, the reaction time may be unreasonably long (on a fairly powerful computer).

Linux is a modern POSIX-compatible and Unix-like operating system for PCs and workstations, i.e. a multi-user network operating system.

Linux OS supports open systems standards and protocols Internet networks. All components of the system, including source code, are distributed with a license for free copying and installation for an unlimited number of users.

Characteristic features of Linux as an OS:

multitasking (is a must);

multiplayer mode;

protected processor mode (386 protected mode);

process memory protection (a program failure cannot cause the system to hang);

dividing pages by record between instances of a running program. This means that processes that are instances of a program can use the same memory when executing. When such a process attempts to write to memory, the 4K page being written to is copied to free space. This property increases performance and saves memory;

virtual memory with page organization (i.e., not the entire inactive process is displaced from memory to disk, but only the required page); virtual memory in separate disk partitions and/or file system files; virtual memory capacity up to 2 GB; changing the size of virtual memory during program execution;

shared program memory and disk cache: all free memory is used to buffer exchange with disk;

dynamic loaded shared libraries;

program dump for post-mortem analysis: allows you to analyze with a debugger not only a running program, but also a program that has terminated abnormally;

POSIX.1 certified, source compatible with System V and BSD standards;

via iBS2-compatible emulator compatibility with SCO, SVR3, SVR4 for downloadable programs;

availability of the source text of all programs, including kernel texts, drivers, development tools and applications. These texts are freely distributed. Currently, some companies supply a number of commercial programs for Linux without source code, but everything that was free remains free;

POSIX job management;

coprocessor emulation is in the kernel, so the application doesn't have to worry about coprocessor emulation. Of course, if a coprocessor is available, then it is used;

multiple virtual consoles: on one display there are several simultaneous independent work sessions switched from the keyboard;

support for a number of common file systems (MINIX, Xenix, System V file systems); availability of its own advanced file system with a capacity of up to 4 TB and with file names of up to 255 characters;

transparent access to DOS partitions (or OS/2 FAT): the DOS partition looks like part of the Linux file system; VFAT support (WNT, Windows 95);

access (read only) to the HPFS-2 OS/2 2.1 file system;

support for everyone standard formats CD ROM;

TCP/IP network support, including ftp, telnet, NFS, etc.

The growing popularity of Linux is prompting developers to take a closer look at this operating system. At the moment, this OS is ready for stable operation, and the openness of its source code and architecture, along with its growing popularity, forces programmers to transfer their developments to many hardware platforms: SGI, IBM, Intel, Motorola, etc.

For real-time tasks, the Linux developer community actively uses special extensions - RTLinux, KURT and UTIME, which make it possible to obtain a stable real-time environment. RTLinux is a hard real-time system, while KURT (KU Real Time Linux) is a soft real-time system. The Linux extension UTIME, included in KURT, allows you to increase the frequency of the system clock, which leads to faster task context switching.

RTLinux is an operating system in which a small real-time kernel coexists with the Posix-like Linux kernel. The main goal is to make available complex services and optimized system behavior in standard situations for a time-sharing system, while at the same time performing real-time tasks. In the past, real-time operating systems were primitive - simple programs that offered the user little more than just a library of basic functions. But nowadays users demand access to TCP/IP, graphic display and window systems, databases, and other services that are neither primitive nor simple. One solution is to add non-real-time services to the underlying real-time kernel, which is what was done in VXworks and, slightly differently, in the QNX microkernel. The second possibility is to modify the standard kernel and make it completely interruptible.

2.3.2 RTLinux organization

RTLinux is organized in a third way, in which a simple real-time kernel runs a regular kernel as one of the lowest priority real-time tasks, using a virtual machine to make the standard kernel completely interruptible.

In RTLinux, all interrupts are serviced by the real-time kernel and then transferred to the standard kernel, but only if there is no need to run one of the real-time tasks. In order to minimize the number of changes to the standard kernel, this mechanism is implemented using ICH (Interrupt Control Hardware) emulation. The Linux real-time kernel and user tasks can communicate through non-blocking queues and shared memory segments.

From a programmer's perspective, queues look like standard UNIX serial devices that can be accessed using the POSIX read/write/open/ioctl system calls. Shared memory is accessed through the mmap system call.

RTLinux uses Linux to boot, access most devices, network, file systems, management Linux processes and loading kernel modules, which makes it possible to easily modify the real-time system.

A real-time program consists of two parts: a task, which is a kernel module, and an ordinary UNIX/Linux process and takes care of data processing, display and network access, and any other functions that do not require such strict timing.

In practice, it turned out that the RTLinux idea was very successful. In the worst case, the interrupt latency on the 486/33Mhz PC turned out to be less than 30 µs, which is close to the hardware limit. For applied tasks, the symbiosis of real-time systems and those optimized for the “general case” turned out to be very successful. The most commonly used RTLinux configuration is primitive real-time tasks with statically allocated memory without memory protection, a simple scheduler with fixed priorities without protection against unrealized plans, hardware interrupt disabling, shared memory is the only mechanism for synchronizing real-time tasks and limited set operations on FIFO queues attached to regular Linux processes.

The Linux kernel allows dynamic loading and unloading of kernel modules. By representing individual parts of the real-time kernel as modules, it is easy to change the real-time kernel. Alternative schedulers and a semaphore module have already been written. While the system is running, you can load a module with real-time tasks, then unload standard scheduler and load, for example, the EDF scheduler. You can try different combinations of modules until the optimal one is found.

This Linux variant allows you to perform real-time tasks, which is achieved by inserting a real-time kernel between the standard Linux kernel and hardware interrupts and gets rid of the main reason why Linux is unsuitable for real-time tasks - the large interrupt lag.

From an RTLinux point of view, Linux is one of the lowest priority real-time tasks that can be interrupted when needed. This structure imposes some restrictions on real-time tasks. They can't easily use various drivers Linux, do not have access to the network, etc., but can exchange data with standard Linux tasks.

Simple FIFO queues are implemented to exchange data between real-time processes and Linux processes. A typical application consists of two parts - a real-time task that directly operates the hardware, and, usually, a Linux task that performs other operations, such as saving data to disk, sending it over the network, interacting with the user (GUI), etc. .

The shortest period for periodically invoked real-time tasks in RTLinux on the Pentium 120 is less than 150 µs. Tasks called by interruption can have a much shorter period.

The real-time kernel does not protect against overloads. If one of the real-time tasks completely utilizes the processor, Linux kernel, having the lowest priority, will not receive control and the system will hang. Real-time tasks run in the kernel address space with kernel privileges and can be implemented, for example, using Linux modules.

It should be noted that LynuxWorks began shipping (05/17/2002) the BlueCat Linux embedded OS for the Intel Internet Exchange Architecture Software Developers Kit (Intel IXA SDK) 2.0, designed for the Intel IXP1200 family of network processors. BlueCat Linux OS is distributed free of charge with Intel IXA SDK 2.0.

VxWorks has long become the de facto standard for the vast majority of systems using embedded operating systems. The IXP1200 computer system's flash memory contains the VxWorks kernel loader. For developers, this simplifies the task of writing new programs. In addition, the ability to operate the network processor under Linux OS (with real-time extensions) has already been implemented. Software support is provided by some Linux OS manufacturers (for example, LynuxWorks, etc.).

2.4 Real-time monitoring and control using OS9

2.4.1 Introduction

To control one or many remote installations from a single center and check their status, CS (France) has developed a monitoring system. It can be used to control energy facilities, air conditioning systems, security systems, process plants, networks, industrial conveyors and has already been implemented in many civilian and military facilities.

The system provides hardware and software solution all aspects of control. Wide range of possibilities Interfaces provide data collection from outdoor sensors, end devices, programmable I/O units, and host systems.

The control system can be divided into two levels:

Level 1 for collecting and processing local data;

Level 2 for collecting and analyzing data from remote objects.

Fig.1. General concept of the system

Tasks at level 1 are performed by the GESCAP unit (for example, a workstation on a Motorola 68010 processor with 1 MB RAM), and at level 2 - by a GESVA unit (for example, a workstation on a Motorola 68030 processor with 4 MB RAM). The GESVA and GESCAP units use the same operating system (OS-9) and application software. Only the video terminals and functionality are different. This uniformity makes the system easier to install, use, and maintain.

Since the user interface of GESVA and GESCAP is intuitive, configuration work is straightforward and does not require any special computer knowledge. The user deals with pop-up menus and dialog boxes, providing access to the following standard features.

Configuration of analog or digital I/O blocks (alarms, messages, priorities, etc.):

logical operations (AND, OR...) on input data;

establishing the correspondence of connectors to each input/output device;

rearrangement of input/output devices;

graphic interaction with animation elements.

Status display functions:

status of I/O blocks, devices, connections, alarms, real-time logbook.

Graphics features:

automatic location of alarms in images;

navigating through images of data sources;

display of curves in real time;

video display of curves in real time.

Communication functions:

JBUS/MODBUS communication protocol (RS-232/RS-422);

communication with the system of assistance in localization and elimination of faults (GESDOC).

Printing functions:

printout of the system structure;

Printing a list of alarms and events.

Functions for various purposes:

integration of new tasks with software without requiring any changes at the source code level.

2.4.2 How did this application system develop?

The main software requirements were:

the same composition of application programs and a single user interface on different boards and display types;

a fast, advanced multi-window environment that consumes as little memory as possible;

a multi-tasking, ROM-flashed real-time operating system with low memory requirements.

As a result, the OS9 operating system was selected, which best meets the listed requirements.

The WINOTOOLS package was selected as a multi-window development environment. Using WINOTOOLS utilities you can develop all elements without programming user interface(windows, graphical data input tools, buttons, warning messages, etc.).

Due to its modest memory requirements and fast response time, WINOTOOLS, combined with the characteristics of OS9, is an ideal environment for developing a variety of real-time applications running in graphical mode.

WINOTOOLS provides the following utilities:

PAINT is an object-oriented graphic editor for developing user interfaces, control panels and diagrams. PAINT is designed to be customizable and integrated into a user's application program. All graphic data files created using PAINT can be completely modified without accessing the source code (files in GIF format are imported).

SCRIPT is a language that allows you to simulate all user interface dialogs before writing a line of source code. This utility allows you to quickly check the correctness of the user interface.

DATABASE - a library of C functions that provides database management (correspondence between data and database index files).

INPUT/OUTPUT LIBRARY - a library of C-functions that provides interface between the user interface and input/output devices.

2.5 Windows NT

2.5.1 Possibility of using Windows NT as a real-time OS

Recently, real-time extensions for Windows NT have become popular. This is due, on the one hand, to the expansion of areas of application of computer control, on the other hand, to the relatively low popularity and high cost of specialized real-time operating systems. But even if this were not so and no less was known about other systems, Win NT RTX would still be the most popular. It’s not for nothing that the ratio of users of Windows operating systems to users of Linux/Unix systems is 1000 to 1. It is quite logical that a person, working at home in one system, wants to see the same one that is understandable to him convenient system and at work. The Win32 interface is standard and familiar to a large number of programmers and users. Under NT there are a huge number of ready-made applications (including communication ones), as well as popular development tools. Unfortunately, Windows NT "in its pure form" cannot be classified as a real-time operating system. The reasons for this are discussed in articles by Martin Timmerman and Jean-Christophe Monfret in Real-Time Magazine Q21997.

Here are some of them:

insufficient number of real-time priorities;

lack of priority inheritance as a means of combating priority inversion;

interrupt handling system unsuitable for RTOS.

In Windows NT, interrupts are accessed from the kernel driver, and the interrupts themselves are processed in two stages: first, a very short Interrupt Service Routine (ISR) is called, which performs critical processing, the main interrupt processing occurs in the Deferred Procedure Call (DPC). All DPCs are executed at the same priority level on a first-in-first-out (FIFO) basis.

Thus, the completion time of your DPC processing turns out to be unpredictable depending on the presence of other drivers in the system and their activity. For systems with strict determinism, it is necessary to know exactly the maximum time from the moment an interrupt occurs to entering the processing procedure and guarantee that it is not exceeded.

2.5.2 RTX - real-time extension for Windows NT from VenturCom

One possible solution is to use a real-time subsystem in conjunction with Windows NT, running on the same processor (if there is only one processor) or on a dedicated processor(s) (if there are several). This approach is used by VenturCom in the RTX product. The essence of the approach is to use a modified HAL (Hardware Abstraction Level). Microsoft does not allow changing the kernel, and the HAL source code is provided to its partners, one of which is VenturCom.

After installing RTX, a standard NT Workstation or Server turns into a hard real-time operating system. NT itself, however, does not suspect this. Neither the NT kernel nor the runtime subsystem has been changed. The real-time subsystem is visible from Windows NT as another device driver.

The Windows NT operating system was originally developed as a general purpose. However, in the current market of specialized systems, in order to ensure openness at each system level, there is a tendency to use Microsoft Windows operating systems. This is due to the following reasons:

the Win32 application programming interface (API) is currently the de facto standard for programmers;

the graphical user interface (GUI) is so popular that the GUI interfaces of other operating systems are beginning to resemble it more and more;

a huge number of drivers from independent manufacturers have been developed;

Many very powerful integrated development tools (IDEs) have been developed.

2.5.3 Windows NT 4.0 as an RTOS. General requirements

To be called an RTOS, the operating system must satisfy some minimum set requirements that are necessary but not sufficient. I pointed this out at the very beginning of my work, but let’s repeat it again:

the operating system must support multithreading (multi-threaded) and task preemption by priority (preemptable);

there must be a concept of thread (thread) priority;

the operating system must support mechanisms for synchronizing the execution of threads (threads) with predictable characteristics;

there must be a mechanism for inheriting priorities;

The behavior of the operating system must be known and predictable (internal interrupt delays, task switching delays, driver delays, etc.).

Windows NT clearly satisfies the first requirement. The second one too, but for real-time mode the priority levels are not enough. It is almost impossible to design a good real-time system, for example with rate-monotonic scheduling, because available quantity there will not be enough priority levels of thread execution. In addition, NT does not have a priority inheritance mechanism.

To handle interrupts in order to minimize the time spent on interrupt service routines (ISRs), NT introduced the concept of deferred procedure calls (DPC). Although the priority of these calls is higher than the priority of user and system threads, they are all at the same level. This means that all DPC calls are queued in a FIFO queue and that a high-level interrupt will only be serviced when all previous DPC calls have completed their execution. As a result, the system response time becomes unpredictable, which contradicts the fifth requirement.

NT's memory management is based on virtual memory. This entails memory protection, address translation, and swapping. For RT applications, swapping is unacceptable. Memory pages may be locked in physical memory. However, Jeffrey Richter argues in his book that if a process is not active, NT can unlock the process's pages and write them from physical memory to disk.

2.5.4 Real-time extensions for Windows NT. Expansion of functionality

Real-time extensions add real-time-specific functionality to Windows NT:

Real-time processes appear, controlled by their own scheduler. This scheduler already works according to all the rules of real-time schedulers and uses a priority-based preemption algorithm. In addition, real-time processes take precedence over standard Win32 processes, displacing them. Real-time processes have a completely different degree of reliability and specific functionality compared to standard Windows NT processes.

Real-time processes and standard Win32 processes have a means of communicating with each other.

Real-time processes have their own RTAPI programming interface, which implements a developed set of tools characteristic of program interfaces (APIs) of real-time operating systems.

The same application can use both standard Win32 functions and specific real-time API (RTAPI) functions, which allows you to isolate critical sections of Windows NT application code and control the timing and reliability of their execution.

It becomes possible to monitor the performance and response times of the system. Standard Windows NT application freezes or system crashes do not cause real-time applications to freeze.

It becomes possible to work with fast clocks and high-resolution timers.

Allows direct access to memory and physical devices

2.5.4.1 RTSS real-time subsystem

The RTSS real-time subsystem provides most of the functions and resource management of real-time extensions. From an implementation point of view, RTSS looks like a Windows NT driver and runs in kernel mode. This allows enough in a simple way arrange interaction between real-time processes and Windows NT processes. RTSS provides execution of RTAPI functions and contains a real-time thread scheduler with 128 fixed priorities. RTSS also contains an object manager that provides unified mechanisms for using system resources.

RTSS Object Management: Provides unified RTSS object management capabilities (create, close, access). RTSS objects are: timers, interrupt and exception handlers (startup, shutdown, blue screen), threads, processes, semaphores, mutexes, shared memory, mailboxes, console and file I/O, registers.

2.5.4.2 Real-time HAL

HAL is a software component of the low level when kernel drivers interact with hardware. In particular, it is at the HAL level that the initial processing of timer interrupts occurs. An important feature of the Real-Time HAL implementation is that it is fully compatible with the standard HAL, and, moreover, the execution time of the Real-Time HAL and standard HAL codes are the same if the real-time subsystem is not used.

2.5.4.3 Real-time programming interface RTAPI

Software interface real-time RTAPI is an extension of Win32 and contains, first of all, a set of functions necessary for managing devices. RTAPI is implemented in two forms - as a subset of the real-time subsystem (RTSS) and as a dynamic-link library (DLL) that can be called from Win32 applications. RTAPI contains the following groups functions:

Process and Thread Management: Provides a Win32-compatible interface for managing, creating, reprioritizing, profiling, and terminating real-time threads.

Inter-process communication: RTAPI uses semaphores, mutexes, and shared memory to communicate both between real-time threads and between real-time threads and between real-time processes and WIN32 processes.

Memory Management: Allows applications to be locked into memory, preventing them from being swapped out to the page file.

Physical memory access: The user application is able to access data at physical memory addresses.

Interrupt Management: Contains functions that allow you to assign and disable interrupt handlers, enable and disable interrupts.

Clocks and timers: Contains functions for managing clocks and timers (creating, deleting, canceling, initializing timers, assigning interrupt handlers)

I/O Control: RTAPI provides two ways to control I/O devices. First, user applications are able to directly access I/O port addresses, allowing devices to be programmed directly. In addition, an external device can be controlled by special (easy to develop) drivers, for which RTAPI provides a special interface.

3. RT OS used in modern CNC systems

Currently, many RT OSs show similar performance indicators, so one of the most important conditions for the success of an operating system (along with high performance) is the presence of a developed development environment, graphical interfaces, and network support; ability to work on multiprocessor devices. Among the most well-known RT OSs for CNC systems are:

• RTMX (company RTMX-Uniflex);

  AMX (Kadak Products Ltd.);

  OS-9000 (Microwave Systems);

  Lynx OS (Lynx Real-Time Systems);

  VRTX (Ready Systems);

  FlexOS (Novell Dedicated Sys Bus Unit);

  QNX (Quantum Software Systems)

  RV OS of our own design.

3.1 RV OS of our own design

Despite the seemingly sufficient number of real-time operating systems, many large companies are starting to develop their own RT OS. Technological processes and cycles are becoming more complex, the quality and demands placed on operating systems are higher. Therefore, the company may face two situations: either pay a third-party company to develop an OS for itself, or the company itself develops its own RT OS for its CNC systems. The second is especially important if the goal is to keep the technological features of production secret.

3.2 FlexOS

Currently used very rarely. This operating system was modern and popular, but now it is rather outdated. Siemens had its own FlexOS operating system, its own languages, and field buses. Then Siemens proclaimed openness as its principle. The de facto standard for earlier Siemens and, in general, process control software from different companies was the Windows NT operating system, which made it possible to use in software all the baggage accumulated in office systems.

3.3 QNX

This operating system is intended not only for personal computers, but also for a wide variety of household and industrial intelligent devices - systems that control technological processes, CNC machines, Internet set-top boxes, video playback units, game consoles. This OS is quite remarkable and unique in many ways. In 1982, in Canada, Quantum Software Systems, Limited - QSSL, created by Messrs. Bell and Dan Dodge, introduced to the world the latest multitasking, multi-user real-time operating system "Quick UNIX", which is said to have been developed , began at the request of the United States Department of Defense. It was a UNIX-like operating system, or rather, compatible with the POSIX application portability standard, according to which UNIX and its popular clone Linux are also made.

3.4 Windows XP

As strange as it may sound, it happens that Windows XP is used as a graphical operator interface, and a special real-time operating system is used to securely provide CNC functions. If a problem occurs on XP (for example, with the network connection), this will not affect the processing or the machine itself, because The CNC operates in its own operating system.

3.5 Windows NT4

It is generally accepted that it is a reliable, multitasking network OS, and, very importantly, it has a Windows 95 interface that has become native to many. Many companies use it when developing their CNC systems:

For example, Walter Grinders equips machines of the Helitronic_Power model with its own open CNC system (type HMC 500). The HMC 500 CNC system uses a Pentium processor, Windows NT operating system and Walter Window Mode software. Walter Window Mode software is a proprietary product of Walter Grinders.

The WinPCNC system is a single-computer CNC system built on a powerful personal computer platform with Windows NT operating system and RTX 4.1 real-time extension. It belongs to the PCNC (Personal Computer Numerical Control) class, i.e. to the class of so-called “personal control systems”, which are rightly considered today the most promising class of new generation CNC systems. The system uses a single processor to service all its functions, including electrical functions. The hardware is represented by standard personal computer equipment and additional interface modules for communication with feed and main motion servo drives, electrical automation drives, and the operator panel. All these tools are available today on the computer market, and therefore there is no need to organize special production of CNC systems.

Of course, I would like to have Windows NT as the RT OS. But can Windows NT today, even with Real-Time Extensions, handle the tasks that RT OS has always solved? Numerous tests have shown that on typical computer platforms based on Pentium processors, the maximum interrupt response time (from the occurrence of the interrupt to entering the processing thread, including context restoration) is 25-80 μs, provided that the system under test is heavily loaded: disk check (chkdsk ), GUI applications and intensive network communication. These figures are comparable to those provided by other RT OSs and exceed some of them.
Considering the above, it makes sense to start looking for a successful Real-Time Extensions solution for Windows NT. It must be said that Windows NT is not an open system, and it is clear in advance that third-party Real-Time Extensions projects will only be add-ons that do not change the essence of the OS.

Supplementing the standard NT kernel with a real-time kernel is the approach that underlies offerings from Radisys, Imagination and LP Elektronik. There are two fundamentally different implementations:

place the real-time kernel inside the Windows NT interrupt service routine or in a device driver;

place the real-time kernel outside the Windows NT address space.

As a result, I would like to note that, although the methods for implementing real-time extensions differ, their essence is the same - simultaneous operation of two operating systems on one processor: Windows NT and real time, plus the ability to interact between real-time processes and Windows NT processes.

3.6 Windows CE 2.0 - open CNC systems

GE Fanuc Automation has prepared for the release of Is series CNC systems - the world's first open CNC systems with a built-in Windows CE 2.0 operating system. The series includes three models: mod. Series 160 Is, mod. Series 180 Is and mod. Series 210. Series Is CNC systems can be used to control various types of metal cutting machines, ranging from 2-axis lathes to 5-axis machining centers, laser cutting machines, punching presses, etc.

The Windows CE 2.0 operating system is, as you know, designed for pocket computers and therefore has a very small size. At the same time, its capabilities are quite sufficient to implement the functions that modern open CNC systems should have. Thanks to the small size of Windows CE 2.0, the Is series CNC systems have been able to eliminate the need for a hard drive. Flash memory with a capacity of 45 MB is used to store the operating system and control programs. The absence of a hard disk in the Is series CNC systems makes them extremely resistant to mechanical stress, which is difficult to eliminate during transportation and operation in real production conditions.

3.7 Nucleus

The Nucleus operating system, designed for embedded applications, was developed by Accelerated Technology Inc. (ATI, USA), founded in 1990 by two programmers. They set themselves a very specific goal: to create a very compact real-time OS for embedded systems, independent of the type of processor, completely open (which means delivery with source code), well documented and at an affordable price.
If Nucleus is compared, for example, with such a well-known RT OS QNX, then it is easy to notice a number of their differences.

Nucleus is a cross-system, while QNX is both a development and runtime environment. A cross-system refers to a development technology in which software is created on one software and hardware platform and executed on another. QNX's combination of development and runtime environments is very useful in cases where the user is working on an IBM PC-compatible architecture.

Nucleus allows you to develop software for many processors, while QNX allows you to develop software only for IBM PC-compatibles.

Unlike QNX, Nucleus comes with source code. This is especially important for the military, since the availability of complete source code makes it easier to certify the created application.

When purchasing Nucleus, the buyer pays only once: ATI does not charge additional fees for replication of its software. The cost of this OS along with the necessary tools is 10-30 thousand dollars. When purchasing QNX, the user must pay for the complete system (about 2500 dollars for the OS and Watcom C compiler), and when replicating the software, buy at least QSSL from the company modular licenses for the required set of drivers (from 50 to 1000 dollars).

QNX 4.x complies with the POSIX 1003 standard. Nucleus does not comply with this standard, but it has a fairly powerful set of system calls.

3.8OSE 5.0

Sharp Microelectronics and Enea Embedded Technology are collaborating to optimize BlueStreak System-on-Chip components specifically for use in mobile end devices.

In the first project, Enea hosts version 5.0 of the OSE real-time operating system (RTOS) on a 32-bit LH7A400 microcontroller. This System-on-Chip, based on the ARM922TT 200 megahertz core, already includes numerous peripheral modules such as USB Device, MultimediaCard Interface, external DMA controller, serial and parallel interfaces including infrared support, as well as programmable controllers with direct LCD interfaces for all common display types (STN, Color STN, TFT and Sharps Advanced-TFT). It supports resolutions up to 1024x768 pixels, with up to 64,000 colors and 15 halftones. Thus, BlueStreak SoC LH7A400 is designed for use as a processor in high-end mobile devices.

3.9 OS-9

OS-9 belongs to the UNIX class of similar real-time operating systems and offers many familiar elements of the UNIX environment for use. However, the system's original modular, object-oriented design is as new now as it was when it was first created. OS-9 is an extremely configurable, high-performance real-time system. The modularity of the system means that it can be scaled to meet the needs of both small embedded systems and large network applications. All functional components of OS-9, including the kernel, are hierarchical file managers, the input/output system and development tools are implemented as independent modules. By combining these modules, the developer can create systems with a wide variety of configurations - from miniature standalone ROM-oriented cores to full-scale multi-user development systems. As a rule, programs are developed in full-featured configurations. Once the real-time program code has been debugged, the development and I/O modules are detached and the resulting code is ready to run under kernel control on the target system.

3.10 VxWorks/Tornado

The VxWorks operating system is a system with cross-tool application software development, that is, development is carried out on a tool computer (host) in the Tornado environment for subsequent execution on a target machine running VxWorks.

VxWorks supports target architectures (targets): Motorola 680x0 and CPU32, Intel 386/486/Pentium/.., Intel 960, SPARC, Mips R3000/4000, ARM, Motorola 88110, HP PA-RISC, Hitachi SH7600, PowerPC, DEC Alpha , Siemens C16x.

Tool platforms supported for Tornado (hosts): Sun SPARCstation (SunOS and Solaris), HP 9000/400,700 (HP-UX), IBM RS6000 (AIX), Silicon Graphics (IRIX), DEC Alpha (OSF/1), PC ( Windows 95 and NT).

Supported host-target interfaces: Ethernet, RS-232, ICE (In-Circuit Emulator), cross-bus (backplane), ROM emulator, BDM interface (Background Debug Mode).

The Tornado toolchain has an open architecture, which allows other real-time software development tool companies to integrate their software products with Tornado. The user can also connect their own specialized development tools to Tornado, as well as expand the capabilities of Wind River Systems tools.

The standard Tornado configuration includes the VxWorks kernel and system libraries, GNU C/C++ Toolkit, CrossWind source language level remote debugger, WindSh shell, BSP WindConfig configurator, etc.

3.12 RTX

VenturCom has developed the RTX (Real-Time Extensions) real-time subsystem for Windows NT with the blessing and support of Microsoft support. Microsoft has licensed the source code for a component of Windows NT called the Hardware Abstraction Level (HAL), which basically defines the OS's interrupt handling characteristics. RTX adds additional calls to the application programming interface (RTAPI, Real-Time API), and also loads a modified HAL that<изолирует>hardware interrupts from the Windows NT kernel. RTX provides the system with a 1ms real-time clock and improves response time. RTX provides processes with access to physical addresses of memory and I/O ports, as well as special methods of working with paged memory that eliminate the latency inherent in Windows NT. Attempts to reboot or heavy shutdowns such as<голубой экран>. In addition, interfaces are offered that replace WIN32 functions responsible for scheduling and synchronizing tasks, intertask messaging, working with hardware interrupts, etc. The most interesting thing is that this does not require changes to Windows NT and this will not affect the performance of existing programs.

For embedded developers, VenturCom offers a version of Windows NT that requires less than 10 MB of ROM and 8 MB of RAM. Paging of virtual memory pages is prohibited, and as a additional drivers Null-Display and Null-Input drivers are offered, allowing the system to operate without a display and keyboard.

3.13 Falcon

Under this beautiful code name we can easily recognize the iRMX operating system, which is familiar to many. After Intel transferred the rights to this RTOS to RadiSys, the latter worked tirelessly to integrate the resulting product with the Windows NT platform. The company chose the standard path of licensing HAL-level source codes from Microsoft, with their subsequent modification to meet the requirements of strict real-time.

As in the previous case, new functions optimized for real-time operation are added to the standard WIN32 functions. The iRMX-based real-time kernel itself coexists with the Windows NT kernel and is responsible for executing performance-critical processes. Windows NT, along with all standard applications, is in this case the lowest priority process, which receives control only if all real-time tasks are in an inactive state. The real-time subsystem can continue to function even if Windows NT freezes completely.

4. CNC Overview

Below is a table of correspondence - in which modern CNCs, which operating systems are used.

CNC system	operating system
Siemens GmbH
840 D/ 810 D	Windows/UNIX Real Time
840 Di	MS Win NT/ XP + RTX
802 D	Real Time DOS
802 S/C	Operating system of our own design
GE Fanuc
0T-D, 1018T, 3000C, 6M, 7,SYS P - Model E	QNX 6.2Windows NT
160i-MB	Windows 2000 (ISO-DIN programmable)
Series 210 Is	Windows CE 2.0
Series 180 Is	Windows CE 2.0
Series 160 Is	Windows CE 2.0
Balt-System SPb
NC201	Operating system of our own development (no information)
NC110
NC210	Operating system of our own development (no information)
M.S.H.
MSH PC-104	MS Win NT/ XP + RTX
MSH TURBO-U	MS Win NT/ XP + RTX
MSH TURBO-M	MS Win NT/ XP + RTX
MSH TURBO-120M	MS Win NT/ XP + RTX
FMS
FMS-3000 - N.Novgorod
FMS-3100 - N.Novgorod	The system software is implemented on the basis of a hard real-time kernel using the RT-Kernel library,
Heidenhain (Germany)
TNC 145TNC 151TNC 155TNC 355TNC 4110TNC 426TNC 530	The following operating systems are used:QNX 6.2DOSWindowsUnixLinux
Gildemeister
Eltra PilotEltra-pilot GD-4A	Windows NT4
MAHO (Germany)
MAHO 332MAHO 432	MS DOS, MS Windows 3.x
NCT
NCT 2000	Linux RT or Windows RT
Numerik
CNC 600CNC 645CNC 646	Windows NT4
WinPCNC	single-computer CNC system built on a personal computer platform with Windows NT OS and real-time extension RTX 4.1 from VentureCom
KRT4-00 - Contour	Terminal partMS Win NT/ XP + RTX

5. Conclusions

So which OS should you choose? If we consider a dual-processor CNC architecture, then it is better to install a reliable OS with a convenient interface (Windows NT) on the PC module that performs the terminal task, and install a RT OS on the NC module, which solves geometric and logical problems, for example QNX, which is well structured and has a developed set of specific real-time mechanisms, compact and predictable.
The computing power of modern personal computers is constantly growing, and today it is possible to build a single-processor CNC system. To implement it, it is necessary to combine two tasks, PC and NC, under the control of a single OS.

It is impossible to say unambiguously which operating systems CNC suppliers use when creating them. Those. It is impossible to single out any specific system from others. The choice of OS depends on the tasks that it must solve and on the financial security of the end user. Even within the same company you can find a large number of different SRVs.

To achieve different production goals, it makes sense to use different systems, best meeting certain requirements. Moreover, sometimes we are talking not only about system characteristics, but also about monetary costs.

Once again, extensions for Win NT should be especially noted as the most flexible and justified system, gaining increasing popularity among leading developers and advanced users.

6. Literature used

• Timmerman M., Monfret J-C., "Windows NT as Real-Time OS?", Real-Time Magazine 2/97, 6-13
• Sorokin S.A. Real-time systems. STA. 1997, No. 2, p. 22-29
• Shalunov S. Hurd OS - FSF development based on a microkernel. Open systems. 1997. No. 3
• Volodin S.V., Makarov A.N., Utrikhin Yu.D., Faradzhaev V.A. System-wide design of real-time automated control systems. M. 1984
• Place of information display systems in real-time automated control systems.
• Windows NT Real-Time Extensions: an Overview, Real-Time Magazine, 97Q2, Dr. ir. Martin Timmerman, Managing Director, Jean-Christophe Monfret, Project Manager, Real-Time Consult.
• Sosonkin V.L., Martinov G.M. Analysis of the current world level of architectural solutions in the field of CNC
• Martinov G.M., Sosonkin V.L. Real-time problem

Introduction

A computer is a computing system consisting of hardware and software. Its operation requires basic software - an operating system. Without an operating system, a computer cannot work.

An operating system is a set of programs that organize and control the operation of a computer.

Goal of the work: conduct a comparative analysis of operating systems of the Windows and Mac OS families.

Tasks:

• Define an operating system;
• Consider the functions of operating systems;
• Conduct a comparative analysis of operating systems.

1. Basic definitions and concepts

1.1. operating system

An operating system is a set of interconnected system programs that are loaded when the computer is turned on and are permanently stored in the computer's memory. They conduct a dialogue with the user, manage the computer, its resources (RAM, disk space, etc.), and launch other (application) programs for execution. The operating system provides the user and application programs with a convenient way to communicate (interface) with computer devices.

The main reason for the need for an operating system is that the elementary operations for operating computer devices and managing computer resources are very low-level operations, so the actions that are required by the user and application programs consist of several hundred or thousands of such elementary operations.

For example, a magnetic disk drive “understands” only such basic operations as turning on/off the drive motor, installing read heads on a specific cylinder, selecting a specific read head, reading information from a disk track into a computer, etc. And even to perform such a simple action as copying a file from one floppy disk to another (a file is a named set of information on a disk or other machine media), it is necessary to perform thousands of operations to run disk drive commands, check their execution, search and process information in tables placing files on disks, etc.

The operating system hides all these complex and unnecessary details from the user and provides him with a convenient interface to work with. It also performs various auxiliary actions, such as copying or printing files. The operating system loads all programs into RAM, transfers control to them at the beginning of their work, performs various actions at the request of executing programs, and frees RAM occupied by programs when they complete.

Operating systems can be divided into groups (classified) according to the following criteria:
1. By the number of users: single-user operating system (serves only one user); multi-user (works with many users)
2. By the number of processes: single-task (process only one task - no longer used); multitasking (locates several tasks simultaneously in RAM, which are alternately processed by the processor)

By type of computer technology: single-processor, multiprocessor (tasks can be performed on different processors; servers are usually multiprocessor), network (provide sharing resources for all tasks performed on the network).

Based on the type of interface (the method of interaction with the user), operating systems are divided into 2 classes: OS with a command line interface and OS with a graphical interface.

There are several types of operating systems: Windows, Mac OS.

1.2. Operating system features

The functions of the operating system include:

• carrying out a dialogue with the user;
• input/output and data management;
• planning and organizing the program processing process;
• resource distribution (RAM and cache, processor, external devices);
• launching programs for execution;
• all kinds of auxiliary maintenance operations;
• transfer of information between various internal devices;
• software support for the operation of peripheral devices (display, keyboard, disk drives, printer, etc.).

2. Comparative analysis operating systems

2.1. Windows XP

The history of Windows (developed by Microsoft) dates back to 1986. It gained popularity in 1990, when Windows 3.0 was released. The popularity of the new version of Windows was due to several reasons. Graphical interface allows you to work with objects on your computer not using commands, but using visual and understandable actions on the icons representing these objects. The ability to simultaneously work with several programs has significantly increased the convenience and efficiency of work. In addition, the convenience and ease of writing programs for Windows has led to the emergence of an increasingly diverse range of programs running under Windows control. Finally, work with a variety of computer equipment was better organized, which also determined the popularity of the system. Subsequent versions of Windows were aimed at improving reliability, as well as support for multimedia (version 3.1) and work in computer networks (version 3.11).

In 1995, the Windows 95 system appeared, which became a new stage in the history of Windows: the interface changed significantly, the speed of programs increased, and the system included Internet browser Explorer.

The continuation of the development of Windows 95 was the operating system that appeared in 1998 (Windows 98). While the interface remained the same, the internal structure was significantly redesigned. Much attention was paid to working with the Internet, as well as supporting modern information transfer protocols - standards that ensure the exchange of information between various devices. Besides, Windows feature 98 is the ability to work with multiple monitors.

The next stage in the development of Windows was the appearance of Windows 2000 and Windows ME (Millennium Edition). The Windows 2000 system was developed on the basis of Windows NT and inherited from it high reliability and security of information from outside interference. The Windows ME operating system became the successor to Windows 98, but acquired many new features. First of all, this is improved work with multimedia, the ability to record not only audio, but also video information, powerful means of recovering information after failures, and much more.

The Microsoft Windows XP operating system (from the English eXPerience - experience), or Microsoft Codename Whistler, is an OS of the Windows family, created on the basis of NT technology.

Currently, Windows XP for desktop PCs and workstations is available in three versions: Home Edition for home personal computers, Professional Edition for office PCs and, finally, Microsoft Windows XP 64bit Edition - this is the version of Windows XP Professional for personal computers built on based on a 64-bit Intel Itanium processor with a clock frequency of more than 1 GHz.

When you compare Windows XP to earlier versions of Microsoft Windows, it's easy to spot many significant differences in the new operating system. Despite the fact that this OS was developed on the basis of the NT platform and, at first glance, its characteristics are in many ways similar to Microsoft Windows 2000, in fact Windows XP belongs to a fundamentally different generation of operating systems of the Windows family. Now the Windows user is not tied to any standard interface installed on the system by default: you can easily change the appearance of windows by downloading any of hundreds of specially designed “Themes” from the Internet. The traditional Main Menu, which provides access to programs installed on the computer, documents stored on disks and operating system settings, has also undergone a number of significant changes. Now, when you press the Start button, a dynamic menu appears containing icons for only the five programs that you use most often. Thanks to this, you can get started with the applications you need much faster. The Log Off and Turn Off Computer buttons are also located here, allowing you to end your current Windows session and turn off your computer.

In the Microsoft Windows environment, the user often has to work simultaneously with several documents or a set of different programs. At the same time, inactive applications are minimized to the Taskbar, as a result of which it sooner or later becomes overcrowded with icons, and switching between tasks becomes difficult. In order to relieve the taskbar and free up more workspace for displaying icons of running applications, Windows XP uses the so-called task grouping algorithm, according to which similar programs running on the computer at the same time are combined into a logical visual group.

Windows has significant security problems in terms of remote hacking of the system. Coping with this problem is partially helped by installing patches regularly released by developers. Then Microsoft products become mostly secure, but without updating, the operating systems may again be open to hackers.

2.2. Mac OS

Go to new architecture, greatly transformed the Mac community and, in fact, divided the understanding of their computers into two eras - “before the transition to Intel” and “after the transition to Intel.”

The first Mac OS appeared in 1984, much earlier than Windows. It was designed specifically for Macintosh (Mac) computers. These computers have a closed architecture, that is, the computers themselves are assembled only by Apple.

The strength of Mac OS is the virtual absence of viruses for Macintosh. And the point is not only that Mac OS is not very widespread compared to Windows, but also that traditional viruses simply do not work in a UNIX environment. Theoretically, of course, there are samples of viruses that can work with some applications for Mac OS, but their number is simply insignificant compared to malicious software written for Windows. Even remote hacking of a computer running Mac OS is much more difficult than hacking a machine running Windows, and anti-virus programs may be needed only to prevent an infected file from being sent to a machine running Windows, since it will not cause you any harm .

The system interface also has significant differences from Windows. For example, if in Windows each program usually corresponds to one window with tabs and toolbars opening in it, then in Mac OS “floating” windows and panels are used, not tied to a common window, but located on the desktop.

The main feature of the Mac OS interface is its minimalism. This means that when the application is launched, the user is presented with key, basic interface and control elements and, only as needed, the user can customize the working environment to his liking. In this case, the user will not experience difficulties in mastering the OS interface.

Another distinctive feature of the interface is the dock panel. This is a panel at the bottom of the desktop where you can find icons for files and applications that you need quick access to, as well as running applications. The panel can be edited, resized, removed and added application icons. You can also note interface elements such as Dashboard and Expose. Dashboard is a panel for working with “widgets,” the simplest graphical applications that, as a rule, perform information functions. Expose – a function to display on the screen in the form of thumbnails all open windows or only windows of the active program.

Mac OS, unlike Windows, comes with the necessary set of tools for full operation from the very beginning. And although the list of programs for Mac OS is not as impressive as for Windows, nevertheless, all the basic necessary applications for work and entertainment are available there.

2.3. Advantages and disadvantages of operating systems
Advantages and disadvantages of Windows and Mac OS operating systems

	Advantages	Flaws
Windows	1. Wide selection of software 2. Full compatibility with all equipment 3. Technical support 4. Widespread 5. Easy to set up	1. Poor security 2. Somewhat high system requirements 3. Many restrictions (digital content control system, first appeared in Windows Vista, Microsoft is always trying to impose its opinion on what is best for the user)
Mac OS	1.Easy setup 2. Does not require knowledge of technical details from the user 3. Intuitiveness of use 4. Convenient organization of windows - all windows are visible and there is no need to switch between them. 5. Installed basic set BY 6.Good security	1. High cost of computers with Mac OS X 2. Closed computer architecture – there is no possibility of upgrading equipment

Conclusion

Over the past 10 years, computers have literally flooded apartments, offices, and businesses. The “smart box” is confidently entering our lives. Many people no longer imagine how they could manage without it before .

A large number of users prefer to use the computer for entertainment. In this case, Windows is suitable for people who need a multimedia center (music, cinema, Internet, games). And for those who need a computer that is not expensive and not too difficult to use for work, and Mac OS X is the best option for people who want to work on a computer without delving into the features of the system

With the help of simple and clear abstractions, the physical details of the computer's operation are hidden from the programmer.

Carries out an orderly and controlled distribution of processor time, memory, etc. between programs

Ensures the safety of each user's data and isolates their running applications from each other

A program that constantly runs on a computer (or part of it - the kernel), interacting with all application programs

Multiprocessor OS

An increasingly common way to increase the power of computers is to combine several central processing units in one system. Depending on the type of connection of processors and division of work, such systems are called parallel computers, multicomputers or multiprocessor systems. They require special operating systems, but often such operating systems are variants of server operating systems with special communication capabilities.

OS for personal computers

The next category is PC OS. Their job is to provide a user-friendly interface for a single user. Such systems are widely used for working with text, spreadsheets and Internet access. The most striking examples are Windows 98, Windows 2000, Windows XP, Windows Vista, Macintosh computer operating systems and Linux. These operating systems are very well known, and many people have no idea about the existence of other types of operating systems other than the one they use.

Real time OS

Another type of OS is real-time systems. The main parameter of such systems is time. For example, in manufacturing control systems, real-time computers collect industrial process data and use it to control machines in a factory. Often such processes must meet strict time requirements. So, if a car moves along a conveyor belt, then each action must be carried out at a strictly defined point in time. If some action must occur at a specific point in time (or within a given time range), we are dealing with a hard real-time system. There is another type: a flexible real-time system in which occasional missed deadlines for an operation are acceptable. Digital audio multimedia systems fall into this category. VxWorks and QNX systems are well-known real-time operating systems.

Embedded OS

Continuing to move from huge systems to smaller ones, we got to handheld computers and embedded systems. A pocket computer (PDA) or PDA (Personal Digital Assistant) is a small computer that fits in a pocket and performs a small set of functions (telephone notebook and notepad). Embedded systems that control device actions run on machines not typically considered computers, such as televisions, microwave ovens, and mobile phones. They often have the same characteristics as real-time systems, but have special size, memory, and power limitations that set them apart. Examples of such operating systems are PalmOS and Windows CE (Consumer Electronics).

OS for smart cards

The smallest OSs run on smart cards, which are credit card-sized devices containing a central processing unit. Such operating systems are subject to extremely strict restrictions on processor power and memory. Some of them can only handle one transaction, such as an electronic payment, but other OSes on the same smart cards perform complex functions. They are often proprietary systems. Some smart cards are Java-based. This means that the smart card ROM contains an interpreter virtual machine Java (JVM, Java Virtual Machine). Java applets (small programs) are loaded onto the card and executed by the JVM interpreter. Some of these cards can manage multiple Java applets at the same time, leading to multitasking and the need for scheduling. Due to the simultaneous operation of two or more programs, there is a need for resource management and protection. Accordingly, all these tasks are usually performed by an extremely primitive OS located on a smart card.

Materials used:

Completed by Borisova Albina 10a

Kukushkin Dmitry, TM-247

Study of OS evolution

Download:

Preview:

State budgetary educational institution of secondary vocational education "Arzamas Instrument-Making College named after P.I. Plandin"

RESEARCH

Completed:

Kukushkin D, student

Groups TM-247

Study of the evolution of operating systems

Scientific adviser:

Teacher Rakova L.V.

Arzamas,

2014

INTRODUCTION………………………………………………………………………………......3

CHAPTER I. The concept of an operating system……………………………………….. 4

CHAPTER II. Evolution of the operating system……………………………………..5

§2.1.First period……………………………………………………………….5

§2.2.Second period………………………………………………………………..5

§2.3. Third period…………………………………………………………………………………..6

§2.4. Fourth period………………………………………………………………7

CHAPTER III. System requirements for common operating systems...8

CHAPTER IV. Analysis of modern operating systems………………………………………….10

Conclusions on Chapter IV………………………………………………………………...12

CONCLUSION………………………………………………………………………………..14

LIST OF SOURCES USED…………………………….15

INTRODUCTION

The history of any branch of science or technology allows us not only to satisfy natural curiosity, but also to better understand the essence of the main achievements of this industry, to understand existing trends and to correctly assess the prospects of certain areas of development. Over the almost half-century period of their existence, operating systems have gone through a difficult path, full of many important events. Advances in improving operating systems had a huge impact on the development of operating systems. element base and computing hardware, therefore many stages of OS development are closely related to the emergence of new types of hardware platforms, such as minicomputers or personal computers. Operating systems have undergone a serious evolution due to the new role of computers in local and global networks. The most important factor in the development of the OS was the Internet. As this Network acquires the features of a universal means of mass communications, operating systems become more simple and convenient to use, include developed means of supporting multimedia information, and are equipped with reliable security measures.

The relevance of researchis caused by the need to improve operating systems to improve the quality of the user’s work with a computer, making it simpler, and freeing him from the responsibility of distributing and managing resources.

Object of study- OS.

Subject of study– effective technologies, scientific works of scientists and programmers, used by the user in working on the operating system.

The purpose of this research workis a description and analysis of the evolution of operating systems.

The goal is achieved through the following tasks:

Consider the historical aspect of the emergence of operating systems;

Identify and consider the stages of evolution of operating systems.

The first chapter covers general information about operating systems.

The second chapter examines periods of development of operating systems.

The third chapter discusses the system requirements of common operating systems.

The fourth chapter provides an analysis of common operating systems.

The work consists of four chapters, an introduction, a conclusion and a list of sources used.

CHAPTER 1. The concept of an operating system

Operating system, OS (English) operating system) - basic complex computer programs a kind of transmitter between computer hardware and other programs. The OS takes command signals sent by other programs and “translates” them into a language understandable to the machine. The OS manages all devices connected to the computer, providing access to them to other programs.

The OS allows you to abstract away from hardware implementation details, providing software developers with the minimum required set of functions. From the point of view of ordinary people, ordinary users computer hardware, the OS also includes user interface programs. Main functions (simple OS):

• Loading applications into RAM and executing them;

• Standardized access to peripheral devices (input/output devices);
• RAM management (distribution between processes, virtual memory);
• Controlling access to data on non-volatile media (such as Hard Disk, CD, etc.), usually using a file system;
• User interface;
• Network operations, protocol stack support

Every OS consists of at least 3 required parts.

The first is the kernel, a command interpreter, a “translator” from a software language to a hardware language, a machine code language.

Second - specialized programs to control various devices included in the computer. Such programs are called drivers. This also includes the so-called “system libraries” used both by the operating system itself and by the programs included in it.

The third part is a convenient shell with which the user communicates - the interface. This is a kind of beautiful wrapper in which a boring and uninteresting kernel is packed. The comparison with packaging is also apt because it is what people pay attention to when choosing an OS, while the kernel, the main part of the OS, is remembered only later.

The most common operating systems today are all Microsoft operating systems, Linux and Mac OS.

CHAPTER II. Evolution of the operating system

§2 .1 First period (1945 -1955)

It is known that the computer was invented by the English mathematician Charles Babage at the end of the eighteenth century. His “analytical engine” was never able to really work, because the technologies of that time did not meet the requirements for the manufacture of precision mechanics parts that were necessary for computer technology. It is also known that this computer did not have an operating system.

Some progress in the creation of digital computers occurred after the Second World War. In the mid-40s, the first tube computing devices were created. At that time, the same group of people participated in the design, operation, and programming of the computer. It was more of a research work in the field of computer technology, rather than the use of computers as a tool for solving any practical problems from other application areas. Programming was carried out exclusively in machine language. There was no talk about operating systems; all tasks of organizing the computing process were solved manually by each programmer from the control panel. There was no other system software other than libraries of mathematical and utility routines.

§ 2.4 Fourth period (1980–present)

The next period in the evolution of operating systems is associated with the advent of large-scale integrated circuits (LSI). During these years, there was a sharp increase in the degree of integration and a reduction in the cost of microcircuits. The computer became available to the individual, and the era of personal computers began. From an architectural point of view, personal computers were no different from the class of minicomputers such as the PDP-11, but their prices were significantly different. If the minicomputer made it possible for a department of an enterprise or a university to have its own computer, then the personal computer made this possible for an individual.

Computers became widely used by non-specialists, which required the development of "friendly" software, which put an end to the caste of programmers.

The operating system market was dominated by two systems: MS-DOS and UNIX. The single-program, single-user MS-DOS OS was widely used for computers built on the Intel 8088, and later 80286, 80386 and 80486 microprocessors. The multi-program, multi-user UNIX OS dominated among "non-Intel" computers, especially those built on high-performance RISC processors.

In the mid-80s, networks of personal computers running under network or distributed operating systems began to rapidly develop.

In networked OSes, users must be aware of the presence of other computers and must log into another computer to use its resources, mainly files. Each machine on the network runs its own local operating system, which differs from the OS of the standalone computer by having additional funds, allowing the computer to work on the network. The network OS has no fundamental differences from the OS of a single-processor computer. It definitely contains software support for network interface devices (network adapter driver), as well as tools for remote login to other computers on the network and tools for accessing deleted files, however, these additions do not significantly change the structure of the operating system itself.

CHAPTER III. System requirements of common operating systems

I will not focus on the Windows OS, since almost anyone who uses a computer probably uses Windows as their desktop operating system. Therefore, let’s immediately move on to the system requirements of this product.

1. Microsoft Windows XP

For fast and stable operation, your computer must have a Pentium-II processor, processor frequency from 500 MHz, free disk space at least 2 GB and, accordingly, a disk reader.

1. Microsoft Windows Vista

If you have chosen Vista, then your computer system must be no weaker than these system requirements: a processor with a clock frequency of at least 800 MHz, 512 MB of RAM, 32 MB of video memory, a graphics card that supports DirectX 9, a DVD reader and at least 15 GB of free hard disk space.

1. Microsoft Windows Seven

To run this system, you need a processor with at least a 1 GHz frequency, 1 GB of RAM or higher, more than 16 GB of free hard disk space, a DVD reader, and a DirectX 9 compatible graphics card.

On September 7, 1991, Finnish student Linus Torvalds posted online the source code for what would later develop into the Linux operating system (“Linux”). The most fundamental difference between Linux and Mac OS X and Windows is that Linux is free software that is distributed under the GPL license. Unlike commercial systems such asMicrosoft Windows or Mac OS , Linux does not have a geographical development center. There is no organization that owns this system; There is not even a single coordination center. Programs for Linux are the result of the work of thousands of projects. Some of these projects are centralized, some are concentrated in firms. Many projects combinehackers from all over the world who know each other only by correspondence. Anyone can create their own project or join an existing one and, if successful, the results of the work will become known to millions of users. Users take part V testing free software , communicate with developers directly, which allows you to quickly find and fix errors and implement new features.

If you decide to install Linux on your computer, then you will need a 33 MHz processor, 8 MB of RAM and 120 MB of disk space.

Last on the list of the most common operating systems is Mac OS. The most important thing is that Mac OS X can only be installed on Macintosh computers manufactured by Apple. In addition, unlike open Linux, Mac OS X is proprietary software, i.e. there is a ban on free distribution, making changes, etc. The first Mac OS appeared in 1984, which is much earlier than the appearance of Windows. Apple Company wanted the Macintosh to be presented as a computer "for everyone else." The term "Mac OS" itself didn't really exist until it was officially used in the mid-1990s. The term has since been applied to all versions of the Macintosh operating systems as a convenient way of distinguishing them in the context of other operating systems. Mac OS can only be installed on Macintosh computers manufactured by Apple. These computers, unlike the PCs we are used to, have a closed architecture, that is, the computers themselves are assembled only by Apple.

CHAPTER 4. Analysis of modern operating systems

Practical data.

Comparing operating systems is a time-consuming process. The result of the work is reflected in the table (Table No. 1).

All operating systems (Windows XP, Windows Vista, Windows Seven, Linux, Mac OS) were evaluated according to several parameters:

1. safety,

1. interface,
2. price.

Table 1

	Windows XP	Windows Vista	Windows Seven	Linux	Mac OS
Safety	Without installing updates and patches - the most defenseless Internet access system. The most delicious target for many viruses and other malware.	Improves security using additional programs, but remains main goal for malware.	Like previous versions of Windows, it needs constant updating.	Linux is more secure system than Windows. For example, Ubuntu, by - by default, doesn't even create administrator account, which is an essential goal for malware. Small Linux prevalence leads to hackers pay less attention to her attention than on Windows.	Clear separation of system and custom files for maximum safety. in this case file permissions are ignored users.
Interface	Lack of interface consistency. There are no clear rules as they should look controls in different applications - everything is in your hands application developers. No normal effects when switching between windows and their folding. Those that exist - I want to turn it off after 5 minutes. Outdated search engine files. It can only be improved third party applications, for example - Google Desktop Search.	Overloaded interface. Changed some provisions elements in the Panel management. Translucency effects, animations make it easier navigate your work and switching between programs. Quickly search files by the entire system. Possibility of use Gadgets in the sidebar on desktop.	Quite a pleasant interface that does not cause irritation. The ability to view windows in 3D, beautiful and convenient panels make using the computer easier. Very fast search helps to better navigate the huge library of files. Possibility of use Gadgets in the sidebar on desktop.	Gnome and KDE interfaces similar to Mac interfaces OS and Windows respectively. Built-in capability use of several virtual desktops. Possibility of inclusion graphics acceleration present but requires separate tuning.	The interface is clear, uncluttered and logical. So good that it trying to recreate it on others operating systems using themes design and special programs. Translucency and Animation Effects very organic and helpful navigate the system. Availability of virtual desktops drag-and-drop windows between tables. Possibility of using widgets. Instant search already at type searches for files and their contents by throughout the system and on the local network, supports logical operations and arithmetic calculations.
Works great for not too fast processors and small volume of operational memory.	Requires more operational memory and disk space. High system requirements.	Quite large system requirements complicate the operation of this OS on older processors. Excellent operating speed.	Works great even on very old computers due to low system requirements. funds first are Windows oriented and Mac OS.	Productivity is high because that the software is very well optimized for specific platform.
Price	2000-5000 rub.	2000-6000 rub.	3000-7000 rub.	3000-6000 rub.	Included in the price of the laptop.

Conclusions on Chapter IV

1. Microsoft Windows XP

Chances are you are very familiar with this system. If you are satisfied with everything, then there is no need to change your habits. Five years of updates have made Windows XP as secure as it can be, but still inferior in this regard to both Vista andSeven and Linux and Mac OS X. Low resource requirements make this system the most suitable for computer games until DirectX 10 takes over the world. It is not demanding and satisfies all the basic needs of the user, but Microsoft is gradually pushing it out of the market, making room for its later products.

1. Microsoft Windows Vista

You will have to get Windows Vista if you buy a new computer. Windows interface Vista is more lively than that of XP, which will allow you to communicate more comfortably with the system during daily routines. Windows Vista contains some new useful tools and it is safer for online use. However, it's not worth the price of a software update and the loss in performance.

Windows Vista, frankly speaking, was not a success, now it is even considered an “inferior” operating system, but a kind of by-product, the transition from XP to Seven.

1. Windows Seven

At the time of the release of Windows 7, the most popular operating system was Windows XP. However, more than eight years have passed since its release, and during this time many new devices and technologies have appeared that require operating system support. After the advent of Windows Seven and updating equipment users, this system became a good replacement for Windows XP, leapfrogging Windows Vista. Windows Seven is a very successful product that many users will enjoy, but it is demanding on your computer's system resources.

1. Linux

If you are tired of worrying about the safety of your data on your computer and dealing with countless malware, you can easily try Linux. Suddenly he will satisfy your requests. Just find your boot disk. The richest customization options make Linux distributions an ideal option for users... with knowledge of Linux (programmers). For ordinary users who just want to work at the computer, the system is still not friendly enough.

1. Apple Mac OS X

Mac OS can be called the best operating system, but it has one huge drawback - to become its proud owner, you will have to buy an Apple laptop, and this is not a cheap pleasure. If Apple computers are within your budget, then the Macintosh is a great choice. You'll get powerful tool with the most functional and user-friendly OS to date.

Thus, today, the Windows XP operating system remains the best option.

CONCLUSION

So, the operating system performs the functions of managing calculations in a computer, distributes computer system resources between various computing processes and forms the software environment in which user applications are executed. This environment is called an operating environment. The latter should be understood in the sense that when the program is launched, it will contact the operating system with appropriate requests to perform certain actions or functions. The operating system performs these functions by launching special system software modules that are part of it.

Currently, about 90% of personal computers use Windows OS, which has a number of advantages and has forced competitors out of this market segment. A broader class of OS is targeted for use on servers. This class of operating systems includes: the Unix family, developments from Microsoft, network products from Novell and IBM Corporation.

Computer resources include: processors, memory, disk drives, network communications, printers and other devices. The OS function is to rationally distribute these resources between processes in order to ensure maximum efficiency computer functioning.

LIST OF SOURCES USED

1. Gordeev A.V. Operating systems: Textbook for universities. 2nd ed. – St. Petersburg: Peter, 2005.

2. Fundamentals of computer science: Textbook. allowance / A.N. Morozevich, N.N. Govyadinova, V.G. Levashenko and others; Edited by A.N. Morozevich. – 2nd ed., rev. – Mn.: New knowledge, 2003.

3. Evsyukov V.V. Economic informatics: Proc. manual - Tula: Publishing House "Graf and K", 2003.

Informatics in economics: Proc. manual / Ed. prof. B.E.

Odintsova, Prof. A.N. Romanova. – M.: University textbook, 2008.

Section "Computer and information technologies in technical systems, economics, science and education"

SOME ASPECTS OF STUDYING MODERN
OPERATING SYSTEMS

Savelyev A.N. (Information Technology Center MSTU)

The need to study modern operating systems (OS) is due to the importance of their selection and application in computer systems for any purpose. Currently, several directions in the development of OS can be distinguished, including: desktop OS (general purpose OS), network OS, embedded OS, etc. Learning about each type of OS involves acquiring relevant skills in key aspects of its use, including installation, configuration, and upgrades throughout its lifecycle.

The life cycle of desktop operating systems today is approximately five years and is mainly determined by the change in generations of application software (software) and the service life of the corresponding types of computers. The life cycle of a network operating system is more difficult to determine because it depends on many factors, including the ability of the operating system to adapt to the need to support new services and comply with newly adopted standards. For example, you can trace the evolution of the life cycle of Novell's main network operating systems:

Table 1.

OS Start End Recommended replacement Life cycle NetWare 3.11 1992 01.1999 NetWare3.2 (since 02.1998) more than 6 years NetWare 3.12 12.1993 05.2000 NetWare3.2 (since 02.1998) 6 years 2 months NetWare 4.1 11.1994 05.2000 NetWare 5 (since 09.1998) 5 years 6 months NetWare 4.11 08.1996 03.2001 NetWare 4.2 (01.1999) 4 years 7 months

Note: Data taken from Novell sources; The end of the life cycle implies the cessation of official support of the OS by the manufacturer.
Thus, we can conclude that the life cycle of network operating systems is steadily decreasing. Speaking about embedded operating systems, it should be noted that their life cycle is mainly determined by the service life of the equipment they control (in particular, on-board computers of passenger cars are controlled by the operating system throughout its entire service life).

In such conditions, studying modern operating systems is difficult, since by the time the training is completed, some of them are already being taken out of service, and some are entering the final stage of operation. This means that acquiring skills in specific operating systems cannot be successful without studying the principles of organization and architecture of the operating system. Knowledge of the industry standards on which modern operating systems are based is also important. For future development engineers, it is useful to study the internal mechanisms of the OS, and for various categories of users - to study the consumer and economic properties of the OS.

A large number of operating systems for various applications exist and are successfully used on the market, including the Microsoft Windows OS family, Novell NetWare, IBM OS/2, as well as a large number of OS varieties UNIX family. All of them, to one degree or another, relate to one of the directions in the development of OS and therefore can be used as a basis for constructing the educational process.