嵌入式微处理器重点学习（二）

soulermax

已于 2024-06-16 16:55:28 修改

阅读量843

点赞数 28

文章标签：学习 java 开发语言

于 2024-06-14 21:58:52 首次发布

本文链接：https://blog.csdn.net/soulermax/article/details/139690249

版权

影响cache命中率的因素

影响Cache命中率的因素主要包括以下几个方面：
Cache大小：一般来说，Cache的大小越大，其能够存储的数据也就越多，因此可能缓存更多需要访问的数据，从而提高命中率。但是，增加Cache大小会增加访问Cache的延迟，同时也会增加成本和功耗。
块大小（Block Size）：Cache被划分为多个块，每个块存储一定量的数据。块大小的选择对命中率有显著影响。较大的块可以利用空间局部性，但如果太大可能会导致浪费（例如，块中只有部分数据被频繁访问）和替换率增加。
映射策略：Cache可以通过不同的映射策略来决定数据应存储在哪个Cache块中，这些策略包括直接映射、全相联映射和组相联映射。不同的映射策略对Cache的命中率有不同的影响。全相联映射提供最灵活的数据存放位置，理论上可以达到最优的命中率，但硬件实现复杂度较高。直接映射硬件实现简单，但可能因冲突而导致命中率下降。组相联映射则试图平衡二者的优缺点。
替换策略：当Cache满了而需要载入新数据时，需要一种策略来决定淘汰哪些旧数据。常见的替换策略有最近最少使用（LRU）、随机（Random）等。不同的替换策略对命中率有直接影响。
预取策略（Prefetching）：预取是一种主动填充Cache的方式，即在数据被实际请求前就将其载入Cache。预取策略的有效性取决于程序的访问模式，对命中率有显著影响。
工作集大小和行为：程序的工作集大小（它在任一时间点实际访问的数据量）和访问模式（时间局部性和空间局部性）直接影响Cache命中率。良好的局部性可以提高命中率。
这些因素通过影响Cache的容量失效（因Cache太小而导致的失效）、冲突失效（特别是在直接映射和组相联映射中，不同数据项需要存储在同一个位置而导致的失效）和强制失效（第一次访问数据时不可避免的失效）来间接影响Cache的总体性能。

arm与riscv结构区别

ARM架构和RISC架构是两种广泛应用于计算机系统中的体系结构，它们在设计理念和实现方式上都有各自的特点。
ARM架构
ARM架构是一种基于RISC原则的处理器架构，由ARM公司设计。ARM架构以其高效的能耗比著称，因此非常适用于移动和嵌入式设备。ARM处理器采用了简单的指令集、固定的指令长度和加载/存储架构，这些特点使得ARM处理器在处理速度和能效上都表现出色。在过去几年中，随着智能手机和平板电脑的广泛使用，ARM架构获得了巨大的成功和广泛的应用。
RISC架构
RISC（Reduced Instruction Set Computer）架构是一种计算机设计理念，其主要原则是利用一套简洁的指令集来实现处理器的高效运算。RISC架构试图通过简化指令集来降低每条指令的执行时间，并通过编译器优化来提高程序执行的效率。RISC处理器通常采用流水线技术来实现指令的快速执行，并且倾向于使用较大的寄存器文件来加速数据访问。
ARM架构与RISC架构的区别
尽管ARM架构被认为是基于RISC原则的，但它和普通意义上的RISC架构之间存在一些区别：
设计目标：ARM架构在设计时更加注重能效比和低能耗，而一般的RISC架构则更侧重于通过简化指令集来提高处理速度和效率。
应用领域：ARM架构由于其出色的能效比，被广泛应用于移动设备、嵌入式系统等领域。而RISC架构的应用则更加广泛，除了嵌入式和移动设备外，还包括一些高性能计算平台。
指令集和扩展：尽管ARM架构基于RISC，它的指令集中包含了一些支持复杂操作的指令和扩展，如SIMD（单指令多数据）指令扩展，这使得ARM处理器能够有效处理多媒体和信号处理等任务。而传统的RISC架构更倾向于维持指令集的简洁性。
其中RISC-V免费开源；指令数简洁，仅40多条；性能好；架构与实现分离，不需要特定实现进行优化；易于编程编译链接
总的来说，ARM架构和RISC架构都强调了通过简化指令集来提高处理器性能的设计理念，但在具体实现和应用目标上存在着一些差异。ARM架构的成功展示了RISC原则在现代计算机体系结构设计中的强大生命力和广泛适用性。

