Flutter 实现StackAllocator简化FFI局部变量的内存管理

---

前言

使用Flutter通过FFI调用c库的时候，经常需要传字符串或者一些指针变量，这里变量通常都是局部变量，在一个代码块运行完成后就不需要了，我们通常用calloc进行内存申请和释放，但这也带来了一个麻烦，每个变量都需要单独释放，且字符串必须用变量进行释放，不能直接使用字面量作为参数，否则就内存泄漏了。本文提供一种针对上述问题的简化操作。

---

一、为何简化？

1、通常做法

错误用法，下列用法会导致内存泄漏，在此表述用于明确简化的意义。

av_dict_set(opts, "rtsp_transport".toNativeUtf8().cast(),"tcp".toNativeUtf8().cast(), 0);

正确用法如下，变量多的时候，每个都要去释放是很麻的。

//对需要的变量进行内存申请
final key = "rtsp_transport".toNativeUtf8(allocator: calloc);
final value = "tcp".toNativeUtf8(allocator: calloc);
final a=calloc.allocate<A>(sizeOf<A>());
final b=calloc.allocate<B>(sizeOf<B>());
final c=calloc.allocate<C>(sizeOf<C>());
ffiTestA(a.ref);
ffiTestB(b.ref);
ffiTestC(c.ref);
av_dict_set(opts, key.cast(), value.cast(), 0);
//每个变量都需要变量进行内存释放
calloc.free(key);
calloc.free(value);
calloc.free(a);
calloc.free(b);
calloc.free(c);

2、简化

我们实现一个Allocator，用于局部的内存管理，就可以省去每个变量内存释放这个步骤。salloc是一个用于管理局部变量的Allocator。

//push表明入栈，可以理解为栈内存开始
salloc.push();
final a=salloc.allocate(sizeOf<A>());
final b=salloc.allocate(sizeOf<B>());
final c=salloc.allocate<C>(sizeOf<C>());
av_dict_set(opts, "rtsp_transport".toNativeUtf8(allocator: salloc).cast(),"tcp".toNativeUtf8(allocator: salloc).cast(), 0);
ffiTestA(a.ref);
ffiTestB(a.ref);
ffiTestC(a.ref);
//pop表明出栈，可以理解为栈内存结束（释放）
salloc.pop();

---

二、完整代码

stack_allocator.dart

import 'dart:ffi'; // For FFI
import 'package:ffi/ffi.dart';

class StackAllocator implements Allocator {
  final List<List<Pointer>> _stacks = [];
  void push() {
    _stacks.add([]);
  }

  void pop() {
    final stack = _stacks.removeLast();
    for (final i in stack) {
      calloc.free(i);
    }
  }

  @override
  Pointer<T> allocate<T extends NativeType>(int byteCount, {int? alignment}) {
    final pointer = calloc.allocate<T>(byteCount, alignment: alignment);
    _stacks.last.add(pointer);
    return pointer;
  }

  @override
  void free(Pointer<NativeType> pointer) {
    _stacks.last.remove(pointer);
    calloc.free(pointer);
  }
}
///栈内使用的Allocator
///salloc.push后期间所有“栈变量”内存申请都通过此对象,salloc.pop释放salloc.push后的所有内存。支持递归嵌套。
///salloc.push和salloc.pop必须成对出现。
StackAllocator salloc = StackAllocator();

---

三、使用示例

1、局部内存管理

void test() {
  //push表明入栈，可以理解为栈内存开始
  salloc.push();
  try {
   //期间的局部变量都通过salloc申请。
    final a = salloc.allocate(sizeOf<A>());
    final b = salloc.allocate(sizeOf<B>());
    final c = salloc.allocate<C>(sizeOf<C>());
    av_dict_set(opts, "rtsp_transport".toNativeUtf8(allocator: salloc).cast(),
        "tcp".toNativeUtf8(allocator: salloc).cast(), 0);
    ffiTestA(a.ref);
    ffiTestB(a.ref);
    ffiTestC(a.ref);
  } finally {
    //pop表明出栈，可以理解为栈内存结束（释放）,在finally确保函数结束一定会调用此方法。
    salloc.pop();
  }
}

2、支持嵌套

void test() {
  //push表明入栈，可以理解为栈内存开始
  salloc.push();
  try {
   //期间的局部变量都通过salloc申请。
    final a = salloc.allocate(sizeOf<A>());
    final b = salloc.allocate(sizeOf<B>());
    final c = salloc.allocate<C>(sizeOf<C>());
    av_dict_set(opts, "rtsp_transport".toNativeUtf8(allocator: salloc).cast(),
        "tcp".toNativeUtf8(allocator: salloc).cast(), 0);
    ffiTestA(a.ref);
    ffiTestB(a.ref);
    ffiTestC(a.ref);
    //支持嵌套，在下列范围内的内存，用完后立刻释放。
    salloc.push();
     av_dict_set(opts, "stimeout".toNativeUtf8(allocator: salloc).cast(),
        "5000000".toNativeUtf8(allocator: salloc).cast(), 0);
    salloc.pop();   
  } finally {
    //pop表明出栈，可以理解为栈内存结束（释放）,在finally确保函数结束一定会调用此方法。
    salloc.pop();
  }
}

---

总结

以上就是今天要讲的内容，本文实现StackAllocator主要目的还是在于方便使用，尤其是与ffi的交互有大量的局部变量时，内存释放是非常繁琐的，而且也不能使用字符串的字面量，导致可读性也降低。有了StackAllocator就可以一定程度的解决这些问题，当然其实最好的方法是能实现真正的栈变量，不需要额外操作就能跟随函数一起释放，但笔者目前还没有找到很好的方式去实现。