Multiprocess by Using Android NDK SharedMemory.h

Issue

I keep trying Multi Processing (using Shared Memory) in Android Studio (With NDK). I installed NDK, LLDB, CMake. Also I use API Level 26 and min SDK is also 26 (OREO, 8.0).

I created native_lib.cpp, and making some files for testing FD.

I made simple small class for testing .

Class has int FileDescriptor, char* buffer.

I checked variables and it seems like made succesfully. ASharedMemory_Create() returns fd, and i can get size of memory from ASharedMemory_getSize(int fd).

But how can i access shared memory from another process? Am i need to use java for IPC? If i can i want to use native only. Currently java is only for UI.

https://developer.android.com/ndk/reference/group/memory

I checekd here. If there are something that worth i can refer please let me know. Thank you.

Edited---------------------------------------------------

I want to make shared memory in both of parent and child. Also want to access shared memory freely. Child to child, child to parents, parents to child.

Making File Descriptor and buffer in parents works smoothly, but when i try to make buffer or fd in child, i cant access it.

I used same name and size for ASharedMemory_create, but other process making different File descriptor in my opinion. Don't know whats wrong.

Below is my native_lib.cpp for testing. Functions matched with Buttons except Init. Init called onCreate.

int fd[4];
char* buffer[4];

int myFd;
int* cBuf;

const char* names[4] = {"Test", "Inter", "Process", "Mech"};
const int size = 512;

extern "C" JNIEXPORT void JNICALL
Java_org_techtwon_multipro_MainActivity_SyncBuffer(
        JNIEnv *env,
        jobject /* this */) {
    int cVal;
    memcpy(&cVal, cBuf, sizeof(int));

    for(int i = 0 ; i < cVal; ++i)
    {
        if(fd[i] != NULL) {
            buffer[i] = (char *) mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd[i], 0);
        }
    }
}

extern "C" JNIEXPORT void JNICALL
Java_org_techtwon_multipro_MainActivity_MakeFileDesc(
        JNIEnv *env,
        jobject /* this */) {

    pid_t pid = fork();
    int cVal;

    if(pid < 0) {
        return;
    } else if(pid == 0) {
        memcpy(&cVal, cBuf, sizeof(int));

        fd[cVal] = ASharedMemory_create(names[cVal], size);
        buffer[cVal] = (char*) mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd[cVal], 0);

        memset(buffer[cVal], 0, size);
        memcpy(buffer[cVal], names[cVal], strlen(names[cVal]));

        cVal++;
        memcpy(cBuf, &cVal, sizeof(int));

        sleep(1);
        exit(1);
    }
}

extern "C" JNIEXPORT void JNICALL
Java_org_techtwon_multipro_MainActivity_Init(
        JNIEnv *env,
        jobject /* this */) {
    myFd = ASharedMemory_create("Num", sizeof(int));
    cBuf = (int*) mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED, myFd, 0);

    for(int i = 0 ; i < 4; ++i) fd[i] = ASharedMemory_create(names[i], size);

    buffer[0] = (char*) mmap(NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_SHARED, fd[0], 0);
    memcpy(buffer[0], names[0], strlen(names[0]));

    memset(cBuf, 0, sizeof(int));
}

extern "C" JNIEXPORT jint JNICALL
Java_org_techtwon_multipro_MainActivity_GetFd(
        JNIEnv *env,
        jobject /* this */, jint idx) {
    return fd[idx];
}

extern "C" JNIEXPORT jbyteArray JNICALL
Java_org_techtwon_multipro_MainActivity_GetBuffer(
        JNIEnv *env,
        jobject /* this */, jint idx) {

    jbyteArray tmp = (*env).NewByteArray(strlen(buffer[idx]));

    env->SetByteArrayRegion(tmp, 0, strlen(buffer[idx]), (jbyte*) buffer[idx]);

    return tmp;
}

extern "C" JNIEXPORT jint JNICALL
Java_org_techtwon_multipro_MainActivity_GetcVal(
        JNIEnv *env,
        jobject /* this */, jint idx) {

    int cVal;
    memcpy(&cVal, cBuf, sizeof(int));

    return cVal;
}

Solution

The code snippet in official docs has it quite clear:

int fd = ASharedMemory_create("memory", 128);

// By default it has PROT_READ | PROT_WRITE | PROT_EXEC.
char *buffer = (char *) mmap(NULL, 128, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

strcpy(buffer, "This is an example."); // trivially initialize content

// limit access to read only
ASharedMemory_setProt(fd, PROT_READ);

// share fd with another process here and the other process can only map with PROT_READ.

The name has no meaning, only helpful for debugging. The size should match.

This is the API you should use for API 29 and higher, the old ways (below) don't work anymore.

If you need also to cover devices below API 26, you need a fallback that makes direct IOCTLs to /dev/ashmem file descriptors. This was available since Android early days:

#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <linux/ashmem.h>

int fd = open("/dev/ashmem", O_RDWR);

ioctl(fd, ASHMEM_SET_NAME, "memory");
ioctl(fd, ASHMEM_SET_SIZE, 128);

char *buffer = (char * ) mmap(NULL, 128, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

There even is a nice example of wrapping this shared memory for use in Java: ANDROID – CREATING SHARED MEMORY USING ASHMEM.

Answered By - Alex Cohn