Please enable JavaScript.

Coggle requires JavaScript to display documents.

Operting systems - Coggle Diagram

- - - - to provide local resources for public use over the network, that is, to function as a server
      - access the resources of other computers over the network, i.e. function as a client
  - - - command interpreter
      - graphical user interface
  - - - system calls for process management
      - system calls for file management
      - system calls for directory management
      - system calls for protection
      - system calls for time management
- - - - The operating system must save the entire contents of memory to a file on disk and then load and run such a program. Since there is only one program in memory at a time, there are no conflicts. This concept is called data swapping.
  - - - An address space is a set of addresses that can be used by a process to access memory.
    - - Basic and limiting registers. When using these registers, programs are loaded into consecutively located free areas of memory without modification of addresses during the loading process. When starting the process, the physical address is loaded into the base register, from which the placement of the program in memory begins, and the length of the program is loaded into the limiting register.
  - - - When using bit matrices, memory is divided into individual blocks ranging in size from a few words to several kilobytes. Each unit block is associated with one bit in the bit matrix, which contains 0 if the unit block is free and 1 if it is occupied.
      - An important issue for the developer is the size of the unit memory block. The smaller the block, the larger the bit matrix. If a larger single block of memory is selected, the bit matrix will be smaller, but then in the last block of the process, if it is not exactly a multiple of the size of the single block, a rather significant amount of memory will be wasted.
      - A bit matrix provides a fairly simple way to keep track of words of memory in a fixed amount of memory, since its size depends only on the size of the memory and the size of the unit memory block. The main problem is that when deciding to place in memory a process that occupies k unit blocks, the memory manager must search the bit matrix for a continuous sequence of zero bits. Searching in a bit matrix for a sequence of a given length is a rather slow operation (since the sequence can cross word boundaries in the matrix), and this circumstance serves as an argument against the use of bit matrices.
    - - Another way to keep track of memory is to maintain linked lists of allocated and free memory segments, where the segment either contains a process or is empty space between two processes. Each entry in the list stores a designation, contains a "hole" segment - hole (H) or process-process (P), the address from which the segment begins, its length and a pointer to the next entry.
      - The list of segments can be compiled by sorted addresses. The advantage of such sorting is that when the process ends or when it is swapped to disk, it is easier to update the list. A completed process has, as a rule, two neighbors (except when it was in the upper or lower memory addresses). These neighbors can be either processes or empty spaces, from which four combinations can be made. Since a process table entry relating to a completed process will typically point to a list entry for that particular process, it may be more convenient to maintain a doubly linked list instead of a singly linked list. Such a structure will make it easier to find a previous record and determine the possibility of merging.
- - - - Class 0: There have been no recent calls or modifications.
      - Class 1: There have been no recent hits, but the page has been modified.
      - Class 2: There have been recent appeals but no modifications.
      - Class 3: recently there were appeals and modifications.
      - The page to be deleted is chosen by the OS from the class with the smallest category. If there are several pages in the class, the system randomly selects the page to be deleted.
  - - - At least one disc recording was scheduled.
      - No disk writes were scheduled.
