最大化 MicroPython 速度

闪电

最大化 MicroPython 速度

内容

• 最大化 MicroPython 速度

  • 为速度而设计

    • 算法

    • 内存分配

    • 缓冲器

    • 浮点

    • 数组

      
      

  • 识别最慢的代码部分

  • MicroPython 代码改进

    • const() 声明

    • 缓存对象引用

    • 控制垃圾收集

      
      ' V; H+ H& e0 B' }: t

  • 本机代码发射器

  • Viper 代码发射器

  • 直接访问硬件

    
    
  
  . C! e7 G6 l% l; R& O- q

9 L% U+ \2 O' Z5 H

本教程介绍了提高 MicroPython 代码性能的方法。涉及其他语言的优化在别处有介绍，即使用 C 编写的模块和 MicroPython 内联汇编器。

开发高性能代码的过程包括以下应按所列顺序执行的阶段。

• 为速度而设计。

• 编码和调试。

  
  . j, m' B3 ~  r

优化步骤：

• 确定代码中最慢的部分。

• 提高 Python 代码的效率。

• 使用本机代码发射器。

• 使用毒蛇代码发射器。

• 使用特定于硬件的优化。

  
  

为速度而设计

一开始就应该考虑性能问题。这涉及查看对性能最关键的代码部分，并特别注意它们的设计。当代码经过测试时，优化过程就开始了：如果设计一开始是正确的，优化将很简单，实际上可能是不必要的。

算法

设计任何性能例程的最重要方面是确保采用最佳算法。这是教科书而不是 MicroPython 指南的主题，但有时可以通过采用以其效率着称的算法来实现惊人的性能提升。

( L  P& k  N9 i! v$ [内存分配

要设计高效的 MicroPython 代码，有必要了解解释器分配 RAM 的方式。当一个对象被创建或变大时（例如，一个项目被添加到一个列表中），必要的 RAM 从一个称为堆的块中分配。这需要大量时间；此外，它有时会触发一个称为垃圾收集的过程，该过程可能需要几毫秒。

因此，如果对象只创建一次并且不允许其大小增长，则可以提高函数或方法的性能。这意味着该对象在其使用期间持续存在：通常它将在类构造函数中实例化并在各种方法中使用。

这将在下面详细介绍控制垃圾收集 。

: a  N1 B! [7 @$ w+ D缓冲器

上述示例是需要缓冲区的常见情况，例如用于与设备通信的缓冲区。典型的驱动程序将在构造函数中创建缓冲区并在其将重复调用的 I/O 方法中使用它。

MicroPython 库通常提供对预分配缓冲区的支持。例如，支持流接口的对象（例如文件或UART）提供了read() 为读取数据分配新缓冲区的 readinto() 方法，也提供了将数据读入现有缓冲区的方法。

" [$ C! u" Q# p* X浮点

一些 MicroPython 端口在堆上分配浮点数。其他一些端口可能缺少专用的浮点协处理器，并且在“软件”中以比整数低得多的速度对它们执行算术运算。在性能很重要的地方，使用整数运算并将浮点的使用限制在性能不是最重要的代码部分。例如，快速将 ADC 读数作为整数值捕获到数组中，然后才将它们转换为浮点数以进行信号处理。

数组

考虑使用各种类型的数组类作为列表的替代方法。该array模块支持各种元素类型，其中包含 Python 内置bytes 和 bytearray类支持的 8 位元素。这些数据结构都将元素存储在连续的内存位置。再次避免在关键代码中分配内存，这些应该预先分配并作为参数或绑定对象传递。

当传递对象的切片（例如 bytearray实例）时，Python 创建一个副本，其中涉及与切片大小成比例的大小分配。这可以通过使用memoryview对象来缓解。 memoryview 它本身在堆上分配，但它是一个小的、固定大小的对象，无论它指向的切片的大小如何。

1. ba = bytearray(10000)  # big array
   ; H! ~+ N# @$ j3 e) b3 y7 V
2. func(ba[30:2000])      # a copy is passed, ~2K new allocation
   0 C9 E  W+ ~" ?+ n
3. mv = memoryview(ba)    # small object is allocated
   
4. func(mv[30:2000])      # a pointer to memory is passed

复制代码

( t) J3 @( o$ S) M6 v2 D6 R" \
( f+ t2 q: h" }1 t+ `/ U

A memoryview 只能应用于支持缓冲区协议的对象 - 这包括数组但不包括列表。需要注意的是，虽然 memoryview 对象处于活动状态，但它也会使原始缓冲区对象保持活动状态。因此，内存视图并不是万能的灵丹妙药。例如，在上面的例子中，如果你用完 10K 缓冲区并且只需要 30:2000 的那些字节，最好制作一个切片，让 10K 缓冲区去（准备好垃圾收集），而不是制作长期内存视图并保持 10K 阻塞以进行 GC。

尽管如此，memoryview对于高级预分配缓冲区管理来说，它是必不可少的。 readinto() 上面讨论的方法将数据放在缓冲区的开头并填充整个缓冲区。如果您需要将数据放在现有缓冲区的中间怎么办？只需在缓冲区的所需部分创建一个内存视图并将其传递给 readinto().

. B) |/ b1 ?7 A3 P( _6 Y识别最慢的代码部分

这是一个称为分析的过程，在教科书和（对于标准 Python）有各种软件工具支持。对于可能的更小的嵌入式应用的类型要在MicroPython平台上运行的最慢的函数或方法，通常可以通过明智地使用的定时来建立ticks 的中记录的功能组 utime。代码执行时间可以 ms、us 或 CPU 周期来衡量。

以下允许通过添加@timed_function 装饰器对任何函数或方法进行计时 ：

1. def timed_function(f, *args, **kwargs):
   
2.     myname = str(f).split(' ')[1]
   
3.     def new_func(*args, **kwargs):
   
4.         t = utime.ticks_us()
   
5.         result = f(*args, **kwargs)
   
6.         delta = utime.ticks_diff(utime.ticks_us(), t)
   
7.         print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
   9 i; X' \1 u; R
8.         return result
   
9.     return new_func

复制代码

( T7 Z: A/ Q8 E/ l0 B8 |8 o5 e
MicroPython 代码改进const() 声明

MicroPython 提供了一个const() 声明。这与#define在 C 中的工作方式类似，因为当代码被编译为字节码时，编译器用数值代替标识符。这避免了在运行时进行字典查找。的参数const()可以是任何在编译时计算为整数的东西，例如0x100或 1 << 8.

缓存对象引用

在函数或方法重复访问对象的情况下，通过将对象缓存在局部变量中可以提高性能：

1. class foo(object):
   
2.     def __init__(self):
   
3.         self.ba = bytearray(100)
   
4.     def bar(self, obj_display):
   
5.         ba_ref = self.ba
   ( W7 i& l1 D$ E7 U
6.         fb = obj_display.framebuffer
   
7.         # iterative code using these two objects

复制代码

3 x% O/ w, c# z3 `7 B% w9 l
, G, k3 C7 u, b9 C' D

这避免了 在方法体中反复查找 self.ba 和查找的需要。 obj_display.framebuffer bar().

: @% @; }. Q" K* |% {控制垃圾收集

当需要分配内存时，MicroPython 会尝试在堆上定位一个足够大的块。这可能会失败，通常是因为堆中堆满了不再被代码引用的对象。如果发生故障，称为垃圾收集的过程会回收这些冗余对象使用的内存，然后再次尝试分配——这个过程可能需要几毫秒。

通过定期发布gc.collect(). 首先在实际需要之前进行收集会更快 - 如果经常进行，通常大约为 1 毫秒。其次，您可以确定代码中使用该时间的点，而不是在随机点（可能在速度关键部分）发生更长的延迟。最后定期执行收集可以减少堆中的碎片。严重的碎片会导致不可恢复的分配失败。

本机代码发射器

这会导致 MicroPython 编译器发出本机 CPU 操作码而不是字节码。它涵盖了 MicroPython 的大部分功能，因此大多数功能不需要修改（但见下文）。它通过函数装饰器调用：

1. @micropython.native
   
2. def foo(self, arg):
   
3.     buf = self.linebuf # Cached object
   
4.     # code

复制代码

. ^$ b8 |% p: X4 Q) i
, q5 X5 Q: R! _- J; _