load store架构是什么？有什么作用？一般用于哪里？

Load/store架构是一种计算机处理器的设计理念，它将数据的移动（加载和存储数据）和数据的操作（如算术运算）分开处理。在这种架构中，处理器只能直接对寄存器执行算术和逻辑操作，而不能直接对内存中的数据进行这些操作。要对内存中的数据进行处理，首先需要使用load指令将数据从内存加载到处理器的寄存器中，处理完成后，再使用store指令将结果存回内存。
作用：
性能提升：将数据操作和数据移动分开可以简化处理器的设计，使处理器能够更高效地执行算术和逻辑操作，从而提高整体性能。
灵活性：通过在寄存器间进行数据操作，处理器可以更灵活地实现复杂的算数和逻辑运算，提高程序的运行效率。
优化内存访问：通过显式的load/store操作，编译器和程序员可以更好地控制数据如何从内存移动到寄存器（反之亦然），从而优化内存访问模式，减少缓存未命中的情况，提高缓存利用率。
一般用于哪里：
Load/store架构广泛应用于RISC（Reduced Instruction Set Computer）架构的处理器设计中。由于其操作简单、高效的特性，这种架构非常适合需要高性能和低功耗的应用场景，如嵌入式系统、移动设备（智能手机、平板电脑等）、高性能计算（HPC）以及图形处理单元（GPU）等领域。在recall slice 1中提到的Fermi体系结构（一种GPU架构）就采用了类似的设计理念，强调了通过CUDA编程环境来开发应用程序，其中CUDA线程的并行执行体现了load/store架构对于提高并行处理能力的重要性。
总之，load/store架构通过寄存器优化计算过程，提高了处理器性能和内存访问效率，是现代高性能计算设备设计的重要组成部分。

运算指令±s选项有什么区别，比如add和adds

在ARM架构下，运算指令中通常add和adds指令之间的主要区别在于adds除了执行加法操作之外，还会更新处理器的状态寄存器（比如零标志Z、负标志N、进位标志C和溢出标志V）。
add指令仅仅执行加法操作，不改变状态寄存器的值。
adds指令执行加法操作，并根据结果更新状态寄存器。这可以用于条件执行后续指令。
简单来说，如果你需要在加法操作后进行条件检查（比如判断加法结果是否为零、是否有进位等），则可以使用adds指令。如果不需要根据加法结果立刻进行条件判断，则可以使用add指令，这样可以避免对状态寄存器的不必要更新，提升执行效率。

bl，bx，blx等的区别

bl（Branch with Link）：这条指令用于函数调用。它将当前的程序计数器（PC）加4的值（即bl指令的下一条指令的地址）保存到链接寄存器（LR）中，并跳转到指定的地址执行。这样做的目的是为了在函数执行完后，可以通过链接寄存器中的返回地址跳回到调用函数的下一条指令继续执行。
bx（Branch and Exchange）：这条指令用于跳转到指定的地址执行，并且可以根据目标地址的最低位来改变处理器的状态，比如从ARM状态切换到Thumb状态或反之。bx指令不会像bl指令那样影响链接寄存器（LR）。
blx（Branch with Link and Exchange）：这条指令结合了bl和bx的功能，既可以跳转到指定的地址执行，又可以保存返回地址到链接寄存器中，同时根据目标地址的最低位改变处理器的状态。它主要用于在不同指令集状态间进行函数调用，例如从ARM状态调用一个Thumb状态的函数。
简单来说，bl用于函数调用且保存返回地址，bx用于改变处理器的状态且跳转执行，而blx则结合了两者的功能，既保存返回地址又可以在状态间切换。

keil和segger在build后输出信息有哪些？分别有什么意义？

