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 constexpr(QTypeInfo<T>::isComplex)  // Call default object constructor
  {
    for(int i = 0; i < n; i++, ptr++)
      new (ptr) T();
  }
  else
  {
    Q_UNUSED(ptr); Q_UNUSED(n);
  }
}
 
template<class T> void GmDestroyObjectsInMemory(T* ptr, int n = 1)
{
  if constexpr(QTypeInfo<T>::isComplex)  // Call object destructor
  {
    for(int i = 0; i < n; i++, ptr++)
      ptr->~T();
  }
  else
  {
    Q_UNUSED(ptr); Q_UNUSED(n);
  }
}
 
template<class T> void GmConstructAlignedObjectsInMemory(T* ptr, int align, int n)
{
  assert(GmMemoryIsAligned(ptr, align));
 
  if constexpr(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);
    }
  }
  else
  {
    Q_UNUSED(ptr); Q_UNUSED(align);  Q_UNUSED(n);
  }
}
 
template<class T> void GmDestroyAlignedObjectsInMemory(T* ptr, int align, int n)
{
  assert(GmMemoryIsAligned(ptr, align));
 
  if constexpr(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);
    }
  }
  else
  {
    Q_UNUSED(ptr); Q_UNUSED(align);  Q_UNUSED(n);
  }
}
 
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