PRINCIPLES OF OPERATING SYSTEM by MUHAMMAD NUR AZREE MOHAMAD NASIR https://padlet.com/2021478032/gzx2d9mh8t82a83u CSC520 en-us 2021-10-13 07:13:40 UTC 2023-07-26 18:56:23 UTC hello@padlet.com https://padlet.net/icons/png/1f4bb.png What is Operating System(OS)? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813145413
  • Operating system is like intermediary person between user and the program.
  • Its interact with hardware and application.
    • ]]>     2021-10-13 07:17:13 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813145413     Computer System can be divided into different components? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813157271 Yes, computer system can be divided by 4 components.

    •  User
    •  Application
    •  Operating System
    •  Hardware

    ]]>     2021-10-13 07:23:58 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813157271     Roles of each Components 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813251786 User : people, machines, other computers.

    Application : word processors, compilers, web browsers.

    Operating System :
    • control and coordinates use of hardware
    • e.g. : Windows, Macintosh, Android, IOS, Linux. 

    Hardware:
    • provides basic computing resources
    • resources : cpu, memory, I/O devices, storage.

    ]]>     2021-10-13 08:14:07 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813251786     What Operating Systems do? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813272650
  • Operating system provides the means for proper use of these resources (cpu, memory, i/o devices, storage) in the operation of the computer system.

    • Provides an environment within which other programs can do useful work.
    ]]>     2021-10-13 08:25:04 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813272650     Operating Systems from two viewpoints? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813282242
  • User view
  • System view
    • ]]>     2021-10-13 08:29:51 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813282242     User view: Single user 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813295748
  • ease of use 
  • good performance
  • efficient


    • ]]>     2021-10-13 08:36:54 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813295748     User view : Multi user 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813301801 Share resources and may exchange information
    • fairness in utilization the resources
    ]]>     2021-10-13 08:39:59 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813301801     User view: Mobile computers 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813316998 Mobile computers (e.g., smartphones and tablets)
    To provide easy accessibility 
    • optimized for usability & battery life
    ]]>     2021-10-13 08:47:11 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813316998     User view: Embedded computers 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813319419 Embedded computers(e.g., computers in home devices, washing machine)

    • Run without user intervention
    ]]>     2021-10-13 08:48:23 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813319419     System view 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813336108 1. Operating System is a resource allocator
    • Manages all resources(cpu, memory, i/o, storage)
    • Decides between conflict request for efficient & fair resource use 

    2. Operating System is a control program
    • Security system
    • Control execution of programs to prevent errors


    ]]>     2021-10-13 08:55:29 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1813336108     Modern Computer System 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1840931560
  • Each of the I/O devices has a controller.
  • Each of the controller has its own buffer.
  • The function of buffer is to store data that required by its own devices.
  • The device controller and buffers are connected to memory subsequently connected to our CPU.
  • CPU will take data/instruction from memory to process it.
    • ]]>     2021-10-25 07:36:32 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1840931560     How does CPU know any task to be process or to be execute? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1845373628 The CPU will be request that some task/services to be process or to be execute.

    The answer is Interrupt.
    Any event that request the CPU to act is known by interrupt.

    ]]>     2021-10-26 15:21:55 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1845373628     Interrupt 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1845415572 The occurrence of an event is usually signaled by an interrupt.

    There are 2 types of interrupt : 
    • Hardware
    • Software  

    Hardware Interrupt 
    • I/O devices that trigger the interrupt by sending a signal to CPU through the System Bus.

    Software Interrupt
    • Software program that trigger the interrupt by another software known by system call. 
    ]]>     2021-10-26 15:32:39 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1845415572     Interrupt Timeline 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855134138 The straight line in the diagram shows that the CPU is executing the process.
    When interrupt occur in the CPU, the CPU will be stop for a while.
    Its stop to handling a new request.
    Then, the CPU will continue the process of executing the request that occur based on the priority of the request. 


    ]]>     2021-10-30 04:31:54 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855134138     Storage Hierarchy 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855173216 2021-10-30 05:48:35 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855173216 Direct Memory Access Structure(DMA) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855181677 Direct memory access is designed so that less interrupt occurs.
    The device controller transfers an entire block of data to or from its own buffer to memory with no intervention by the CPU.]]>     2021-10-30 06:07:09 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855181677     Multicore Systems 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855184594 Most CPU design nowadays includes multiple computing cores on a single chip. Such multiprocessor systems are called multicore.

    ]]>     2021-10-30 06:12:59 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1855184594     Operating System Services 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887925177 There is 2 types of services:
    1. For User
    2. For System Programs

    Operating System Services provide their function for both types.]]>     2021-11-13 06:28:46 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887925177     OS Services that are helpful to user: 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887926149 1. User interface 
    •  Command Line Interface(CLI), Graphical User Interface(GUI), Touch Screen, Batch
    2. Program execution
    • System must be able to load a program into memory and to run that program, end execution, either normally or abnormally( indicating error)
    3. I/O operations
    • A running program may require I/O, which may involve a file or an I/O devices.
    4. File-system manipulation 
    • Programs need to read and write files or directories, create, delete, search, list file information, and permission management for file. 
    5. Communication
    • Processes may exchange information, on the same computer or between another computer over a network
    6. Error detection (aware of possible errors in the OS)
    • error may occur in the CPU and memory hardware, I/O devices, or in user program.
    • OS should take the appropriate action of the error.
    • Debug the facilities can enhance the user's and programmer's abilities to efficiently use the system.
    ]]>     2021-11-13 06:30:44 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887926149     OS Services that are helpful for the system programs. 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887926475 1. Resource allocation 
    • when multiple users or multiple jobs running concurrently, resources must be allocated to each of them
    - Many types of resources:- CPU cycles, main memory file storage, I/O devices.
    2. Logging 
    • to keep track of which users use how much and what kinds of computer resources
    3. Protection and security
    owners information stored in a multiuser or networked computer system may want to control use of that information and should not interfere with each other.
    - Protection involves ensuring that all access to system resources is controlled
    - Security     of the system from outsiders requires user authentication, extends to defending external I/O devices from invalid access.

    ]]>     2021-11-13 06:31:17 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887926475     A view of OS Services 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887977740 2021-11-13 08:01:32 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887977740 System Call 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887987343
  • Programming interface to the services provided by the OS
  • Is a system operation that have instruction to tell the CPU what had to be done to execute the task. 
  • It is a set of instruction. 
  • Use High Level Language (API)
    • ]]>     2021-11-13 08:16:55 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887987343     API - System Call - OS Relationship 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887988668 Explanation:
    When user click open of the file directories.
    System call will switch from user mode to kernel mode, where kernel mode is the part of the operating system want to execute the task.
    System call will take the instruction of the task and implement the instruction to do the task that user want.
    The user can view the file directories.]]>     2021-11-13 08:19:00 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887988668     Types of System Calls 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887992678
  • Process control
  • File Management
  • Device Management
    • ]]>     2021-11-13 08:25:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1887992678     System Services 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1888096118 Provide a convenient environment for program development and execution.
    Can be divided into:
    • File manipulation
    • Status information sometimes stored in a file
    • Programming language support
    • Program loading and execution
    • Communications
    • Background services
    • Application programs
    Most user's view of the operation system is defined by system programs, not the actual system calls.
    ]]>     2021-11-13 10:53:01 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1888096118     Process Concept 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1893465281
  • Process - a program in execution; process must progress in sequential fashion.
  • Multiple parts
    •    program code also known as text section.
    •    current activity including program counter
    •    Stack containing temporary data
    •    Data section containing global variables
    •    Heap containing memory dynamically allocated during time
  • Program is passive entity; process is active 
    •    Program becomes process when execute file loaded into memory
  • Execution of program started via GUI mouse clicks, cmd entry of its name, etc
  • One program can be several processes
    •     Consider multiple users executing the same program
    • ]]>     2021-11-16 07:42:31 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1893465281     2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907671305 When a program in the secondary storage is being execute, that program will be transfer into memory and becoming a process.]]> 2021-11-23 05:59:43 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907671305 Process State 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907684248 As a process executes, it changes state.
    A process at any one time can be at any state:
    • New - the process  is being created.
    • Running - Instructions are being executed
    • Waiting - The process is waiting for event to occur
    • Ready - The process is waiting to be assigned to a processor
    • Terminated - The process has finished execution
    ]]>     2021-11-23 06:10:47 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907684248     Process Control Block (PCB) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907696164
  • For each process, it has process control block (PCB).
  • It keeps the information of that process.
  • OS will generate the process control block (PCB).
  • Process State - running, waiting, etc.
  • Program Counter - location of instruction to next execute.
  • CPU Registers - contents of all process-centric registers
  • CPU scheduling information - priorities, scheduling queue pointers.
  • Memory-management information - memory allocated to the process.
  • Accounting information - CPU used, clock time elapsed since start, time limits.
  • I/O status information - I/O devices allocated to process, list of open files

    • ]]>     2021-11-23 06:21:06 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907696164     Threads 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907697532 A process can have many threads.
    so far, process has a single thread of execution.
    This topic will be explain more on the next chapter.

    ]]>     2021-11-23 06:22:12 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907697532     Process Scheduling 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907792700
  • maximize CPU use, quickly switch processes onto CPU core
  • Process scheduler selects among available processes for next execution on CPU core
  • Maintains scheduling queues of processes 
    1. Ready queue - set of all processes residing in main memory, ready and waiting to execute.
    2. Waiting queue - set of processes waiting for an event to occur. example: I/O
    ]]>     2021-11-23 07:29:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907792700     Context Switch 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907813553
  • When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process via a context switch.
  • Context of a process represented in the PCB
  • Context-switch time is overhead; the system does no useful work while switching
  • Time dependent on hardware support

    • ]]>     2021-11-23 07:42:14 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1907813553     Operations on Process 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912075843 System must provide mechanisms for:
    • process creation
    • process termination

    ]]>     2021-11-25 07:39:40 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912075843     Process Creation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912083324
  • Parent process create children processes, which, in turn create other processes, forming a tree of processes.
  • Process identified and managed via a process identifier(pid)
  • Resource sharing options 
    - Parent and children share all resources
    - Children share subset of parent's resources
    - Parent and child share no resources
  • Execution options
    - Parent and children execute simultaneously 
    - Parent waits until children terminate
  • Address space
    - Child duplicate of parent
    - Child has a program loaded into it
    • ]]>     2021-11-25 07:44:25 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912083324     Process Termination 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912120502
  • Process executes last statement and then asks the os to delete it using exit ( ) system call.
    - Returns status data from child to parent (via wait ( ))
    - Process' resources are deallocated by operating system
  • Parent may terminate the execution of children processes using the abort ( ) system call.
  • Some reasons for doing so:
    - Child has exceeded allocated resources
    - Task assigned to child is no longer required
    The parent is exiting and the os does not allow a child to continue if its parent terminates.

    • ]]>     2021-11-25 08:07:01 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912120502     Interprocess Communication 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912136398 Proses may be independent or cooperating.]]> 2021-11-25 08:17:18 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912136398 Two Models of IPC 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912413356
  • Shared memory
  • Message passing
    • ]]>     2021-11-25 11:13:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912413356     Producer-Consumer Problem in Cooperating Processes 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912416336 Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process
    • unbounded-buffer places no practical limit on the size of the buffer
    • bounded-buffer assumes that there is a fixed buffer size
    ]]>     2021-11-25 11:15:50 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912416336     Interprocess Communication - Shared Memory 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912595655
  • An area of memory shared among the processes that wish to communicate.
  • The communication is under the control of the users processes not the os.
  • Major issues is to provide the mechanism that will allow user processes to synchronize their actions when they access shared memory.
    • ]]>     2021-11-25 13:14:14 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912595655     Interprocess Communication - Message Passing 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912619864
  • Mechanism for processes to communicate and to synchronize their actions
  • The operations:
    - send(message)
    - receive(message)
  • Message size is either fixed or variable
  • If process A and process B wish to communicate with each other, they will need to:
    - establish a communication link between them
    - exchange messages via send or receive
  • Major issues for message passing is:
    - how the links are being established.
    - the capacity of a link.
    - the direction of link which is unidirectional or bi-directional.
    - can a link be associated with more than two processes?
    • ]]>     2021-11-25 13:28:09 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912619864     Implementation of communication link (Message Passing) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912629779
  • Physical
    - Shared memory
    - Hardware bus
    - Network
  • Logical
    - Direct or indirect
    - Synchronous or asynchronous
    - Automatic or explicit buffering
    • ]]>     2021-11-25 13:33:25 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912629779     Logical (Direct Communication) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912634565
  • The processes must name each other explicitly
    - send (A, message) - send a message to process A
    - receive (B, message) - message are being received by process B
  • Properties of communication link
    - Links are established automatically
    - A link is associated with exactly one pair of communicating processes
    - Between each pair there exists exactly on link
    - Link may be unidirectional, but is usually bi-directinal
    • ]]>     2021-11-25 13:35:54 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1912634565     Logical (Indirect Communication) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920778696 Message are being directed to mailbox. 
    • The mailbox will receive all the messages.
    • Each mailbox has a unique id to indicates to the processes that will send to it.
    • Processes can communicate if they share the same mailbox.
    Properties of communication link
    • Link establish if processes share a common mailbox
    • A link may be associated with many processes
    • Each pair of processes may share several communication links
    • Link may be unidirectional or bi-directional
    ]]>     2021-11-30 16:05:55 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920778696     Single Thread Processes 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920790081
  • code, data and files belong to the process
  • where the bottom part of the diagram is belong to the thread
  • this thread with take the information about code, data and files from the process

    • ]]>     2021-11-30 16:10:17 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920790081     What is thread? 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920794766
  • Thread is the smallest sequence of programmed instructions that can be managed independently by a scheduler for execution
  • A process may have 1 or many threads to complete their execution
    - process with 1 thread - single threaded process
    - process with many thread - multi threaded process
  • The sharing function of thread makes it lighter, easier to be executed and easier to create the thread.
    • ]]>     2021-11-30 16:12:06 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920794766     Multithreaded processes 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920813007 for each thread the with have their own register, stack and PC (program counter).
    they will share the information about the code, data and files which belong to the process.]]>     2021-11-30 16:19:00 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920813007     Multiprocessors vs Multicore 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920841165 Both multiprocessors and multicore will support multitasking or multiprogramming in different ways.
    Multiprocessor - its having more than 2 CPUs added to the system
    Multicore - its having single CPU with multiple execution units 

    Efficiency 
    Multicore is more efficient than multiprocessor

    ]]>     2021-11-30 16:30:03 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920841165     Multicore Programming 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920909233 pressure on the programmers, challenges include:
    • Dividing activities
    • Balance
    • Data splitting
    • Data dependency
    • Testing and debugging

    Parallelism implies a system can perform more than one task simultaneously
    Concurrency support more than one task making a progress
    - Single processor / core, scheduler providing concurrency

    Both Parallelism and Concurrency allow multitasking but
    Concurrency for single core 
    Parallelism for multi core

    ]]>     2021-11-30 16:56:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920909233     Concurrency vs Parallelism 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920915162 2021-11-30 16:59:16 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920915162 Multithreading Models 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920918425 There are user threads and kernel threads

    Many-to-one
    One-to-One
    Many-to-Many

    The relationships models is refer to user threads and kernel threads.

    • Many-to-One: Many user threads to One kernel threads
    • One-to-One: One user threads to One kernel threads
    • Many-to-Many: Many user threads to Many kernel threads

    ]]>     2021-11-30 17:00:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920918425     Multithread models (Many-to-One) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920929625
  • The main disadvantage is one thread blocking causes all to block
  • Multiple threads may not run in parallel on multicore system because only one may be in kernel at a time

    • ]]>     2021-11-30 17:05:22 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1920929625     Multithread Model(One-to-One) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921037724
  • Each user-level thread maps to kernel thread
  • By creating a user-level thread, it also creates a kernel thread
  • More concurrency than many-to-one
  • Number of threads per process sometimes restricted due to overhead(cost for creation the threads)
    • ]]>     2021-11-30 17:47:50 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921037724     Multithread Model (Many-to-Many) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921047028
  • Allows many user-level threads to maps to many kernel threads
  • Allows the OS to create a sufficient number of kernel threads
    • ]]>     2021-11-30 17:52:00 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921047028     Multithread Model (Two-level) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921052222 Combination of many-to-many model and one-to-one model]]> 2021-11-30 17:54:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1921052222 Introduction 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1930350064
  • A race condition exists when access to shared data is not controlled, possibly resulting in corrupt data values.
  • To avoid the corrupt data values requires a mechanism called process synchronization
  • Process synchronization is the OS task to coordinate among cooperating processes.
  • Synchronization is done through locking and critical section problem.
    • ]]>     2021-12-06 04:25:12 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1930350064     Process Synchronization Software Tools 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1930355595
  • Peterson's solution
  • Mutex
  • Semaphore
    • ]]>     2021-12-06 04:30:29 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1930355595     Logical (Indirect Communication) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997406502 Operations
    • create a new mailbox (port)
    • send and receive messages through mailbox
    • destroy a mailbox
    Primitives are defined as:
    • send(A, message) - send a message to mailbox A
    • receive(A, message) - receive a message from mailbox A
    Mailbox sharing
    • P1, P2, and P3 share the same mailbox
    • P1 sends, while P2 and P3 receive
    • Who gets the message?
    The solutions for many processes share the same mailbox:
    Allow a link to be associated with at most two processes
    Allow only one process at a time to execute a receive operation
    Allow the system to select arbitrarily the receiver. Sender is notified who the receiver.

    ]]>     2022-01-18 08:58:31 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997406502     Synchronization 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997425366 Message passing may blocking or non-blocking
    Blocking is considered synchronous:
    • Blocking send - the sender is blocked until the message is receive
    • Blocking receive - the receiver is blocked until a message is available
    Non-blocking is considered synchronous:
    • Non-blocking send - the sender sends the message
    • Non-blocking receive - the receiver receives either a valid or null messages.
    Different combinations possible
    • If both send and receive are blocking, we have a rendezvous.


    ]]>     2022-01-18 09:09:50 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997425366     Buffering 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997433576 It uses queues of messages attached to the link.

    There is 3 ways to implement:
    1. Zero capacity - no messages are queued on a link.
    Sender must wait for receiver.
    2. Bounded capacity - finite length of n messages
    Sender must wait to send the message if the link is full.
    3. Unbounded capacity - infinite length
    Sender never waits to send the message]]>     2022-01-18 09:14:35 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997433576     Basic Concepts 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997446684 2022-01-18 09:21:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997446684 My perspective on this topic: 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997456497 Thread is the smallest version of process that help process to run and execute it. There is two types of thread which is single thread and multithread.

    From my perspective multithread is more efficient than single thread because in multithread each thread have its own register and stack number to execute the process and they also can share the resource that they need.

    Multithread is the capabilities to run the process based on the relation which is many to one, one to one or many to many. 

    The concept that I can relate with multithread is:
    It is like working in a group of project and single person project. The ways working in a group so much faster than single person because we can divide the work for each person and complete it faster.


    ]]>     2022-01-18 09:26:47 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997456497     CPU Scheduler 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997484062 Selects from among the processes in ready queue, and allocates the CPU core to one of them.

    CPU Scheduling may take places when a process:
    • Switches from running to waiting state
    • Switches from running to ready state
    • Switches from waiting to ready
    • Terminates

    Non-preemptive scheduling:
    • running to waiting state
    • terminates

    Preemptive scheduling:
    • All other scheduling
    - Consider access to shared data
    - Consider preemption while in kernel mode
    - Consider interrupts occur during OS activities

    ]]>     2022-01-18 09:41:50 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997484062     Dispatcher 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997505666 Gives control of the CPU the process selected by the short-term scheduler, this involves:
    • Switching context
    • Switching to user mode
    • Jumping to the proper location in the user program to restart the program
    Dispatch latency - time to take for the dispatcher to stop one process and start another running state
    ]]>     2022-01-18 09:53:01 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997505666     Scheduling Criteria 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997507589
  • CPU utilization – keep the CPU as busy as possible
  • Throughput – number of processes that complete their execution per time unit
  • Turnaround time – amount of time to execute a particular process
  • Waiting time – amount of time a process has been waiting in the ready queue
  • Response time – amount of time it takes from when a request was submitted until the first response is produced, not output  (for time-sharing environment)

    • Optimization Criteria
    • Maximize CPU utilization
    • Maximize throughput
    • Minimize the turnaround time
    • Minimize the waiting time
    • Minimize the response time
    ]]>     2022-01-18 09:54:05 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997507589     Scheduling Algorithms 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997518746 2022-01-18 09:59:34 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997518746 First Come First Serve (FCFS) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997526245 2022-01-18 10:03:49 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997526245 Shortest Job First (SJF) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997532971 2022-01-18 10:07:26 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997532971 Shortest Remaining Time 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997534932 2022-01-18 10:08:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997534932 Round Robin 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997535831 2022-01-18 10:09:12 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997535831 Priority 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997536776 2022-01-18 10:09:46 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997536776 Process Synchronization 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997811259 Involves using tools that control access to shared data to avoid race conditions. These tools must be used carefully, as their incorrect use can result in poor system performance, including deadlock.

    ]]>     2022-01-18 12:59:05 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997811259     Critical Section Problem 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997813566
  • Each process has a segment code called the critical section problem
  • Critical section problem is a section for processes to share resources (files, data or database)
  • A critical section consists of
    - Entry section: requesting entry into critical section
    - Critical section: a section where only one process can execute at any one time
    - Exit section: release the shared resources
    - Remainder section: the rest of codes for execution
  • Each process must request permission to enter its critical section. The section of code implement this request is the entry section
    • ]]>     2022-01-18 13:00:15 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997813566     Race Condition 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997816414 2022-01-18 13:01:45 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997816414 Solution to Critical Section Problem 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997840854 2022-01-18 13:12:43 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997840854 Peterson's Solution 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997853617
  • Applicable to only 2 processes at a time, so it is a 2 process solution only
  • Two processes share two variables:
    - Int turn;
    - Boolean flag[2]
  • The variable turn indicates whose turn to enter the critical section.
  • The flag array to indicate if a process is ready to enter critical section. flag[i] = true implies that process Pi is ready!

    • ]]>     2022-01-18 13:17:51 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997853617     Peterson's solution and Critical Section Requirement 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997863212 Mutual exclusion is preserved
    Pi enters Critical section only if:
    either flag[i] = false or turn = i
    Progress requirement is satisfied
    Bounded-waiting requirement is met]]>     2022-01-18 13:21:40 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997863212     Algorithms for process Pi 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997869291 2022-01-18 13:24:15 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997869291 Mutex lock 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997880022
  • Mutex lock is the simplest tools to solve critical section
  • Protect a critical section by first acquire() a lock then release() the lock
    - Boolean indicates whether if lock is available or not
  • A process that attempts to acquire an unavailable lock is blocked until the lock is released.
  • Mutex lock solution requires busy waiting, therefore this lock called a spinlock
    • ]]>     2022-01-18 13:28:49 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997880022     Semaphore 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997894746
  • Its provide more sophisticated ways than mutex lock for process to synchronize their activities.
  • S - integer variable
  • Can only be accessed via two indivisible (atomic) operations:
    - wait() 
    - signal()
    • ]]>     2022-01-18 13:34:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997894746     Semaphore usage 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997903052 Its has two types of semaphore values
    • Counting semaphore - S takes unrestricted domain numbers
    • Binary semaphore - S takes only 0 and 1
    Can solve various synchronization problems.
    ]]>     2022-01-18 13:37:41 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997903052     Liveness 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997914307
  • Refers to a set of properties that a system must satisfy to ensure that processes make progress during their execution life cycle.
  • A process waiting indefinitely under the certain circumstances is an example of a "liveness failure"

    • ]]>     2022-01-18 13:41:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997914307     Liveness failure 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997921129 Deadlock
    • A situation where two or more processes are waiting indefinitely for an event that can be caused only by one of the waiting processes.
    Priority Inversion 
    • Scheduling problem when lower-priority process holds a lock needed by higher-priority process
    • Solved via priority-inheritance protocol
    ]]>     2022-01-18 13:44:11 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1997921129     Deadlock 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998005344
  • Is a state when every process in a set waiting for an event that can be caused only by another process in that set.
  • Can be described by the Resource Allocation Graph.

    • ]]>     2022-01-18 14:14:06 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998005344     Deadlock Characterization 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998017601
  • Mutual exclusion - only 1 process at a time can use a resource
  • Hold and wait - a process holding at least one resource is waiting to acquire additional resources held by other processes. 
  • No preemption - a resource can be released only voluntarily by the process holding it, after that process has completed its task.
  • Circular wait - there exists a set of process of waiting processes such that P0 is waiting for a resource that is held by P1, P1 is waiting for a resource that is held by P2, and so on.
    • ]]>     2022-01-18 14:18:09 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998017601     Resource Allocation Graph 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998026623 request edge 
    - directed edge Pi -> Rj
    assignment edge 
    - directed edge Rj ->Pi

    ]]>     2022-01-18 14:21:27 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998026623     Resource Allocation Graph: Example 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998037430 Basic Facts

    If graph contains no cycles
    = No deadlock

    If graph contains a cycles
    - If only one instance per resource type, then deadlock
    - If several instances per resource type, possibility of deadlock]]>     2022-01-18 14:25:15 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998037430     Handling Deadlock 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998065747 OS will try to ignore the problem and pretend that deadlocks never occur in the system.
    • Deadlock prevention
    • Deadlock avoidance
    Use a protocol to prevent deadlocks and ensuring that the system will never enter a deadlocked state.
    If the deadlock still occur in the operating system, then it will allow the system to enter a deadlocked state, detect it, and recover.
    ]]>     2022-01-18 14:34:45 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1998065747     Deadlock Prevention 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999690086 It provides a set methods to ensure that at least one of the necessary conditions cannot hold.
    Its try its best to make sure at least one of the 4 characteristics of the deadlock is not happen in the operating system.
    These methods prevent deadlocks by constraining how requests for resources can be made.

    ]]>     2022-01-19 06:49:46 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999690086     Deadlock Prevention: 4 Characteristic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999691530
  • Mutual Exclusion 
    • not required for shareable resources. example: read-only files. 
    • must hold for non-sharable resources
  • Hold and wait
    • must guarantee that whenever a process requests a resource, it does not hold any other resources. 
  • No preemption
    • If a process is holding resources and then it require another resource and requests another resources that cannot be allocated to it, it needs to release all the resources that being held at the moments.
    • Process will be restarted again when only it can regain its old resources with the new request resources that it needs.
  • Circular wait
    • impose a total ordering of all resource types, and require that each process requests resources in an increasing order of enumeration
    • ]]>     2022-01-19 06:50:57 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999691530     Deadlock avoidance 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999716835
  • Requires some future knowledge of requests for resources from each of the participating processes.
  • It much declare the maximum number of resources of each type that it may needs.
  • Examines the resource-allocation state to ensure that there can never be a circular-wait condition
    • ]]>     2022-01-19 07:09:33 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999716835     Safe state 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999718148

    ]]>     2022-01-19 07:10:29 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999718148     Prevention VS Avoidance 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999753760 2022-01-19 07:33:14 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999753760 Avoidance Algorithms 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999755908
  • Single instance resource
    • Use a resource-allocation graph

    • Multiple instance resource
      • Use banker's algorithm
    ]]>     2022-01-19 07:34:29 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999755908     Resource-Allocation Graph Scheme 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999777099 Process P1 request resource R2
    Process P1 is holding resource R1 
    Process P2 request resource R1
    Process P2 is holding resource R2

    There is a cycle so, the deadlock is occur.]]>     2022-01-19 07:46:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999777099     Banker's Algorithm 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999783156
  • This algorithm is used to avoid deadlock with multiple instances of a resource type
  • Each process must have a priori claim maximum use
  • When a process requests a resource it may have to wait
  • When a process gets all its resources it must return them in a finite amount of time
    • ]]>     2022-01-19 07:50:11 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999783156     Data structures Banker's algorithm 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999784877 2022-01-19 07:51:11 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999784877 Safety Algorithm 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999799498 2022-01-19 07:59:10 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999799498 Memory Management 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999857242 2022-01-19 08:31:10 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999857242 Background 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999857601
  • Every process must be in a memory in order to executed.
  • The process will be swap in and swap out in the memory.
  • Typical instruction 
    - fetch instruction from memory
    - decode the instructions
    - operand fetch
    - possible storage of result in memory
  • Register access or Cache can be done in one CPU clock (or less)
    - It sits between CPU and Memory to deal with the "stall" issue
  • Protection of memory is required to ensure correct operation:
    • User process cannot access operating system memory
    • 1 user process cannot access the memory of another user process
    • ]]>     2022-01-19 08:31:21 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999857601     Memory Protection 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999961555
  • Protect using base registers and limit registers.
    • base register: hold smallest physical address of a program memory
    • limit register: specify the size of the program
    • ]]>     2022-01-19 09:29:20 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/1999961555     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000674477 In this topic, I can understand how every process is being manage for the execution. There is 5 state for the process may occur in the os, which is new, ready, running, waiting, and execute. Each state may require additional input for the os to execute the process. 

    From my perspective on state diagram: 
    The process state is the same concept as the requirement to complete some task in our daily life. Such as example, we want to cook some meals for that day but we didn't have the ingredients, so we need to do some task in order to cook that meals such as buy the ingredients for the meals.

    My perspective on indirect communication:
    Its like people share the same house and they may receive the same information about the news on the tv, if they watch together. ]]>     2022-01-19 15:17:21 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000674477     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000694511 Computer system has 4 components which is user, application, operating system and harware.
    The roles of each components is the same concept as any company that has position roles in the company such as manager, ceo, admin, etc. each position has its own responsibilities toward the company.

    Based on my understanding of How CPU can be excuted: 
    Interrupt is occur when some task/process is needed.
    Interrupt is just like our assignment that needs to be done, our deadline to submit is the priority of the request that needs to be execute. When a new assignment is assigned, we will stop the process of finishing the other assignment to process the task of that new assignment. Hehe

    From my perspective of multicore: 
    This multicore is the same concept as human multitasking. Some of us may have an ability to multitask to complete several work.]]>     2022-01-19 15:24:25 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000694511     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000695437 Operating system provide functions for user and program. So that user and program functions really well. It is like a program that user can use and inside the program, it is manage by os. 

    System Call Point of view:
    System call from my point of view is instruction that we required to do.
    Such as in mathematic subject, we have a formula to answer certain question.
    That formula is almost the same as system call because in order to get the answer we need to follow the procedure to complete the task.

    ]]>     2022-01-19 15:24:45 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000695437     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000696322 In this topic, I learned that CPU scheduling is important for the operating system because os need to use the CPU as best as it can. All the functionality of the CPU may use to output the best result and for user to use the program.

    There is 4 state that CPU scheduler may occur in the system. Which is from running to ready state, running to waiting state, waiting to ready state and terminate state.

    CPU scheduler criteria that os needs to achieve is to maximize CPU utilization, maximize throughput, minimize the turnaround time, minimize the waiting time, minimize the response time in order to make the os and user can enjoy the system.]]>     2022-01-19 15:25:05 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000696322     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000696783 In this topic, we knew that process synchronization is a way to coordinate processes that use the shared data. It is occur when the process is cooperating that we call as "cooperating processes" because the processes share the resources between them.

    Process synchronization helps the processes that share the resources to act and execute properly to avoid data inconsistency. If data inconsistency occur, race condition may occur in the process.
     
    Critical section is a segment of code that can be access by only 1 signal process at a certain time.

    There is 3 tools of  process synchronization which is peterson's algorithm, mutex lock, and semaphore. 

    In the end of this topic, we knew that process synchronization is important to os in order to manage the processes that share the resources. If the process enter the critical section, there is a way to manage the process, which is mutual exclusion, progress and bounded-waiting.

    ]]>     2022-01-19 15:25:15 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000696783     My perspective on this topic 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000697236 In this topic, I learned that when operating system handles multiple processes it may triggered deadlock to occur in the system. A deadlock occurrence can be detected by the resource scheduler. Deadlock can occur when at least 1 process that is waiting for resources to be released by another process, it require that resources in order to execute and terminates the task correctly. 

    A deadlock can occur if these conditions are fulfilled simultaneously. These conditions are: mutual exclusion, circular wait, hold and wait and last is no preemption.

    We can avoid the deadlock instead of dealing with the deadlock instead. Deadlock avoidance is the simplest and most useful model that each process declares the maximum of resources that they need to terminates the task correctly.

    Sometimes, we cannot avoid the deadlock so we can prevent the deadlock before it can occur in the operating system. It is a method to ensuring that at least one of the conditions cannot hold.


    ]]>     2022-01-19 15:25:25 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2000697236     Address Binding 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002669794 Every program that needs to be executed must be in memory(ram) in order to execute it.

    3 different types of address
    • Symbolic address
    • Logical address
    • Physical address
    ]]>     2022-01-20 12:08:53 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002669794     Binding of Instructions and Data to Memory 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002677594
  • Compile Time - If it is known at compile time where a program will reside in physical memory, then absolute code can be generated by the compiler, containing actual physical addresses. However if the load address changes at some later time, then the program will have to be recompiled. DOS .COM programs use compile time binding.
  • Load Time - If the location at which a program will be loaded is not known at compile time, then the compiler must generate relocatable code, which references addresses relative to the start of the program. If that starting address changes, then the program must be reloaded but not recompiled.
  • Execution Time - If a program can be moved around in memory during the course of its execution, then binding must be delayed until execution time. This requires special hardware, and is the method implemented by most modern OS.

    • ]]>     2022-01-20 12:14:23 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002677594     Logical vs Physical Address Space 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002679443
  • The address generated by the CPU is a logical address, whereas the address actually seen by the memory hardware is a physical address.
  • The set of all logical addresses used by a program composes the logical address space, and the set of all corresponding physical addresses composes the physical address space.
  • Address that bound at compile time or load time have identical logical and physical addresses.

    • ]]>     2022-01-20 12:15:33 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002679443     Memory-Management Unit (MMU) 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002687412 The run time mapping of logical to physical addresses is handled by the memory-management unit, MMU.
    • The MMU can take on many forms. One of the simplest is a modification of the base-register scheme described earlier.
    • The base register is now termed a relocation register, whose value is added to every memory request at the hardware level.
    ]]>     2022-01-20 12:20:40 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002687412     Memory Allocation Scheme 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002690029 2 Main Ways for allocate memory space:
    • Contiguous
    • Non-Contiguous
    ]]>     2022-01-20 12:22:18 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002690029     Contiguous Allocation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002702647
  • Main memory(ram) must support both OS and user processes.
  • Memory is a limited resource so, it needs to be allocate efficiently.
  • Main memory divided into 2 partitions:
    •  The operating system is allocated space first, usually at low  memory locations.
    •  The remaining available memory is allocated to user processes as needed, usually at high memory locations.
    • ]]>     2022-01-20 12:30:28 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002702647     Multiple-partition allocation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002704360
  • Variable-partition: memory space has variable size to assign the process needs.
  • Hole: block of free space that available in the memory.
    • ]]>     2022-01-20 12:31:30 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002704360     Dynamic Storage-Allocation Problem 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002718130
  • First Fit: In the first fit, the partition is allocated which is the first sufficient block from the top of Main Memory. It scans memory from the beginning and chooses the first available block that is large enough. Thus it allocates the first hole that is large enough. 

    • Best Fit Allocate the process to the partition which is the first smallest sufficient partition among the free available partition. It searches the entire list of holes to find the smallest hole whose size is greater than or equal to the size of the process. 

    • Worst Fit Allocate the process to the partition which is the largest sufficient among the freely available partitions available in the main memory. It is opposite to the best-fit algorithm. It searches the entire list of holes to find the largest hole and allocate it to process.  

    First-fit and best-fit are better than worst-fit in terms of speed and storage utilization.
    ]]>     2022-01-20 12:39:51 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002718130     Fragmentation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002723019
  • External fragmentation - Total memory space is enough to satisfy a request or to reside a process in it, but it is not contiguous, so it cannot be used.
  • Internal fragmentation - Memory block assigned to process is bigger. Some portion of memory is left unused, as it cannot be used by another process.
    • ]]>     2022-01-20 12:42:38 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002723019     Non-Contiguous Allocation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002726696
  • Partition the program into a number of small units, each of which can reside in a different part of the memory.
  • Need hardware support.
  • Various methods of partitions:
    • Segmentation
    • Paging 
    • Paged segmentation
    • ]]>     2022-01-20 12:44:41 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002726696     Segmentation 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002747170 Segmentation is another memory management scheme that supports the user-view of memory. Segmentation allows breaking of the virtual address space of a single process into segments that may be placed in non-contiguous areas of physical memory.]]> 2022-01-20 12:54:29 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002747170 Paging 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002754554
  • A solution to fragmentation problem is Paging. Paging is a memory management mechanism that allows the physical address space of a process to be non-contagious. Here physical memory is divided into blocks of equal size called Pages. The pages belonging to a certain process are loaded into available memory frames.
  • Mapping from logical memory to physical memory using the page table.
    • ]]>     2022-01-20 12:58:10 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002754554     Swapping 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002763409 A process needs to be in memory for execution. But sometimes there is not enough main memory to hold all the currently active processes in a timesharing system. So, excess process are kept on disk and brought in to run dynamically. Swapping is the process of bringing in each process in main memory, running it for a while and then putting it back to the disk.]]> 2022-01-20 13:02:47 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002763409 My perspective on this topic: 2021478032 https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002765564 This topic quiet heavy because it covers all the memory management that operating system should take part of. 

    Main Memory refers to a physical memory that is the internal memory to the computer. The word main is used to distinguish it from external mass storage devices such as disk drives. Main memory is also known as RAM. The computer is able to change only data that is in main memory. Therefore, every program we execute and every file we access must be copied from a storage device into main memory.

    From this topic, I learned that every process needs to be in the main memory in order to execute it correctly. Every process has its own address to navigate to memory.]]>     2022-01-20 13:03:57 UTC https://padlet.com/2021478032/gzx2d9mh8t82a83u/wish/2002765564