pal_memory.c

00001 /*******************************************************************************
00002  * Copyright 2016, 2017 ARM Ltd.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  *******************************************************************************/
00016 /*
00017  * pal_memory.c
00018  *
00019  *  Created on: Jun 26, 2017
00020  *      Author: pal
00021  */
00022 
00023 #ifndef PAL_MEMORY_PRINT_DATA
00024     #define PAL_MEMORY_PRINT_DATA   0
00025 #endif
00026 
00027 #ifndef PAL_MEMORY_BUCKET
00028     #define PAL_MEMORY_BUCKET       0
00029 #endif
00030 
00031 #ifdef PAL_MEMORY_STATISTICS
00032 #include "stdio.h"
00033 #include "mbed-trace/mbed_trace.h"
00034 
00035 #define TRACE_GROUP "PAL_MEMORY"
00036 
00037 #ifdef PAL_MEMORY_BUCKET
00038 
00039 #define SMALL_BUCKET    32
00040 #define LARGE_BUCKET    4096
00041 
00042 typedef enum _memoryBucketSizes
00043 {
00044     PAL_BUCKET_SIZE_32 = 0,
00045     PAL_BUCKET_SIZE_64,
00046     PAL_BUCKET_SIZE_128,
00047     PAL_BUCKET_SIZE_256,
00048     PAL_BUCKET_SIZE_512,
00049     PAL_BUCKET_SIZE_1024,
00050     PAL_BUCKET_SIZE_2048,
00051     PAL_BUCKET_SIZE_4096,
00052     PAL_BUCKET_SIZE_LARGE,
00053     PAL_BUCKET_NUMBER
00054 }memoryBucketSizes;
00055 
00056 typedef struct _memoryAllocationData
00057 {
00058     int32_t totalsize;
00059     int32_t waterMark;
00060     int32_t buckets[PAL_BUCKET_NUMBER];
00061     int32_t waterMarkBuckets[PAL_BUCKET_NUMBER];
00062 }memoryAllocationData;
00063 
00064 static memoryAllocationData memoryStats = {0};
00065 
00066 
00067 static inline memoryBucketSizes getBucketNumber(size_t size)
00068 {
00069     if (size <= SMALL_BUCKET)
00070     {
00071         return PAL_BUCKET_SIZE_32;
00072     }
00073     if (size >= LARGE_BUCKET)
00074     {
00075         return PAL_BUCKET_SIZE_LARGE;
00076     }
00077 
00078     uint8_t bucket = 1;
00079     uint32_t power = 64; // Starting with 32
00080     while (power < size)
00081     {
00082         bucket++;
00083         power*=2;
00084     }
00085     return bucket;
00086 }
00087 #endif //PAL_MEMORY_BUCKET
00088 
00089 
00090 void* __wrap_malloc(size_t c)
00091 {
00092     void *ptr  = NULL;
00093 #ifdef PAL_MEMORY_BUCKET
00094     ptr = __real_malloc(c + sizeof(size_t) + sizeof(size_t));
00095     if (ptr == NULL)
00096     {
00097         return NULL;
00098     }
00099      int32_t currentTotal = pal_osAtomicIncrement((&memoryStats.totalsize),c);
00100     if (currentTotal > memoryStats.waterMark)
00101     {
00102         memoryStats.waterMark = currentTotal; // need to make this thread safe
00103     }
00104 
00105     *(size_t*)ptr = c;
00106     ptr = ((size_t*)ptr+1);
00107     *(size_t*)ptr = (size_t)getBucketNumber(c);
00108      int32_t currentBucketTotal = pal_osAtomicIncrement(&(memoryStats.buckets[*(size_t*)ptr]),1);
00109     if (memoryStats.waterMarkBuckets[*(size_t*)ptr] < currentBucketTotal)
00110     {
00111         memoryStats.waterMarkBuckets[*(size_t*)ptr] = currentBucketTotal;
00112     }
00113     ptr = ((size_t*)ptr + 1);
00114 #else
00115     ptr = __real_malloc(c);
00116 #endif
00117 
00118 #if PAL_MEMORY_PRINT_DATA
00119 #ifdef __LINUX__
00120     printf("malloc: ptr - %p, size - %d\n\r",ptr,c);
00121 #else
00122     tr_info("malloc: ptr - %p, size - %d\n\r",ptr,c);
00123 #endif//LINUX
00124 
00125 #endif
00126     return ptr;
00127 }
00128 
00129 
00130 void __wrap_free(void* ptr)
00131 {
00132     if (NULL == ptr)
00133     {
00134         return;
00135     }
00136 #if PAL_MEMORY_PRINT_DATA
00137 #ifdef __LINUX__
00138     printf("free: ptr - %p\n\r",ptr);
00139 #endif
00140 #endif
00141 
00142 #ifdef PAL_MEMORY_BUCKET
00143     ptr = ((size_t*)ptr-1);
00144     pal_osAtomicIncrement(&(memoryStats.buckets[*(size_t*)ptr]),-1);
00145     ptr = ((size_t*)ptr-1);
00146     pal_osAtomicIncrement((&memoryStats.totalsize),-1*(*(size_t*)ptr));
00147 #endif
00148 
00149 
00150 
00151     __real_free(ptr);
00152 
00153 }
00154 
00155 
00156 void* __wrap_calloc(size_t num, size_t size)
00157 {
00158     void* ptr = __wrap_malloc(num*size);
00159     if (NULL != ptr)
00160     {
00161         memset(ptr,0,(num*size));
00162     }
00163     return (ptr);
00164 }
00165 
00166 
00167 
00168 void printMemoryStats(void)
00169 {
00170 #ifdef PAL_MEMORY_BUCKET
00171     tr_info("\n*******************************************************\r\n");
00172     tr_info("water mark size = %ld\r\n",memoryStats.waterMark);
00173     tr_info("total size = %ld\r\n",memoryStats.totalsize);
00174     tr_info("bucket 32    allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_32]);
00175     tr_info("bucket 64    allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_64]);
00176     tr_info("bucket 128   allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_128]);
00177     tr_info("bucket 258   allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_256]);
00178     tr_info("bucket 512   allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_512]);
00179     tr_info("bucket 1024  allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_1024]);
00180     tr_info("bucket 2048  allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_2048]);
00181     tr_info("bucket 4096  allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_4096]);
00182     tr_info("bucket large allocation number %ld\r\n",memoryStats.buckets[PAL_BUCKET_SIZE_LARGE]);
00183 
00184     tr_info("water mark bucket 32    allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_32]);
00185     tr_info("water mark bucket 64    allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_64]);
00186     tr_info("water mark bucket 128   allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_128]);
00187     tr_info("water mark bucket 256   allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_256]);
00188     tr_info("water mark bucket 512   allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_512]);
00189     tr_info("water mark bucket 1024  allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_1024]);
00190     tr_info("water mark bucket 2048  allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_2048]);
00191     tr_info("water mark bucket 4096  allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_4096]);
00192     tr_info("water mark bucket large allocation number %ld\r\n",memoryStats.waterMarkBuckets[PAL_BUCKET_SIZE_LARGE]);
00193     tr_info("*******************************************************\r\n");
00194 #endif
00195 
00196 }
00197 #endif