Android开发之Memory类的分析

在Android系统，由于内存空间一般比较有限，为了方便进程间共享数据，Android提供了一种匿名共享内存的机制。为了方便的使用匿名共享内存机制，系统提供了Java的调用接口MemoryFile和C++调用接口MemoryHeapBase和MemoryBase。

MemoryHeapBase:一般用于在进程间共享一个完整的匿名共享内存块

MemoryBase: 一般用于在进程间共享一个匿名共享内存块的其中一部分。

MemoryBase接口是建立在MemoryHeapBase接口的基础上实现的，他们都可以作为一个Binder对象在进程间通信。下面我们主要来分析者两个类：

所有的Binder对象都必须实现IInterface接口，无论是Service端实体对象，还是Client的引用对象，通过这个接口的asBinder成员函数我们可以获得Binder对象的IBinder接口，然后通过Binder驱动程序把它传输到另外一个进程，当一个类的对象作为Service端的实体对象时，还必须实现一个目标类BnInterface，它里面有一个重要的成员函数onTransact，当Client端引用请求Server端对象执行命令时，Binder系统会调用Bnxx类的onTransact成员函数来执行具体的命令。当一个类作为Server端实体时，它需要继承于BBinder类，这是一个实现了IBinder接口的类，它里面有一个重要的成员函数transact，当我们从Server端线程中接收到Client端的请求时，会调用注册在这个线程中的BBinder对象的transact函数，将这些请求发送给Bnxx类的onTransact成员函数。

IMemoryHeap 类主要定义几个重要的操作匿名共享内存的方法。

frameworks/base/include/binder/IMemory.h文件中：

class IMemoryHeap : public IInterface{public:    DECLARE_META_INTERFACE(MemoryHeap);    // flags returned by getFlags()    enum {        READ_ONLY   = 0x00000001    };    virtual int         getHeapID() const = 0;    virtual void*       getBase() const = 0;    virtual size_t      getSize() const = 0;    virtual uint32_t    getFlags() const = 0;    virtual uint32_t    getOffset() const = 0;    // these are there just for backward source compatibility    int32_t heapID() const { return getHeapID(); }    void*   base() const  { return getBase(); }    size_t  virtualSize() const { return getSize(); }};

其中几个纯虚的成员函数：

getHeapID() 获得匿名共享内存块的打开文件描述符

getBase() 获得匿名共享内存的基地址

getSize() 获得匿名共享内存块的大小

BnMemoryHeap 类继承于BnInterface<IMemoryHeap>

class BnMemoryHeap : public BnInterface<IMemoryHeap>{public:    virtual status_t onTransact(             uint32_t code,            const Parcel& data,            Parcel* reply,            uint32_t flags = 0);        BnMemoryHeap();protected:    virtual ~BnMemoryHeap();};

MemoryHeapBase 类主要用来实现上面的IMemoryHeap类的几个成员函数：

frameworks/base/include/binder/MemoryHeapBase.h

class MemoryHeapBase : public virtual BnMemoryHeap{public:    MemoryHeapBase(int fd, size_t size, uint32_t flags = 0, uint32_t offset = 0);    MemoryHeapBase(const char* device, size_t size = 0, uint32_t flags = 0);    MemoryHeapBase(size_t size, uint32_t flags = 0, char const* name = NULL);    virtual ~MemoryHeapBase();    /* implement IMemoryHeap interface */    virtual int         getHeapID() const;    virtual void*       getBase() const;    virtual size_t      getSize() const;    virtual uint32_t    getFlags() const;    virtual uint32_t      getOffset() const;    const char*         getDevice() const;    void dispose();    status_t setDevice(const char* device) {        if (mDevice == 0)            mDevice = device;        return mDevice ? NO_ERROR : ALREADY_EXISTS;    }protected:            MemoryHeapBase();     status_t init(int fd, void *base, int size,            int flags = 0, const char* device = NULL);private:    status_t mapfd(int fd, size_t size, uint32_t offset = 0);    int         mFD;    size_t      mSize;    void*       mBase;    uint32_t    mFlags;    const char* mDevice;    bool        mNeedUnmap;    uint32_t    mOffset;};

frameworks/base/libs/binder/MemoryHeapBase.cpp

MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name)    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),      mDevice(0), mNeedUnmap(false), mOffset(0){    const size_t pagesize = getpagesize();    size = ((size + pagesize-1) & ~(pagesize-1));    int fd = ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);    LOGE_IF(fd<0, "error creating ashmem region: %s", strerror(errno));    if (fd >= 0) {        if (mapfd(fd, size) == NO_ERROR) {            if (flags & READ_ONLY) {                ashmem_set_prot_region(fd, PROT_READ);            }        }    }}

