op_malloc.h

Go to the documentation of this file.

/* This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation, either version 3 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

/* Code: */


#ifndef OP_MALLOC_H
#define OP_MALLOC_H 1

#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <fcntl.h>
#include <string.h>
#include "opic/common/op_assert.h"
#include "opic/common/op_macros.h"

OP_BEGIN_DECLS

#define OPHEAP_BITS 36

#define OPHEAP_SIZE (1UL << OPHEAP_BITS)

typedef struct OPHeap OPHeap;

typedef uintptr_t opref_t;

typedef uintptr_t oplenref_t;

#define OPLENREF_MAX_LEN (1ULL << (64 - OPHEAP_BITS))

OPHeap* OPHeapOpen(const char* path, int flags);

OPHeap* OPHeapOpenTmp();

void OPHeapMSync(OPHeap* heap);

void OPHeapClose(OPHeap* heap);

void OPHeapStorePtr(OPHeap* heap, void* ptr, int pos);

void* OPHeapRestorePtr(OPHeap* heap, int pos);

void* OPMalloc(OPHeap* heap, size_t size)
  __attribute__ ((malloc));

void* OPCalloc(OPHeap* heap, size_t num, size_t size)
  __attribute__ ((malloc));

void* OPMallocAdviced(OPHeap* heap, size_t size, int advice)
  __attribute__ ((malloc));

void* OPCallocAdviced(OPHeap* heap, size_t num, size_t size, int advice)
  __attribute__ ((malloc));

void
OPDealloc(void* addr);

static inline OPHeap*
ObtainOPHeap(void* addr)
{
  return (OPHeap*)((uintptr_t)addr & ~(OPHEAP_SIZE - 1));
}

static inline opref_t
OPPtr2Ref(void* addr)
{
  return (opref_t)addr & (OPHEAP_SIZE - 1);
}

static inline void*
OPRef2Ptr(void* ptr_in_heap, opref_t ref)
{
  return (void*)((opref_t)ObtainOPHeap(ptr_in_heap) + ref);
}

static inline size_t
OPLenRef2Size(oplenref_t ref)
{
  return (size_t)(ref >> OPHEAP_BITS);
}

#ifndef DOXYGEN_SKIP
/*
 * Internal use only.  Extracts opref_t part from oplenref_t. This
 * value could be 0 if the size portion of oplenref_t is smaller than
 * the container size.
 *
 * In most cases, user should use OPLenRef2Ptr instead of this
 * function.
 *
 */
static inline opref_t
OPLenRef2Ref(oplenref_t ref)
{
  return ref & (OPHEAP_SIZE - 1);
}

/*
 * Internal use only.  It encodes if a reference is an empty key in
 * container.
 */
static inline bool
OPLenRefIsEmpty(oplenref_t ref)
{
  return ref == 0;
}

/*
 * Internal use only.  It encodes if a reference is a deleted key in
 * container.
 */
static inline bool
OPLenRefIsDeleted(oplenref_t ref)
{
  return ref == ~0ULL;
}
#endif

static inline void*
OPLenRef2Ptr(oplenref_t* ref, size_t container_size)
{
  uintptr_t uintref = (uintptr_t)ref;
  if (OPLenRefIsEmpty(*ref) || OPLenRefIsDeleted(*ref))
    return NULL;
  if (OPLenRef2Size(*ref) > container_size)
    return OPRef2Ptr(ObtainOPHeap(ref), OPLenRef2Ref(*ref));
  return (void*)(uintref + sizeof(oplenref_t));
}

static inline void*
OPLenRef2PtrOnHeap(oplenref_t* ref, size_t container_size, OPHeap* heap)
{
  uintptr_t uintref = (uintptr_t)ref;
  if (OPLenRefIsEmpty(*ref) || OPLenRefIsDeleted(*ref))
    return NULL;
  if (OPLenRef2Size(*ref) > container_size)
    return OPRef2Ptr(heap, OPLenRef2Ref(*ref));
  return (void*)(uintref + sizeof(oplenref_t));
}

static inline void
OPLenRefCreate(oplenref_t* ref, void* data, size_t data_size,
               size_t container_size)
{
  uintptr_t uintref = (uintptr_t)ref;
  if (data_size > OPLENREF_MAX_LEN)
    {
      *ref = 0;
      return;
    }
  if (data_size > container_size)
    {
      void* ptr;
      ptr = OPCalloc(ObtainOPHeap(ref), 1, data_size);
      if (!ptr)
        {
          *ref = 0;
          return;
        }
      memcpy(ptr, data, data_size);
      *ref = (oplenref_t)OPPtr2Ref(ptr);
    }
  else
    {
      memcpy((void*)(uintref + sizeof(oplenref_t)), data, data_size);
      *ref = 0;
    }
  *ref |= data_size << OPHEAP_BITS;
}

static inline void
OPLenRefDelete(oplenref_t* ref, size_t container_size)
{
  if (OPLenRefIsEmpty(*ref) || OPLenRefIsDeleted(*ref))
    return;
  if (OPLenRef2Size(*ref) > container_size)
    {
      OPDealloc(OPLenRef2Ptr(ref, container_size));
    }
  *ref = ~0ULL;
}

static inline void
OPLenRefRelpace(oplenref_t* ref, void* data, size_t data_size,
                size_t container_size)
{
  if (OPLenRefIsEmpty(*ref) || OPLenRefIsDeleted(*ref))
    {
      OPLenRefCreate(ref, data, data_size, container_size);
      return;
    }
  if (data == OPLenRef2Ptr(ref, container_size))
    return;
  if (OPLenRef2Size(*ref) > container_size)
    {
      OPDealloc(OPLenRef2Ptr(ref, container_size));
    }
  OPLenRefCreate(ref, data, data_size, container_size);
}

OP_END_DECLS

#endif

/* op_malloc.h ends here */