精华内容
下载资源
问答
  • 初学Linux中进程调度与进程切换过程

    千次阅读 2015-04-26 10:14:03
    孙业毅 原创作品 转载请注明出处 《Linux内核分析》MOOC课程:http://mooc.study.163.com/course/USTC-1000029000 第八讲 进程切换和系统的一般执行过程  @2015.04 一、理论知识 正在更新……

    孙业毅 原创作品 转载请注明出处

    Linux内核分析》MOOC课程:http://mooc.study.163.com/course/USTC-1000029000

    第八讲 进程的切换和系统的一般执行过程 

    @2015.04


    一、理论知识

    Linux系统的一般执行过程

    最一般的情况:正在运行的用户态进程X切换到运行用户态进程Y的过程

    1. 正在运行的用户态进程X

    2. 发生中断——save cs:eip/esp/eflags(current) to kernel stack, then load cs:eip(entry of a specific ISR) and ss:esp(point to kernel stack).

    3. SAVE_ALL //保存现场,这里是已经进入内核中断处里过程

    4. 中断处理过程中或中断返回前调用了schedule(),其中的switch_to做了关键的进程上下文切换

    5. 标号1之后开始运行用户态进程Y(这里Y曾经通过以上步骤被切换出去过因此可以从标号1继续执行)

    6. restore_all //恢复现场

    7. iret - pop cs:eip/ss:esp/eflags from kernel stack

    8. 继续运行用户态进程Y

    几种特殊情况

    • 通过中断处理过程中的调度时机,用户态进程与内核线程之间互相切换和内核线程之间互相切换,与最一般的情况非常类似,只是内核线程运行过程中发生中断没有进程用户态和内核态的转换;
    • 内核线程主动调用schedule(),只有进程上下文的切换,没有发生中断上下文的切换,与最一般的情况略简略;
    • 创建子进程的系统调用在子进程中的执行起点及返回用户态,如fork
    • 加载一个新的可执行程序后返回到用户态的情况,如execve


    进程的调度时机与进程的切换

    操作系统原理中介绍了大量进程调度算法,这些算法从实现的角度看仅仅是从运行队列中选择一个新进程,选择的过程中运用了不同的策略而已。

    对于理解操作系统的工作机制,反而是进程的调度时机与进程的切换机制更为关键。

    进程调度的时机

    • 中断处理过程(包括时钟中断、I/O中断、系统调用和异常)中,直接调用schedule(),或者返回用户态时根据need_resched标记调用schedule()比如sleep,就可能直接调用了schedule
    • 内核线程可以直接调用schedule()进行进程切换,也可以在中断处理过程中进行调度,也就是说内核线程作为一类的特殊的进程可以主动调度,也可以被动调度;
    • 用户态进程无法实现主动调度,仅能通过陷入内核态后的某个时机点进行调度,即在中断处理过程中进行调度。用户态进程只能被动调度。

    进程的切换

    • 为了控制进程的执行,内核必须有能力挂起正在CPU上执行的进程,并恢复以前挂起的某个进程的执行,这叫做进程切换、任务切换、上下文切换;即进程上下文切换!
    • 挂起正在CPU上执行的进程,与中断时保存现场是不同的,中断前后是在同一个进程上下文中,只是由用户态转向内核态执行;
    • 进程上下文包含了进程执行需要的所有信息
      • 用户地址空间:包括程序代码,数据,用户堆栈等
      • 控制信息:进程描述符,内核堆栈等
      • 硬件上下文(注意中断也要保存硬件上下文只是保存的方法不同)
    • schedule()函数选择一个新的进程来运行,并调用context_switch进行上下文的切换,这个宏调用switch_to来进行关键上下文切换

    31#define switch_to(prev, next, last)                     \

    32do {                                  \

    33  /*                               \

    34   * Context-switching clobbers all registers, so we clobber   \

    35   * them explicitly, via unused output variables.      \

    36   * (EAX and EBP is not listed because EBP is saved/restored   \

    37   * explicitly for wchan access and EAX is the return value of    \

    38   * __switch_to())                      \

    39   */                                 \

    40  unsigned long ebx, ecx, edx, esi, edi;                 \

    41                                   \

    42  asm volatile("pushfl\n\t"      /* save    flags */    \

    43           "pushl %%ebp\n\t"        /* save    EBP   */  \

    44           "movl %%esp,%[prev_sp]\n\t"  /* save    ESP   */  \

    45           "movl %[next_sp],%%esp\n\t"  /* restore ESP   */  \

    46           "movl $1f,%[prev_ip]\n\t"    /* save    EIP   */  \

    47           "pushl %[next_ip]\n\t"   /* restore EIP   */     \

    48           __switch_canary                    \

    49           "jmp __switch_to\n"  /* regparm call  */  \

    50           "1:\t" /*下一个进程开始执行的地方!*/                        \

    51           "popl %%ebp\n\t"     /* restore EBP   */     \

    52           "popfl\n"         /* restore flags */   \

    53                                   \

    54           /* output parameters */                 \

    55           : [prev_sp] "=m" (prev->thread.sp),      \

    56             [prev_ip] "=m" (prev->thread.ip),         \

    57             "=a" (last),                  \

    58                                   \

    59             /* clobbered output registers: */      \

    60             "=b" (ebx), "=c" (ecx), "=d" (edx),       \

    61             "=S" (esi), "=D" (edi)              \

    62                                        \

    63             __switch_canary_oparam                 \

    64                                   \

    65             /* input parameters: */                 \

    66           : [next_sp]  "m" (next->thread.sp),         \

    67             [next_ip]  "m" (next->thread.ip),        \

    68                                        \

    69             /* regparm parameters for __switch_to(): */   \

    70             [prev]     "a" (prev),               \

    71             [next]     "d" (next)                \

    72                                   \

    73             __switch_canary_iparam                 \

    74                                   \

    75           : /* reloaded segment registers */            \

    76          "memory");                   \

    77} while (0)


    二、实验

    实验内容

    1.理解Linux系统中进程调度的时机,可以在内核代码中搜索schedule()函数,看都是哪里调用了schedule(),判断我们课程内容中的总结是否准确;
    2.使用gdb跟踪分析一个schedule()函数 ,验证您对Linux系统进程调度与进程切换过程的理解;推荐在实验楼Linux虚拟机环境下完成实验。
    3.特别关注并仔细分析switch_to中的汇编代码,理解进程上下文的切换机制,以及与中断上下文切换的关系;

    实验步骤

    1. 打开实验楼虚拟机 https://www.shiyanlou.com/courses/running/890

    2. 在shell中依次运行以下命令,获取本次实验的代码,并编译运行

    cd LinuxKernel

    rm menu -rf

    git clone https://github.com/mengning/menu.git

    cd menu

    mv test_exec.c test.c

    make rootfs 

    效果如下:



    3. 关闭QEMU窗口,在shell窗口中,cd LinuxKernel回退到LinuxKernel目录,使用下面的命令启动内核并在CPU运行代码前停下以便调试:

    qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S 

    接下来,我们就可以水平分割一个新的shell窗口出来,依次使用下面的命令启动gdb调试

    gdb

    (gdb) file linux-3.18.6/vmlinux

    (gdb) target remote:1234

    并在系统调用

    关闭QEMU窗口,在shell窗口中,cd LinuxKernel回退到LinuxKernel目录,使用下面的命令启动内核并在CPU运行代码前停下以便调试:

    qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S 

    接下来,我们就可以水平分割一个新的shell窗口出来,依次使用下面的命令启动gdb调试

    gdb

    (gdb) file linux-3.18.6/vmlinux

    (gdb) target remote:1234

    并在内核函数schedule的入口处设置断点,接下来输入c继续执行,则系统即可停在该函数处,接下来我们就可以使用命令n或者s逐步跟踪,可以详细浏览pick_next_task,switch_to等函数的执行过程,有图为证:





    展开全文
  • 进程切换过程详解

    千次阅读 2015-04-03 21:24:00
    进程切换过程详解 /* 注:在学习内核的时候有一个困难,那就是任何一个模块都不是孤立的,比如进程的调度就设计到中断处理、信号处理还有进程上下文的切换等等。作为一个初学者,想一下子把操作系统...

    /*

    注:在学习内核的时候有一个困难,那就是任何一个模块都不是孤立的,比如进程的调度就设计到中断处理、信号处理还有进程上下文的切换等等。作为一个初学者,想一下子把操作系统的整个运行过程都清晰地展现在脑海是不现实的。尽管如此,每个模块还是有它所关注的焦点,我们所采取的策略是把整个操作系统分为几个大模块,比如:进程的管理、内存管理、文件系统等等。然后把这些大模块进一步分解成一个个小模块,比如进程的管理可以细分为进程的创建、进程的切换、系统调用的处理、信号的处理等等。在分析每一个模块时,先把其他的模块抽象化,千万不要陷入其他模块的细节当中,,也可以说这是一种各个击破的方法,当你把每个小模块的功能搞清楚后,到最后整个操作系统的运行过程就很清晰了!

    */

     

     

     

    在上一篇博客中,我们提到当一个任务从系统调用处理函数返回之前会检查是否需要进行进程切换。那么什么时候会发生进程的切换呢(任务调度)?当系统发生硬件中断、系统调用或者时钟中断时,就有可能发生进程的切换。 下面我们以时钟中断为例来看看进程的切换是如何进行的。

    在此之前,我们先要做一个说明,由于我们并没有开始介绍进程的详细知识,对进程的详细介绍将放在进程的创建这一篇博客中(还没开始写O(∩_∩)O~),因此在这里我们先对进程做一个粗略的抽象:一个任务(就是进程)含有代码段、数据段、堆栈段,还有一个任务状态段TSS。这个任务状态段TSS记录当前任务的所有状态信息,包括寄存器、系统参数等等。TSS段的描述符放在TR寄存器中(也就是说访问TR就能访问当前任务的TSS段了)。

    假设此刻CPU正在执行进程1,我们知道:系统有一个时钟频率,每隔一段时间就会发生一次时钟中断,这个时间段我们称为一个滴答。假设经过了一个滴答,系统发生时钟中断,此时时钟中断处理程序就会被自动调用(timer_interrupt),timer_interrupt定义在kernel/System_call.s中,如下图所示:

    同我们上一篇讲的_system_call一样,它首先会执行一些保护现场的工作,接着在第189行代码中把_jiffies的值加1(_jiffies表示自系统启动以来经过的滴答数),接下来第192-194的代码将执行此次时钟中断的特权级CPL压入堆栈,用来作为后面do_timer的参数,接下来开始执行do_timer,do_timer函数定义在Kernel/Sched.c中,这个函数的主要作用是将当前进程的用户态执行时间或内核态执行时间加1,然后将当前进程的剩余时间片减1.

    如果当前进程的时间片还有剩余,那么直接return返回继续执行,接下来判断当前任务的CPL是否是0,如果是0,说明当前任务是在内核态被中断的,而Linux0.11中内核态是不能被抢占的,所以直接返回执行,如果不是0,则执行进程调度程序schedule()。接下来我们来分析schedule()这个函数,schedule函数同样定义在Sched.c中,它里面包含下面两段代码:

    这段代码的作用是:遍历任务数组,检查它们的报警定时值,如果该值小于jiffies,说明该任务的alarm时间已经过了,那么就在它的信号位图中置SIGALRM信号,表示向任务发送SIGALARM信号,然后将alarm清零,接下来检查是不是还有别的未被阻塞的信号,如果有并且当前的进程状态是可以被打断的,那么把这个任务置为就绪态。

    第124-142行的代码重新遍历整个任务数组,找出任务状态处于TASK_RUNING并且时间片最长的那个任务。并调用swith_to()函数切换到那个任务。swith_to函数定义在include/Linux/Sched.h中。

    switch_to是一段汇编代码,下面来解释一下这段代码的含义:首先检查要切换的任务是不是当前任务,如果是则直接退出。接下来把任务n(要切换去的任务)的TSS段放到_tmp.b中,然后把任务n放入_current中,把当前任务放入%ecx中切换出来,然后执行一个长跳转到*&_tmp的位置(这是新任务的TSS地址处),此时CPU会把所有寄存器的内容保存到当前任务TR执行的TSS段中,然后把新任务的TSS段中的寄存器信息恢复到CPU的各个寄存器中,这样系统就正式开始执行新的任务了。第178-180的代码是判断原任务是否使用过协处理器,如果没有则直接结束。

     

    posted on 2015-04-03 21:24 愚&道 阅读( ...) 评论( ...) 编辑 收藏

    转载于:https://www.cnblogs.com/yudao/p/4388575.html

    展开全文
  • 进程切换过程之一:上下文切换

    千次阅读 2020-01-26 22:32:25
    进程切换过程之一:上下文切换 注:下面给出的源码均出自https://github.com/mit-pdos/xv6-public 在进程进行切换时,需要进行上下文切换,也就是寄存器的值的保存。 对于上下文的切换,有两种情况:硬件自动...

    进程切换过程之一:上下文切换

    注:下面给出的源码均出自https://github.com/mit-pdos/xv6-public

     

     

    在进程进行切换时,需要进行上下文切换,也就是寄存器的值的保存。

    对于上下文的切换,有两种情况:硬件自动(隐式)完成、操作系统显式保存。

    下面分析两段xv6的源代码,都是上下文切换部分,版本有所不同:

    注:每个进程都有一个用来维护过程调用的栈,有的书把这个栈叫做内核栈;在编译原理中,这个栈的术语叫活动记录,在下文中,提到的栈都是说的这个保存活动记录的栈。每个进程都有自己的活动记录(当然,如果是多CPU的情况下,就会引入线程的概念,则每个线程有一个活动记录)

    较老的版本

    #   void swtch(struct context *old, struct context *new);
    #  
    # Save current register context in old
    # and then load register context from new.
    
    .globl swtch
    swtch:
      # Save old registers
      movl 4(%esp), %eax
      popl 0(%eax)  # %eip
      movl %esp, 4(%eax)
      movl %ebx, 8(%eax)
      movl %ecx, 12(%eax)
      movl %edx, 16(%eax)
      movl %esi, 20(%eax)
      movl %edi, 24(%eax)
      movl %ebp, 28(%eax)
    
      # Load new registers
      movl 4(%esp), %eax  # not 8(%esp) - popped return address above
    
      movl 28(%eax), %ebp
      movl 24(%eax), %edi
      movl 20(%eax), %esi
      movl 16(%eax), %edx
      movl 12(%eax), %ecx
      movl 8(%eax), %ebx
      movl 4(%eax), %esp
      pushl 0(%eax)  # %eip   
    

    这个版本的上下文结构struct context的内容如下:

    struct context {
        int eip;    //程序计数器
        int esp;    //栈指针
        int ebp;
        int ecx;
        int edx;
        int esi;
        int edi;
        int ebp;
    };
    

    分析一下上下文切换的源代码:

    源代码的上半段是将“老”的进程的上下文保存,下半段将“新”的进程(要切换到的)的上下文恢复。

    执行swtch的指令时,栈的状态:

                                                             

    movl 4(%esp), %eax
    

    将old(参数)的值放入寄存器%eax。

    popl 0(%eax)
    

    然后将栈顶的值保存到0(%eax)的位置。也就是将返回地址(%eip)的值保存到old指向的context空间中

    之后,就是将其他的寄存器放入old指向的context空间中。

    通过上面的源码,可以得到context在内存中分配空间的方式:

                                          

    下面的代码就是从new指向的context空间中,将各个寄存器的值恢复,就不详细说明了。

    较新的版本:就像一开始提到的,硬件会自动保存一部分

    硬件会保存一部分的寄存器,还有剩余的需要进行手动保存。

    # Context switch
    #
    #   void swtch(struct context **old, struct context *new);
    # 
    # Save the current registers on the stack, creating
    # a struct context, and save its address in *old.
    # Switch stacks to new and pop previously-saved registers.
    
    .globl swtch
    swtch:
      movl 4(%esp), %eax
      movl 8(%esp), %edx
    
      # Save old callee-saved registers
      pushl %ebp
      pushl %ebx
      pushl %esi
      pushl %edi
    
      # Switch stacks
      movl %esp, (%eax)
      movl %edx, %esp
    
      # Load new callee-saved registers
      popl %edi
      popl %esi
      popl %ebx
      popl %ebp
      ret
    

    开始的两条代码,将old与new放入%eax和%edx,方便后面通过指针的方式访问内存。

    接下来的四条压栈指令,直接将要手动保存的寄存器压入栈中。

    执行到这里,“老”进程和“新”进程对应的栈的示意图如下:

                                                  

    与之前旧版本的有些许不同,新版本的直接将上下文保存在进程自己的栈中;旧版本的保存在了其他的地方(暂时就理解到这个程度,由于没有分析过所有的源码,这里的分析可能比较片面,但这是我整个的分析过程,如有有大佬看出哪里不会,请指正)

    展开全文
  • 进程切换过程

    万次阅读 2019-10-17 11:03:20
    进程切换,实质上就是被中断运行进程与待运行进程的上下文切换。从主观上来理解。只分为两步: 1.切换新的页表,然后使用新的虚拟地址空间 2.切换内核栈,加入新的内容(PCB控制块,资源相关),实现上下文切换 现在...

    切换方式

    进程的切换,实质上就是被中断运行进程与待运行进程的上下文切换。从主观上来理解。只分为两步:
    1.切换新的页表,然后使用新的虚拟地址空间
    2.切换内核栈,加入新的内容(PCB控制块,资源相关),硬件上下文切换

    现在从这两句话理解,来看看这些东西到底是什么。

    1,虚拟地址空间

    虚拟地址空间,顾名思义:就是虚拟的,不是真的地址空间
    在早期的计算机中,我们的计算机内存都非常的小。如果计算机内存是100M.已经运行了两个40M的任务。如果还想运行一个40M的。那么空间肯定就不够了。

    所以后来 它在磁盘上划分出一块空间由操作系统管理,当物理内存耗尽是充当物理内存来使用。它将多个物理内存碎片和部分磁盘空间重定义为连续的地址空间,以此让程序认为自己拥有连续可用的内存
    但是具体要讲清楚这个,我们还要看页表

    2,页表

    刚刚讲到了虚拟地址空间,说了他只是虚拟的一段空间,但是。程序可不管你那么多。人家只要在物理内存上运行。你给人家画空饼可没意思。
    所以出现了页表。把虚拟地址空间对应的部分,映射到物理地址上
    现在计算机一般是采用分页管理居多,这里分段管理我个人也理解了就不多叙述。
    我们来看下分页管理:
    在这里插入图片描述
    很多初学者在这里会有一个疑问,既然给程序造成连续的空间假象,那要是内存中确实没内存可用了,会怎么办呢?那么对于*新的页数,他就会发生缺页中断,然后会覆盖起其他的页
    缺页中断大概有三种算法:
    1.(OPT)最晚不使用的算法:表示新的页如果进来没内存框可放了,会替换之后 几乎或者根本不会用到的页。但这种算法只是一种理想算法,因为没人能预估之后的事,包括计算机
    2.(FIFO)先进先出算法:表示没来一个新的页,他都会替换最早进来的那个页。这种办法有个缺点:如果最早进来的那个页是经常被访问的,那么一定情况下效率会比较低。所以FIFO算法在按 线性顺序访问地址空间时使用
    3.(LRU)最近最久未使用:这种办法,会找出当前内存中,最近一段时间最久没被使用的页。然后替换他。这种办法是前两个算法的折中选择,基本现在都用这种。还有一种是LFU 最常不使用算法,这种是找系统内使用频率最少的页(LRU是最近一段时间),然后替换他。但是,这种算法实现要长期的为每个页维护一个计数代价较大不常使用。

    具体三个的算法的图解:https://blog.csdn.net/qq_34777600/article/details/79508613

    第二步的切换内核栈,就是使用新的栈来存放进程运行时资源了。然后新进程有新的PCB控制块。第二步也是线程切换的步骤,因为线程共享进程的虚拟地址空间,所以切换的时候没有第一步的过程

    进程一共有五个状态:
    像刚刚的切换:
    1.会把原来的进程保存状态,然后进入阻塞状态。这种情况一般是IO请求或者内存申请失败了。
    2.可能是原来的进程正常终止了,或者CPU的时间片没了,终止是进入终止态,CPU时间片没了是进入就绪态,加入就绪队列等待下一次获得CPU
    在这里插入图片描述

    展开全文
  • 进程切换一定发生在中断/异常/系统调用处理过程中,常见的有以下情况: 时间片中断、IO中断后 更改优先级进程;(导致被中断进程进入就绪态); 阻塞式系统调用、虚拟地址异常;(导致被中断进程进入等待态) 终止...
  • 进程切换过程分析

    千次阅读 2013-06-27 14:21:59
    进程切换 为了控制进程的执行,内核必须有能力挂起正在CPU上运行的进程,并恢复以前挂起的某个进程的执行。这种行为被称为进程切换,任务切换或上下文切换。下面几节描述在Linux中进行进程切换的主要内容。 ...
  • Linux中进程调度与切换过程

    千次阅读 2017-04-10 09:54:29
     今天我们要学习的是Linux中进程调度与切换过程。有关进程的知识在前面的博客中已经提到了,有不懂的地方请参考我前面的博客,今天我直接从进程调度和切换开始讲。  Linux一个较大的优势就是进程调度,因为
  • 操作系统之进程切换

    万次阅读 多人点赞 2017-06-22 22:36:50
    并不是所有的中断/异常都会引发进程切换
  • 理解进程调度时机跟踪分析进程调度与进程切换过程
  • 进程用户态和内核态及其切换过程

    千次阅读 2020-05-24 22:50:10
    1.进程的堆栈     内核在创建进程的时候,会为...2.进程用户栈和内核栈的切换     当进程因为中断或者系统调用而陷入内核态之行时,进程所使用的堆栈也要从用户栈转到内核栈
  • 内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。 2、另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说,一旦去切换上下文,处理器中所有已经缓存的内存地址一瞬间都作废了。...
  • linux 基于时间片轮转的进程切换

    千次阅读 2019-03-11 22:12:51
    linux 基于时间片轮转的进程切换 学号:413 原创作品 转载注明出处 ...内容:主要讲述Linux操作系统中时间片轮转调度方法中,进程切换的实现方法和切换过程的堆栈的变化 一、环境 该博客内容来自与课堂作业,...
  • 本篇文章通过用gdb对进程调度时机跟踪来分析在Linux系统中进程调度与进程切换过程
  • 1)当前运行进程主动放弃处理机:进程正常终止,运行过程发生堵塞,进程主动请求堵塞(等待I/O) 2)当前运行进程被动放弃处理机:分配给进程的时间片用完了 ,有更紧急的事需要处理(如I/O中断),有更高优先级的...
  • ARM-LINUX的进程切换

    千次阅读 2016-09-08 17:56:18
    本文主要记录S3C6410/ARM1176JZF-S架构下Linux(kernel 2.6.35)内核如何进行进程切换进程切换是操作系统进程调度的基础,首先要能够实现切换,接下来才谈得上“多进程”、“多线程”以及调度算法等更高级的话题。...
  • (2)进程切换过程中的上下文信息保存与恢复,必须在内核态吗?(3)信号量和管程机制是否可以相互实现,有没有确定的答案和证明?首先理解以下概念:一、进程控制块进程控制块:PCB是操作系统管理控制进程运行所有...
  • 本文主要是以context_switch为起点,分析了整个进程切换过程中的基本操作和基本的代码框架,很多细节,例如tlb的操作,cache的操作,锁的操作等等会在其他专门的文档中描述。进程切换包括体系结构相关的代码和系统...
  • 进程切换与模式切换

    2020-12-22 00:51:42
    2.4.3进程切换 中断 普通中断 timeout:进程时间片耗尽 I/O中断:I/O就绪,OS决定该唤醒哪个进程 内存失效(缺页):阻塞当前进程 陷阱(自陷) 进程错误或异常 进程切换原因 普通中断:对外部事件的反应 陷阱:...
  • 上下文切换(Context Switch)有时也称做进程切换或任务切换,是指CPU 从一个进程或线程切换到另一个进程或线程。 上下文切换包括保存当前任务的运行环境,恢复将要运行任务的运行环境。当进程被切换时,操作系统...
  • 进程调度与进程切换过程分析

    千次阅读 2016-04-17 17:06:08
    一实验过程 1.打开终端,与前几次实验相同,输入命令cd Linux/menu进入到menu目录下,然后输入命令qemu -kernel ../linux-3.18.6/arch/x86/boot/bzImage -initrd ../rootfs.img -s -S启动MENUOS ,然后打开gdb,...
  • 为什么用多线程或多进程? 程序的大部分耗时在等待IO上,瓶颈不在CPU上时,可以提高CPU利用率 需要集中快速处理大量数据,并且不受先后顺序影响 评论区还可补充ing 线程和线程 线程的实现可以分为两类: 用户级...
  • 进程切换与线程切换

    2020-09-07 21:44:56
    进程切换分两步: 切换页目录以使用新的地址空间 切换内核栈和硬件上下文 ...内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。 另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制
  • 内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。 2、另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说,一旦去切换上下文,处理器中所有已经缓存的内存地址一瞬间都作废了...
  • 进程主动放弃继续执行,例如yield系统调用和一些阻塞型的系统调用会引发进程切换,某些异常的发生也会导致进程切换的发生。 由内核主动暂停进程的执行,转而执行别的进程或中断。例如中断的发生和更高优先级进程的...
  • 进程切换与中断

    千次阅读 2020-03-21 10:15:28
    进程切换指从正在运行的进程中收回处理器,让待...进程切换一定发生在中断/异常/系统调用处理过程中,常见的有以下情况: 1、阻塞式系统调用、虚拟地址异常。 导致被中断进程进入等待态。 2、时间片中断、I/O中断...
  • 进程在运行时,使用系统调用
  • linux 操作系统如果是进程占据了 cpu 的运行空间,那么是由什么模块控制进程的状态,并且控制进程之间的切换
  • 进程上下文和处理器状态切换

    千次阅读 2017-04-03 12:48:31
    进程上下文VS中断上下文 1.内和空间和用户空间 内核空间和用户空间是现代操作系统的两种工作模式,内核模块运行在内核空间,而用户态应用程序运行在用户空间。它们代表不同的级别,而对系统资源具有不同的访问权限...
  • 进程切换和线程切换

    千次阅读 2019-08-11 09:52:12
    这种行为被称为进程切换(process switch)、任务切换(task switch)或上下文切换(content switch)。 原文 :https://www.cnblogs.com/kkshaq/p/4547725.html 进程切换分两步: 1.切换页目录以使用新的地址...
  • 实现进程切换

    千次阅读 2018-03-17 21:38:26
    1.直接执行的下一个问题是在进程之间实现切换 直接执行的下一个问题是在进程之间实现切换。在进程之间切换应该很简单,对吗?操作系统应该决定停止一个进程,启动另一个进程。有什么大不了的?但是它实际上有点棘手:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 281,301
精华内容 112,520
关键字:

进程切换的过程