Please enable JavaScript.

Coggle requires JavaScript to display documents.

Operating Systems - Coggle Diagram

- - - - Handles virtual memory. Logical address space is divided into fixed size memory units = pages. When a page is loaded into main memory, it is stored in a page frame - block of sequential addresses that is the same size as a page. Pages of the same process do not need to be stored together, but can be allocated wherever there is free space in the main memory. Page table - to keep track of which page frame is allocated to each page. Memory manager records number & page location in a 'page table'.
    - - OS sets memory for the process to use. Segments are not fixed size; they're as large as needed. Segments can be moved in and out of memory as required.
        Memory segment is divided into several sections - 'stack segment', 'data segment', 'code segment' and 'free memory' - don't have to be physically next to each other- operating system tracks where each part of the process' memory segment is.
        
        'Code segment' - where program instructions for the process reside.
        
        'Data segment' - memory space allocated for the variables that the program will use.
        
        'Free memory' - allocated memory for the stack to grow and shrink as necessary.
        
        'Stack segment' - what allows the program to use functions and subroutines:
        When an instruction is interrupted by a subroutine, the program notes the address of where it left off. Address is kept in the stack while the subroutine runs. When the subroutine is complete, the program returns to the address in the stack.
        More subroutines running, more memory is needed in the stack to store addresses. Memory is freed up when the subroutines are completed. Stack gets bigger and smaller while the program runs.
        OS tracks the memory allocation for each process using a segment table - records where each segment required for a process is located.
        Memory leak - memory remains unavailable, locked up. As program runs, more and more memory gets locked up.
    - - Operating system can extend the physical memory space by using other storage in the computer. For example, a hard disk can act as virtual memory: operating system can swap parts of a process that aren't in use from the main memory to an allocated space on the hard disk, then swap it into main memory when needed. Swapping instructions and data out of main memory into secondary storage means that memory is available. Accessing a secondary storage medium, hard drive, is slower than accessing main memory, slowing the performance.
        RAM has many memory locations. When RAM gets full, the memory manager marks sections of secondary storage (hard disk) to act as main memory AKA virtual memory.
        Disadvantages to virtual memory:
        
        Slow for the CPU to access. When CPU needs data held in virtual memory, the memory manager re-loads it into RAM, swapping out less-used data to make room for it.
        
        Slow process - if virtual memory is in heavy use, computer is slower and you may hear hard disk spinning.
        
        Excessive use of the hard disk as virtual memory. More time is spent swapping pages than on processing the data = disk thrashing. If computer seems slow, it is worth checking how much RAM is in use with an utility such as Task Manager (in Windows).
        
        If memory use is high, to avoid using slow virtual memory, you need more RAM to handle all the programs you are trying to run at the same time.
    - - Similarities:
        
        Both divide up memory
        
        Both are assigned by the memory manager.
        
        Both are managed by the memory manager within the OS.
        
        Neither physically divides memory.
        
        Used when RAM space is insufficient, can cause disk thrashing.
      - Differences:
        
        Pagination is used if virtual memory is needed, segmentation is always used.
        
        Pagination is used to swap data in and out of virtual memory, segmentation is used to load and unload processes.
        
        Page is assigned a fixed size by the memory manager whilst the size of a segment varies.
        
        Page is not subdivided into smaller elements, segmentation has sub-elements of code, data, stack and free segments.
        
        Pages are contiguous blocks of memory whilst segments are not.
- - - - A hardware device has signalled that it has data to process
        
        A hardware device has completed a task that it was asked to do
        
        Software process needs a service to be provided/OS function to be performed
        
        Allotted amount of time has expired and an action needs to be performed
        
        A hardware failure has occurred and needs to be addressed
        ISR - program that has been designed to respond to an interrupt’s request. Can be built into an operating system or provided via device drivers.
    - - Interrupts come with a 'priority' label. Processor can suspend what it is executing so it can run ISR.
        Instructions jumping from current CPU operations to the ISR and back = 'context switching'
        An interrupt will affect the execution of the fetch-decode-execute cycle of a running program:
        
        Interrupt register checked at the end of each Fetch-Decode-Execute cycle.
        
        If an interrrupt exists with a higher priority to the current process, the current contents of the registers in the CPU are transferred into a stack.
        
        The relevant interrupt service routine is loaded into RAM.
        
        A flag s set to signal the ISR has begun.
        
        The flag is reset once the ISR has finished.
        
        Interrupt register checked again. If interrupts are of a higher priority, the process is repeated.
        
        If there are no interrupts with a higher priority, contents of the stack are popped and placed back into the special memory registers. The Fetch-Decode-Execute cycle renews as before.
    - - Latency
        
        Delay between an input into the system and the desired output.
        If the CPU keeps receiving interrupts, it can take time for it to finish processing the task.
      - Stack overflow
        
        CPU receives interrupts while it is processing the last interrupt. If the new one has priority, it loads the registers values into the stack while it processes the newest interrupt. The stack can grow quickly as interrupts are queued up. If too many interrupts are queued up, stack runs out of memory to write addresses into - 'stack overflow', leads to a crashed computer.
        Polling systems avoid these problems at the cost of efficiency.
