Código Malloc em C

Question

Eu tenho um bloco de código que parece ser o código por trás malloc. Mas, à medida que passo pelo código, tenho a sensação de que partes do código estão faltando. Alguém sabe se há uma parte da função que está faltando? Faz malloc Sempre combine pedaços adjacentes?

int heap[10000];
void* malloc(int size) {
int sz = (size + 3) / 4;
int chunk = 0;
if(heap[chunk] > sz) {
    int my_size = heap[chunk];
    if (my_size < 0) {
      my_size = -my_size
    }
    chunk = chunk + my_size + 2;
    if (chunk == heap_size) { 
      return 0;
    }
}

Answer 1

O código por trás do Malloc é certamente muito mais complexo que isso. Existem várias estratégias. Um código popular é o dlmalloc biblioteca. Um mais simples é descrito em K&R.

Answer 2

O código está obviamente incompleto (nem todos os caminhos retornam um valor). Mas, de qualquer forma, isso não é um malloc "real". Provavelmente, essa é uma tentativa de implementar um "modelo" altamente simplificado de 'malloc'. A abordagem escolhida pelo autor do código não pode realmente levar a uma implementação prática útil.

(E btw, o parâmetro padrão 'MaiCloc tem tipo' size_t ', não' int ').

Answer 3

Bem, um erro nesse código é que ele não retorna um ponteiro para os dados.

Eu suspeito que a melhor abordagem para esse código é [excluir].

Answer 4

Quando possível, espero que o Malloc tente colocar diferentes solicitações próximas umas das outras, pois terá um bloco de código disponível para o MaiC, até que ele tenha que obter um novo bloco.

Mas isso também depende dos requisitos impostos pela arquitetura do sistema operacional e do hardware. Se você só tiver permissão para solicitar um certo tamanho mínimo de código, pode ser que cada alocação não esteja próxima.

Como outros mencionaram, há problemas com o trecho de código.

Você pode encontrar vários projetos de código aberto que têm sua própria função malloc, e pode ser melhor olhar para um desses, a fim de ter uma idéia do que está faltando.

Answer 5

malloc é para alocado dinamicamente memória. E isso envolve sbrk, mmap, ou talvez algumas outras funções do sistema para janelas e/ou outras arquiteturas. Eu não tenho certeza do que você int heap[10000] é para, pois o código é muito incompleto.

A versão de Efso faz um pouco mais de sentido, mas depois introduz outra função de caixa preta get_block, então não ajuda muito.

Answer 6

O código parece estar executado em uma máquina de metal, normalmente nenhum mapeamento de endereços virtual em um sistema que usa apenas o espaço de endereço físico diretamente.

Veja meu entendimento, em um sistema de 32 bits, sizeof (ptr) = 4 bytes:

extern block_t *block_head; // the real heap, and its address 
                            // is >= 0x80000000, see below "my_size < 0"
extern void *get_block(int index); // get a block from the heap 
                                   // (lead by block_head)
int heap[10000]; // just the indicators, not the real heap

void* malloc(int size) 
{
    int sz = (size + 3) / 4; // make the size aligns with 4 bytes,
                             // you know, allocated size would be aligned.
    int chunk = 0; // the first check point
    if(heap[chunk] > sz) { // the value is either a valid free-block size 
                           // which meets my requirement, or an 
                           // address of an allocated block
        int my_size = heap[chunk]; // verify size or address
        if (my_size < 0) { // it is an address, say a 32-bit value which 
                           // is >0x8000...., not a size. 
              my_size = -my_size // the algo, convert it
        }
        chunk = chunk + my_size + 2; // the algo too, get available 
                                     // block index
        if (chunk == heap_size) { // no free chunks left
           return NULL; // Out of Memory
        }
        void *block = get_block(chunk);
        heap[chunk] = (int)block;
        return block;
    }
    // my blocks is too small initially, none of the blocks 
    // will meet the requirement
    return NULL;
}

EDIT: Alguém poderia ajudar a explicar o Algo, ou seja, Convertendo Endereço -> My_size -> Chunk? Você sabe, quando a chamada Reclaim, digamos grátis (void *addr), ele usará este endereço -> MY_SIZE -> Algo de Chunk também, para atualizar o heap [Chunk] de acordo após o retorno do bloco à pilha.

Answer 7

Para ser uma implementação inteira de um malloc

Pegue um Llok nas fontes da biblioteca C do Visual Studio 6.0, você encontrará a implementação do MALLOC se eu me lembrar corretamente