本机代码发射器的当前实现存在某些限制。

• 不支持上下文管理器（with 语句）。

• 不支持生成器。

• 如果raise使用，则必须提供参数。

  
  0 @2 a+ I, j- C' j/ f2 D( B6 `3 t

提高性能（大约是字节码的两倍）的代价是编译代码大小的增加。

Viper 代码发射器

上面讨论的优化涉及符合标准的 Python 代码。Viper 代码发射器不完全兼容。它支持特殊的 Viper 本地数据类型以追求性能。整数处理是不合规的，因为它使用机器字：32 位硬件上的算术以 2**32 为模执行。

像 Native 发射器 Viper 产生机器指令，但会执行进一步的优化，显着提高性能，特别是对于整数算术和位操作。它是使用装饰器调用的：

1. @micropython.viper
   
2. def foo(self, arg: int) -> int:
   5 b+ S) n/ T/ n- t: e
3.     # code

复制代码

1 O' `3 A, y- \0 a% {/ L: C$ ~& w

正如上面的片段所示，使用 Python 类型提示来辅助 Viper 优化器是有益的。类型提示提供有关参数和返回值的数据类型的信息；这些是在这里 PEP0484正式定义的标准 Python 语言功能。Viper 支持它自己的一组类型，即int, uint（无符号整数）ptr, ptr8, ptr16 和ptr32。 ptrX 下面讨论这些类型。目前该 uint 类型有一个用途：作为函数返回值的类型提示。如果这样的函数返回， 0xffffffffPython 会将结果解释为 2**32 -1 而不是 -1。

除了本机发射器施加的限制外，还适用以下限制：

• 函数最多可以有四个参数。

• 不允许使用默认参数值。

• 可以使用浮点，但没有优化。

  
  / ?, `6 Q8 k, u& V* M- `5 M

Viper 提供了指针类型来帮助优化器。这些包括

• ptr指向对象的指针。

• ptr8指向一个字节。

