livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

changed ll_aligned_(malloc|free) to take alignment size as a template argument

master
Richard Linden 2013-10-14 10:18:41 -07:00
parent a6a40bd69f
commit 1acceb3633
8 changed files with 43 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
indra/llcommon/llalignedarray.h
View File

@ -60,7 +60,7 @@ LLAlignedArray<T, alignment>::LLAlignedArray()
template <class T, U32 alignment>
LLAlignedArray<T, alignment>::~LLAlignedArray()
{
ll_aligned_free(alignment, mArray);
ll_aligned_free<alignment>(mArray);
mArray = NULL;
mElementCount = 0;
mCapacity = 0;
@ -74,7 +74,7 @@ void LLAlignedArray<T, alignment>::push_back(const T& elem)
{
mCapacity++;
mCapacity *= 2;
T* new_buf = (T*) ll_aligned_malloc(alignment, mCapacity*sizeof(T));
T* new_buf = (T*) ll_aligned_malloc<alignment>(mCapacity*sizeof(T));
if (mArray)
{
ll_memcpy_nonaliased_aligned_16((char*)new_buf, (char*)mArray, sizeof(T)*mElementCount);
@ -86,7 +86,7 @@ void LLAlignedArray<T, alignment>::push_back(const T& elem)
mArray[mElementCount++] = elem;
//delete old array here to prevent error on a.push_back(a[0])
ll_aligned_free(alignment, old_buf);
ll_aligned_free<alignment>(old_buf);
}
template <class T, U32 alignment>
@ -95,11 +95,11 @@ void LLAlignedArray<T, alignment>::resize(U32 size)
if (mCapacity < size)
{
mCapacity = size+mCapacity*2;
T* new_buf = mCapacity > 0 ? (T*) ll_aligned_malloc(alignment, mCapacity*sizeof(T)) : NULL;
T* new_buf = mCapacity > 0 ? (T*) ll_aligned_malloc<alignment>(mCapacity*sizeof(T)) : NULL;
if (mArray)
{
ll_memcpy_nonaliased_aligned_16((char*) new_buf, (char*) mArray, sizeof(T)*mElementCount);
ll_aligned_free(alignment, mArray);
ll_aligned_free<alignment>(mArray);
}
/*for (U32 i = mElementCount; i < mCapacity; ++i)

20
indra/llcommon/llmemory.h
View File

@ -204,37 +204,39 @@ inline void ll_aligned_free_32(void *p)
}
// general purpose dispatch functions that are forced inline so they can compile down to a single call
LL_FORCE_INLINE void* ll_aligned_malloc(size_t alignment, size_t size)
template<size_t ALIGNMENT>
LL_FORCE_INLINE void* ll_aligned_malloc(size_t size)
{
if (LL_DEFAULT_HEAP_ALIGN % alignment == 0)
if (LL_DEFAULT_HEAP_ALIGN % ALIGNMENT == 0)
{
return malloc(size);
}
else if (alignment == 16)
else if (ALIGNMENT == 16)
{
return ll_aligned_malloc_16(size);
}
else if (alignment == 32)
else if (ALIGNMENT == 32)
{
return ll_aligned_malloc_32(size);
}
else
{
return ll_aligned_malloc_fallback(size, alignment);
return ll_aligned_malloc_fallback(size, ALIGNMENT);
}
}
LL_FORCE_INLINE void ll_aligned_free(size_t alignment, void* ptr)
template<size_t ALIGNMENT>
LL_FORCE_INLINE void ll_aligned_free(void* ptr)
{
if (alignment == LL_DEFAULT_HEAP_ALIGN)
if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN)
{
free(ptr);
}
else if (alignment == 16)
else if (ALIGNMENT == 16)
{
ll_aligned_free_16(ptr);
}
else if (alignment == 32)
else if (ALIGNMENT == 32)
{
return ll_aligned_free_32(ptr);
}

12
indra/llcommon/lltrace.h
View File

@ -371,40 +371,40 @@ public:
void* operator new(size_t size)
{
claim_alloc(sMemStat, size);
return ll_aligned_malloc(ALIGNMENT, size);
return ll_aligned_malloc<ALIGNMENT>(size);
}
template<int CUSTOM_ALIGNMENT>
static void* aligned_new(size_t size)
{
claim_alloc(sMemStat, size);
return ll_aligned_malloc(CUSTOM_ALIGNMENT, size);
return ll_aligned_malloc<CUSTOM_ALIGNMENT>(size);
}
void operator delete(void* ptr, size_t size)
{
disclaim_alloc(sMemStat, size);
ll_aligned_free(ALIGNMENT, ptr);
ll_aligned_free<ALIGNMENT>(ptr);
}
template<int CUSTOM_ALIGNMENT>
static void aligned_delete(void* ptr, size_t size)
{
disclaim_alloc(sMemStat, size);
ll_aligned_free(CUSTOM_ALIGNMENT, ptr);
ll_aligned_free<CUSTOM_ALIGNMENT>(ptr);
}
void* operator new [](size_t size)
{
claim_alloc(sMemStat, size);
return ll_aligned_malloc(ALIGNMENT, size);
return ll_aligned_malloc<ALIGNMENT>(size);
}
void operator delete[](void* ptr, size_t size)
{
disclaim_alloc(sMemStat, size);
ll_aligned_free(ALIGNMENT, ptr);
ll_aligned_free<ALIGNMENT>(ptr);
}
// claim memory associated with other objects/data as our own, adding to our calculated footprint

4
indra/llcommon/lltraceaccumulators.h
View File

@ -441,12 +441,12 @@ namespace LLTrace
// arrays are allocated with 32 byte alignment
void *operator new [](size_t size)
{
return ll_aligned_malloc(32, size);
return ll_aligned_malloc<32>(size);
}
void operator delete[](void* ptr, size_t size)
{
ll_aligned_free(32, ptr);
ll_aligned_free<32>(ptr);
}
TimeBlockAccumulator();

16
indra/llmath/llvolume.cpp
View File

@ -4667,7 +4667,7 @@ LLVolumeFace::~LLVolumeFace()
void LLVolumeFace::freeData()
{
ll_aligned_free(64, mPositions);
ll_aligned_free<64>(mPositions);
mPositions = NULL;
//normals and texture coordinates are part of the same buffer as mPositions, do not free them separately
@ -5245,7 +5245,7 @@ void LLVolumeFace::cacheOptimize()
//allocate space for new buffer
S32 num_verts = mNumVertices;
S32 size = ((num_verts*sizeof(LLVector2)) + 0xF) & ~0xF;
LLVector4a* pos = (LLVector4a*) ll_aligned_malloc(64, sizeof(LLVector4a)*2*num_verts+size);
LLVector4a* pos = (LLVector4a*) ll_aligned_malloc<64>(sizeof(LLVector4a)*2*num_verts+size);
LLVector4a* norm = pos + num_verts;
LLVector2* tc = (LLVector2*) (norm + num_verts);
@ -5295,7 +5295,7 @@ void LLVolumeFace::cacheOptimize()
mIndices[i] = new_idx[mIndices[i]];
}
ll_aligned_free(64, mPositions);
ll_aligned_free<64>(mPositions);
// DO NOT free mNormals and mTexCoords as they are part of mPositions buffer
ll_aligned_free_16(mWeights);
ll_aligned_free_16(mTangents);
@ -6023,7 +6023,7 @@ void LLVolumeFace::createTangents()
void LLVolumeFace::resizeVertices(S32 num_verts)
{
ll_aligned_free(64, mPositions);
ll_aligned_free<64>(mPositions);
//DO NOT free mNormals and mTexCoords as they are part of mPositions buffer
ll_aligned_free_16(mTangents);
@ -6034,7 +6034,7 @@ void LLVolumeFace::resizeVertices(S32 num_verts)
//pad texture coordinate block end to allow for QWORD reads
S32 size = ((num_verts*sizeof(LLVector2)) + 0xF) & ~0xF;
mPositions = (LLVector4a*) ll_aligned_malloc(64, sizeof(LLVector4a)*2*num_verts+size);
mPositions = (LLVector4a*) ll_aligned_malloc<64>(sizeof(LLVector4a)*2*num_verts+size);
mNormals = mPositions+num_verts;
mTexCoords = (LLVector2*) (mNormals+num_verts);
@ -6074,7 +6074,7 @@ void LLVolumeFace::pushVertex(const LLVector4a& pos, const LLVector4a& norm, con
LLVector4a* old_buf = mPositions;
mPositions = (LLVector4a*) ll_aligned_malloc(64, new_size);
mPositions = (LLVector4a*) ll_aligned_malloc<64>(new_size);
mNormals = mPositions+new_verts;
mTexCoords = (LLVector2*) (mNormals+new_verts);
@ -6090,7 +6090,7 @@ void LLVolumeFace::pushVertex(const LLVector4a& pos, const LLVector4a& norm, con
//just clear tangents
ll_aligned_free_16(mTangents);
mTangents = NULL;
ll_aligned_free(64, old_buf);
ll_aligned_free<64>(old_buf);
mNumAllocatedVertices = new_verts;
@ -6191,7 +6191,7 @@ void LLVolumeFace::appendFace(const LLVolumeFace& face, LLMatrix4& mat_in, LLMat
//allocate new buffer space
LLVector4a* old_buf = mPositions;
mPositions = (LLVector4a*) ll_aligned_malloc(64, new_size);
mPositions = (LLVector4a*) ll_aligned_malloc<64>(new_size);
mNormals = mPositions + new_count;
mTexCoords = (LLVector2*) (mNormals+new_count);

4
indra/llrender/llvertexbuffer.cpp
View File

@ -202,7 +202,7 @@ volatile U8* LLVBOPool::allocate(U32& name, U32 size, bool for_seed)
glBufferDataARB(mType, size, 0, mUsage);
if (mUsage != GL_DYNAMIC_COPY_ARB)
{ //data will be provided by application
ret = (U8*) ll_aligned_malloc(64, size);
ret = (U8*) ll_aligned_malloc<64>(size);
}
}
else
@ -310,7 +310,7 @@ void LLVBOPool::cleanup()
if (r.mClientData)
{
ll_aligned_free(64, (void*) r.mClientData);
ll_aligned_free<64>((void*) r.mClientData);
}
l.pop_front();

4
indra/llvfs/llvfile.cpp
View File

@ -137,12 +137,12 @@ U8* LLVFile::readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S
}
else
{
data = (U8*) ll_aligned_malloc(16, file_size);
data = (U8*) ll_aligned_malloc<16>(file_size);
file.read(data, file_size); /* Flawfinder: ignore */
if (file.getLastBytesRead() != (S32)file_size)
{
ll_aligned_free(16, data);
ll_aligned_free<16>(data);
data = NULL;
file_size = 0;
}

14
indra/newview/llvovolume.cpp
View File

@ -4433,13 +4433,13 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
const U32 MAX_FACE_COUNT = 4096;
static LLFace** fullbright_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** bump_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** simple_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** norm_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** spec_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** normspec_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** alpha_faces = (LLFace**) ll_aligned_malloc(64, MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** fullbright_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** bump_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** simple_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** norm_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** spec_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** normspec_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
static LLFace** alpha_faces = (LLFace**) ll_aligned_malloc<64>(MAX_FACE_COUNT*sizeof(LLFace*));
U32 fullbright_count = 0;
U32 bump_count = 0;