mirror of https://github.com/NekoX-Dev/NekoX.git
175 lines
5.8 KiB
C++
175 lines
5.8 KiB
C++
/*!
|
|
* \copy
|
|
* Copyright (c) 2013, Cisco Systems
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "memory_align.h"
|
|
#include "macros.h"
|
|
|
|
namespace WelsCommon {
|
|
|
|
#ifdef MEMORY_CHECK
|
|
static FILE* fpMemChkPoint;
|
|
static uint32_t nCountRequestNum;
|
|
static int32_t g_iMemoryLength;
|
|
#endif
|
|
|
|
|
|
CMemoryAlign::CMemoryAlign (const uint32_t kuiCacheLineSize)
|
|
#ifdef MEMORY_MONITOR
|
|
: m_nMemoryUsageInBytes (0)
|
|
#endif//MEMORY_MONITOR
|
|
{
|
|
if ((kuiCacheLineSize == 0) || (kuiCacheLineSize & 0x0f))
|
|
m_nCacheLineSize = 0x10;
|
|
else
|
|
m_nCacheLineSize = kuiCacheLineSize;
|
|
}
|
|
|
|
CMemoryAlign::~CMemoryAlign() {
|
|
#ifdef MEMORY_MONITOR
|
|
assert (m_nMemoryUsageInBytes == 0);
|
|
#endif//MEMORY_MONITOR
|
|
}
|
|
|
|
void* WelsMalloc (const uint32_t kuiSize, const char* kpTag, const uint32_t kiAlign) {
|
|
const int32_t kiSizeOfVoidPointer = sizeof (void**);
|
|
const int32_t kiSizeOfInt = sizeof (int32_t);
|
|
const int32_t kiAlignedBytes = kiAlign - 1;
|
|
const int32_t kiTrialRequestedSize = kuiSize + kiAlignedBytes + kiSizeOfVoidPointer + kiSizeOfInt;
|
|
const int32_t kiActualRequestedSize = kiTrialRequestedSize;
|
|
const uint32_t kiPayloadSize = kuiSize;
|
|
|
|
uint8_t* pBuf = (uint8_t*) malloc (kiActualRequestedSize);
|
|
if (NULL == pBuf)
|
|
return NULL;
|
|
|
|
#ifdef MEMORY_CHECK
|
|
if (fpMemChkPoint == NULL) {
|
|
fpMemChkPoint = fopen ("./enc_mem_check_point.txt", "at+");
|
|
nCountRequestNum = 0;
|
|
}
|
|
|
|
if (fpMemChkPoint != NULL) {
|
|
if (kpTag != NULL)
|
|
fprintf (fpMemChkPoint, "WelsMalloc(), 0x%x : actual uiSize:\t%d\tbytes, input uiSize: %d bytes, %d - %s\n",
|
|
(void*)pBuf, kiActualRequestedSize, kuiSize, nCountRequestNum++, kpTag);
|
|
else
|
|
fprintf (fpMemChkPoint, "WelsMalloc(), 0x%x : actual uiSize:\t%d\tbytes, input uiSize: %d bytes, %d \n", (void*)pBuf,
|
|
kiActualRequestedSize, kuiSize, nCountRequestNum++);
|
|
fflush (fpMemChkPoint);
|
|
}
|
|
#endif
|
|
uint8_t* pAlignedBuffer;
|
|
pAlignedBuffer = pBuf + kiAlignedBytes + kiSizeOfVoidPointer + kiSizeOfInt;
|
|
pAlignedBuffer -= ((uintptr_t) pAlignedBuffer & kiAlignedBytes);
|
|
* ((void**) (pAlignedBuffer - kiSizeOfVoidPointer)) = pBuf;
|
|
* ((int32_t*) (pAlignedBuffer - (kiSizeOfVoidPointer + kiSizeOfInt))) = kiPayloadSize;
|
|
|
|
return pAlignedBuffer;
|
|
}
|
|
|
|
void WelsFree (void* pPointer, const char* kpTag) {
|
|
if (pPointer) {
|
|
#ifdef MEMORY_CHECK
|
|
if (fpMemChkPoint != NULL) {
|
|
if (kpTag != NULL)
|
|
fprintf (fpMemChkPoint, "WelsFree(), 0x%x - %s: \t%d\t bytes \n", (void*) (* (((void**) pPointer) - 1)), kpTag,
|
|
g_iMemoryLength);
|
|
else
|
|
fprintf (fpMemChkPoint, "WelsFree(), 0x%x \n", (void*) (* (((void**) pPointer) - 1)));
|
|
fflush (fpMemChkPoint);
|
|
}
|
|
#endif
|
|
free (* (((void**) pPointer) - 1));
|
|
}
|
|
}
|
|
|
|
void* CMemoryAlign::WelsMallocz (const uint32_t kuiSize, const char* kpTag) {
|
|
void* pPointer = WelsMalloc (kuiSize, kpTag);
|
|
if (NULL == pPointer) {
|
|
return NULL;
|
|
}
|
|
// zero memory
|
|
memset (pPointer, 0, kuiSize);
|
|
|
|
return pPointer;
|
|
}
|
|
|
|
void* CMemoryAlign::WelsMalloc (const uint32_t kuiSize, const char* kpTag) {
|
|
void* pPointer = WelsCommon::WelsMalloc (kuiSize, kpTag, m_nCacheLineSize);
|
|
#ifdef MEMORY_MONITOR
|
|
if (pPointer != NULL) {
|
|
const int32_t kiMemoryLength = * ((int32_t*) ((uint8_t*)pPointer - sizeof (void**) - sizeof (
|
|
int32_t))) + m_nCacheLineSize - 1 + sizeof (void**) + sizeof (int32_t);
|
|
m_nMemoryUsageInBytes += kiMemoryLength;
|
|
#ifdef MEMORY_CHECK
|
|
g_iMemoryLength = kiMemoryLength;
|
|
#endif
|
|
}
|
|
#endif//MEMORY_MONITOR
|
|
return pPointer;
|
|
}
|
|
|
|
void CMemoryAlign::WelsFree (void* pPointer, const char* kpTag) {
|
|
#ifdef MEMORY_MONITOR
|
|
if (pPointer) {
|
|
const int32_t kiMemoryLength = * ((int32_t*) ((uint8_t*)pPointer - sizeof (void**) - sizeof (
|
|
int32_t))) + m_nCacheLineSize - 1 + sizeof (void**) + sizeof (int32_t);
|
|
m_nMemoryUsageInBytes -= kiMemoryLength;
|
|
#ifdef MEMORY_CHECK
|
|
g_iMemoryLength = kiMemoryLength;
|
|
#endif
|
|
}
|
|
#endif//MEMORY_MONITOR
|
|
WelsCommon::WelsFree (pPointer, kpTag);
|
|
}
|
|
|
|
void* WelsMallocz (const uint32_t kuiSize, const char* kpTag) {
|
|
void* pPointer = WelsMalloc (kuiSize, kpTag, 16);
|
|
if (NULL == pPointer) {
|
|
return NULL;
|
|
}
|
|
memset (pPointer, 0, kuiSize);
|
|
return pPointer;
|
|
}
|
|
|
|
const uint32_t CMemoryAlign::WelsGetCacheLineSize() const {
|
|
return m_nCacheLineSize;
|
|
}
|
|
|
|
const uint32_t CMemoryAlign::WelsGetMemoryUsage() const {
|
|
return m_nMemoryUsageInBytes;
|
|
}
|
|
|
|
} // end of namespace WelsCommon
|