Gralloc图形缓冲的分配过程

首先帮我朋友打个广告我们一起在运营一个视频号感兴趣的可以帮忙点击右边这个小铃铛铃铛

序

其实越往底下走在很多人嘴里就会变得很玄乎，变得不可思议，这里的gralloc就是一个native service，只是分装了一些调用接口，上层只是利用这些平台提供的接口组织业务场景而已，本质的来说完全可以把 ps -A | grep hardware 所有进程看成一个后台app即可，例如xxxcomposexxx等等，在我看来Android就是由一个一个app组织起来的

还是那句话，逆水行舟不进则退，我是发现00后的同事质素越来越高了

如有小伙伴需要笔者可提供所有原材料供二次编辑 whsgzcy@foxmail.com

本文阐述的预期

1.只做对架构理解上的辅助case

一、从一个架构图开始

Gralloc 图形缓冲是一段保存图形数据的内存，这是一段共享的内存，Fence机制释放也是大多数都是通过memcpXXX等c++函数完成，也就是把指针重新指向一个地址，在Android系统中，Gralloc负责分配图形缓冲，也就是你要什么样的Buffer在此会给你申请一段Buffer，他是由一个结构体描述出来的，也就是我们通常看到的GraphicBuffer，并在业务层用数据组织起来，业务场景中再包裹一个结构体并按照需要设置为FREE、DEQUEUED、QUEUED、ACQUIRED、FREE等等

Gralloc是一个独立的进程，native service，hal的接口是

