android/AndroidShmServer/test/shmservicetest.cpp

   1 #include "../../IAndroidShm.h"
   2 #include <binder/MemoryHeapBase.h>
   3 #include <binder/IServiceManager.h>
   4
   5 namespace android {
   6
   7 static sp<IMemoryHeap> receiverMemBase;
   8 #define MAX_SHARED_MEMORY_COUNT 257
   9
  10 sp<IAndroidShm> getAndroidShmService() {
  11     sp<IAndroidShm> shm = 0;
  12
  13     /* Get the buffer service */
  14     if (shm == NULL) {
  15         sp<IServiceManager> sm = defaultServiceManager();
  16         sp<IBinder> binder;
  17         binder = sm->getService(String16("com.samsung.android.jam.IAndroidShm"));
  18         if (binder != 0) {
  19             shm = IAndroidShm::asInterface(binder);
  20             //shm = interface_cast<IAndroidShm>(binder);
  21         }
  22     }
  23     return shm;
  24 }
  25
  26 unsigned int * getBufferMemPointer(int index) {
  27     sp<IAndroidShm> shm = getAndroidShmService();
  28     if (shm == NULL) {
  29         ALOGE("The EneaBufferServer is not published");
  30         return (unsigned int *)-1; /* return an errorcode... */
  31     } else {
  32         receiverMemBase = shm->getBuffer(index);
  33         if(receiverMemBase != NULL)
  34             return (unsigned int *) receiverMemBase->getBase();
  35         else
  36             return (unsigned int*)-1;
  37     }
  38 }
  39
  40 }
  41
  42 using namespace android;
  43
  44 void setup_test() {
  45     sp<IAndroidShm> shm = getAndroidShmService();
  46     if(shm == NULL) return;
  47     for(int i = 0; i < MAX_SHARED_MEMORY_COUNT; i++) {
  48         shm->removeShm(i);
  49     }
  50 }
  51
  52 void teardown_test() {
  53 }
  54
  55 void increase_value_once() {
  56     ALOGD("*****test: increase_value_once*****\n");
  57     sp<IAndroidShm> shm = getAndroidShmService();
  58     if(shm == NULL) return;
  59
  60     int slot = shm->allocShm(10000);
  61     unsigned int *base = getBufferMemPointer(slot);
  62     if(base != (unsigned int *)-1) {
  63         ALOGD("ShmServiceTest base=%p Data=0x%x\n",base, *base);
  64         *base = (*base)+1;
  65         ALOGD("ShmServiceTest base=%p Data=0x%x CHANGED\n",base, *base);
  66         //receiverMemBase = 0;
  67     } else {
  68         ALOGE("Error shared memory not available\n");
  69     }
  70 }
  71
  72 void increase_value_10times() {
  73     ALOGD("*****test: increase_value_10times*****\n");
  74     sp<IAndroidShm> shm = getAndroidShmService();
  75     if(shm == NULL) return;
  76
  77     int slot = shm->allocShm(10000);
  78
  79     for(int i = 0; i < 10; i++) {
  80         unsigned int *base = getBufferMemPointer(slot);
  81         if(base != (unsigned int *)-1) {
  82             ALOGD("ShmServiceTest base=%p Data=0x%x\n",base, *base);
  83             *base = (*base)+1;
  84             ALOGD("ShmServiceTest base=%p Data=0x%x CHANGED\n",base, *base);
  85             //receiverMemBase = 0;
  86         } else {
  87             ALOGE("Error shared memory not available\n");
  88         }
  89     }
  90 }
  91
  92 void check_allocated() {
  93     ALOGD("*****test: check_allocated*****\n");
  94     sp<IAndroidShm> shm = getAndroidShmService();
  95     if(shm == NULL) return;
  96
  97     int slot = shm->allocShm(10000);
  98     int i = 0;
  99     for(; i < MAX_SHARED_MEMORY_COUNT; i++) {
 100         if(slot == i) {
 101             if(shm->isAllocated(i) == 1) {
 102             //ALOGD("pass\n");
 103             } else {
 104             ALOGD("failed\n");
 105             }
 106         } else {
 107             if(shm->isAllocated(i) == 0) {
 108                 //ALOGD("pass\n");
 109             } else {
 110                 ALOGD("failed\n");
 111             }
 112         }
 113     }
 114
 115     if(i == MAX_SHARED_MEMORY_COUNT) {
 116         ALOGD("pass\n");
 117     }
 118 }
 119
 120 void test_set_get_registry_index() {
 121     ALOGD("*****test: test_set_get_registry_index*****\n");
 122     sp<IAndroidShm> shm = getAndroidShmService();
 123     if(shm == NULL) return;
 124
 125     int registry = 1;
 126     shm->setRegistryIndex(registry);
 127     if(registry == shm->getRegistryIndex()) {
 128         ALOGD("pass\n");
 129     } else {
 130         ALOGD("fail\n");
 131     }
 132
 133     registry = 0;
 134     shm->setRegistryIndex(registry);
 135     if(registry == shm->getRegistryIndex()) {
 136         ALOGD("pass\n");
 137     } else {
 138         ALOGD("fail\n");
 139     }
 140 }
 141
 142 void test_memset() {
 143     ALOGD("*****test: test_memset*****\n");
 144     sp<IAndroidShm> shm = getAndroidShmService();
 145     if(shm == NULL)  return;
 146
 147     int slot = shm->allocShm(10000);
 148
 149     unsigned int * pnt = getBufferMemPointer(slot);
 150
 151     memset (pnt, 0, 10000);
 152
 153     ALOGD("result : 0 0 0 0\n");
 154     ALOGD("memory dump : %d %d %d %d\n", pnt[0], pnt[1], pnt[2], pnt[3]);
 155
 156     memset (pnt, 0xffffffff, 10000);
 157
 158     ALOGD("result : -1 -1 -1 -1\n");
 159     ALOGD("memory dump : %d %d %d %d", pnt[0], pnt[1], pnt[2], pnt[3]);
 160 }
 161
 162 int main(int argc, char** argv) {
 163     // base could be on same address as Servers base but this
 164     // is purely by luck do NEVER rely on this. Linux memory
 165     // management may put it wherever it likes.
 166
 167     setup_test();
 168     increase_value_once();
 169     teardown_test();
 170
 171     setup_test();
 172     increase_value_10times();
 173     teardown_test();
 174
 175     setup_test();
 176     check_allocated();
 177     teardown_test();
 178
 179     setup_test();
 180     test_set_get_registry_index();
 181     teardown_test();
 182
 183     setup_test();
 184     test_memset();
 185     teardown_test();
 186
 187     return 0;
 188 }
 189