161 lines
4.3 KiB
C++
161 lines
4.3 KiB
C++
/*
|
|
* NOTICE and LICENSE for Tecplot Input/Output Library (TecIO) - OpenFOAM
|
|
*
|
|
* Copyright (C) 1988-2009 Tecplot, Inc. All rights reserved worldwide.
|
|
*
|
|
* Tecplot hereby grants OpenCFD limited authority to distribute without
|
|
* alteration the source code to the Tecplot Input/Output library, known
|
|
* as TecIO, as part of its distribution of OpenFOAM and the
|
|
* OpenFOAM_to_Tecplot converter. Users of this converter are also hereby
|
|
* granted access to the TecIO source code, and may redistribute it for the
|
|
* purpose of maintaining the converter. However, no authority is granted
|
|
* to alter the TecIO source code in any form or manner.
|
|
*
|
|
* This limited grant of distribution does not supersede Tecplot, Inc.'s
|
|
* copyright in TecIO. Contact Tecplot, Inc. for further information.
|
|
*
|
|
* Tecplot, Inc.
|
|
* 3535 Factoria Blvd, Ste. 550
|
|
* Bellevue, WA 98006, USA
|
|
* Phone: +1 425 653 1200
|
|
* http://www.tecplot.com/
|
|
*
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "MASTER.h"
|
|
|
|
#define TECPLOTENGINEMODULE
|
|
|
|
/*
|
|
******************************************************************
|
|
******************************************************************
|
|
******* ********
|
|
****** (C) 1988-2008 Tecplot, Inc. *******
|
|
******* ********
|
|
******************************************************************
|
|
******************************************************************
|
|
*/
|
|
|
|
#define ALLOCMODULE
|
|
#include "GLOBAL.h"
|
|
#include "ALLOC.h"
|
|
#include "TASSERT.h"
|
|
#if defined TECPLOTKERNEL
|
|
/* CORE SOURCE CODE REMOVED */
|
|
#endif
|
|
|
|
#if defined TRACK_MEMORY_USAGE
|
|
static size_t memInUse = 0;
|
|
static size_t memTotalHighMark = 0;
|
|
static size_t memCurrentHighMark = 0;
|
|
static size_t memSavedHighMark = 0;
|
|
Mutex_pa memMutex;
|
|
|
|
void initMemoryUsageTracking(void)
|
|
{
|
|
REQUIRE(!Thread_ThreadingIsInitialized());
|
|
Thread_InitMutex(&memMutex);
|
|
}
|
|
|
|
void cleanUpMemoryUsageTracking(void)
|
|
{
|
|
REQUIRE(!Thread_ThreadingIsInitialized());
|
|
Thread_FreeMutex(&memMutex);
|
|
}
|
|
|
|
void trackMemoryClearHighMark(void)
|
|
{
|
|
memCurrentHighMark = memInUse;
|
|
}
|
|
|
|
void trackMemorySaveHighMark(void)
|
|
{
|
|
memSavedHighMark = memCurrentHighMark;
|
|
}
|
|
|
|
void trackMemoryAlloc(size_t size)
|
|
{
|
|
REQUIRE(memInUse >= 0);
|
|
|
|
if (Thread_ThreadingIsInitialized())
|
|
Thread_LockMutex(memMutex);
|
|
|
|
memInUse += size;
|
|
if (memInUse > memTotalHighMark)
|
|
memTotalHighMark = memInUse;
|
|
if (memInUse > memCurrentHighMark)
|
|
memCurrentHighMark = memInUse;
|
|
|
|
if (Thread_ThreadingIsInitialized())
|
|
Thread_UnlockMutex(memMutex);
|
|
}
|
|
|
|
void trackMemoryFree(size_t size)
|
|
{
|
|
if (Thread_ThreadingIsInitialized())
|
|
Thread_LockMutex(memMutex);
|
|
|
|
memInUse -= size;
|
|
|
|
if (Thread_ThreadingIsInitialized())
|
|
Thread_UnlockMutex(memMutex);
|
|
|
|
ENSURE(memInUse >= 0);
|
|
}
|
|
|
|
void getMemoryUsage(size_t* memoryInUse,
|
|
size_t* memoryCurrentHighMark,
|
|
size_t* memorySavedHighMark,
|
|
size_t* memoryTotalHighMark)
|
|
{
|
|
REQUIRE(VALID_REF_OR_NULL(memoryInUse));
|
|
REQUIRE(VALID_REF_OR_NULL(memoryCurrentHighMark));
|
|
REQUIRE(VALID_REF_OR_NULL(memorySavedHighMark));
|
|
REQUIRE(VALID_REF_OR_NULL(memoryTotalHighMark));
|
|
if (memoryInUse != NULL)
|
|
*memoryInUse = memInUse;
|
|
if (memoryCurrentHighMark != NULL)
|
|
*memoryCurrentHighMark = memCurrentHighMark;
|
|
if (memorySavedHighMark != NULL)
|
|
*memorySavedHighMark = memSavedHighMark;
|
|
if (memoryTotalHighMark != NULL)
|
|
*memoryTotalHighMark = memTotalHighMark;
|
|
}
|
|
#endif
|
|
|
|
#if defined MSWIN && defined ALLOC_HEAP
|
|
#define HEAPMIN 512
|
|
#endif
|
|
|
|
#if defined MSWIN && defined ALLOC_HEAP
|
|
/**
|
|
*/
|
|
void *MSWinAlloc(DWORD nSize)
|
|
{
|
|
long *pMem = NULL;
|
|
if (nSize < HEAPMIN)
|
|
pMem = (long *)malloc(sizeof(long) + nSize);
|
|
else
|
|
pMem = (long *)HeapAlloc(GetProcessHeap(), NULL, sizeof(long) + nSize);
|
|
if (pMem)
|
|
pMem[0] = nSize;
|
|
return (void *)&(pMem[1]);
|
|
}
|
|
#endif
|
|
|
|
#if defined MSWIN && defined ALLOC_HEAP
|
|
/**
|
|
*/
|
|
void MSWinFree(void *pMem)
|
|
{
|
|
REQUIRE(VALID_REF(pMem));
|
|
if (pMem)
|
|
{
|
|
long *pMemLong = &(((long *)pMem)[-1]);
|
|
if (pMemLong[0] < HEAPMIN)
|
|
free((void *)pMemLong);
|
|
else
|
|
HeapFree(GetProcessHeap(), NULL, (void *)pMemLong);
|
|
}
|
|
}
|
|
#endif
|