Как свободно приводить между указателями в C, для общего пула памяти?

Question

Я начинаю реализовывать общий пул памяти. Это для целей обучения, так что, безусловно, есть множество ошибок. Но я двигался вперед. Теперь я застрял в новой части. Во-первых, код

#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

typedef enum { FALSE, TRUE } BOOL;

typedef struct mem_block {
    uint8_t* data;
    size_t block_size;
    size_t pool_position;
    BOOL is_freed;
} mem_block;

typedef struct mem_pool {
    mem_block* blocks;
    size_t index;
    size_t pool_size;
} mem_pool;

mem_pool *pool_init() {
    mem_pool *pool = (mem_pool *) malloc(sizeof(mem_pool));
    pool->pool_size = (size_t) 128;
    mem_block* blk = (mem_block *) malloc(pool->pool_size * sizeof (mem_block));
    pool->index = 0;
    pool->blocks = blk;

    return pool;
}

void *pool_allocate(mem_pool **pool, size_t size) {
    mem_pool* _pool = *pool;
    size_t free_portion = _pool->pool_size - _pool->index;

    if(size < free_portion){
        mem_block* allocated_blk = _pool->blocks + _pool->index;
        uint8_t* data = (uint8_t*) malloc(size * sizeof(uint8_t));
        allocated_blk->data = data;
        allocated_blk->block_size = size;
        allocated_blk->is_freed = FALSE;
        allocated_blk->pool_position = _pool->index;
        _pool->index += size; 
        return (void *) allocated_blk->data;
    }
    else{
        printf("Pool is out of memory");
        return NULL;
    }
}

/*void pool_free(mem_pool **pool, void *block) {
    mem_block* cur = (mem_block*) block;
    mem_block* next = cur + 1;
    // override the unneeded memory
memmove(cur, next, (*pool)->pool_size - next->pool_position);
}*/

typedef struct complex {
    double i;
    double r;
} complex;

mem_pool *GLOBAL_POOL = pool_init();
int main() {
    complex *c1 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c1->r = 1.0;
    c1->i = 2.0;
    printf("Value is (%f + %fi)\n", c1->r, c1->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size -   GLOBAL_POOL->index);

    complex *c2 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c2->r = 2.0;
    c2->i = 3.0;
    printf("Value is (%f + %fi)\n", c2->r, c2->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    mem_block* cur = (mem_block *) &c2;
    printf("Position of c2 is %ld\n", cur->pool_position);
    printf("Adress of c2's block is %x\n", cur);
    printf("Address of c2 is %x\n", &c2);
    printf("c2 points to %x\n", c2);

    complex *c3 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c3->r = 3.0;
    c3->i = 4.0;
    printf("Value is (%f + %fi)\n", c3->r, c3->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    cur = (mem_block *) &c3;
    printf("Position of c3 is %ld\n", cur->pool_position);
    printf("Adress of c3's block is %x\n", cur);
    printf("Address of c3 is %x\n", &c3);
    printf("c3 points to %x\n", c3);

    complex *c4 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c4->r = 4.0;
    c4->i = 5.0;
    printf("Value is (%f + %fi)\n", c4->r, c4->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    complex *c5 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c5->r = 5.0;
    c5->i = 6.0;
    printf("Value is (%f + %fi)\n", c5->r, c5->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    complex *c6 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c6->r = 6.0;
    c6->i = 7.0;
    printf("Value is (%f + %fi)\n", c6->r, c6->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    complex *c7 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    c7->r = 7.0;
    c7->i = 8.0;
    printf("Value is (%f + %fi)\n", c7->r, c7->i);
    printf("Remaining free size is %ld\n", GLOBAL_POOL->pool_size - GLOBAL_POOL->index);

    complex *c8 = (complex *) pool_allocate(&GLOBAL_POOL, sizeof(complex));
    if(c8 != NULL) {
        c8->r = 3.0;
        c8->i = 4.0;
        printf("Value is (%f + %fi)\n", c8->r, c8->i);
    }else {
        return -1;   
    }
    return 0;
}

На данный момент его размер составляет 128 байт, но как только я получу основы, я сделаю его неограниченного размера. Распределение, вероятно, работает хорошо, вы можете увидеть вывод и увидеть, что я могу установить выделенные указатели и использовать значение. Кроме того, я хотел реализовать free, Это в закомментированной функции pool_free, Выполнять memmoveМне нужно знать индекс mem_block Я удаляю.

в pool_allocateвидишь что я верну data указатель на выделенный блок, а не весь объект, так что его можно использовать аналогично обычному malloc, Это означает, что при освобождении мне нужно восстановить mem_block из указателя данных. Чтобы иметь возможность сделать это, я положил data указатель как первый элемент mem_block,

Позвольте мне объяснить далее по коду

mem_block* cur = (mem_block *) &c3;
printf("Position of c3 is %ld\n", cur->pool_position);
printf("Adress of c3's block is %x\n", cur);
printf("Address of c3 is %x\n", &c3);
printf("c3 points to %x\n", c3);

c3 здесь выделяется с помощью pool_allocate и в результате указатель на данные, uint8_t* на самом деле был приведен к complex * использоваться. Так c3 указывает на complex объект. Разыменование должно давать фактические данные, и я думаю, что это работает. Но у него также есть свой адрес. Я предположил, что этот адрес совпадает с data указатель на его блок, так как он является первым членом в mem_block, Так что я бросил его свободно mem_block*, Но это не работает.

printf("Position of c3 is %ld\n", cur->pool_position);

говорит Position of c3 is 0 или другой бред. Я ожидаю увидеть такие вещи, как 16, 32 и т. Д., Так как каждый mem_block 16 байтов. Итак, почему вы думаете, что актеры

mem_block* cur = (mem_block *) &c3;

не позволит мне работать с c3 как будто это mem_block? Может быть, я не могу правильно передать указатель по ссылке, чтобы изменения в указанных объектах не были видны снаружи? Это кажется маловероятным, поскольку я могу работать с выделенными объектами, как и ожидалось, но кто знает? Я проверил каждую часть, но все еще не мог решить проблему.

Answer 1

В malloc это работает так, что у каждого блока есть заголовок (структура управления), и при выделении вы возвращаете адрес после этой структуры. Тогда на бесплатной вы знаете, что у вас есть адрес после заголовка, так что вы можете вычислить адрес фактического заголовка из этого.

Одним из простых приемов для этого является использование

void alloc(size_t size) {
    ...
    struct mem_block *block = <address of block you return>
    return &block[1];
}

void free(void *addr) {
    struct mem_block *block = addr;
    block[-1].is_freed = false;
    ...
}