- - - - Accounting for the relative priorities assigned to each thread
      - Minimizing the response time of interactive applications
    - - The kernel manager uses a priority system to determine the execution order of threads. Each thread is assigned a priority given by a number in the range from 1 to 31. Real-time priorities — 16-31; they are reserved by the system for actions whose execution time is a critical factor. Dynamic priorities — 1-15; they can be assigned to user application threads.
    - - In Windows XP, you can interactively set the following quantum length (select Settings in the Performance group on the Advanced tab of the My Computer properties window):
        
        Short, variable-length quanta (Advanced tab, Programs switch in the Processor Scheduling property group). Possible quantum length10 or 30 ms, while the application the user starts working with automatically switches to using longer quanta. This setup favors interactive processes;
        
        Fixed-length long quanta (Advanced tab, Background services switch in the Processor Scheduling properties group). The quantum length is fixed and equal to 120 ms. This setting gives preference to background processes.
    - - During the execution of the ready thread search algorithm, the scheduler looks through all thread queues, starting with the highest priority queue. As soon as a thread is encountered during this view, it is immediately selected for execution. With the help of this algorithm, the first thread of the non-empty queue with the highest priority is selected. We can say that within one queue, a circular planning algorithm is used, if we do not take into account the dynamic correction of priorities, which we will consider further
    - - Dynamic change:
        
        boosting
        
        decay
      - When an I/O operation completes, the priority increase depends on the type of operation.
      - When the state of the synchronization object changes, the priority of the thread waiting for this change is increased by one.
      - Exiting any waiting state for interactive application threads results in a priority increase of 2, the same increase occurs when entering the ready state of threads related to user interface display.
      - To prevent starvation, threads that have not executed for a long enough time are dramatically increased in priority.
    - - A special kernel thread once per second goes through the queue of ready threads in search of those that have been in the ready state for a long time and never got a chance to execute. When such a thread is found, it is assigned a priority of 15 in addition, the length of his time quantum is doubled. After two time quanta elapse, the flow's priority and its quantum return to their original values. This algorithm does not take into account the causes of starvation and does not distinguish between the flows of interactive and background processes
  - - - They will always take precedence over normal processes during planning
      - A FIFO-scheduled process executes until it gives up the CPU itself or is squeezed out by a higher-priority real-time process
      - The same applies to the round robin process, except that it will additionally be pushed out after the time quantum is exhausted
    - - The basis of the algorithm is the division of processor time into epochs. During an epoch, each process has a quantum of time, the length of which is calculated at the moment of the beginning of the epoch. For the most part, different processes have quanta of different lengths. When a process has exhausted its quantum, it is pushed out and will not be executed again during the current epoch. Control is transferred to another process. If a process has been suspended for I/O or synchronization, its quantum is not considered exhausted and it can be selected by the scheduler during the current epoch. An epoch ends when all ready-to-run processes have exhausted their quanta. In this case, the scheduling algorithm recalculates the quanta for all processes and starts a new epoch.
    - - Supports separate queues of ready processes for each processor, ensuring efficient operation under conditions of multiprocessing.
      - Each ready process queue is an array of ready process queues, where elements are ordered by dynamic priority.
      - There are two arrays of queues of ready processes — an array of queues of active processes and an array of queues of processes with an exhausted quantum. After the process has exhausted its quantum, it is transferred from the first array to the second. When no process remains in the active queue array, the two arrays are swapped and the sequence of steps is repeated from the beginning.
  - - - Threads are put into execution in the order they appear in the system and execute until waiting, explicit transfer of control, or termination.
      - It is by definition irreplaceable
      - The average response time for it can be quite significant
      - It is subject to the convoy effect
    - - Each thread is allocated a time interval, called a time quantum, during which this thread is allowed to execute. When a thread is still executing after the time quantum is exhausted, it is interrupted and the processor is switched to another thread's instructions. When it blocks or ends its execution before the time quantum is exhausted, the processor is also handed over to another thread. The length of the time quantum is the same for the entire system.
    - - First of all, it should be noted the algorithm "first - with the shortest execution time", when the duration of the next interval of its use of the processor is associated with each thread, and the thread with the shortest interval is chosen for execution each time. As a result, threads that occupy the processor for a shorter time receive priority during scheduling and exit the system faster.
    - - From the point of view of the organization of data structures, this algorithm is similar to the usual multilevel queuing algorithm: there are several queues of ready threads with different priorities, while the threads of the lower priority queue are executed only when all the top-level queues are empty.
        
        Differences:
        
        Threads are allowed to move from one level to another
        
        Threads in the same queue are not grouped by priority, but by the length of the processor usage interval, threads with a shorter interval are in a queue with a higher priority.
    - - Idea of lottery planning:
        
        A thread receives a number of lottery tickets, each of which gives the right to use the processor over time
        
        The scheduler randomly selects one lottery ticket after a time interval
        
        The "winning" thread gets control until the next draw.
      - Lottery planning enables:
        
        Emulate round robin scheduling by issuing the same number of tickets to each thread
        
        Emulate priority scheduling by allocating tickets according to thread priorities
        
        Emulate SRTCF — Give short threads more tickets than long threads
        
        Ensure the distribution of processor time between threads - give each thread a number of tickets proportional to the share of processor time it needs to allocate
        
        Dynamically change priorities, selecting and adding tickets as you go.
  - - - After the thread has entered the wait state
      - After the execution of the stream
      - Explicitly (the thread itself gives the processor to other threads for a while, while it is not busy with useful work)
      - by interruption
  - - - The long-term planning tools determine which of the programs must be loaded into memory for execution.
    - - Medium-term planning tools manage the transition of threads from the suspended state to the ready state and back again.
    - - Short-term planning-this is an OS subsystem that, if necessary, interrupts the active thread and selects the one that should be executed from the queue of ready threads.
  - - - Minimum response time
      - Maximum bandwidth
      - Justice
