phoenix_template_alloc_impl.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __PHOENIX_TEMPLATE_ALLOC_IMPL_H__
#define __PHOENIX_TEMPLATE_ALLOC_IMPL_H__
 
#include "phoenix_template_alloc.h"


template<typename T>
size_t phoenix_getPadding(size_t nbElement){
        size_t regVecSizeType(phoenix_alignement_type<T>());
        size_t padding = regVecSizeType - (nbElement % regVecSizeType);
        if(padding == regVecSizeType){padding = 0lu;}
        return padding;
}


template<typename T>
T * phoenix_template_alloc(size_t & padding, bool & isAligned, Phoenix::AllocMode mode, const size_t * tabDim, size_t nbDim){
        padding = 0lu;
        isAligned = false;
        if(mode == Phoenix::NONE){
                T * tabData = new T[phoenix_getFullSize(tabDim, nbDim)];
                return tabData;
        }else if(mode == Phoenix::ALIGNED){
                isAligned = true;
                size_t alignementInByte(phoenix_alignement_in_bytes<T>());
                if(alignementInByte == 0lu){    //No alignement for this type
                        T * tabData = new T[phoenix_getFullSize(tabDim, nbDim)];
                        return tabData;
                }else{
                        T * tabData = (T*)phoenix_allocAlignedTab(phoenix_getFullSize(tabDim, nbDim)*sizeof(T), alignementInByte);
                        return tabData;
                }
        }else if(mode == Phoenix::PADDING){
                isAligned = true;
                size_t alignementInByte(phoenix_alignement_in_bytes<T>());
                if(alignementInByte == 0lu){    //No alignement for this type
                        T * tabData = new T[phoenix_getFullSize(tabDim, nbDim)];
                        return tabData;
                }else{
                        size_t fullSize(phoenix_getFullSize(tabDim, nbDim));
                        size_t nbCol(tabDim[nbDim - 1lu]);
                        size_t nbRow(fullSize/nbCol);
                        padding = phoenix_getPadding<T>(nbCol);
                        T * tabData = (T*)phoenix_allocAlignedTab((nbRow*(nbCol + padding))*sizeof(T), alignementInByte);
                        return tabData;
                }
        }
        return NULL;
}


template<typename T>
T * phoenix_template_alloc_aligned1d(size_t nbValue){
        size_t padding(0lu);
        bool isAligned(false);
        return phoenix_template_alloc<T>(padding, isAligned, Phoenix::ALIGNED, &nbValue, 1lu);
}


template<typename T>
void phoenix_newAlignedTab(T* & alignedPtr, size_t sizeOfVectorInT){
        alignedPtr = (T*)phoenix_allocAlignedTab(sizeOfVectorInT*sizeof(T), phoenix_alignement_in_bytes<T>());
}


template<typename T>
bool phoenix_checkIsAligned(const T* ptr){
        return (((size_t)ptr) % phoenix_alignement_in_bytes<T>()) == 0lu;
}
 
#endif