• ptr16指向一个 16 位半字。

• ptr32 指向一个 32 位机器字。

  
  5 H& J+ Q1 r: h7 q

Python 程序员可能不熟悉指针的概念。它与 Pythonmemoryview对象的相似之处在于它提供对存储在内存中的数据的直接访问。使用下标符号访问项目，但不支持切片：指针只能返回单个项目。其目的是提供对存储在连续内存位置中的数据的快速随机访问 - 例如存储在支持缓冲区协议的对象中的数据，以及微控制器中的内存映射外设寄存器。应该注意的是，使用指针编程是危险的：不执行边界检查，编译器没有采取任何措施来防止缓冲区溢出错误。

典型用法是缓存变量：

1. @micropython.viper
   
2. def foo(self, arg: int) -> int:
   
3.     buf = ptr8(self.linebuf) # self.linebuf is a bytearray or bytes object
   
4.     for x in range(20, 30):
   
5.         bar = buf[x] # Access a data item through the pointer
   ) r9 F: e5 h2 n! D. {/ b
6.         # code omitted

复制代码

9 C, a! E! n. Z3 H' G1 q" k

在这种情况下，编译器“知道”这buf 是一个字节数组的地址；它可以发出代码来快速计算buf[x]运行时的地址。在使用强制转换将对象转换为 Viper 原生类型的情况下，这些应该在函数开始时执行，而不是在关键的计时循环中执行，因为强制转换操作可能需要几微秒。铸造规则如下：

• 铸造运营商目前： int, bool, uint, ptr, ptr8, ptr16 和 ptr32.

• 转换的结果将是一个本地 Viper 变量。

• 强制转换的参数可以是 Python 对象或本机 Viper 变量。

• 如果参数是一个本地 Viper 变量，那么 cast 是一个无操作（即在运行时没有任何成本），它只是更改类型（例如 从uint到ptr8），以便您可以使用此指针存储/加载。

• 如果参数是 Python 对象并且强制转换为int 或 uint，则 Python 对象必须是整数类型并返回该整数对象的值。

• bool 类型转换的参数必须是整型（boolean 或 integer）；当用作返回类型时，viper 函数将返回 True 或 False 对象。

• 如果参数是 Python 对象并且强制转换是ptr, ptr, ptr16 或ptr32，则 Python 对象必须具有缓冲区协议（在这种情况下返回指向缓冲区开头的指针）或者它必须是整数类型（其中如果返回该整数对象的值）。

  
  

写入指向只读对象的指针将导致未定义的行为。

以下示例说明了如何使用 ptr16强制转换来切换引脚 X1n 次：

1. BIT0 = const(1)
   / m! A4 e* ?& o! _1 Y9 O8 q
2. @micropython.viper
   
3. def toggle_n(n: int):
   
4.     odr = ptr16(stm.GPIOA + stm.GPIO_ODR)
   
5.     for _ in range(n):
   
6.         odr[0] ^= BIT0

复制代码

1 Y2 i& x) g  ?/ _' i4 ]

$ _& {2 K: z9 ?0 v2 u0 c" u7 f

三个代码发射器的详细技术说明可以在 Kickstarter 上找到这里Note 1 和这里 Note 2

; R- K# t, G7 M2 K  E直接访问硬件

笔记

本节中的代码示例是针对 Pyboard 给出的。然而，所描述的技术也可以应用于其他 MicroPython 端口。

% M# o1 h$ @. s

这属于更高级的编程范畴，涉及目标 MCU 的一些知识。考虑在 Pyboard 上切换输出引脚的示例。标准的方法是写

mypin.value(mypin.value() ^ 1) # mypin was instantiated as an output pin
+ |3 ]8 e/ x4 @7 X! V) |: A
4 P4 t" U2 Y- V; |, }* x: G

这涉及对Pin实例 value() 方法的两次调用的开销。通过对芯片的 GPIO 端口输出数据寄存器 (odr) 的相关位执行读/写操作，可以消除这种开销。为方便起见，该stm 模块提供了一组常量，提供相关寄存器的地址。引脚 P4（CPU 引脚A14）的快速切换- 对应于绿色 LED - 可以执行如下：

1. import machine
   9 ?# |* X5 h, ~/ C' q- A
2. import stm
   5 X7 }  P* S# C4 ]2 e1 }; S: u) k
3. 
   " `/ A, K& ?! w/ @7 g) A
4. BIT14 = const(1 << 14)
   
5. machine.mem16[stm.GPIOA + stm.GPIO_ODR] ^= BIT14

复制代码

ChinaPaype

I well understand it. I can help with the question decision. Together we can find the decision.

ChinaPaype

It is rather valuable piece

ChinaPaype

It is remarkable, rather amusing information

ChinaPaype

It agree, this remarkable opinion

ChinaPaype

the excellent message

ChinaPaype

I think, that you are not right. I am assured. I can defend the position.

DavidLop

You have hit the mark. It seems to me it is very good thought. Completely with you I will agree.

Ameliagor

Ideal variant

TatyalGeree

Absolutely with you it agree. In it something is also to me it seems it is very excellent idea. Completely with you I will agree.