implementing malloc with mmap

Question

I saw this post.

Is this a good implementation of malloc using mmap?

memory.hpp

#ifndef MEMORY_HPP
#define MEMORY_HPP

void *malloc(unsigned int);
void *calloc(unsigned int);
void free(void *);

#endif

memory.cpp

// https://stackoverflow.com/questions/33791310/c-mmap-initialize-at-0xffffffff
// https://stackoverflow.com/questions/8475609/implementing-your-own-malloc-free-with-mmap-and-munmap
#include "memory.hpp"
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>

void *malloc(unsigned int size)
{
    unsigned int *plen;
    unsigned int len = size + sizeof(size); // Add sizeof( size ) for holding length.

    plen = (unsigned int *)mmap(0, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_SHARED, -1, 0);

    if (plen == MAP_FAILED)
    {
        printf("map failed\n");
        return NULL;
    }

    *plen = len;               // First 4 bytes contain length.
    return (void *)(&plen[1]); // Memory that is after length variable.
}

void *calloc(unsigned int size)
{
    void *ptr = malloc(size);
    memset(ptr, 0, size);
    return ptr;
}

void free(void *ptr)
{
    if (ptr == NULL)
    {
        return;
    }
    unsigned int *plen = (unsigned int *)ptr - 1; // Get length variable.
    munmap(plen, *plen);
}

Answer 1

Some limitations of this implementation include:

There is no realloc().

This implementation uses unsigned int rather than size_t, so it does not follow the Standard, and can only allocate 32 bits on most 64-bit implementations.

It passes a value of -1 as the file descriptor, which is not conformant to the POSIX standard.

For most applications, it would be better to map copy-on-write pages from a device like /dev/zero that only get mapped into physical memory if they are used than for calloc() to touch every page of memory and write zeroes to it. In addition to taking much more time, this will evict other pages of memory from your cache and cause cache misses when calloc() returns.

Although you are not required by the specification to have free() do any error-checking at all, it is a very bad idea to fail silently and leave the program in an unstable state.

Finally, although you know this already, real-world implementations of malloc() only use this scheme for large allocations, and allocate smaller blocks from a heap.

Answer 2

Alignment requirements not certainly met.

The standard library *alloc() functions return pointers that are "suitably aligned so that it may be assigned to a pointer to any type of object with a fundamental alignment requirement". OP's code makes no provision for the returned pointer to be so aligned. Research max_align_t.