- - - - Pre-emptive
        Processor time is divided equally among all running tasks. Time period = time slice.
        Every task is allocated processor time without a long wait. As more processes run, the time slice for each process gets smaller, more urgent tasks are less likely to be completed quickly.
        A queue is made holding all processes, with their time slice, that are ready to run. When the first process is loaded into main memory, it is given a set amount of CPU time to use. If the process is completed during the allocated time then the next process in the queue is loaded immediately. However, if the process is not finished when it's time expires, it is put at the back of the queue to wait for another turn.
      - Advantages:
        
        Simple to implement
        
        Disadvantages:
        
        Doesn't take into account how important a process is.
        
        Doesn't consider that some processes are short and others are long. Makes round robin inefficient to allocate time and resources.
    - - Non-preemptive
        Processes run from start to finish in the order in which the processor receives their request to run.
        Simplest method to implement.
        As the processes run in the order in which the processor receives their request to run, there can be a long wait before a process can run.
        Lines up processes ready to run in a 'first in first out' queue, ready to put into memory.
        Each process is allowed to run to completion before the next one begins. New processes are loaded into memory when space is available after one of the ones in there finishes running.
      - Advantages:
        
        Simple to implement. Ensures that once a process starts, it will run to completion in minimal time.
        
        Disadvantages:
        
        Once a job starts it prevents other jobs from being processed until it is completed
        
        A job that needs to access a slow resource wastes processor time whilst it is waiting for that resource
        
        Does not take into account the priority of a process. High priority processes are put behind low priority ones if they arrive later.
        
        Does not consider that some processes are short and others long. A long process will delay all the processes in the queue behind it.
    - - Non-preemptive
        Processes are queued and the process that needs the shortest total time to complete goes first. Reduces wait times because shorter processes are removed quickly and the processor can allocate more time to longer jobs.
        Causes starvation if shorter jobs keep being added; the scheduler will keep prioritising these jobs, longer processes will not be serviced.
        The idea of this algorithm is to push as many processes as possible through the CPU in a given time.
      - Advantages:
        
        Ensures the maximum number of jobs are completed
        
        Short jobs aren't kept waiting while long processes tie up CPU resources.
        
        Minimises the average time a process takes to complete.
        
        Disadvantages:
        
        Does not take into account the priority of a process. High priority but long process will have to wait for shorter processes to complete first.
        
        If a long job is nearly completed, it will be interrupted and put back in the queue when a shorter job arrives.
        
        Scheduler can estimate how long a job will take to complete, but its estimation could be wrong.
        
        Long jobs may never complete if shorter jobs keep 'jumping the queue'.
    - - Pre-emptive
        Processes with the shortest time to completion go first, until a different task is added with a shorter time to completion, which then takes priority. This is different to the shortest job first algorithm because a long job which is mostly complete might have a very short time remaining, and would therefore be prioritised.
        Delays longer processes from completing sooner if shorter processes are added. The less a process has left to do, the higher priority it becomes.
        Orders jobs by how much time they have remaining, rather than their total length.
        If a process comes along requiring a certain number of cycles to finish, it gets slotted into the queue at the appropriate point. Jobs will only be interrupted if the new process is shorter than the time remaining before completion.
      - Advantages:
        
        Allows short processes to be handled very quickly
        
        Maximum number of processes are completed in a given time, taking into account what has happened so far.
        
        Disadvantages:
        
        Does not take into account the priority of a process. High priority processes remain at the back of the queue if they need a lot of time to complete, even if the jobs ahead of them are unimportant.
        
        Long jobs may never complete if shorter jobs continually keep 'jumping the queue'.
    - - Pree-emptive
        Each queue of tasks has a different level of priority. Processes are chosen from different queues based on the priority of each queue and how much processing time each process has already had:
        Processes are added to a queue with a certain level of priority.
        If a process uses too much CPU time, it is moved to a lower priority queue and if a process has been idle for a long time, it is moved to a higher priority queue - avoids starvation.
        Processes that depend on input/output devices require a lot of processing time = high priority queues. Processes that are quick to complete are served first. All tasks are given processor time, more important jobs are dealt with sooner. The queues become more balanced the more the tasks are processed, ensuring that no single high-priority task dominates the processor's time.
      - Advatanges:
        
        Makes sophisticated use of process priority.
        
        It ensures that higher priority processes run on time.
        
        Ensures that most urge
        
        Disadvantages:
        
        Complex to implement.
        
        Not very efficient if all jobs have similar priority.
        
        Low priority jobs may take a long time to complete if the queue algorithm doesn't compensate for wait-time, especially if new high-priority jobs keep arriving.