/hardware/interfaces/graphics/allocator/2.0/IAllocator.hal
/**
...
28      * @param descriptor Properties of the buffers to allocate. This must be
29      *     obtained from IMapper::createDescriptor().
...
42     allocate(BufferDescriptor descriptor, uint32_t count)
43         generates (Error error,
44                    uint32_t stride,
45                    vec<handle> buffers);

第一个参数descriptor 包含了缓冲layer的宽、高等其他格式参数，第二个是申请的个数，申请成功后图形缓冲以handle的格式返回

IAllocator 创建在 HIDL_FETCH_IAllocator

/hardware/interfaces/graphics/mapper/2.0/default/passthrough.cpp#include <android/hardware/graphics/mapper/2.0/IMapper.h>
17  #include <mapper-passthrough/2.0/GrallocLoader.h>
18  
19  using android::hardware::graphics::mapper::V2_0::IMapper;
20  using android::hardware::graphics::mapper::V2_0::passthrough::GrallocLoader;
21  
22  extern "C" IMapper* HIDL_FETCH_IMapper(const char* /*name*/) {
23      return GrallocLoader::load();
24  }/hardware/interfaces/graphics/allocator/2.0/utils/passthrough/include/allocator-passthrough/2.0/GrallocLoader.h
39  class GrallocLoader {
40     public:
41      static IAllocator* load() {
42          const hw_module_t* module = loadModule();
43          if (!module) {
44              return nullptr;
45          }
46          auto hal = createHal(module);
47          if (!hal) {
48              return nullptr;
49          }
50          return createAllocator(std::move(hal));
51      }// load the gralloc module
54      static const hw_module_t* loadModule() {
55          const hw_module_t* module;
56          int error = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
57          if (error) {
58              ALOGE("failed to get gralloc module");
59              return nullptr;
60          }
61  
62          return module;
63      }

加载loadModule id为GRALLOC_HARDWARE_MODULE_ID对象，createHal适配层可获取设备抽象出的对象，收到缓冲请求后再交给设备对象处理，创建IAllocator在createAllocator中创建AllocatorImpl，该对象收到请求后交给适配层对象处理

启动Gralloc服务

/hardware/interfaces/graphics/allocator/2.0/default/service.cppusing android::hardware::defaultPassthroughServiceImplementation;
24  using android::hardware::graphics::allocator::V2_0::IAllocator;
25  
26  int main() {
27      return defaultPassthroughServiceImplementation<IAllocator>(4);
28  }
29

上述代码不是很多，接下来分析分配图形缓冲流程

/frameworks/native/libs/ui/Gralloc2.cppGralloc2Allocator::Gralloc2Allocator(const Gralloc2Mapper& mapper) : mMapper(mapper) {
364      mAllocator = IAllocator::getService();
365      if (mAllocator == nullptr) {
366          ALOGW("allocator 2.x is not supported");
367          return;
368      }
369  }5  status_t Gralloc2Allocator::allocate(std::string /*requestorName*/, uint32_t width, uint32_t height,
386                                       PixelFormat format, uint32_t layerCount, uint64_t usage,
387                                       uint32_t bufferCount, uint32_t* outStride,
388                                       buffer_handle_t* outBufferHandles, bool importBuffers) const {
389      IMapper::BufferDescriptorInfo descriptorInfo = {};
390      descriptorInfo.width = width;
391      descriptorInfo.height = height;
392      descriptorInfo.layerCount = layerCount;
393      descriptorInfo.format = static_cast<hardware::graphics::common::V1_1::PixelFormat>(format);
394      descriptorInfo.usage = usage;
395  
396      BufferDescriptor descriptor;
397      status_t error = mMapper.createDescriptor(static_cast<void*>(&descriptorInfo),
398                                                static_cast<void*>(&descriptor));
399      if (error != NO_ERROR) {
400          return error;
401      }
402  
403      auto ret = mAllocator->allocate(descriptor, bufferCount,
404                                      [&](const auto& tmpError, const auto& tmpStride,
405                                          const auto& tmpBuffers) {
406                                          error = static_cast<status_t>(tmpError);
407                                          if (tmpError != Error::NONE) {
408                                              return;
409                                          }
410  
411                                          if (importBuffers) {
412                                              for (uint32_t i = 0; i < bufferCount; i++) {
413                                                  error = mMapper.importBuffer(tmpBuffers[i],
414                                                                               &outBufferHandles[i]);
415                                                  if (error != NO_ERROR) {
416                                                      for (uint32_t j = 0; j < i; j++) {
417                                                          mMapper.freeBuffer(outBufferHandles[j]);
418                                                          outBufferHandles[j] = nullptr;
419                                                      }
420                                                      return;
421                                                  }
422                                              }
423                                          } else {
424                                              for (uint32_t i = 0; i < bufferCount; i++) {
425                                                  outBufferHandles[i] = native_handle_clone(
426                                                          tmpBuffers[i].getNativeHandle());
427                                                  if (!outBufferHandles[i]) {
428                                                      for (uint32_t j = 0; j < i; j++) {
429                                                          auto buffer = const_cast<native_handle_t*>(
430                                                                  outBufferHandles[j]);
431                                                          native_handle_close(buffer);
432                                                          native_handle_delete(buffer);
433                                                          outBufferHandles[j] = nullptr;
434                                                      }
435                                                  }
436                                              }
437                                          }
438                                          *outStride = tmpStride;
439                                      });
440  
441      // make sure the kernel driver sees BC_FREE_BUFFER and closes the fds now
442      hardware::IPCThreadState::self()->flushCommands();
443  
444      return (ret.isOk()) ? error : static_cast<status_t>(kTransactionError);

这里主要是allocate成功之后将句柄通过outBufferHandles返回调用者，AllocatorImpl收到请求后转到适配层调用gralloc_alloc_buffer

/hardware/libhardware/modules/gralloc/gralloc.cpp
167  static int gralloc_alloc_buffer(alloc_device_t* dev,
168          size_t size, int /*usage*/, buffer_handle_t* pHandle)
169  {
170      int err = 0;
171      int fd = -1;
172  
173      size = roundUpToPageSize(size);
174  
175      fd = ashmem_create_region("gralloc-buffer", size);
176      if (fd < 0) {
177          ALOGE("couldn't create ashmem (%s)", strerror(-errno));
178          err = -errno;
179      }
180  
181      if (err == 0) {
182          private_handle_t* hnd = new private_handle_t(fd, size, 0);
183          gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
184                  dev->common.module);
185          err = mapBuffer(module, hnd);
186          if (err == 0) {
187              *pHandle = hnd;
188          }
189      }
190  
191      ALOGE_IF(err, "gralloc failed err=%s", strerror(-err));
192  
193      return err;
194  }

通过ashmem_create_region分配内存，得到文件描述符，客户进程拿到文件描述符通过mmap操作得到缓冲区地址

图形显示系统缓存图形数据是用GraphicBuffer表示

/frameworks/native/libs/nativebase/include/nativebase/nativebase.h
typedef struct ANativeWindowBuffer
67  {
68  #ifdef __cplusplus
69      ANativeWindowBuffer() {
70          common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
71          common.version = sizeof(ANativeWindowBuffer);
72          memset(common.reserved, 0, sizeof(common.reserved));
73      }
74  
75      // Implement the methods that sp<ANativeWindowBuffer> expects so that it
76      // can be used to automatically refcount ANativeWindowBuffer's.
77      void incStrong(const void* /*id*/) const {
78          common.incRef(const_cast<android_native_base_t*>(&common));
79      }
80      void decStrong(const void* /*id*/) const {
81          common.decRef(const_cast<android_native_base_t*>(&common));
82      }
83  #endif
84  
85      struct android_native_base_t common;
86  
87      int width;
88      int height;
89      int stride;
90      int format;
91      int usage_deprecated;
92      uintptr_t layerCount;
93  
94      void* reserved[1];
95  
96      const native_handle_t* handle;
97      uint64_t usage;
98  
99      // we needed extra space for storing the 64-bits usage flags
100      // the number of slots to use from reserved_proc depends on the
101      // architecture.
102      void* reserved_proc[8 - (sizeof(uint64_t) / sizeof(void*))];
103  } ANativeWindowBuffer_t;
104  
/frameworks/native/libs/ui/include/ui/GraphicBuffer.h49  class GraphicBuffer
50      : public ANativeObjectBase<ANativeWindowBuffer, GraphicBuffer, RefBase>,
51        public Flattenable<GraphicBuffer>
52  {
53      friend class Flattenable<GraphicBuffer>;

GraphicBuffer继承于ANativeWindowBuffer，handle用户保存缓存对应文件描述符，创建GraphicBuffer代码如下

/frameworks/native/libs/ui/GraphicBuffer.cpp
4  GraphicBuffer::GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
85                               uint32_t inLayerCount, uint64_t inUsage, std::string requestorName)
86        : GraphicBuffer() {
87      mInitCheck = initWithSize(inWidth, inHeight, inFormat, inLayerCount, inUsage,
88                                std::move(requestorName));
89  }

申请成功后缓冲保存到handle中，使用者得到GraphicBuffer对象后需要取出地址才能保存图形数据

 status_t GraphicBuffer::unlock()
286  {
287      status_t res = getBufferMapper().unlock(handle);
288      return res;
289  }
290  
291  status_t GraphicBuffer::lockAsync(uint32_t inUsage, void** vaddr, int fenceFd,
292                                    int32_t* outBytesPerPixel, int32_t* outBytesPerStride) {
293      const Rect lockBounds(width, height);
294      status_t res =
295              lockAsync(inUsage, lockBounds, vaddr, fenceFd, outBytesPerPixel, outBytesPerStride);
296      return res;
297  }
298  
299  status_t GraphicBuffer::lockAsync(uint32_t inUsage, const Rect& rect, void** vaddr, int fenceFd,
300                                    int32_t* outBytesPerPixel, int32_t* outBytesPerStride) {
301      return lockAsync(inUsage, inUsage, rect, vaddr, fenceFd, outBytesPerPixel, outBytesPerStride);
302  }
303  
304  status_t GraphicBuffer::lockAsync(uint64_t inProducerUsage, uint64_t inConsumerUsage,
305                                    const Rect& rect, void** vaddr, int fenceFd,
306                                    int32_t* outBytesPerPixel, int32_t* outBytesPerStride) {
307      if (rect.left < 0 || rect.right  > width ||
308          rect.top  < 0 || rect.bottom > height) {
309          ALOGE("locking pixels (%d,%d,%d,%d) outside of buffer (w=%d, h=%d)",
310                  rect.left, rect.top, rect.right, rect.bottom,
311                  width, height);
312          return BAD_VALUE;
313      }
314  
315      status_t res = getBufferMapper().lockAsync(handle, inProducerUsage, inConsumerUsage, rect,
316                                                 vaddr, fenceFd, outBytesPerPixel, outBytesPerStride);
317  
318      return res;
319  }

应用程序调用lockAsync可以获取缓冲区地址，此时应用程序就可以渲染、queuebuffer操作，后续分享会继续

其实这块分配的业务比较直接，一般问题都是在上层APP，例如闪屏、卡顿等，按照我现有的经验可以排查内存是否存在泄露等