Please enable JavaScript.

Coggle requires JavaScript to display documents.

OS Ch3 (Processes), from file to process, Exceptions and Interupts, The…

- - - - it is not loaded into memory in a single continouous piece
      - the executable file contains tables that allow the kernal to assemble variaous section so the memory image
- - - - newly created and not ready to run
    - - ready to run but just needs to be loaded into cpu
    - - in cpu and running
    - - made request for service and waiting for something to happen
    - - only happens once, program is finished
  - - - admit
        
        ready
        
        dispatch
        
        running
        
        exit
        
        terminated
        
        I/O or event request
        
        waiting
        
        1 more item...
        
        taken out of the processor cause it needs something
        
        preempt
        
        ready
        
        when the process used too much time it was allowed
        
        given resources to run, ready to run
        
        completely load something into memory or admitted into the system to be ready
- - - - to manage these things each process block has process ID
  - - - program counter
      - CPU registers
- - - - the mode is swtiched to kernal mode
      - the registers are saved
      - registers are restored
      - the mode is switched to user mode
- - - - Text Segment at the bottom of address space
        
        initialized data, like global constants
        
        uninitialized data, such as uninitialized global variables called bss
        
        The heap is the free space below the stack and above the bss. This is where dynamically-allocated variables are stored.
      - Command line arguments and environment strings are in the highest part of user addressable memory
        
        user stack grows downward towards bss
- - - - what should be admitted into the sytem
    - - how many processes should be in memory
        
        to little processes in memory the CPU will be idle
      - which processes should be in memory
        
        I/O Bound Processes, heavy use of I/O devices and dependent on those processes
        
        Compute-Bound, are compute-intensive, making little to no I/O requests
        
        you need a good mixure of processes for the best scheduling
    - - CPU scheduling, which memory resident processes should be given to the CPU next
        
        does this by using queues
        
        ready queue
        
        contains process IDs or pointers to processes in linked list, not entire Control Blocks cause its a waste
        
        Waiting queue
        
        waititng for events related to the device
        
        Queue processes
        
        ready goes to cpu and runs
        
        makes request for something
        
        goes to wait queue
        
        1 more item...
        
        queueing diagram
        
        events
        
        resource
        
        CPU scheudler gotta be fast as fuck
        
        gotta run in assemby cause speeeeeddd
        
        runs frequently cause gotta go fast
  - - - save the old context
        
        load the new one
- - - - two or more programs may need to access or modify the same information at the same size
      - you can pipe things using |
        
        both processes are started simultaniously
    - - you can break up a problem into subtasks and run them simultaniously
        
        if designed well it can run faster than a single program
    - - you can still break down a problem for easier
        
        modify
        
        maintain
        
        debug
        
        document
        
        understand
  - - - browser processes, manages the user interface and all disk and network I/O
      - renderer process
  - - - can be a shared file or shared variable
        
        they might read and write from the same thing, you have to build syncronicztion method
      - can pass data back and fourth
        
        built in syncronizaiton method
        
        shared memory model
        
        only work if theyre running on the same machine, they need a shared memory
        
        they write and read from a shared region of memory, they both have access
        
        using threads
        
        light weight processes (ch4 talks about threads)
        
        can share an address space
        
        when processes share memory to communicate, it is Very Dangerous (subject of ch6)
        
        shared memory in Linux
        
        theres a system 5 API
        
        also has its own POSIX shared memory API
        
        parent allocates shared memory
        
        child attatches to that shared memory through the segmentID
        
        parent also needs to attach itself to the
        
        message passing model
        
        message short sequence of bytes, depends on the implementation
        
        fixed or variable sized, also based on implementation
        
        the IPC system has an API that can be used to communicate
        
        send
        
        can sometimes not need a destination, acts like a broadcast
        
        recieve
        
        implementation
        
        when on the same machine
        
        done using a queue
        
        communication link
        
        sending things through channels
        
        1 more item...
        
        no data is lost and not duplicated
        
        Issues
        
        buffer is a FIFO queue
        
        if there is zero capacity, it is a synchornous communication
        
        bounded capcaity,
        
        unbounded capacity, sending is asynchronous and the sender is never blocked
        
        direct communication
        
        explicitly sending and recieving each other from a process
        
        bounded at compile time since you are naming the process
        
        links are established between every pair of processes
        
        can be unidirection or bidirectional
        
        naming can be asymmetric (you can use one explicitly and one indirectly)
        
        Indirect communication
        
        mailbox or port
        
        you can place and remove items
        
        queueing system
      - Visualization time
  - - - blocking send, if the process sending this is blocked until it recieves a return
      - blocking recieve, if the process is blocked until a message is available
      - considered synchronous operations because with blocks the processes are forced to be syncronized
      - if both are blocked because they are both waiting for a message send and received is called a rendezvous because thats when they both are waiting for each other and meet up
  - - - doesnt wait for input, if the data is available it recieves it, if not then you get a null or special operator saying it didnt recieve anything
  - - - named pipes can be used by unrelated processes
      - unnamed pipes can only be used by related processes , like parent and child, or sibling processes