1 / 66

Processes: program + execution state Pseudoparallelism Multiprogramming Many processes active at once With switching: pr

Processes: program + execution state Pseudoparallelism Multiprogramming Many processes active at once With switching: process execution is not repeatable processes should make no assumptions about timing Process consists of: Process’ core image: program, data, run-time stack

jarah
Download Presentation

Processes: program + execution state Pseudoparallelism Multiprogramming Many processes active at once With switching: pr

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Processes: program + execution state • Pseudoparallelism • Multiprogramming • Many processes active at once • With switching: • process execution is not repeatable • processes should make no assumptions about timing • Process consists of: • Process’ core image: program, data, run-time stack • Program counter, registers, stack pointer • OS bookkeeping information

  2. Process State • As a process executes, it changes state • 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.

  3. Diagram of Process State

  4. Diagram of Process State X

  5. Diagram of Process State X X

  6. Diagram of Process State X X X

  7. PCB PCB PCB PCB PCB Process Table One entry per process. Pr 0 Pr 1 Pr 2 Pr 4 …..Pr N

  8. PCB: Process Management • registers, program counter, program status word, stack pointer • process state • time process started, CPU time used, children’s CPU time used • alarm clock setting • pending signal bits • pid • message queue pointers, other flag bits

  9. PCB: Memory-Related Information • pointers to • text • Data • stack segments • Pointer to page table

  10. PCB: File-Related Information • root, working directory • file descriptors • User ID • Group ID

  11. Process Control Block (PCB)

  12. Context Switch (or Process Switch) • Currently executing process looses control of CPU • Its “context” must be saved (if not terminated) into PCS. • New process is chosen for execution. • New process context is restored. • New process is given control of the CPU.

  13. CPU Switch From Process to Process

  14. Process Scheduling Queues • Job queue – set of all processes in the system. • 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. • Process migration between the various queues.

  15. Ready Queue And Various I/O Device Queues

  16. Representation of Process Scheduling

  17. Low Level Interrupt Processing • Each HW device has slot in interrupt vector (IV). • On interrupt, HW pushes PC, PSW, one or more registers. • Loads in new PC from IV. • END OF HW • Assembly code to save registers and info on stack (to PCB). • Assembly sets up new stack for handling process. • Calls C interrupt handling routing to complete interrupt processing. • Scheduler is called and determines next process to run. • Assembly language restores registers and other necessary items (e.g., memory map) of selected process and begins its execution.

  18. Schedulers • Long-term scheduler (or job scheduler) – selects which processes should be brought into the ready queue. • Short-term scheduler (or CPU scheduler) – selects which process should be executed next and allocates CPU.

  19. Schedulers (Cont.) • Short-term scheduler is invoked very frequently (milliseconds)  (must be fast). • Long-term scheduler is invoked very infrequently (seconds, minutes)  (may be slow). • The long-term scheduler controls the degree of multiprogramming.

  20. Schedulers (Cont.) • Processes can be described as either: • I/O-bound process – spends more time doing I/O than computations, many short CPU bursts. • CPU-bound process – spends more time doing computations; few very long CPU bursts.

  21. Context Switch • 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. • Context-switch time is overhead; the system does no useful work while switching. • Time dependent on hardware support.

  22. Process Creation • Parent process create children processes, which, in turn create other processes, forming a tree of processes. • Resource sharing • Parent and children share all resources. • Children share subset of parent’s resources. • Parent and child share no resources. • Execution • Parent and children execute concurrently. • Parent waits until children terminate.

  23. Process Creation (Cont.) • Address space • Child duplicate of parent. • Child has a program loaded into it. • UNIX examples • fork system call creates new process • exec system call used after a fork to replace the process’ memory space with a new program.

  24. Unix Fork() #include <stdio.h> main(int argc, char *argv[]) { int pid, j ; j = 10 ; pid = fork() ; if (pid == 0) /*I am the child*/ { Do child things } else /* I am the parent */ wait(NULL) ; /* Block execution until child terminates */ }

  25. fork()

  26. Processes Tree on a UNIX System

  27. exec Function calls Used to begin a processes execution. Accomplished by overwriting process imaged of caller with that of called. Several flavors, use the one most suited to needs. int execv( char *path, char *argvec[]) ;

  28. exec Function calls int execv( char *path, char *argvec[]) ; pathname: Can be an executable program in your directory (application code) or a system program such as ls, cd, date, ………….. argvec: Pointers to NULL terminated strings. First element should always be the name of the program, last element should always be NULL. Assume: a.out b.out x.exe. By.by all in home directory.

  29. main (int argc, *argv[]) { int pid ; char args[2] ; pid = fork() ; if (pid ==0) { args[0] = “./a.out” ; All executed by args[1] = NULL ; child process execv(“./aout”, args) ; printf(“OOOpppssss.\n”) ; } else printf(“Not a problem!\n”) ; Executed by parent }

  30. Process Termination • Process executes last statement and asks the operating system to decide it (exit). • Output data from child to parent (via wait). • Process’ resources are deallocated by operating system.

  31. Process Termination • Parent may terminate execution of children processes (abort). • Child has exceeded allocated resources. • Task assigned to child is no longer required. • Parent is exiting. • Operating system does not allow child to continue if its parent terminates. • Cascading termination.

  32. TA • Xiao Han • Office Number: 581-2260 • Consulting hours: 2:00-4:00 pm Tuesday and Thursday • Place: Unix computer cluster at the first floor in Neville Hall

  33. void setup(char inputBuffer[], char *args[],int *background) { int length, /* # of characters in the command line */ i, /* loop index for accessing inputBuffer array */ start, /* index where beginning of next command parameter is */ ct; /* index of where to place the next parameter into args[] */ ct = 0; /* read what the user enters on the command line */ length = read(STDIN_FILENO, inputBuffer, MAX_LINE); //ssize_t read(int fd, void *buf, size_t count); if (length == 0) exit(0); /* ^d was entered, end of user command stream * if (length < 0) {perror("error reading the command"); exit(-1) ; }

  34. /* examine every character in the inputBuffer */ for (i=0;i<length;i++) { switch (inputBuffer[i]){ case ' ': case '\t' : /* argument separators */ if (start != -1) { args[ct] = &inputBuffer[start]; ct++; } inputBuffer[i] = '\0'; /* add a null char; make a C string */ start = -1; break;

  35. case '\n': if (start != -1){ args[ct] = &inputBuffer[start]; ct++; } inputBuffer[i] = '\0'; args[ct] = NULL; break; default : /* some other character */ if (start == -1) start = i; if (inputBuffer[i] == '&') { *background = 1; inputBuffer[i] = '\0'; } } } args[ct] = NULL; /* just in case the input line was > 80 */

  36. Cooperating Processes • Independent process cannot affect or be affected by the execution of another process. • Cooperating process can affect or be affected by the execution of another process • Advantages of process cooperation • Information sharing • Computation speed-up • Modularity • Convenience

  37. Producer-Consumer Problem • 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.

  38. Constraints • Do not over-write an item not yet consumed. • Do not write to a full buffer • Do not read from a previously read item. • Do not read from an empty buffer.

  39. Bounded-Buffer – Shared-Memory Solution • Shared data #define BUFFER_SIZE 10 typedef struct { . . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0;

  40. Bounded-Buffer – Producer Process item nextProduced; while (1) { while (((in + 1) % BUFFER_SIZE) == out) ; /* do nothing */ buffer[in] = nextProduced; in = (in + 1) % BUFFER_SIZE; }

  41. Bounded-Buffer – Consumer Process item nextConsumed; while (1) { while (in == out) ; /* do nothing */ nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; }

  42. Producer: while (((in + 1) % BUFFER_SIZE) == out) ; Consumer Blocked: while (in == out) ; out in

  43. out in Producer Blocked: while (((in + 1) % BUFFER_SIZE) == out) ; Consumer: while (in == out) ; O O O O O

  44. out in Producer: while (((in + 1) % BUFFER_SIZE) == out) ; Consumer Blocked: while (in == out) ; X X X X X

  45. Interprocess Communication (IPC) • Mechanism for processes to communicate and to synchronize their actions • Message system – processes communicate with each other without resorting to shared variables • IPC facility provides two operations: • send(message) – message size fixed or variable • receive(message)

  46. Interprocess Communication (IPC) • If P and Q wish to communicate, they need to: • establish a communicationlink between them • exchange messages via send/receive • Implementation of communication link • physical (e.g., shared memory, hardware bus) • logical (e.g., logical properties)

  47. Implementation Questions • How are links established? • Can a link be associated with more than two processes? • How many links can there be between every pair of communicating processes? • What is the capacity of a link? • Is the size of a message that the link can accommodate fixed or variable? • Is a link unidirectional or bi-directional?

  48. Communications Models

  49. Shared Memory in POSIX • Requires allocating a shared memory region • Attaching region to processes address space • Read/write to memory as usual. • Detach from address space • Delete shared memory.

More Related