它的构造函数具有三个参数：size表示要创建的匿名共享内存大小，flag用来设置匿名共享内存的属性，可是只读或读写，name是用来标示这个匿名共享内存的。

MemoryHeapBase类创建的匿名共享内存是以页作为单位的，页的大小一般为4k，这个函数先通过getpagesize获得系统中一页内存大小，然后把size参数对其到页大小区。如果size不是页大小的整数倍时就增加它的大小，使得它的值为页大小的整数倍。

然后就调用C接口asmem_create_region()来创建一块共享内存了。得到共享内存的文件描述符后，就需要调用mapfd函数把它映射到进程地址空间。

BpMemoryHeap类是MemoryHeapBase的远端代理，负责暴露接口给客户端

BpMemoryHeap需要实现BpInterface、BpRefBase和BpBinder类，在BpRefBase里面有一个成员变量mRemote，它指向一个BpBinder对象，当BpMemoryBase需要向Server端发送请求时，就会通过这个BpBinder对象的transact函数发出。

frameworks/base/libs/binder/IMemory.cpp：

class BpMemoryHeap : public BpInterface<IMemoryHeap>{public:    BpMemoryHeap(const sp<IBinder>& impl);    virtual ~BpMemoryHeap();    virtual int getHeapID() const;    virtual void* getBase() const;    virtual size_t getSize() const;    virtual uint32_t getFlags() const;    virtual uint32_t getOffset() const;