Keil

在Keil环境下构建项目后，输出信息一般包括：
编译信息：显示了编译过程中的详细信息，包括编译成功或失败的模块数，编译时间等。
警告和错误信息：如果代码中有语法错误、类型不匹配、未定义的标识符等问题，这些信息会被详细列出。
内存使用情况：包括代码大小、只读数据大小、读写数据大小以及堆和栈的使用情况。这些信息对于嵌入式系统特别重要，因为它们通常有限的内存资源。

Segger Embedded Studio

在使用Segger Embedded Studio构建项目后，也会产生类似的输出信息：
Build Log：展示了整个编译链接过程的输出，包括编译和链接的详细步骤，以及耗时。
警告和错误：编译过程中的问题会在这里以明确的形式列出，方便开发者定位和修正问题。
内存布局：Segger Embedded Studio提供了详细的内存使用报告，包括每个段（如代码段、数据段）的大小，以及总的内存使用情况。
两种环境构建项目后的输出信息虽然在格式上可能有所不同，但基本上都为开发者提供了编译过程中的详细情况、代码的内存消耗、以及任何可能影响程序运行的问题。这些信息对于调试和优化程序至关重要。

keil中的rw，ro等输出信息是什么？有什么作用？要怎么去看哪里是入口地址？现在正在执行的地址？

在Keil环境下构建项目后，在输出信息中常见的rw和ro等术语表示内存区域的属性：
ro：表示"read-only"（只读）。这部分通常是指存储代码（即程序指令）、常量和初始化的全局变量的内存区段。由于这些数据不需要在程序运行时修改，因此被放置在只读内存区。
rw：表示"read-write"（可读写）。这部分通常是指用于存储全局变量和静态变量的内存区段，这些变量的值可能会在程序运行过程中被改变。
这些信息有助于开发者了解程序中不同类型数据的布局和内存使用情况，对于优化内存使用和调试程序都非常有用。
要查看程序的入口地址和当前执行的地址：
入口地址：通常在链接器的设置或者map文件中可以找到。入口地址指的是程序开始执行的第一条指令的位置，有时也称为“启动地址”。在Keil中，这个地址一般由链接器脚本定义，也可以在链接器的设置中指定。
当前执行的地址：这个信息在调试过程中特别有用，可以通过调试器（debugger）来查看。在Keil中，当你调试程序时，可以在调试视图中看到当前执行到的指令的地址。你可以使用"Disassembly"（反汇编）窗口或者调试视图中的"Call Stack"（调用堆栈）来查看当前的执行地址及调用链。
通过这些信息，开发者可以确保程序正确地映射到预期的内存区域，并在程序执行过程中有效地跟踪和调试程序。

嵌入式中参数怎么传递，结果怎么返回

在ARM嵌入式系统中，参数的传递和结果的返回遵循特定的调用规范。
参数传递
整型参数：基本整型调用规范提供了8个参数寄存器＄a0~＄a7用于参数传递。如果参数数量超过这些寄存器的数量，则剩余的参数会被传递到栈上。栈空间的分配是向下增长的（朝向更低的地址），并且栈指针应该对齐到一个16字节的边界上。
浮点参数：浮点参数寄存器共有8个，为＄fa0~＄fa7，这些寄存器也可用于传递浮点类型的参数。根据情况，如果整型参数寄存器已经用完，浮点参数仍可以传递到浮点寄存器中。
结果返回
对于整型返回值，前两个参数寄存器＄a0和＄a1也用于返回值。这意味着，如果有返回值的函数返回的是整型，它将通过＄a0返回；如果返回值是复合整型（即需要多个寄存器来表示的类型），则可能会使用到＄a1。
对于浮点返回值，＄fa0和＄fa1寄存器用于传递返回值。这两个寄存器能够携带浮点函数的结果返回给调用者。
特殊情况
可变参数的传递遵循整型调用规范，也即使用＄a0~＄a7寄存器，并在这些寄存器用尽后使用栈进行参数传递。
在调用标准ABI过程之前，非标准ABI代码必须重新调整栈指针，以确保栈指针的对齐要求得到满足。
被调用的函数负责保证寄存器＄s0~＄s8在函数返回时与入口时的值一致，这有助于保护函数中使用的局部变量和其他数据。
这些调用规范确保了在ARM嵌入式系统的软件开发过程中，函数参数和返回值的处理在不同编译器和代码库之间保持一致性，有助于提高代码的可移植性和可维护性。

