Please enable JavaScript.

Coggle requires JavaScript to display documents.

Operating Systems (Memory (memory protection (base register (holds the…

- - - - area in disk to serve I/O jobs
        
        Input of LAN
        
        output for printer
  - - - holds the smallest legal physical memory address.
    - - contains the size of the range
- - - - sectors
  - - - caching
        
        copying information into faster storage system
      - fast storage
    - - This requires data that is simultaneously stored in
        more than one level to be consistent
- - - - user choise
      - IPC_PRIVATE
    - - the number of semaphores in the group
    - - Permissions
      - IPC_CREATE
      - IPC_EXCL
  - - - Semaphore ID
    - - sem_num
        
        number of the semaphore (0 if you only have 1)
      - sem_op
        
        Increment number
        
        negetive
        
        require that many resources
        
        positive
        
        returning that number of resources
      - sem_flag
        
        SEM_UNDO
        
        if my task dies, then undo any operation that I am hanging onto
    - - number of entries in the structure pointed to
  - - - semctl(sem_id, 0, IPC_RMID, sem_union) ;
    - - sem_union.val = 1;
      - semctl(sem_id, 0, SETVAL, sem_union) ;
    - - semctl(sem_id, 0, GETVAL, sem_union);
- - - - Master-Slave
      - for large systems
    - - modern computers
      - for small systems (PC)
      - each proccessor runs identical operating system
- - - - Code
      - Data
      - Stack
      - Process Creation
        
        Resource sharing (ALL,PART,NONE)
        
        Execution (concurrently, waits until children terminate.)
        
        Address space (duplicate of parent.program loaded into it.)
        
        Parent process creates children processes
      - Process Termination
        
        exit (Output data from child to parent)
        
        kill
        
        Any process may terminate execution of another processes of the same
        user.
        
        UNIX - parent exit -- "orphan" child adopted by init
      - Process State
        
        UNIX
        
        R
        
        running / ready
        
        S
        
        sleeping (waiting)
        
        T
        
        stopped
        
        Z
        
        zombie
        
        D
        
        uninterruptible sleep (IO).
        
        NO UNIX
        
        new
        
        The process is being created.
        
        running
        
        Instructions are being executed.
        
        waiting
        
        The process is waiting for some event to occur.
        
        ready
        
        The process is waiting to be assigned to a process.
        
        terminated
        
        The process has finished execution.
      - PCB
        
        Information associated with each process.
        
        Process State
        
        Process number
        
        Program Counter
        
        CPU registers
        
        CPU schedualing information
        
        Memory managmen information
        
        Accounting information
        
        I/O information(open files)
      - Process Scheduling Queues
        
        Schedulers
        
        Long-Term (job scheduler)
        
        selects which processes
        should be brought into the ready queue.
        
        NOT IN UNIX
        
        (may be slow)
        
        controls the degree of multi programming
        
        Short-Term (CPU scheduler)
        
        selects which process should
        be executed next and allocates CPU.
        
        (must be fast)
        
        I/O-bound process
        
        many short CPU bursts.
        
        CPU-bound process
        
        few
        very long CPU bursts.
        
        Ready queue
        
        set of all processes residing in main memory,
        ready and waiting to execute.
        
        Device queues
        
        set of processes waiting for an I/O device.
      - Context Switch
        
        system must save the state
        of the old and load the saved of the new process.
        
        system does no useful work while
        switching.
        
        Time dependent on hardware support.
      - Cooperating Processes
        
        Independent process
        
        cannot affect or be affected
        
        Cooperating process
        
        can affect or be affected
        
        Information sharing
        
        Computation speed-up
        
        Modularity
      - Direct Communication
        
        send/recieve with links
      - Indirect Communication
        
        received from the resource
        
        resource has unique id
        
        can communicate only via shared resource
        
        link to many processes
        
        Operations
        
        create resource
        
        send / recieve via resource
        
        destroy resource
      - Synchronization
        
        synchronous
        
        blocking
        
        asynchronous
        
        non blocking
      - Buffering
        
        Queue of messages attached to the link; implemented:
        
        Zero capacity
        
        0 bytes Sender must wait for receiver
        
        Bounded capacity
        
        finite length of n bytes Sender must wait if the link is full.
        
        Pipes in UNIX
        
        Unbounded Capacity
        
        infinite length Sender never waits.
        
        Messages in UNIX
      - thread
        
        a basic unit of CPU utilization
        
        PCB in the kernel
        
        Stack space
        
        thread shares
        
        Text/Code section
        
        Data section
        
        Multithreaded Processes
        
        while one server thread is blocked and
        waiting, a second thread in the same task can run.
        
        applications that require sharing a common buffer (i.e.,
        producer-consumer) benefit from thread utilization.
        
        Threads provide a mechanism that allows sequential processes to make
        blocking system calls while also achieving parallelism.
        
        Types
        
        Kernel-supported
        
        User-level
        
        via a set of library
        calls at the user level.
        
        Anderson's threads
        
        sends events that influence user-level scheduling
        
        Multithreading Models
        
        Many-to-One
        
        Used on systems that do not support kernel threads.
        
        Us -> K
        
        One-to-One
        
        U -> K
        
        Win95/98
        
        Many-to-Many
        
        implements both user-level and
        kernel-supported threads.
        
        Us -> Ks
        
        Solaris 2, Linux, WindowsNT, Windows2000.
- - - - CPU
        
        CPU Protection
        
        Timer
        
        interrupts after specified period to ensure operating
        system maintains control.
        
        decremented every clock tick.
        
        value 0, an interrupt occurs.
        
        implement time sharing.
        
        compute the current time.
      - Device controllers
        
        each controller has Buffer for I/O
        
        disk controller
        
        determines the logical interaction between the
        device and the computer.
        
        Printer controller
        
        printer
        
        informs the CPU when finished by Interrupt
        
        interrupt vector
        
        contains the addresses of all the
        service routines.
        
        disabling interuppts to prevent lost interrupt
        
        trap
        
        a software-generated interrupt caused either by an error or a
        user request
        
        operating system is interrupt driven
        
        Operating systems saves Device status table to manage devices
- - - - Privileged instructions
        
        I/O instructions
        
        load instructions for the base and limit registers
        
        Load-timer
    - - System call
        
        used by a process to request action
        
        takes the form of a trap
        
        Control passes through the interrupt vector to a service routine
        
        the mode bit is set to kernel mode.
        
        kernel verifies that the parameters are correct and legal,