    static inline sp<IMemoryHeap> find_heap(const sp<IBinder>& binder) {

          return gHeapCache->find_heap(binder);

private:    friend class IMemory;    friend class HeapCache;    mutable volatile int32_t mHeapId;    mutable void*       mBase;    mutable size_t      mSize;    mutable uint32_t    mFlags;    mutable uint32_t    mOffset;    mutable bool        mRealHeap;    mutable Mutex       mLock;};

我们先看看构造函数：

BpMemoryHeap::BpMemoryHeap(const sp<IBinder>& impl)    : BpInterface<IMemoryHeap>(impl),        mHeapId(-1), mBase(MAP_FAILED), mSize(0), mFlags(0), mOffset(0), mRealHeap(false){}

注意：构造函数的参数impl指向的值一个BpBinder对象，它里面包含了一个指向Server端的Binder对象，即MemoryHeapBase对象的引用。

在frameworks/base/lib/binder/IMemory.cpp：

类HeapCache的全局变量gHeapCache：它维护着当前进程中所有的MemoryHeapBase对象的引用。

由于在Client端进程中，可能会有多个引用，即多个BpMemoryHeap对象对应同一个MemoryHeapBase对象，因此当第一个BpMemoryHeap对象在本进程中映射好这块匿名共享内存之后，后面的BpMemoryHeap对象就可以直接使用，不需要再映射一次。

class HeapCache : public IBinder::DeathRecipient{public:    HeapCache();    virtual ~HeapCache();    virtual void binderDied(const wp<IBinder>& who);    sp<IMemoryHeap> find_heap(const sp<IBinder>& binder);    void free_heap(const sp<IBinder>& binder);    sp<IMemoryHeap> get_heap(const sp<IBinder>& binder);    void dump_heaps();private:    struct heap_info_t {        sp<IMemoryHeap> heap;        int32_t         count;    };    void free_heap(const wp<IBinder>& binder);    Mutex mHeapCacheLock;    KeyedVector< wp<IBinder>, heap_info_t > mHeapCache; //维护本进程中所有的BpMemoryHeap对象

};

我们主要看下find_heap函数的实现：

sp<IMemoryHeap> HeapCache::find_heap(const sp<IBinder>& binder){    Mutex::Autolock _l(mHeapCacheLock);    ssize_t i = mHeapCache.indexOfKey(binder);    if (i>=0) {  // 当前进程中有其他的BpMemoryHeap对象存在        heap_info_t& info = mHeapCache.editValueAt(i);        LOGD_IF(VERBOSE,                "found binder=%p, heap=%p, size=%d, fd=%d, count=%d",                binder.get(), info.heap.get(),                static_cast<BpMemoryHeap*>(info.heap.get())->mSize,                static_cast<BpMemoryHeap*>(info.heap.get())->mHeapId,                info.count);        android_atomic_inc(&info.count);        return info.heap;    } else {    // 这个进程中没有其他的BpMemoryHeap对象存在，需要将这个对象添加到mHeapCache中去        heap_info_t info;        info.heap = interface_cast<IMemoryHeap>(binder);        info.count = 1;        //LOGD("adding binder=%p, heap=%p, count=%d",        //      binder.get(), info.heap.get(), info.count);        mHeapCache.add(binder, info);        return info.heap;    }}

这个函数比较简单，首先以传进来的参数binder为关键字，在mHeapCache中查找，看看是否有对应的heap_info对象Info存在，如果有的话，就直接增加它的引用计数info.count值，表示这个BpBinder对象多了一个使用值。如果没有的话，那么就需要创建一个heap_info对象info,并且加到mHeapCache中去。

我们发现在BpMemoryHeap的业务函数之前都会调用assertMapped()函数确定这个BpMemoryHeap对象中的匿名共享内存是否已经就绪。如果mHeapID为-1，表示还没有准备好，就需要执行一次映射匿名共享内存的操作。

在执行映射之前，先通过find_heap()函数查看在本进程中是否有其他映射到同一个MemoryHeapBase对象的BpMemoryHeap对象存在：

void BpMemoryHeap::assertMapped() const{    if (mHeapId == -1) {        sp<IBinder> binder(const_cast<BpMemoryHeap*>(this)->asBinder());        sp<BpMemoryHeap> heap(static_cast<BpMemoryHeap*>(find_heap(binder).get()));        heap->assertReallyMapped();        if (heap->mBase != MAP_FAILED) {  说明这个heap对象的匿名共享内存已经映射好了，有可能是别的对象映射的            Mutex::Autolock _l(mLock);            if (mHeapId == -1) {          说明正在执行assertMapped函数的BpMemoryHeap对象和前面find()查找BpMemoryHeap对象不是同一个对象，需要初始化BpMemoryHeap对象的相关变量

                mBase   = heap->mBase;                mSize   = heap->mSize;                mOffset = heap->mOffset;                android_atomic_write( dup( heap->mHeapId ), &mHeapId );            }        } else {            // something went wrong            free_heap(binder);        }    }}

然后再调用这个BpMemoryHeap对象heap->assertReallyMapped()函数确定内部的共享内存是否已经映射了。
如果mHeapId为-1.表示在Server端的MemoryHeapBase对象中的匿名共享内存还没映射到本进程中来，于是就需要一个Binder进程间调用吧Server端的MemoryHeapBase对象中的匿名共享内存信息取回来。

void BpMemoryHeap::assertReallyMapped() const{    if (mHeapId == -1) {        Parcel data, reply;        data.writeInterfaceToken(IMemoryHeap::getInterfaceDescriptor());        status_t err = remote()->transact(HEAP_ID, data, &reply);        int parcel_fd = reply.readFileDescriptor();        ssize_t size = reply.readInt32();        uint32_t flags = reply.readInt32();        uint32_t offset = reply.readInt32();        int fd = dup( parcel_fd );        int access = PROT_READ;        if (!(flags & READ_ONLY)) {            access |= PROT_WRITE;        }        Mutex::Autolock _l(mLock);        if (mHeapId == -1) {            mRealHeap = true;            mBase = mmap(0, size, access, MAP_SHARED, fd, offset);            if (mBase == MAP_FAILED) {                LOGE("cannot map BpMemoryHeap (binder=%p), size=%ld, fd=%d (%s)",                        asBinder().get(), size, fd, strerror(errno));                close(fd);            } else {                mSize = size;                mFlags = flags;                mOffset = offset;                android_atomic_write(fd, &mHeapId);            }        }    }}

取回来的信息包括文件描述符，大小以及访问属性，获得这些信息之后就可以对它进行内存映射操作了。

这样BpMemoryHeap对象的匿名共享内存就已经准备就绪了，我们可以通过使用它的mBase成员变量直接访问这块匿名共享内存了。

总结：

1）new BpMemoryHeap(sp<IBinder>& impl) 对象，调用它的成员函数获取匿名共享内存信息。

2）首先通过assertMapped()函数判断是否已经准备就绪

3）成员变量mHeapCache维持着当前进程中所有BpMemoryHeap对象的引用，进程中第一个BpMemoryHeap对象需要先映射。

4）通过binder关键字在find_heap函数中查找当前进程中是否已经有其他的BpMemoryHeap对象引用，如果有就直接增加引用计数，否则需要将本BpMemoryHeap对象引用添加到mHeapCache中。

5）调用assertReallyMapped()判断上面找到的BpMemoryHeap引用是否已经映射好内存了，如果没有需要映射。

6）判断上面find_heap找到的BpMemoryHeap对象是否和当前对象是同一个对象，如果过不是同一个对象，需要设置当前对象的mBase，mSize，mOffset， mHeapId等参数。

MemoryBase

我们知道MemoryBase是建立在MemoryHeapBase的基础上，他们都可以作为一个Binder对象在进程间数据共享。

在MemoryBase类内部包含一个成员变量sp<IMemoryHeap> mHeap，通过这个成员变量来实现匿名共享内存操作。

MemoryBase类在Server端的实现和MemoryHeapBase类在Server端的实现是类似的，只需要将IMemory类换成IMemoryHeap类，将BnMemory类换成BnMemoryHeap类，将MemoryBase类替换成MemoryHeapBase类就可以了。这里我们只见到分析IMemory和MemoryBase类：

IMemory接口

frameworks/base/include/binder/IMemory.h

class IMemory : public IInterface{public:    DECLARE_META_INTERFACE(Memory);       // 获取内部MemoryHeapBase对象的IMemoryHeap接口    virtual sp<IMemoryHeap> getMemory(ssize_t* offset=0, size_t* size=0) const = 0;         void* fastPointer(const sp<IBinder>& heap, ssize_t offset) const;     void* pointer() const; // 获取内部所维护的匿名共享内存的基地址    size_t size() const;   // 获取内部所维护的匿名共享内存的大小    ssize_t offset() const;// 获取内部所维护的匿名共享内存在整个匿名共享内存中的偏移量};

frameworks/base/libs/binder/IMemory.cpp

void* IMemory::pointer() const {    ssize_t offset;    sp<IMemoryHeap> heap = getMemory(&offset);    void* const base = heap!=0 ? heap->base() : MAP_FAILED;    if (base == MAP_FAILED)        return 0;    return static_cast<char*>(base) + offset;}

IMemory类的子类MemoryBase只需要实现getMemory成员函数就可以了。

MemoryBase实现类：

frameworks/base/include/binder/MemoryBase.h

class MemoryBase : public BnMemory {public:    MemoryBase(const sp<IMemoryHeap>& heap, ssize_t offset, size_t size);    virtual ~MemoryBase();    virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size) const;protected:    size_t getSize() const { return mSize; }    ssize_t getOffset() const { return mOffset; }    const sp<IMemoryHeap>& getHeap() const { return mHeap; }private:    size_t          mSize;    ssize_t         mOffset;    sp<IMemoryHeap> mHeap;};

定义在frameworks/base/libs/binder/MemoryBase.cpp

sp<IMemoryHeap> MemoryBase::getMemory(ssize_t* offset, size_t* size) const{    if (offset) *offset = mOffset;    if (size)   *size = mSize;    return mHeap;}

成员函数getMemory()比较简单，就是返回内部的MemoryHeapBase对象的IMemoryHeap接口。

BpMemory客户端代理类：
frameworks/base/libs/binder/IMemory.cpp

class BpMemory : public BpInterface<IMemory>{public:    BpMemory(const sp<IBinder>& impl);    virtual ~BpMemory();    virtual sp<IMemoryHeap> getMemory(ssize_t* offset=0, size_t* size=0) const;private:    mutable sp<IMemoryHeap> mHeap;    mutable ssize_t mOffset;    mutable size_t mSize;};

和MemoryBase类一样，它实现了IMemory类和getMemory成员函数，在成员变量中mHeap为sp<IMemoryHeap>类型，指向一个BpMemoryHeap对象。

sp<IMemoryHeap> BpMemory::getMemory(ssize_t* offset, size_t* size) const{    if (mHeap == 0) {        Parcel data, reply;        data.writeInterfaceToken(IMemory::getInterfaceDescriptor());        if (remote()->transact(GET_MEMORY, data, &reply) == NO_ERROR) {            sp<IBinder> heap = reply.readStrongBinder();            ssize_t o = reply.readInt32();            size_t s = reply.readInt32();            if (heap != 0) {                mHeap = interface_cast<IMemoryHeap>(heap);                if (mHeap != 0) {                    mOffset = o;                    mSize = s;                }            }        }    }    if (offset) *offset = mOffset;    if (size) *size = mSize;    return mHeap;}

如果成员变量mHeap的值为0，表示这个BpMemory对象尚未建立好匿名共享内存，于是通过Binder进程间调用去Server端请求建立匿名共享内存信息，最重要的是Server端的MemoryHeapBase对象的引用heap。通过这个引用可以在Client端进程中创建一个BpMemoryHeap远程接口，最后将这个BpMemoryHeap远程接口保存到成员变量mHeap中。

更多相关文章

随机推荐