程序优化目标是什么，数组大小的考虑，优化手段及权衡

程序优化的目标

程序优化的目标是为了提高程序的执行效率，降低资源消耗。这通常涉及到以下几个方面：

执行速度

主要包括指令周期和数据访问

实际执行指令数

内存使用：

减少程序运行时占用的内存量。

能耗：

对于移动设备或嵌入式系统，减少能耗也是一个重要的优化目标。

代码体积：

对于存储空间有限的系统，减少程序的体积也很重要。

数组大小的考虑

数组大小直接影响内存的使用。在对数组进行优化时，需要考虑数据结构对空间效率的影响，以及是否存在空间换时间的可能。

优化手段及权衡

数据类型

数据对齐时，访问效率最高。

代码层面优化：

循环优化，如循环展开、循环融合等可以减少循环开销。

循环展开

循环展开（Loop Unrolling）是一种编译器优化技术，其目的是减少程序运行时循环控制的开销，并增加程序的执行效率。在这种技术中，编译器通过减少循环次数和增加每次循环内的操作数量来实现优化。循环展开通过减小循环迭代的次数和减少每次迭代中的分支预测失误来提高程序的性能。
例如，假设有一个简单的循环：
c

for (int i = 0; i < 4; i++) {
    array[i] = array[i] * 2;
}

循环展开后可能会变成：

array[0] = array[0] * 2;
array[1] = array[1] * 2;
array[2] = array[2] * 2;
array[3] = array[3] * 2;

通过展开循环，程序不再需要进行四次迭代中的比较和跳转操作，从而减少了循环控制的开销。循环展开的程度（即展开多少次）可以自动由编译器决定，也可以通过编译指令或编程手动指定。正确应用循环展开可以提升程序的局部性和执行速度，尤其是在处理大量数据的循环计算中。然而，过度展开可能会导致代码膨胀，增加指令缓存的压力，因此需要合理控制循环展开的程度。

递减循环

因为递加循环时增加一条CMP指令
算法优化，选择更高效的算法能显著提高程序性能。
数据结构选择，适合的数据结构可以提高数据处理的效率。
权衡：代码复杂性与执行效率之间的平衡。过度优化可能导致代码难以理解和维护。

