arm中的五级流水线

最新推荐文章于 2023-08-10 12:29:08 发布
最新推荐文章于 2023-08-10 12:29:08 发布
阅读量1.1w 收藏 17
点赞数 4
分类专栏： 汇编语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34888036/article/details/81182926
版权

本文主要是通过分析五级流水及流水线互锁的原理，从而可以编写出更加高效的汇编代码。


1. ARM9五级流水线

ARM7采用的是典型的三级流水线结构，包括取指、译码和执行三个部分。其中执行单元完成了大量的工作，包括与操作数相关的寄存器和存储器读写操作、ALU操作及相关器件之间的数据传输。这三个阶段每个阶段一般会占用一个时钟周期，但是三条指令同时进行三级流水的三个阶段的话，还是可以达到每个周期一条指令的。但执行单元往往会占用多个时钟周期，从而成为系统性能的瓶颈。

ARM9采用了更高效的五级流水线设计，在取指（fetch）、译码(decode)、执行(ALU)之后增加了LS1和LS2阶段，LS1负责加载和存储指令中指定的数据，LS2负责提取、符号扩展通过字节或半字加载命令加载的数据。但是LS1和LS2仅对加载和存储命令有效，其它指令不需要执行这两个阶段。比如：ldr,str就是两个加载和存储指令， ARM微处理器支持加载/存储指令用于在寄存器和存储器之间传送数据，加载指令用于将存储器中的数据传送到寄存器，存储指令则完成相反的操作。

下面是ARM官方文档的定义：

  • Fetch: Fetch from memory the instruction at addresspc. The instruction is loaded intothe core and then processes down the core pipeline.

  • Decode: Decode the instruction that was fetched in the previous cycle. The processoralso reads the input operands from the register bank if they are not available via one ofthe forwarding paths.

  • ALU: Executes the instruction that was decoded in the previous cycle. Note this instruc-tion was originally fetched from addresspc−8 (ARM state) orpc−4 (Thumb state).Normally this involves calculating the answer for a data processing operation, or theaddress for a load, store, or branch operation. Some instructions may spend severalcycles in this stage. For example, multiply and register-controlled shift operations takeseveral ALU cycles. 

  • LS1: Load or store the data specified by a load or store instruction. If the instruction isnot a load or store, then this stage has no effect.

  • LS2: Extract and zero- or sign-extend the data loaded by a byte or halfword loadinstruction. If the instruction is not a load of an 8-bit byte or 16-bit halfword item,then this stage has no effect. 


ARM9五级流水中，读寄存器的操作转移到译码阶段，将三级流水中的执行阶段进一步细化，减少了每个时钟周期内必须完成的工作量，这样可以使流水线的各个阶段在功能上更加平衡，避免数据访问和取指的总线冲突，每条指令的平均周期数明显减少。

流水线的概念与原理

处理器按照一系列的步骤来执行每一条指令，典型的步骤如下：

1.从存储器读取指令（fetch）

2.译码以鉴别它是属于哪一条指令（decode）

3.从指令中提取指令的操作数（这些操作数往往位于寄存器中）（reg）

4.将操作数进行组合以得到结果或存储器地址（ALU）

5.如果需要，则访问存储器以存储数据（mem）

6.将结果写回到寄存器堆（res）

5级流水线ARM组织：取指令->译码->执行->缓冲/数据->回写

2. 流水线互锁问题

