nm_memalloc_helper.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2025-2026 (see AUTHORS file)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <errno.h>
 
#ifndef MAP_HUGE_SHIFT
/* If undefined, use default value. The 2MB page mmap is likely to fail on this architecture */
#define MAP_HUGE_SHIFT 26
#endif
 
#define MAP_HUGE_2MB    (21 << MAP_HUGE_SHIFT)
#define HUGE_PAGE_2MB_SIZE  (1 << 21)
 
#define MAP_HUGE_1GB    (30 << MAP_HUGE_SHIFT)
#define HUGE_PAGE_1GB_SIZE  (1 << 30)
 
#define CHECK(rc,s) _memalloc_helper_check_and_exit((rc), __func__, __LINE__, (s))
 
typedef enum
  {
    ALLOC_MALLOC,
    ALLOC_CALLOC,
    ALLOC_MEMALIGN,
    ALLOC_MMAP_4KB,
    ALLOC_MMAP_2MB,
    ALLOC_MMAP_1GB
  } alloc_type_t;
 
static inline void _memalloc_helper_check_and_exit(const int rc, const char*func, const int line, char*cmt)
{
  if (!rc)
    {
      fprintf(stderr, "# Error : %s at line %d in %s\n", cmt, line, func);
      if (errno)
        perror(NULL);
      else
        exit(EXIT_FAILURE);
    }
}
 
static void*allocate_buffer(size_t size, alloc_type_t alloc_type)
{
  void*buffer;
  switch(alloc_type)
    {
      case ALLOC_MALLOC:
        {
          buffer = malloc(size);
          CHECK(buffer != NULL, "malloc failed");
        }
        break;
      case ALLOC_CALLOC:
        {
          buffer = calloc(1, size);
          CHECK(buffer != NULL, "malloc failed");
        }
        break;
      case ALLOC_MEMALIGN:
        {
          const int ret = posix_memalign(&buffer, 64, size);
          CHECK(ret == 0, "posix_memalign failed");
        }
        break;
      case ALLOC_MMAP_4KB:
        {
          const size_t page_size = 4096;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          buffer = mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
          CHECK(buffer != MAP_FAILED, "mmap failed for 4kB page");
        }
        break;
      case ALLOC_MMAP_2MB:
        {
          const size_t page_size = HUGE_PAGE_2MB_SIZE;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          buffer = mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_HUGETLB | MAP_HUGE_2MB, -1, 0);
          CHECK(buffer != MAP_FAILED, "mmap failed for 2 MB page");
        }
        break;
      case ALLOC_MMAP_1GB:
        {
          const size_t page_size = HUGE_PAGE_1GB_SIZE;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          buffer = mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_HUGETLB | MAP_HUGE_1GB, -1, 0);
          CHECK(buffer != MAP_FAILED, "mmap failed for 1 GB page");
        }
      default:
        CHECK(0, "Unknown alloc_type argument passed");
    }
  return buffer;
}
 
static void free_buffer(void*buffer, size_t size, alloc_type_t alloc_type)
{
  switch (alloc_type)
    {
      case ALLOC_MALLOC:
      case ALLOC_CALLOC:
      case ALLOC_MEMALIGN:
        free(buffer);
        break;
      case ALLOC_MMAP_4KB:
        {
          const size_t page_size = 4096;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          CHECK(munmap(buffer, alloc_size ) == 0, "munmap 4kB page failed");
        }
        break;
      case ALLOC_MMAP_2MB:
        {
          const size_t page_size = HUGE_PAGE_2MB_SIZE;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          CHECK(munmap(buffer, alloc_size ) == 0, "munmap 2MB page failed");
        }
        break;
      case ALLOC_MMAP_1GB:
        {
          const size_t page_size = HUGE_PAGE_1GB_SIZE;
          const size_t alloc_size = (size / page_size + (size % page_size ? 1 : 0)) * page_size;
          CHECK(munmap(buffer, alloc_size ) == 0, "munmap 1GB page failed");
        }
      default:
        CHECK(0, "Unknown alloc_type argument passed");
    }
}