do – while 比 for(;😉 更有效

减少重复计算

将循环中的常量计算移到循环体外，减少重复计算。

计算替换

利用加法替代乘法和索引。

改变依赖

改变指令顺序，减少指令之间的依赖。

编译器优化

使用编译器优化选项，如-O2、-O3等，可以让编译器自动进行一系列的优化操作。
权衡：高级别的优化可能导致编译时间长，并且在一些情况下可能会产生不可预料的结果。
并行化和向量化：
利用多核处理器的并行计算能力或SIMD（单指令多数据）指令集进行向量化，可以显著提升处理能力。
权衡：并行化和向量化需要额外考虑数据的切分、同步和并发问题。

计算方式

简单替代复杂；查找表。

存储访问

访问连续的数据区，充分发挥数据Cache的优势。逐行而不是逐列。使用TCM。减少存储器访问。使用 Register。

TCM

TCM（Tightly Coupled Memory）指的是紧密耦合内存，是一种与处理器核紧密集成的快速内存，用于提高处理器访问数据和指令的速度。TCM通常位于处理器芯片上，与CPU核共享相同的时钟域，这样可以实现非常低的延迟和高速的数据传输，相比之下，传统的RAM（如DRAM）访问速度慢得多。
TCM的特性使其非常适合实时系统和性能敏感的应用，例如嵌入式系统、数字信号处理（DSP）和高性能计算应用。使用TCM可以显著提高程序的执行速度，尤其是对于那些对延迟和数据处理速度有严格要求的应用。
在程序优化中，开发者可以将经常访问的数据或者性能关键的代码段放置在TCM中，以减少存储访问的时间。例如，在嵌入式系统中，将关键任务的代码或者实时任务的数据放置在TCM中，可以确保快速响应和高效执行。

分支跳转

采用分支预测技术。

取消内联函数

如果内联代码是冷代码，会让程序跑的更慢。

冷代码

冷代码（Cold Code）通常指在程序运行期间很少或者根本不被执行的代码路径。这与热代码（Hot Code）形成对比，热代码指的是在程序运行期间频繁执行的代码部分，如循环体内部或者经常调用的函数。
冷代码的特点包括：
不经常执行：可能只在特定条件下才会执行，如错误处理逻辑、异常情况处理等。
执行影响较小：由于这部分代码不经常执行，它们对整个程序性能的影响相对较小。
优化重点较低：在程序优化过程中，开发者和编译器倾向于关注热代码的优化，因为这样做能获得更明显的性能提升。
了解哪些代码是冷代码，可以帮助开发者和编译器在优化时作出合理决策，集中资源优化那些对程序性能影响更大的热代码区域。

选择短长度指令集

对于支持多种指令长度的处理器，选择短长度的指令集，可以减少程序code所占有的空间。

内存访问优化

尽量减少内存访问延迟，例如通过优化数据的局部性来提高缓存命中率。
权衡：可能需要对数据布局进行特殊处理，这有时会增加程序的复杂度。
综上，程序优化是一个需要考虑多方面因素并做出适当权衡的过程。在具体的应用场景中，应根据具体需求和资源限制选择合适的优化策略。

开源处理器开源的内容是什么

开源处理器，开源的内容主要是其指令集架构（Instruction Set Architecture, ISA）。这意味着RISC-V的指令集的设计、规范以及相关的文档等都是公开的，任何个人或组织都可以自由地访问这些资源，使用这些指令集规范来设计、实现自己的处理器芯片，无需支付版税或遵循严格的许可协议。
开源指令集架构的主要内容包括：
指令集规范：详细定义了支持的所有指令，包括数据操作、控制流程操作等，以及每条指令如何对系统状态产生影响。
编码规范：说明了如何以二进制形式表示各种指令。
调用约定：定义了函数或过程调用过程中如何传递参数、返回值，以及如何使用寄存器。
内存模型：描述了处理器如何访问内存，包括寻址方式、内存一致性等。
异常与中断处理机制：规定了处理器遇到异常情况和中断时的处理流程。
通过开源指令集架构，RISC-V等开源处理器平台促进了技术创新，降低了芯片设计的入门门槛，使得学术界、产业界以及业余爱好者都能在共享的基础上实现定制化的处理器设计，促进了技术的快速发展和多样化应用。

openmp要求如何把循环并行化，用什么编译的指令，多层循环哪一层效果最好，为什么不能加速反而可能更慢

在OpenMP中，要将循环并行化，可以使用**#pragma omp parallel for**编译指令。这个指令告诉支持OpenMP的编译器将紧随其后的循环转换成并行执行的形式。OpenMP通过在源代码中加入这种特殊的#pragma来实现对循环的并行化，从而在多线程环境中加速程序的执行。
对于多层循环，将最外层循环并行化通常会获得最好的效果。这是因为最外层循环并行化可以最大限度地减少线程创建和销毁的开销，同时也能较好地利用缓存，因为内层循环的迭代可能会重复访问同一块数据。此外，最外层循环并行化还能提供足够的并行工作量，从而更有效地利用多核处理器的计算资源。
然而，并行化并不总是能带来性能提升。在某些情况下，循环并行化可能会导致性能下降，原因包括：
线程开销：创建和管理线程本身就需要耗费时间和资源。如果被并行化的循环执行时间非常短，则线程管理的开销可能会超过并行执行带来的收益。
数据竞争和同步开销：在并行环境中，不同线程可能需要访问和修改共享数据。为了防止数据竞争（Data Race），可能需要使用同步机制（如锁）。同步会引入额外的开销，并可能导致线程之间的竞态条件，影响性能。
负载不均衡：如果循环的迭代之间执行时间差异很大，可能会导致一部分线程早早完成任务而空闲，而其他线程还在忙碌。这种负载不均衡会造成计算资源的浪费，降低并行效率。
因此，决定是否对循环进行并行化以及如何选择并行化的循环时，需要综合考虑循环的特性、计算量、以及可能引入的额外开销。在某些情况下，适当的优化和调整（如循环分块、减少同步等）是必要的，以确保并行化能够真正带来性能上的提升。

cuda要求如何构建核函数，调用核函数，把线程的功能运用好

在CUDA（Compute Unified Device Architecture）中，构建和调用核函数（kernel functions）以及有效利用线程是实现高性能并行计算的关键。核函数是在GPU上并行执行的函数，可以由成百上千的线程同时执行。以下是一些基本要求和指导原则：

构建核函数

核函数通过__global__修饰符在CUDA C/C++代码中定义，示例如下：
cuda

__global__ void myKernel(int *a, int *b, int *c, int N) {
    int i = threadIdx.x + blockIdx.x * blockDim.x;
    if (i < N) {
        c[i] = a[i] + b[i];
    }
}

threadIdx.x：这是当前线程在其线程块（Block）内的索引，它提供了线程在X维度的位置。CUDA允许一个线程块包含多维的线程布局，但这里用到的是一维索引。threadIdx.x的值从0开始，在一维线程块的情况下，它直接标识了线程块内每个线程的唯一编号。
blockIdx.x：这是当前线程块在网格（Grid）中的索引，用于标识线程块在X维度的位置。与threadIdx.x相似，CUDA也支持多维的网格布局，但在这段代码中使用的是一维索引。blockIdx.x的值同样从0开始，它唯一标识了网格中每个线程块的位置。
blockDim.x：这是定义了一个线程块中包含线程的数量，即每个线程块的维度大小。在一维的情况下，它告诉我们线程块包含多少个线程。
结合这三个变量，int i = threadIdx.x + blockIdx.x * blockDim.x;
这行代码的作用是计算当前线程在整个执行网格中的全局唯一索引i。这个索引可以用于标识当前线程应该处理的数据元素，确保每个线程都在不同的数据元素上工作，避免重复或遗漏。
在这个例子中，myKernel是一个执行向量加法的核函数。它接受指向设备内存中数组的指针和数组大小N作为输入参数。

调用核函数

核函数的调用与普通函数不同，需要使用特殊的语法指定执行配置，包括线程块（Block）的数量和每个线程块中的线程数量。语法格式为kernel<<<numBlocks, blockSize>>>(arguments)，例如：
cuda

int numBlocks = (N + blockSize - 1) / blockSize;
myKernel<<<numBlocks, blockSize>>>(d_a, d_b, d_c, N);

在这个例子中，numBlocks计算了需要多少个线程块以确保至少有N个线程被启动，blockSize是一个预先定义的每个线程块的线程数，d_a、d_b、d_c是存储在设备内存的数组，N是数组的大小。

二维数组求和计算案例

// Kernel definition
__global__ void MatAdd(float A[N][N], float B[N][N], float C[N][N])
{
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    int j = blockIdx.y * blockDim.y + threadIdx.y;
    if (i < N && j < N)
        C[i][j] = A[i][j] + B[i][j];
}

int main()
{
    ...
    // Kernel invocation
    dim3 threadsPerBlock(16, 16);
    dim3 numBlocks(N / threadsPerBlock.x, N / threadsPerBlock.y);
    MatAdd<<<numBlocks, threadsPerBlock>>>(A, B, C);
    ...
}

dim3是CUDA编程中用于定义一个三维向量的结构体类型，主要用于指定线程块的尺寸（线程的数量）或网格的尺寸（块的数量）。在上述代码中，threadsPerBlock用dim3类型定义了每个线程块中的线程布局，这里是16x16。numBlocks用dim3类型定义了网格中的块布局，计算方式基于矩阵大小N和每块的线程数。这种布局使得kernel可以按照二维矩阵的结构来并行执行计算。