Line data    Source code

       1              : /*
       2              :  * libpino - memory.c
       3              :  *
       4              :  * This file is part of libpino.
       5              :  *
       6              :  * Author: Go Kudo <zeriyoshi@gmail.com>
       7              :  * SPDX-License-Identifier: MIT
       8              :  */
       9              : 
      10              : #include <pino.h>
      11              : #include <pino/handler.h>
      12              : 
      13              : #include "internal/common.h"
      14              : 
      15          248 : static inline bool glow_mm(mm_t *mm, size_t step)
      16              : {
      17              :     void **ptrs;
      18              :     size_t i;
      19              : 
      20          248 :     ptrs = (void **)prealloc(mm->ptrs, (mm->capacity + step) * sizeof(void *));
      21          248 :     if (!ptrs) {
      22            0 :         return false;
      23              :     }
      24              : 
      25         2232 :     for (i = mm->capacity; i < mm->capacity + step; i++) {
      26         1984 :         ptrs[i] = NULL;
      27              :     }
      28              : 
      29          248 :     mm->ptrs = ptrs;
      30          248 :     mm->capacity += step;
      31              : 
      32          248 :     return true;
      33              : }
      34              : 
      35         1026 : extern bool pino_memory_manager_obj_init(mm_t *mm, size_t initialize_size)
      36              : {
      37         1026 :     if (initialize_size == 0) {
      38            0 :         return false;
      39              :     }
      40              : 
      41         1026 :     mm->usage = 0;
      42         1026 :     mm->capacity = 0;
      43         1026 :     mm->ptrs = (void **)pcalloc(initialize_size, sizeof(void *));
      44         1026 :     if (!mm->ptrs) {
      45            0 :         return false;
      46              :     }
      47              : 
      48         1026 :     mm->usage = 0;
      49         1026 :     mm->capacity = initialize_size;
      50              : 
      51         1026 :     return true;
      52              : }
      53              : 
      54         1026 : extern void pino_memory_manager_obj_free(mm_t *mm)
      55              : {
      56              :     size_t i;
      57              : 
      58         1026 :     if (!mm) {
      59            0 :         return;
      60              :     }
      61              : 
      62        19426 :     for (i = 0; i < mm->capacity; i++) {
      63        18400 :         if (mm->ptrs[i]) {
      64         1006 :             pfree(mm->ptrs[i]);
      65         1006 :             mm->ptrs[i] = NULL;
      66         1006 :             --mm->usage;
      67              :         }
      68              :     }
      69              : 
      70         1026 :     pfree(mm->ptrs);
      71         1026 :     mm->ptrs = NULL;
      72         1026 :     mm->usage = 0;
      73         1026 :     mm->capacity = 0;
      74              : }
      75              : 
      76         4028 : extern void *pino_memory_manager_malloc(/* handler_entry_t */ void *entry, size_t size)
      77              : {
      78              :     size_t i;
      79              : 
      80         4028 :     if (!entry || size == 0) {
      81         1009 :         return NULL;
      82              :     }
      83              : 
      84         3019 :     if (((handler_entry_t *)entry)->mm.usage >= ((handler_entry_t *)entry)->mm.capacity) {
      85          248 :         if (!glow_mm(&((handler_entry_t *)entry)->mm, HANDLER_STEP)) {
      86            0 :             return NULL;
      87              :         }
      88              :     }
      89              : 
      90      3002043 :     for (i = 0; i < ((handler_entry_t *)entry)->mm.capacity; i++) {
      91      3002043 :         if (!((handler_entry_t *)entry)->mm.ptrs[i]) {
      92         3019 :             ((handler_entry_t *)entry)->mm.ptrs[i] = pmalloc(size);
      93         3019 :             if (!((handler_entry_t *)entry)->mm.ptrs[i]) {
      94            0 :                 return NULL;
      95              :             }
      96              : 
      97         3019 :             ++((handler_entry_t *)entry)->mm.usage;
      98              : 
      99         3019 :             return ((handler_entry_t *)entry)->mm.ptrs[i];
     100              :         }
     101              :     }
     102              : 
     103            0 :     return NULL;
     104              : }
     105              : 
     106         2014 : extern void *pino_memory_manager_calloc(/* handler_entry_t */ void *entry, size_t count, size_t size)
     107              : {
     108              :     void *ptr;
     109              : 
     110         2014 :     ptr = pino_memory_manager_malloc(entry, count * size);
     111         2014 :     if (!ptr) {
     112            1 :         return NULL;
     113              :     }
     114              : 
     115         2013 :     memset(ptr, 0, count * size);
     116              : 
     117         2013 :     return ptr;
     118              : }
     119              : 
     120         3021 : extern void pino_memory_manager_free(/* handler_entry_t */ void *entry, void *ptr)
     121              : {
     122              :     size_t i;
     123              : 
     124         3021 :     if (!entry || !ptr) {
     125         1008 :         return;
     126              :     }
     127              : 
     128      2002033 :     for (i = 0; i < ((handler_entry_t *)entry)->mm.capacity; i++) {
     129      2002033 :         if (((handler_entry_t *)entry)->mm.ptrs[i] && ((handler_entry_t *)entry)->mm.ptrs[i] == ptr) {
     130         2013 :             pfree(ptr);
     131         2013 :             ((handler_entry_t *)entry)->mm.ptrs[i] = NULL;
     132         2013 :             ptr = NULL;
     133         2013 :             --((handler_entry_t *)entry)->mm.usage;
     134              : 
     135         2013 :             return;
     136              :         }
     137              :     }
     138              : }