- - - - System initialization
      - Execution by a running process of a system call designed to create a process
      - User request to create a new process
      - Batch task initiation
  - - - Normal output (voluntary)
      - Exit when an error occurs (voluntary)
      - The occurrence of a fatal error (forced)
      - Destruction by another process (forced)
  - - - Generation - conditions are being prepared for the first execution on the processor
      - Active state or "number" state - the program is executed on the processor
      - Waiting - the program is not executed on the processor due to the occupation of a certain necessary resource
      - Readiness - the program is not being executed, but it has been provided with all the resources it needs at the moment, except for the central processor
      - Termination - normal or emergency termination of program execution, after which the processor and other resources are not provided to it
- - - - Universal, low-level, which can be used in various ways
        
        Semaphores
      - Simple, low-level, each of which is adapted to solving only one problem
        
        Mutual exclusion
        
        Conditional variables
      - Universal high level, expressed through simple; this group includes the concept of a monitor, which can be expressed through mutexes and conditional variables
        
        Monitor concept
      - High-level, adapted to the solution of a specific synchronization problem
  - - - Stream sockets — specify reliable two-way data exchange in a continuous stream without delineating boundaries
      - Datagram sockets — specify unreliable two-way message exchange with boundary allocation
- - - - Create one process that has several execution threads
      - Create several processes, each of which has one or more threads of execution
    - - State of the registers
      - The system stack of the OS kernel
      - The user stack located in the process address space
      - Block of stream environment variables
  - - - Parallelism of multiprocessor systems
      - Parallelism of input-output operations
      - Parallelism of interaction with the user
      - Parallelism of distributed systems
- - - - On-demand execution of programs
      - On-demand execution of programs
      - Loading programs into RAM and their execution.
      - Standardized access to peripheral devices
      - RAM management
      - Management of access to data on non-volatile media organized in one or another file system.
      - Providing a user interface.
      - Saving information about system errors.
    - - Parallel or pseudo-parallel execution of tasks
      - Effective distribution of computing system resources between processes.
      - Demarcation of access of different processes to resources.
      - Organization of reliable computing, based on
        delineation of access to resources.
      - Interaction between processes: data exchange, mutual synchronization.
      - Protection of the system itself, as well as user data and programs from the actions of users or applications.
      - Multi-user mode of operation and delineation of access rights
  - - - One program
      - Multi program
      - Multi-user
    - - Batch processing systems
      - Dialog or interactive access
      - Real-time OS.
    - - Mainframe operating systems
      - Server operating systems
      - Multiprocessor operating systems
      - Operating systems of personal computers
      - Operating systems of pocket personal computers
      - Embedded operating systems
      - Operating systems of sensor nodes
      - Real-time operating systems
      - Operating systems of smart cards
- - - - information input-output management
      - interrupt handling
      - RAM management
      - process management
      - multitasking support
    - - utilities
      - system processing programs
      - programs for providing the user with additional services
      - libraries of procedures for various purposes
  - - - monolithic kernel
      - modular kernel
      - multilevel kernel
      - microkernel
      - exokernel
      - nanokernel
      - hybrid kernel
    - - Means of abstraction from the equipment, which interact with the hardware directly, freeing other components of the system from the implementation of such interaction
      - Basic kernel facilities that are responsible for the most basic, basic kernel operations, such as writing a block of data
        to disk
      - Resource management tools that implement the main functions of the OS
      - A system call interface that serves to implement communication with system and application software.