前面虽然说过在三级和五级流水中一般可以达到每个周期一条指令，但并不是所有指令都可以一个周期就可以完成的。不同的指令需要占用的时钟周期是不一样的，具体可以参考ARM的官方文档Arm System Developer’s Guide中的Appendix D：Instruction Cycle Timings，这里就不详细介绍了。文档在我的资源中也可以找到。
而且不同的指令顺序也会造成时钟周期的不同，比如一条指令的执行需要前一条指令执行的结果，如果这时结果还没出来，那就需要等待，这就是流水线互锁(pipeline interlock)。
举个最简单的例子： 

     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         LDR r1, [r2, #
         
         4] 
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         ADD r0, r0, r1
上面这段代码就需要占用三个时钟周期，因为LDR指令在ALU阶段会去计算r2+4的值，这时ADD指令还在译码阶段，而这一个时钟周期还完不成从[r2, #4]内存中取出数据并回写到r1寄存器中，到下一个时钟周期的时候ADD指令的ALU需要用到r1，但是它还没有准备好，这时候pipeline就会把ADD指令stall停止，等待LDR指令的LS1阶段完成，然后才会行进到ADD指令的ALU阶段。下图表示了上面例子中流水线互锁的情况：



再看下面的例子： 

     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         LDRB r1, [r2, #
         
         1] 
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         ADD r0, r0, r2 
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         EOR r0, r0, r1
上面的代码需要占用四个时钟周期，因为LDRB指令完成对r1的回写需要在LS2阶段完成后（它是byte字节加载指令），所以EOR指令需要等待一个时钟周期。流水线运行情况如下图：

再看下面例子：


     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 MOV r1, #
         
         1
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 B case1
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 AND r0, r0, r1 EOR r2, r2, r3 ...
        
        
    
       
       
  4. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         case1:
        
        
    
       
       
  5. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 SUB r0, r0, r1
上面代码需要占用五个时钟周期，一条B指令就要占用三个时钟周期，因为遇到跳转指令就会去清空pipeline后面的指令，到新的地址去重新取指。流水线运行情况如下图：


3. 避免流水线互锁以提高运行效率

Load指令在代码中出现的非常频繁，官方文档中给出的数据是大概三分之一的概率。所以对Load指令及其附近指令的优化可以防止流水线互锁的发生，从而提高运行效率。
看下面一个例子，C代码实现的是将输入字符串中的大写字母转为小写字母。以下实验均以ARM9TDMI为平台。 

     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         void str_tolower(char *out, char *in)
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         {
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         unsigned 
         
         int c;
        
        
    
       
       
  4. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         do {
        
        
    
       
       
  5. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             c = *(in++);
        
        
    
       
       
  6. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         if (c>=’A’ && c<=’Z’)
        
        
    
       
       
  7. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             {
        
        
    
       
       
  8. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               c = c + (’a’ -’A’);
        
        
    
       
       
  9. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             }
        
        
    
       
       
  10. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             *(out++) = (
         
         char)c;
        
        
    
       
       
  11. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           } 
         
         while (c);
        
        
    
       
       
  12. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         }
编译器生成下面汇编代码： 

     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         str_tolower
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         LDRB r2,[r1],#
         
         1        ; c = *(in++)
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         SUB r3,r2,#
         
         0x41       ; r3=c-‘A’
        
        
    
       
       
  4. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         CMP r3,#
         
         0x19           ; 
         
         if (c <=‘Z’-‘A’)
        
        
    
       
       
  5. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         ADDLS r2,r2,#
         
         0x20    ; c +=‘a’-‘A’
        
        
    
       
       
  6. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         STRB r2,[r0],#
         
         1         ; *(out++) = (
         
         char)c
        
        
    
       
       
  7. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         CMP r2,#
         
         0                 ; 
         
         if (c!=
         
         0)
        
        
    
       
       
  8. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         BNE str_tolower         ; 
         
         goto str_tolower
        
        
    
       
       
  9. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                         MOV pc,r14                ; 
         
         return
其中(c >= ‘A’ && c <= ‘Z’)条件判断编译成汇编以后变型成了0 <= c - ‘A’ <= ‘Z’ - ‘A’。
可以看到上面的汇编代码LDRB加载字符给c的时候，下一条SUB指令需要多等待2个时钟周期。有两种方法可以进行优化：预先加载(Preloading)和展开(Unrolling)。
3.1 Load Scheduling by Preloading
这种方法的基本思想是在上一个循环的结尾去加载数据，而不是在本循环的开头加载。下面是优化后的汇编代码： 

      
      
  1. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          out RN 
          
          0 ; pointer to output 
          
          string 
         
         
    
        
        
  2. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          in RN 
          
          1 ; pointer to input 
          
          string
         
         
    
        
        
  3. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          c       RN 
          
          2    ; character loaded
         
         
    
        
        
  4. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          t       RN 
          
          3    ; scratch 
          
          register
         
         
    
        
        
  5. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                  ; 
          
          void str_tolower_preload(char *out, char *in)
         
         
    
        
        
  6. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                  str_tolower_preload
         
         
    
        
        
  7. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                LDRB    c, [in], #1            ; c = *(in++)
         
         
    
        
        
  8. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          loop
         
         
    
        
        
  9. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                SUB     t, c, #’A’              ; t = c-’A’
         
         
    
        
        
  10. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                CMP     t, #’Z’-’A’             ; 
          
          if (t <= ’Z’-’A’)
         
         
    
        
        
  11. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                ADDLS   c, c, #’a’-’A’        ;   c += ’a’-’A’;
         
         
    
        
        
  12. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                STRB    c, [out], #
          
          1          ; *(out++) = (
          
          char)c;
         
         
    
        
        
  13. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                TEQ     c, #
          
          0                   ; test 
          
          if c==
          
          0
         
         
    
        
        
  14. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                LDRNEB  c, [in], #
          
          1         ; 
          
          if (c!=
          
          0) { c=*in++;
         
         
    
        
        
  15. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                BNE     loop             ;             
          
          goto loop; }
         
         
    
        
        
  16. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                MOV     pc, lr           ; 
          
          return
这个版本的汇编比C编译器编译出来的汇编多了一条指令，但是却省了2个时钟周期，将循环的时钟周期从每个字符11个降到了9个，效率是C编译版本的1.22倍。
另外其中的RN是伪指令，用来给寄存器起一个别名，比如c   RN  2;就是用c来表示r2寄存器。
3.2 Load Scheduling by Unrolling
这种方法的基本思想是对循环进行展开然后将代码进行交错处理。比如，我们可以每个循环去处理i，i+1，i+2三个数据，当i的处理指令还没有完成的时候，我们可以去开始i+1的处理，这样就不用等待i的处理结果了。
优化后的汇编代码如下： 

      
      
  1. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          out     RN 
          
          0   ; pointer to output 
          
          string
         
         
    
        
        
  2. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          in      RN 
          
          1   ; pointer to input 
          
          string
         
         
    
        
        
  3. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          ca0     RN 
          
          2   ; character 
          
          0
         
         
    
        
        
  4. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          t       RN 
          
          3   ; scratch 
          
          register
         
         
    
        
        
  5. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          ca1     RN 
          
          12   ; character 
          
          1
         
         
    
        
        
  6. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          ca2     RN 
          
          14   ; character 
          
          2
         
         
    
        
        
  7. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
     
         
         
    
        
        
  8. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            ; 
          
          void str_tolower_unrolled(char *out, char *in)
         
         
    
        
        
  9. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
              str_tolower_unrolled
         
         
    
        
        
  10. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           STMFD   sp!, {lr}        ; function entry
         
         
    
        
        
  11. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
          loop_next3
         
         
    
        
        
  12. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
                  LDRB    ca0, [in], #
          
          1        ; ca0 = *in++;
         
         
    
        
        
  13. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            LDRB    ca1, [in], #
          
          1      ; ca1 = *in++;
         
         
    
        
        
  14. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            LDRB    ca2, [in], #
          
          1      ; ca2 = *in++;
         
         
    
        
        
  15. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            SUB     t, ca0, #’A’        ; convert ca0 to lower 
          
          case
         
         
    
        
        
  16. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
             CMP     t, #’Z’-’A’
         
         
    
        
        
  17. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           ADDLS   ca0, ca0, #’a’-’A’
         
         
    
        
        
  18. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            SUB     t, ca1, #’A’      ; convert ca1 to lower 
          
          case
         
         
    
        
        
  19. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           CMP     t, #’Z’-’A’
         
         
    
        
        
  20. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           ADDLS   ca1, ca1, #’a’-’A’
         
         
    
        
        
  21. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            SUB     t, ca2, #’A’      ; convert ca2 to lower 
          
          case
         
         
    
        
        
  22. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           CMP     t, #’Z’-’A’
         
         
    
        
        
  23. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           ADDLS   ca2, ca2, #’a’-’A’
         
         
    
        
        
  24. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            STRB    ca0, [out], #
          
          1    ; *out++ = ca0;
         
         
    
        
        
  25. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            TEQ     ca0, #
          
          0           ; 
          
          if (ca0!=
          
          0)
         
         
    
        
        
  26. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
           STRNEB  ca1, [out], #
          
          1    ;   *out++ = ca1;
         
         
    
        
        
  27. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
              TEQNE   ca1, #
          
          0           ; 
          
          if (ca0!=
          
          0 && ca1!=
          
          0)
         
         
    
        
        
  28. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
            STRNEB  ca2, [out], #
          
          1    ;   *out++ = ca2;
         
         
    
        
        
  29. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
              TEQNE   ca2, #
          
          0          ; 
          
          if (ca0!=
          
          0 && ca1!=
          
          0 && ca2!=
          
          0)
         
         
    
        
        
  30. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
              BNE     loop_next3    ;   
          
          goto loop_next3;
         
         
    
        
        
  31. 
        
        
    
         
         
    
        
        
    
        
        
    
         
         
    
          
              LDMFD   sp!, {pc}     ; 
          
          return;
上面的代码是目前位置我们实验出的最高效的实现。此方法对于每个字符的处理只需要7个时钟周期，效率是C编译版本的1.57倍。
但是此方法总的运行时间却和C编译版本的时间相同，因为它的代码量是C编译版本的两倍还多。而且上面的代码在读取字符的时候有可能存在越界。在这里只是提供一种优化的方法和思想，你可以在应用中对时间要求严格，并且需要处理的数据量比较大的地方使用这种方法。



笑看江湖路6
关注
  • 4
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ARM指令流水线和ARM存储加载指令
wangjie36的博客
10-15 1208
ARM寄存器之SPSR(保存当前程序状态寄存器) 位宽也是32位，用来保存CPSR,当CPU正在运行某个进程,此时CPU的工作模式为 +User模式,此时UART控制器给CPU发送一个IRQ中断,CPU相应IRQ中断,伴随着CPU由User模式切换到IRQ模式,但是在切 +换之前,应该保存当前进程的运行状态(否则将来再返回就没法继续运行),只需将cpsr保存在IRQ模式下的spsr下,将来中断处理完毕以 +后,再将IRQ模式下的spsr给cpsr,恢复到之前被打断的进程的状态。=0,使能IRQ中断。
嵌入式系统/ARM技术中的探秘X86架构CPU流水线
10-20
英文原文：A Journey Through the CPU Pipeline 　　作为程序员，CPU 在我们的工作中扮演了核心角色，因此了解处理器内部的工作方式对程序员来说不无裨益。 　　CPU 是如何工作的呢？一条指令执行需要多长时间？当我们讨论某个新款处理器拥有 12 级流水线还是 18 级流水线，甚至是更深的 31 级流水线时，这到些都意味着什么呢？ 　　应用程序通常会将 CPU 看作是黑盒子。程序中的指令按照顺序依次进入 CPU,执行完之后再按顺序依次从 CPU 中出来，而内部到底发生了什么，我们通常并不了解。 　　对我们程序员来说，尤其是对做程序性能调优工作的程序员来说，学
ARM 流水线
10-17
讲述ARM类CPU流水线工作原理，适用于刚刚接触初学的同学
嵌入式系统/ARM技术中的ARM流水线
11-13
流水线的实质就是在明显制约系统速度的那条长路径上插入几级寄存器，使信号在时钟的作用下到达目的地，这样由于用寄存器截断了长路径，使得寄存器到寄存器最大延时缩短，因而可以提高整个系统的速度。 　　不同于微编码的处理器，ARM（保持它的RISC性）是完全硬布线的。ARM流水线结构如图所示。 　　ARM流水线的执行分三个阶段：第1阶段持有从内存中取回的指令，第2阶段开始解码，而第3阶段实际执行它。故此，程序计数器总是超出当前执行指令的2个指令（在为分支指令计算偏移量时必须计算在内）。 　　图 ARM流水线结构 　　因为有这个流水线，在分支时丢失2个指令周期（因为要重新填满流水线），所以最好
5级流水线和6级流水线ARM组织.pdf
07-09
5级流水线和6级流水线ARM组织.pdf 学习资料 复习资料 教学资源
Arm汇编学习笔记(七)——ARM9五级流水及流水线互锁
beyond702的专栏
08-17 1万+
本文主要是通过分析五级流水及流水线互锁的原理，从而可以编写出更加高效的汇编代码。 1. ARM9五级流水线 ARM7采用的是典型的三级流水线结构，包括取指、译码和执行三个部分。其中执行单元完成了大量的工作，包括与操作数相关的寄存器和存储器读写操作、ALU操作及相关器件之间的数据传输。这三个阶段每个阶段一般会占用一个时钟周期，但是三条指令同时进行三级流水的三个阶段的话，还是可以达到每个周
计算机结构-----五级流水线设计MIPS
m0_63691156的博客
03-26 1841
个人学习
流水线技术
ZachZheng的专栏
08-25 4551
文章目录流水线技术原理流水线技术指标五级流水线 流水线技术原理 流水线技术就是将一条指令分解成一连串执行的子过程。例如：把指令的执行过程细分为取指令、指令编码、取操作数和执行 444 个子过程。这样多条指令可以重叠执行，因为取指令操作、指令编码操作、取操作、执行操作 是可以同时执行的。如下图所示：其中 1、2、3、4、5 表示要处理 5 条指令。 上述过程可以看出，在 8 个时间片段中，执行了...
ARM9——五级流水线结构，以及PC指针
猪哥的专栏
07-03 9457
    ARM7是三级流水线，所以PC = 执行指令地址 + 8，这很好理解，但是在ARM9中，是五级流水线，仍然是：PC = 执行指令地址 + 8，而不是 PC = 执行指令地址 + 16.    这个理解显然有些难度，首先看下ARM7和ARM9的流水线区别和联系：        相比ARM7，ARM9采用了更高效的五级流水线设计，在取指令、译码、执行之后，又增加了LS1和LS2阶段，LS1负责...
五级流水线结构CPU中的数据相关问题
来了就别走啦
06-14 1950
流水线中经常有一些被称为"相关"的情况发生，它使得指令序列中下一条指令无法按照设计的时钟周期执行，这些“相关”会降低流水线的性能。流水线中的相关分为以下三种类型:流水线数据相关又分为：如下图是实现逻辑或操作的简单五级流水线各模块连接图，从下图可以看出只有在回写阶段才会写入数据到寄存器中。...
MIPS五级流水线CPU（全部注释）
04-28
系统硬件综合设计 设计并实现一个多周期和流水CPU。 1.若干段流水、可以处理冲突。 2.三种类型的指令（R类，I类，J类指令）若干条。 3.CPU指令集（MIPS、ARM、RISC-V等均可）不限
为什么CPU流水线会提高代码执行效率？
strongerHuang
04-18 4646
关注、星标公众号，不错过精彩内容素材来源：网络编辑整理：strongerHuang为什么有些CPU的主频更低，但运算效率却更高呢？比如：51单片机30M主频，STM32单片机20M主频，...
嵌入式通用面经——大疆嵌入式知识点
Naruto_8的博客
08-10 561
而ldr伪指令没有这个限制。异常向量表占32个字节，其中有一个预留的（0x14），ARM异常向量表地址默认在地址0，有些处理可以设置为0xFFFF0000地址处，具体看CPU手册。由于每个异常入口在向量表中只有4个字节，所以在异常向量表中每种异常都只放一条ARM跳转指令（发生异常后，处理器自动切换到ARM状态 ），跳转到对应的异常处理程序继续执行。特权模式中，除去系统模式，其余的5种模式都称为异常模式（在用户模式和系统模式开来这些都属于异常），常用于处理中断或异常，以及需要访问受保护的系统资源等情况。
ARM_5级流水解析
Funning的博客
09-20 1559
指令周期Cycle1 取指 PC总是指向将要读取的指令的地址（即我们常说的，指向下一条指令的地址），而当前PC=4， 所以去取物理地址为4对对应的指令"A" 二进制代码为"A_BIT" 此处取指完之后，自动更新PC的值，即PC=PC+4（单个指令占4字节，所以加4）=4+4=8（pc=8） 指令周期Cycle2 译指 翻译指令"A"
MIPS-5级流水线CPU
热门推荐
weixin_43877853的博客
12-31 1万+
一、流水线CPU 流水线CPU就是指将一条分解为多步，在同一周期内进行多条指令的同时执行。MIPS五级流水线就是将指令分为：取指(IF)，译码(ID)，执行(EX)，访存(MEM)，写回(WB)五个阶段。举个例子： 比如第二条指令lui $t2,0x2100 在流水线CPU中执行的就是 可以看到在200-300ns的周期里，IF阶段取到0x00400004处的指令，300-400ns，这条指令到了ID阶段，而IF阶段执行下一条指令。400-500ns，执行这条指令，ALU的结果为0x2100
嵌入式系统期末复习
weixin_45613955的博客
06-25 4671
第一章 嵌入式系统概论 1.嵌入式系统定义 从技术的角度定义：以应用为中心、以计算机技术为基础、软件硬件可裁剪、对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。 2.嵌入式系统特点 嵌入式系统中运行的任务是专用而确定的； 嵌入式系统都是实时系统，有实时性的要求； 系统可靠性要求高（因为使用环境可能很恶劣）； 具有功耗约束； 系统资源紧缺； 3.risc 与cisc区别 CISC适用于通用计算机，RISC使用于嵌入式系统。 4.嵌入式系统组成 硬件包括微处理器、外围硬件设备、嵌入式操作系统，以及用
5级流水线ARM组织
CodeAllen嵌入式
03-30 693
5级流水线中提前1级来读取指令操作数，得到的值是不同的，由此产生的代码不兼容是不容许的。在取指级增加的PC值被直接送到译码级的寄存器，穿过两级之间的流水线寄存器。把指令的执行分割为5部分而不是3部分，这就在每个时钟周期内增加了必须完成的工作量，进而可以使用更高的时钟频率，分开的指令和数据存储器使核的CPI明显减少。指定ARM7为止，在ARM核中使用的3级流水线的性价比是很高的。第一，可以提高时钟频率。时钟频率的提高，必然引起指令执行周期的缩短，所以要求简化流水线每一级的逻辑，因而流水线的级数就增加了。
ARM base instruction -- 经典五级流水线
xiaozhi
03-01 246
/* * 经典五级流水线 */ IF Instruction fetch 取指 ID Instruction decode & register file read 译码&读取寄存器堆数据 EX Execution or address calculation 执行or地址计算 MEM...
ARM：软件是挑战X86的最后瓶颈
航海日志
11-09 1785
有意思的是，尽管Intel和IBM在RISC-CISC上的争论持续了很多年，CISC也正在不断蚕食以IBM为代表的RISC低端市场，但时至今日，Intel突然转过头发现，自己的低端市场也正在遭遇以ARM为代表的RISC产品侵蚀。 在2009年，Dell就已经推出了基于威盛Nano芯片的低功耗XS11-VX8服务器，其体积相当于一块3.5英寸的硬盘，而且在一个标准2U机箱内放置12台这样的服务
riscv五级流水线
最新发布
09-14
RISC-V五级流水线是一种用于处理指令的设计架构。它将指令处理过程分为五个阶段，以提高处理器的效率和性能。这五个阶段分别是取指阶段（IF_stage）、译码阶段（ID_stage）、执行阶段（EX_stage）、访存阶段（MEM_stage）和写回阶段（WB_stage）。每个阶段负责不同的任务，并且这些阶段是连续且并行工作的，即在处理完一条指令的某个阶段后，立即开始处理下一条指令的同一阶段。 具体来说，五级流水线的设计步骤可以按照以下方式进行： 1. 首先，需要对整个流水线进行模块化划分。这意味着将整个处理器分为多个模块，每个模块负责处理指令处理过程的一个阶段。常见的模块包括指令存储器、译码器、执行单元、数据存储器和寄存器文件等。 2. 其次，需要在每两个模块之间添加流水线寄存器。这样可以确保指令在不同阶段之间流动时能够被正确地传递和处理。流水线寄存器用于存储每个阶段的中间结果，并在时钟上升沿时将结果传递给下一个阶段。 3. 接下来，需要对每个阶段进行详细的设计和实现。例如，在取指阶段（IF_stage），处理器从指令存储器中读取指令，并将其传递给下一个阶段。在译码阶段（ID_stage），处理器解码指令并确定需要执行的操作。在执行阶段（EX_stage），处理器执行指令的操作。在访存阶段（MEM_stage），处理器访问内存并处理相关数据。最后，在写回阶段（WB_stage），处理器将结果写回寄存器文件。 需要注意的是，五级流水线的设计需要考虑数据冒险和控制冒险等问题，以确保指令之间的依赖和顺序正确处理。为了解决这些问题，可以采用一些技术，如数据前移、静态预测等。 总结来说，RISC-V五级流水线的设计包括模块化划分、添加流水线寄存器以及详细设计和实现每个阶段的功能。这样可以提高处理器的效率和性能，实现指令的快速处理和执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值