gmMemory.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_MEMORY_H_
#define _GEMA_MEMORY_H_

#include "gmCoreConfig.h"
#include <assert.h>

#include "gmOmp.h"


#define GM_CACHE_LINE_SIZE 64

#ifdef Q_OS_WIN

#define GM_CACHE_ALIGNED __declspec(align(GM_CACHE_LINE_SIZE))

#define GmAlignedMalloc(size, align) _aligned_malloc((size), (align))

#define GmAlignedFree(ptr) _aligned_free(ptr)

#else

#define GM_CACHE_ALIGNED __attribute__((aligned(GM_CACHE_LINE_SIZE)))

inline void* GmAlignedMalloc(size_t size, size_t align)
{ 
  void* ptr = NULL;
  if(align < sizeof(void*)) // memalign requires a multiple of sizeof(void*)
    align = sizeof(void*);
  return posix_memalign(&ptr, align, size) ? NULL : ptr;
}

#define GmAlignedFree(ptr) ::free(ptr)

#endif

inline void* GmAlignedMallocThrow(size_t size, size_t align)
{
  void* p = GmAlignedMalloc(size, align);
  if(p)
    return p;
  else
    throw std::bad_alloc();
}

inline bool GmMemoryIsAligned(void* ptr, int align)
{
  return (((quintptr)ptr) & (align-1)) == 0;
}

inline bool GmIsCacheAligned(void* ptr) { return GmMemoryIsAligned(ptr, GM_CACHE_LINE_SIZE); }

template<class T> void GmConstructObjectsInMemory(T* ptr, int n = 1)
{
  if(QTypeInfo<T>::isComplex)  // Call default object constructor
  {
    for(int i = 0; i < n; i++, ptr++)
      new (ptr) T();
  }
}

template<class T> void GmDestroyObjectsInMemory(T* ptr, int n = 1)
{
  if(QTypeInfo<T>::isComplex)  // Call object destructor
  {
    for(int i = 0; i < n; i++, ptr++)
      ptr->~T();
  }
}

template<class T> void GmConstructAlignedObjectsInMemory(T* ptr, int align, int n)
{
  assert(GmMemoryIsAligned(ptr, align));

  if(QTypeInfo<T>::isComplex)  // Call default object constructor
  {
    int objectOffset = ceil(sizeof(T)/(double)align) * align;
    for(int i = 0; i < n; i++)
    {
      new (ptr)T();
      ptr = (T*)(((char*)ptr) + objectOffset);
    }
  }
}

template<class T> void GmDestroyAlignedObjectsInMemory(T* ptr, int align, int n)
{
  assert(GmMemoryIsAligned(ptr, align));

  if(QTypeInfo<T>::isComplex)  // Call object destructor
  {
    int objectOffset = ceil(sizeof(T)/(double)align) * align;
    for(int i = 0; i < n; i++)
    {
      ptr->~T();
      ptr = (T*)(((char*)ptr) + objectOffset);
    }
  }
}

inline void* GmPmemcpy(void* dst, const void* src, size_t n, int nt = 0, 
                       size_t min = 10 * 1024 * 1024)
{
#ifdef _OPENMP
  if(n < min)
    return memcpy(dst, src, n);

  nt = GmOmpAdjustNumThreads(nt);

  // If n is < nt, it should also be less than min since our 
  // pre-condition states that min > maximum number of threads.
  // This enables us to skip a test for adjusting nt if nt > n
  assert(n >= nt);

  size_t bn = n / nt;
  size_t ln = bn + n % nt; // The size of the last copy block

#pragma omp parallel for num_threads(nt)
  for(int i = 0; i < nt; i++)
    memcpy(((char*)dst) + i * bn, ((const char*)src) + i * bn, i < nt - 1 ? bn : ln);

  return dst;
#else
  Q_UNUSED(nt); Q_UNUSED(min);
  return memcpy(dst, src, n);
#endif
}



#ifdef ARMA_USE_GEMA_MEMORY_POOL

GMC_API_EXPORT void* GmMemoryArmadilloPoolAlloc(size_t s);
GMC_API_EXPORT void  GmMemoryArmadilloPoolFree (void* p);

#endif

#endif