1 / 55

Process IDs

Process IDs. Process IDs are 16-bit numbers that are assigned sequentially by Linux as new processes are created. Printing the Process ID #include &lt;stdio.h&gt; #include &lt;unistd.h&gt; int main () { printf (“The process ID is %d<br>”, (int) getpid ());

gareth
Télécharger la présentation

Process IDs

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. Process IDs • Process IDs are 16-bit numbers that are assigned sequentially by Linux as new processes are created. • Printing the Process ID #include <stdio.h> #include <unistd.h> int main () { printf (“The process ID is %d\n”, (int) getpid ()); printf (“The parent process ID is %d\n”, (int) getppid ()); return 0; }

  2. Process IDs • Viewing Active Processes % ps PID TTY TIME CMD 21693 pts/8 00:00:00 bash 21694 pts/8 00:00:00 ps • % ps -e -o pid,ppid,command The -e option instructs ps to display all processes running on the system.The -o pid,ppid,command option tells ps what information to show about each process in this case, the process ID, the parent process ID, and the command running in this process. • % ps -e -o pid,ppid,command PID PPID COMMAND 1 0 init [5] 2 1 [kflushd] 3 1 [kupdate] ... 21725 21693 xterm 21727 21725 bash 21728 21727 ps -e -o pid,ppid,command

  3. Killing a Process • The kill command works by sending the process a SIGTERM, or termination,signal. • % kill -KILL pid

  4. Creating Processes • Using system #include <stdlib.h> int main () { int return_value; return_value = system (“ls -l /”); return return_value; } • Using fork and exec

  5. Creating Processes • Using fork to Duplicate a Program’s Process #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main () { pid_t child_pid; printf (“the main program process ID is %d\n”, (int) getpid ()); child_pid = fork (); if (child_pid != 0) { printf (“this is the parent process, with id %d\n”, (int) getpid ()); printf (“the child’s process ID is %d\n”, (int) child_pid); } else printf (“this is the child process, with id %d\n”, (int) getpid ()); return 0; }

  6. Process Scheduling • % nice -n 10 sort input.txt > output.txt

  7. Signals • The Linux system sends signals to processes in response to specific conditions. For instance, SIGBUS (bus error), IGSEGV (segmentation violation), and SIGFPE (floating point exception) may be sent to a process that attempts to perform an illegal peration.

  8. Signals • Using a Signal Handler #include <signal.h> #include <stdio.h> #include <string.h> #include <sys/types.h> #include <unistd.h> sig_atomic_t sigusr1_count = 0; void handler (int signal_number) { ++sigusr1_count; } int main () { struct sigaction sa; memset (&sa, 0, sizeof (sa)); sa.sa_handler = &handler; sigaction (SIGUSR1, &sa, NULL); /* Do some lengthy stuff here. */ /* ... */ printf (“SIGUSR1 was raised %d times\n”, sigusr1_count); return 0; }

  9. Waiting for Process Termination • int main () { int child_status; /* The argument list to pass to the “ls” command. */ char* arg_list[] = { “ls”, /* argv[0], the name of the program. */ “-l”, “/”, NULL /* The argument list must end with a NULL. */ }; /* Spawn a child process running the “ls” command. Ignore the returned child process ID. */ spawn (“ls”, arg_list); /* Wait for the child process to complete. */ wait (&child_status); if (WIFEXITED (child_status)) printf (“the child process exited normally, with exit code %d\n”, WEXITSTATUS (child_status)); else printf (“the child process exited abnormally\n”); return 0; }

  10. Waiting for Process Termination • waitpid function can be used to wait for a specific child process to exit instead of any child process. • wait3 function returns CPU usage statistics about the exiting child process, • wait4 function allows you to specify additional options about which processes to wait for.

  11. Zombie Processes • #include <stdlib.h> #include <sys/types.h> #include <unistd.h> int main () { pid_t child_pid; /* Create a child process. */ child_pid = fork (); if (child_pid > 0) { /* This is the parent process. Sleep for a minute. */ sleep (60); } else { /* This is the child process. Exit immediately. */ exit (0); } return 0; }

  12. Threads • Threads,like processes are a mechanism to allow a program to do more than one thing at a time.As with processes, threads appear to run concurrently; the Linux kernel schedules them asynchronously, interrupting each thread from time to time to give others a chance to execute.

  13. Threads • #include <pthread.h> #include <stdio.h> void* print_xs (void* unused) { while (1) fputc (‘x’, stderr); return NULL; } int main () { pthread_t thread_id; pthread_create (&thread_id, NULL, &print_xs, NULL); /* Print o’s continuously to stderr. */ while (1) fputc (‘o’, stderr); return 0; }

  14. Passing Data to Threads #include <pthread.h> #include <stdio.h> struct char_print_parms { char character; int count; }; void* char_print (void* parameters) { struct char_print_parms* p = (struct char_print_parms*) parameters; int i; for (i = 0; i < p->count; ++i) fputc (p->character, stderr); return NULL; } int main () { pthread_t thread1_id; pthread_t thread2_id; struct char_print_parms thread1_args; struct char_print_parms thread2_args; thread1_args.character = ’x’; thread1_args.count = 30000; pthread_create (&thread1_id, NULL, &char_print, &thread1_args); thread2_args.character = ’o’; thread2_args.count = 20000; pthread_create (&thread2_id, NULL, &char_print, &thread2_args); thread2_args.character = ’o’; thread2_args.count = 20000; pthread_create (&thread2_id, NULL, &char_print, &thread2_args);

  15. Module 6: CPU Scheduling • Basic Concepts （基本概念） • Scheduling Criteria （调度准则） • Scheduling Algorithms （调度算法） • Multiple-Processor Scheduling （多处理器调度） • Real-Time Scheduling （实时调度） • Algorithm Evaluation （算法评估）

  16. Basic Concepts • Maximum CPU utilization obtained with multiprogramming （通过多道程序设计得到CPU的最高利用率） • CPU–I/O Burst Cycle – Process execution consists of a cycle of CPU execution and I/O wait. （CPU-I/O脉冲周期 - 进程的执行包括进程在CPU上执行和等待I/O） • CPU burst distribution （CPU脉冲的分布）

  17. Alternating Sequence of CPU And I/O Bursts

  18. Histogram of CPU-burst Times

  19. CPU Scheduler • Selects from among the processes in memory that are ready to execute, and allocates the CPU to one of them.（选择内存中的就绪进程，并分配CPU给其中之一） • CPU scheduling decisions may take place when a process （CPU调度可能发生在当一个进程）: 1. Switches from running to waiting state（从运行转到等待）. 2. Switches from running to ready state（从运行转到就绪）. 3. Switches from waiting to ready（从等待转到就绪）. 4. Terminates（终止运行）. • Scheduling under 1 and 4 is nonpreemptive （发生在1、4两种情况下的调度称为非抢占式调度）. • All other scheduling is preemptive （其他情况下发生的调度称为抢占式调度）.

  20. Dispatcher • Dispatcher module gives control of the CPU to the process selected by the short-term scheduler; this involves（进程调度模块负责将对CPU的控制权转交给由CPU调度程序，包括）: • switching context（切换上下文） • switching to user mode（切换到用户态） • jumping to the proper location in the user program to restart that program（跳转到用户程序的适当位置并重新运行之） • Dispatch latency – time it takes for the dispatcher to stop one process and start another running（调度时间 – 调度程序终止一个进程的运行并启动另一个进程运行所花的时间）.

  21. Scheduling Criteria • CPU utilization – keep the CPU as busy as possible （CPU利用率 – 使CPU尽可能的忙碌） • Throughput – the number of processes that complete their execution per time unit（吞吐量 – 单位时间内运行完的进程数） • Turnaround time – the interval from submission to completion （周转时间 – 进程从提交到运行结束的全部时间 ） • 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)（响应时间 – 从进程提出请求到 首次被响应[而不是输出结果]的时间段[在分时系统环境下] ）

  22. Optimization Criteria • Max CPU utilization （最大的CPU利用率） • Max throughput （最大的吞吐量） • Min turnaround time （最短的周转时间） • Min waiting time （最短的等待时间） • Min response time （最短的响应时间）

  23. First-Come, First-Served (FCFS) Scheduling P1 P2 P3 0 24 27 30 • Example: ProcessBurst Time P1 24 P2 3 P3 3 • Suppose that the processes arrive in the order（假定进程到达顺序如下）: P1 , P2 , P3 The Gantt Chart for the schedule is（该调度的Gantt图为）: • Waiting time（等待时间）for P1 = 0; P2 = 24; P3 = 27 • Average waiting time（平均等待时间）: (0 + 24 + 27)/3 = 17

  24. FCFS Scheduling (Cont.) Suppose that the processes arrive in the order （假定进程到达顺序如下）P2 , P3 , P1 . • The Gantt chart for the schedule is （该调度的Gantt图为） : • Waiting time （等待时间）for P1 = 6;P2 = 0; P3 = 3 • Average waiting time （平均等待时间） : (6 + 0 + 3)/3 = 3 • Much better than previous case（比前例好得多）. • Convoy effect short process behind long process （此种结果产生是由于长进程先于短进程到达） P2 P3 P1 0 3 6 30

  25. Shortest-Job-First (SJF) Scheduling • Associate with each process the length of its next CPU burst. Use these lengths to schedule the process with the shortest time.（关联到每个进程下次运行的CPU脉冲长度，调度最短的进程） • Two schemes: • nonpreemptive – once CPU given to the process it cannot be preempted until completes its CPU burst（非抢占式调度 – 一旦进程拥有CPU，它的使用权限只能在该CPU 脉冲结束后让出). • Preemptive – if a new process arrives with CPU burst length less than remaining time of current 法executing process, preempt. This scheme is know as the Shortest-Remaining-Time-First (SRTF).（抢占式调度 – 发生在有比当前进程剩余时间片更短的进程到达时，也称为最短剩余时间优先调度） • SJF is optimal – gives minimum average waiting time for a given set of processes.（SJF是最优的 – 对一组指定的进程而言，它给出了最短的平均等待时间）

  26. Example of Non-Preemptive SJF Process Arrival TimeBurst Time P1 0.0 7 P2 2.0 4 P3 4.0 1 P4 5.0 4 • SJF (non-preemptive) • Average waiting time = (0 + 6 + 3 + 7)/4 - 4 P1 P3 P2 P4 0 3 7 8 12 16

  27. Example of Preemptive SJF Process Arrival TimeBurst Time P1 0.0 7 P2 2.0 4 P3 4.0 1 P4 5.0 4 • SJF (preemptive) • Average waiting time = (9 + 1 + 0 +2)/4 - 3 P1 P2 P3 P2 P4 P1 11 16 0 2 4 5 7

  28. Determining Length of Next CPU Burst • Can only estimate the length（其长度只能估计）. • Can be done by using the length of previous CPU bursts, using exponential averaging（可以通过先前的CPU脉冲长度及计算指 数均值进行）.

  29. Examples of Exponential Averaging •  =0 • n+1 = n • Recent history does not count. •  =1 • n+1 = tn • Only the actual last CPU burst counts. • If we expand the formula, we get: n+1 =  tn+(1 - )  tn -1 + … +(1 -  )j  tn -1 + … +(1 -  )n=1 tn 0 • Since both  and (1 - ) are less than or equal to 1, each successive term has less weight than its predecessor.

  30. Prediction of the Length of the Next CPU Burst

  31. Priority Scheduling • A priority number (integer) is associated with each process（每个进程都有自己的优先数[整数]） • The CPU is allocated to the process with the highest priority (smallest integer  highest priority)（CPU分配给最高优先级的进程[假定最小的整数  最高的优先级]）. • Preemptive（抢占式） • Nonpreemptive （非抢占式） • SJF is a priority scheduling where priority is the predicted next CPU burst time（SJF是以下一次CPU脉冲长度为优先数的优先级调度）. • Problem  Starvation – low priority processes may never execute （问题  饥饿 – 低优先级的可能永远得不到运行）. • Solution  Aging – as time progresses increase the priority of the process （解决方法  老化 – 视进程等待时间的延长提高其优先数）.

  32. Round Robin (RR) • Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this time has elapsed, the process is preempted and added to the end of the ready queue （每个进程将得到小单位的CPU时间[时间片]，通常为10-100毫 秒。时间片用完后，该进程将被抢占并插入就绪队列末尾）. • If there are n processes in the ready queue and the time quantum is q, then each process gets 1/n of the CPU time in chunks of at most q time units at once. No process waits more than (n-1)q time units（假定就绪队列中有n个进程、时间量为q, 则每个进程每次得到1/n的、不超过q单位的成块CPU时间，没有任何一个进程的等待时间会超过(n-1) q单位）. • Performance（特性） • q large  FIFO • q small  q must be large with respect to context switch, otherwise overhead is too high（q相对于切换上下文的时间而言不许足够长，否则将导致系统开销过大）.

  33. Example: RR with Time Quantum = 20 P1 P2 P3 P4 P1 P3 P4 P1 P3 P3 ProcessBurst Time P1 53 P2 17 P3 68 P4 24 • The Gantt chart is: • Typically, higher average turnaround than SJF, but better response（典型的说，RR的平均周转时间比SJF长，但响应时间要短一些）. 0 20 37 57 77 97 117 121 134 154 162

  34. How a Smaller Time Quantum Increases Context Switches

  35. Turnaround Time Varies With The Time Quantum

  36. Multilevel Queue • Ready queue is partitioned into separate queues（就绪队列分为）:foreground (interactive)（前台）[交互式]background (batch) （后台） [批处理] • Each queue has its own scheduling algorithm （每个队列有自己的调度算法）foreground – RRbackground – FCFS • Scheduling must be done between the queues（调度须在队列间进行）. • Fixed priority scheduling; i.e., serve all from foreground then from background. Possibility of starvation（固定优先级调度，即前台运行完后再运行后台。有可能产生饥饿）. • Time slice – each queue gets a certain amount of CPU time which it can schedule amongst its processes; e.g.,80% to foreground in RR 20% to background in FCFS （给定时间片调度，即每个队列得到一定的CPU时间，进程在给定时间内执行；如，80%的时间执行前台的RR调度，20%的时间执行后台的FCFS调度）

  37. Multilevel Queue Scheduling

  38. Multilevel Feedback Queue • A process can move between the various queues; aging can be implemented this way（进程能在不同的队列间移动；可实现老化）. • Multilevel-feedback-queue scheduler defined by the following parameters（多级反馈队列调度程序由以下参数定义）: • number of queues（队列数） • scheduling algorithms for each queue（每一队列的调度算法） • method used to determine when to upgrade a process（决定进程升级的方法） • method used to determine when to demote a process（决定进程降级的方法） • method used to determine which queue a process will enter when that process needs service（决定需要服务的进程将进入哪个队列的方法）

  39. Multilevel Feedback Queues

  40. Example of Multilevel Feedback Queue • Three queues: • Q0 – time quantum 8 milliseconds • Q1 – time quantum 16 milliseconds • Q2 – FCFS • Scheduling • A new job enters queue Q0which is servedFCFS. When it gains CPU, job receives 8 milliseconds. If it does not finish in 8 milliseconds, job is moved to queue Q1（新的作业进入FCFS的Q0队列，它得到CPU时能使用8毫秒，如果它不能在8毫秒内完成，将移动到队列Q1 ） . • At Q1 job is again served FCFS and receives 16 additional milliseconds. If it still does not complete, it is preempted and moved to queue Q2（作业在Q1仍将作为FCFS调度，能使用附加的16毫秒，如果它还不能完成，将被抢占，移至队列Q2 ）.

  41. Multiple-Processor Scheduling • CPU scheduling more complex when multiple CPUs are available（多个CPU可用时，CPU调度将更为复杂）. • Homogeneous processors within a multiprocessor （多处理器内的同类处理器）. • Load sharing（负载共享） • Symmetric Multiprocessing (SMP) – each processor makes its own scheduling decisions（对称多处理器 – 每个处理器决定自己的调度方案）. • Asymmetric multiprocessing – only one processor accesses the system data structures, alleviating the need for data sharing. （非对称多处理器 – 仅一个处理器能处理系统数据结构，这就减轻了对数据的共享需求）

  42. Real-Time Scheduling • Hard real-time systems – required to complete a critical task within a guaranteed amount of time. （硬件实现的实时系统 – 用于实现要求在给定的时间内执行完临界进程的场合） 比如航天中的宇宙飞船的控制等就是现实中这样的系统. • Soft real-time computing – requires that critical processes receive priority over less fortunate ones. （软件实现的实时计算 – 当要求临界进程得到比其他进程更高的优先级时）

  43. Linux内核在实时性方面的不足 • 1）Linux分为用户态和内核态两种模式，进程运行在用户态时，实时进程具有高的优先级，能进行进程抢占，故可以较好的完成任务；运行在内核态时，如系统调用，实时进程不能抢占该进程。因此，从实质上来说，Linux内核是非抢占式的。

  44. 内核kernel 将系统的一些关键性程序分离出来构成操作系统内核 .内核必须完成下面的一些任务： • 管理对文件系统的读写，把对文件系统的操作映射成对磁盘或其他块设备的操作 • 管理程序的运行，为程序分配资源，并且处理程序之间的通讯 • 管理存储器，为程序分配内存，并且管理虚拟内存 • 管理输入输出，将设备映射成设备文件 管理网络

  45. LKMs就是可卸载的内核模块(Loadable Kernel Modules)。这些模块本来是Linux系统用于扩展他的功能的。

  46. 2）在定时器方面，有下列几方面缺陷：第一，Linux的周期模式定时器频率仅为100Hz，远不能满足多种实时应用的要求。第二，软定时由时钟定时器完成，当软定时器较多时，势必引起共享时钟定时器的冲突。第三，Linux中断句柄不可调度，但在实时系统中，期望能在一个可调度整体内处理这些中断句柄，从而能更有效的区分不同实时任务的紧迫度，分配不同的优先级。因此，单纯缩短时间片在对实时性能严格要求的场合是不受欢迎的。

  47. （3）Linux进程采用多级轮转调度算法，该调度算法，仅能获得秒级响应时间，一个实时进程在一个时间片内未完成，其优先级将降低，从而可能造成到截止时间无法完成。（3）Linux进程采用多级轮转调度算法，该调度算法，仅能获得秒级响应时间，一个实时进程在一个时间片内未完成，其优先级将降低，从而可能造成到截止时间无法完成。

  48. 4）Linux虽然给实时进程提供了较高的优先级，但是，并没有加入时间限制。例如完成的最后期限、应在多长时间内完成、执行周期等等。同时，其它大量的非实时进程也可能对实时进程造成阻塞，无法确保实时进程的响应时间。另外，当有多个实时进程互斥请求共享资源时，由于其使用的同步原语不支持优先级继承协议（PIP），易产生优先级倒置。

  49. 当前Linux在实时内核方面的发展 • 1)兼容内核方法。即含有一个兼容Linux内核，符合POSIX的API层的实时内核 • 2)双内核方法。双内核系统在硬件平台上增加一个实时内核，建立双内核，如现在流行的RT-Linux • 3)内核修改方法。通过修改Linux内核源码来实现。如RED-Linux就采用该方法。在内核代码中增加抢占点，从而减少内核抢占延迟。

More Related