fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6ef113db1791f57773602bf3ea8857cd161efc40
harbour-core/harbour/source/vm/fm.c
Przemyslaw Czerpak 9169e0e94f 2009-07-03 08:28 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) 
+ harbour/include/hbtask.h
  + harbour/source/vm/task.c
  * harbour/include/hbthread.h
  * harbour/include/hbatomic.h
  * harbour/source/vm/thread.c
  * harbour/source/vm/hvm.c
  * harbour/source/vm/fm.c
  * harbour/source/rtl/idle.c
  * harbour/source/rtl/filesys.c
    + implemented OS independent task switching system - it gives PTHREAD
      compatible basic API so it can be used in HVM as alternative MT support
      which does not use any OS threads. As long as Harbour does not call
      any blocking OS function then it's possible to create and execute
      simultaneously many threads though only one CPU is used and switched
      between HVM threads. It gives similar scalability to xbase++ threads
      and also similar behavior in item protection at .prg level.
      Now it's possible to use HVM threads in any OS.
      Of course it does not mean that Harbour adds in some magic way
      thread support to OS-es which does not support threads like DOS.
      It only means that HVM supports threads for .prg code just like
      in native MT environment as long as some C code does not block
      task switching or process execution will not be frozen by sth, i.e.
      executing other process (__run()) in single process OS like DOS.
      In some cases it can be interesting alternative even in OS which
      have native thread support.
      All tests/mttest*.prg programs and speedtst --thread=<n> --scale
      are executed correctly with new task switching just like with
      OS native MT support.
      Compilation with task switching in hbvmmt library can be forced
      by HB_TASK_THREAD macro which also disable native OS threads
      support.
      For task context switching two alternative methods are used:
         1) getcontext()/makecontext()/swapcontext() (SUSv2, POSIX.1-2001)
            which is preferable because does not need any additional
            hacks but not all OS-es supports these functions.
            It's enabled by default in Linux builds.
         2) setjmp()/longjmp() (POSIX, ISO 9899 (C99)) otherwise.
            These functions are supported by most of C compilers
            but there is no function to set new stack in saved context
            so it's necessary to introduce for each architecure/C compiler
            peace of code which makes it. Macro HB_TASK_STACK_INIT() in
            task.c makes it. I defined this macro for x86@32 in DJGPP
            Linux GCC and OpenWatcom builds. I tested OpenWatcom builds only
            in DOS and Linux but probably it works in all x86@32 builds.
            If someone is interesting in adding support for some other
            platforms which does not support ucontext.h and 1-st methods
            then please define above macro for them.

      Have a fun with new toy ;-)

  * harbour/source/vm/Makefile
    * enabled hbvmmt in DJGPP and OpenWatcom DOS builds. It works well.
      Viktor if possible please add support for -mt switch in hbmk2
      in all builds even if we do not compile hbvmmt by default so
      it can be used with DJGPP and OW and any other builds for which
      someone enable hbtask.c though OS does not support threads.

  * harbour/contrib/hbmzip/hbmzip.c
    ! fixed '[const] char|BYTE *' casting in DOS and OS2 builds
2009-07-03 06:29:26 +00:00

1302 lines
35 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* Harbour Project source code:
* The Fixed Memory API
*
* Copyright 1999 Antonio Linares <alinares@fivetech.com>
* www - http://www.harbour-project.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries with other
* files to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
/*
* The following parts are Copyright of the individual authors.
* www - http://www.harbour-project.org
*
* Copyright 1999-2001 Viktor Szakats (harbour.01 syenar.hu)
* hb_xquery()
*
* See COPYING for licensing terms.
*
*/
/* NOTE: This definitions must be ahead of any and all #include statements */
#if !defined( HB_FM_STATISTICS ) && \
!defined( HB_FM_STATISTICS_OFF ) && \
!defined( HB_FM_STATISTICS_DYN_OFF )
# define HB_FM_STATISTICS_OFF
#endif
/* For MS-Win builds */
#define HB_OS_WIN_USED
/* For Linux and mremap() function */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
/* NOTE: For OS/2. Must be ahead of any and all #include statements */
#define INCL_BASE
#define INCL_DOSMISC
#define INCL_DOSERRORS
#define INCL_DOSPROCESS
/* malloc.h has been obsoleted by stdlib.h, which is included via
hbvmpub.h, which is include via hbapi.h
#include <malloc.h>
*/
#define HB_STACK_PRELOAD
#include "hbvmopt.h"
#include "hbapi.h"
#include "hbapiitm.h"
#include "hbapifs.h"
#include "hbstack.h"
#include "hbapierr.h"
#include "hbmemory.ch"
#include "hbdate.h"
#include "hbset.h"
#if defined( HB_MT_VM )
# include "hbthread.h"
# include "hbatomic.h"
#endif
#if defined( HB_FM_STD_ALLOC )
# undef HB_FM_DL_ALLOC
# undef HB_FM_WIN_ALLOC
#elif !defined( HB_FM_DL_ALLOC ) && !defined( HB_FM_WIN_ALLOC )
# if defined( _MSC_VER ) || defined( __BORLANDC__ ) || defined( __MINGW32__ ) || \
( defined( __WATCOMC__ ) && defined( HB_OS_WIN ) ) || \
( defined( HB_FM_DLMT_ALLOC ) && defined( HB_MT_VM ) )
# define HB_FM_DL_ALLOC
# else
/* #define HB_FM_DL_ALLOC */
# endif
#endif
#if defined( HB_FM_STATISTICS_OFF )
# undef HB_FM_STATISTICS
#endif
/* #define HB_FM_WIN_ALLOC */
/* #define HB_FM_STATISTICS */
/* #define HB_PARANOID_MEM_CHECK */
#if defined( HB_FM_DL_ALLOC )
/* # define NO_MALLINFO 1 */
/* # define INSECURE */
/* # define USE_DL_PREFIX */
# define REALLOC_ZERO_BYTES_FREES
# if defined( HB_MT_VM )
# define USE_LOCKS 1
# if defined( HB_FM_DLMT_ALLOC )
# define ONLY_MSPACES 1
# define FOOTERS 1
# endif
# else
# undef HB_FM_DLMT_ALLOC
# endif
# if defined( __BORLANDC__ )
# pragma warn -aus
# pragma warn -ccc
# pragma warn -eff
# pragma warn -ngu
# pragma warn -prc
# pragma warn -rch
# elif defined( HB_OS_WIN_CE ) && defined( __POCC__ )
# define ABORT TerminateProcess( GetCurrentProcess(), 0 )
# elif defined( __POCC__ ) && !defined( InterlockedCompareExchangePointer )
# define InterlockedCompareExchangePointer
# elif ( defined( _MSC_VER ) || defined( __WATCOMC__ ) ) && \
!defined( USE_DL_PREFIX ) && !defined( HB_FM_DLMT_ALLOC )
# define USE_DL_PREFIX
# endif
# include "dlmalloc.c"
# if defined( __BORLANDC__ )
# pragma warn +aus
# pragma warn +ccc
# pragma warn +eff
# pragma warn +ngu
# pragma warn +prc
# pragma warn +rch
# endif
# if defined( HB_FM_DLMT_ALLOC )
# define malloc( n ) mspace_malloc( hb_mspace(), ( n ) )
# define realloc( p, n ) mspace_realloc( NULL, ( p ), ( n ) )
# define free( p ) mspace_free( NULL, ( p ) )
# elif defined( USE_DL_PREFIX )
# define malloc( n ) dlmalloc( ( n ) )
# define realloc( p, n ) dlrealloc( ( p ), ( n ) )
# define free( p ) dlfree( ( p ) )
# endif
#else
# undef HB_FM_DLMT_ALLOC
# if defined( HB_FM_WIN_ALLOC ) && defined( HB_OS_WIN )
# if defined( HB_FM_LOCALALLOC )
# define malloc( n ) ( void * ) LocalAlloc( LMEM_FIXED, ( n ) )
# define realloc( p, n ) ( void * ) LocalReAlloc( ( HLOCAL ) ( p ), ( n ), LMEM_MOVEABLE )
# define free( p ) LocalFree( ( HLOCAL ) ( p ) )
# else
static HANDLE s_hProcessHeap = NULL;
# define HB_FM_NEED_INIT
# define HB_FM_HEAP_INIT
# define malloc( n ) ( void * ) HeapAlloc( s_hProcessHeap, 0, ( n ) )
# define realloc( p, n ) ( void * ) HeapReAlloc( s_hProcessHeap, 0, ( void * ) ( p ), ( n ) )
# define free( p ) HeapFree( s_hProcessHeap, 0, ( void * ) ( p ) )
# endif
# endif
#endif
#if defined( HB_MT_VM ) && ( defined( HB_FM_STATISTICS ) || \
defined( HB_FM_DLMT_ALLOC ) || \
!defined( HB_ATOM_INC ) || !defined( HB_ATOM_DEC ) )
static HB_CRITICAL_NEW( s_fmMtx );
# define HB_FM_LOCK hb_threadEnterCriticalSection( &s_fmMtx );
# define HB_FM_UNLOCK hb_threadLeaveCriticalSection( &s_fmMtx );
#else
# define HB_FM_LOCK
# define HB_FM_UNLOCK
#endif
#if defined( HB_FM_STATISTICS )
# if !defined( HB_FM_NEED_INIT )
# define HB_FM_NEED_INIT
# endif
#else
# undef HB_PARANOID_MEM_CHECK
#endif
#if defined( HB_FM_STATISTICS ) && !defined( HB_TR_LEVEL )
# define HB_TR_LEVEL HB_TR_ERROR
#endif
#ifdef HB_FM_NEED_INIT
static BOOL s_fInitedFM = FALSE;
#endif
#ifdef HB_FM_STATISTICS
#ifndef HB_MEMFILER
# define HB_MEMFILER 0xff
#endif
#define HB_MEMINFO_SIGNATURE 0x19730403
typedef struct _HB_MEMINFO
{
UINT32 u32Signature;
ULONG ulSize;
USHORT uiProcLine;
char szProcName[ HB_SYMBOL_NAME_LEN + 1 ];
struct _HB_MEMINFO * pPrevBlock;
struct _HB_MEMINFO * pNextBlock;
} HB_MEMINFO, * PHB_MEMINFO;
#ifdef HB_ALLOC_ALIGNMENT
# define _HB_MEMINFO_SIZE ( ( ( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) - \
( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) % HB_ALLOC_ALIGNMENT ) + \
HB_COUNTER_OFFSET )
#else
# define _HB_MEMINFO_SIZE ( sizeof( HB_MEMINFO ) + HB_COUNTER_OFFSET )
#endif
#define HB_MEMINFO_SIZE ( s_fStatistic ? sizeof( HB_MEMINFO ) + HB_COUNTER_OFFSET : HB_COUNTER_OFFSET )
#define HB_FM_GETSIG( p, n ) HB_GET_UINT32( ( BYTE * ) ( p ) + ( n ) )
#define HB_FM_SETSIG( p, n ) HB_PUT_UINT32( ( BYTE * ) ( p ) + ( n ), HB_MEMINFO_SIGNATURE )
#define HB_FM_CLRSIG( p, n ) HB_PUT_UINT32( ( BYTE * ) ( p ) + ( n ), 0 )
#define HB_ALLOC_SIZE( n ) ( ( n ) + ( s_fStatistic ? _HB_MEMINFO_SIZE + sizeof( UINT32 ) : HB_COUNTER_OFFSET ) )
#define HB_FM_PTR( p ) ( ( PHB_MEMINFO ) ( ( BYTE * ) ( p ) - HB_MEMINFO_SIZE ) )
#define HB_FM_BLOCKSIZE( p ) ( s_fStatistic ? HB_FM_PTR( pMem )->ulSize : 0 )
/* NOTE: we cannot use here HB_TRACE because it will overwrite the
* function name/line number of code which called hb_xalloc/hb_xgrab
*/
#define HB_TRACE_FM HB_TRACE_STEALTH
static BOOL s_fStatistic = FALSE;
static long s_lMemoryBlocks = 0; /* memory blocks used */
static long s_lMemoryMaxBlocks = 0; /* maximum number of used memory blocks */
static long s_lMemoryMaxConsumed = 0; /* memory size consumed */
static long s_lMemoryConsumed = 0; /* memory max size consumed */
static PHB_MEMINFO s_pFirstBlock = NULL;
static PHB_MEMINFO s_pLastBlock = NULL;
static char s_szFileName[ HB_PATH_MAX ] = { '\0' };
static char s_szInfo[ 256 ] = { '\0' };
#else /* ! HB_FM_STATISTICS */
typedef void * PHB_MEMINFO;
#define HB_MEMINFO_SIZE HB_COUNTER_OFFSET
#define HB_ALLOC_SIZE( n ) ( ( n ) + HB_MEMINFO_SIZE )
#define HB_FM_PTR( p ) HB_COUNTER_PTR( p )
#define HB_TRACE_FM HB_TRACE
#endif /* HB_FM_STATISTICS */
#define HB_MEM_PTR( p ) ( ( void * ) ( ( BYTE * ) ( p ) + HB_MEMINFO_SIZE ) )
#if !defined( HB_MT_VM )
# undef HB_ATOM_DEC
# undef HB_ATOM_INC
# undef HB_ATOM_GET
# undef HB_ATOM_SET
# define HB_ATOM_INC( p ) ( ++(*(p)) )
# define HB_ATOM_DEC( p ) ( --(*(p)) )
#elif !defined( HB_ATOM_INC ) || !defined( HB_ATOM_DEC )
/* HB_ATOM_INC and HB_ATOM_DEC have to be synced together */
# undef HB_ATOM_DEC
# undef HB_ATOM_INC
# undef HB_ATOM_GET
# undef HB_ATOM_SET
static __inline void hb_counterIncrement( volatile HB_COUNTER * p )
{
HB_FM_LOCK
++(*p);
HB_FM_UNLOCK
}
# define HB_ATOM_INC( p ) hb_counterIncrement( p )
static __inline int hb_counterDecrement( volatile HB_COUNTER * p )
{
int iResult;
HB_FM_LOCK
iResult = --(*p) != 0;
HB_FM_UNLOCK
return iResult;
}
# define HB_ATOM_DEC( p ) hb_counterDecrement( p )
#endif
#ifndef HB_ATOM_GET
# define HB_ATOM_GET( p ) (*(p))
#endif
#ifndef HB_ATOM_SET
# define HB_ATOM_SET( p, n ) ( (*(p)) = (n) )
#endif
#if defined( HB_FM_DLMT_ALLOC )
# if !defined( HB_MSPACE_COUNT )
# define HB_MSPACE_COUNT 16
# endif
typedef struct
{
int count;
mspace ms;
} HB_MSPACE, * PHB_MSPACE;
static mspace s_gm = NULL;
static HB_MSPACE s_mspool[ HB_MSPACE_COUNT ];
static mspace hb_mspace( void )
{
HB_STACK_TLS_PRELOAD
if( hb_stackId() && hb_stack.allocator )
return ( ( PHB_MSPACE ) hb_stack.allocator )->ms;
if( !s_gm )
s_gm = create_mspace( 0, 1 );
return s_gm;
}
static void hb_mspace_cleanup( void )
{
int i;
s_gm = NULL;
for( i = 0; i < HB_MSPACE_COUNT; ++i )
{
if( s_mspool[ i ].ms )
{
destroy_mspace( s_mspool[ i ].ms );
s_mspool[ i ].ms = NULL;
s_mspool[ i ].count = 0;
}
}
}
#elif defined( HB_FM_DL_ALLOC ) && defined( USE_DL_PREFIX )
static void dlmalloc_destroy( void )
{
if( ok_magic(gm) )
{
msegmentptr sp = &gm->seg;
while(sp != 0 )
{
char* base = sp->base;
size_t size = sp->size;
flag_t flag = sp->sflags;
sp = sp->next;
if( (flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) )
CALL_MUNMAP(base, size);
}
}
}
#endif
void hb_xinit_thread( void )
{
#if defined( HB_FM_DLMT_ALLOC )
HB_STACK_TLS_PRELOAD
if( hb_stack.allocator == NULL )
{
HB_FM_LOCK
if( s_mspool[ 0 ].ms == NULL && s_gm )
{
s_mspool[ 0 ].count = 1;
s_mspool[ 0 ].ms = s_gm;
hb_stack.allocator = ( void * ) &s_mspool[ 0 ];
}
else
{
int i, imin = 0;
for( i = 1; i < HB_MSPACE_COUNT; ++i )
{
if( s_mspool[ i ].count < s_mspool[ imin ].count )
imin = i;
}
if( s_mspool[ imin ].ms == NULL )
s_mspool[ imin ].ms = create_mspace( 0, 1 );
s_mspool[ imin ].count++;
hb_stack.allocator = ( void * ) &s_mspool[ imin ];
}
HB_FM_UNLOCK
}
#endif
}
void hb_xexit_thread( void )
{
#if defined( HB_FM_DLMT_ALLOC )
HB_STACK_TLS_PRELOAD
if( hb_stack.allocator != NULL )
{
HB_FM_LOCK
( ( PHB_MSPACE ) hb_stack.allocator )->count--;
hb_stack.allocator = NULL;
HB_FM_UNLOCK
}
#endif
}
void hb_xsetfilename( const char * szValue )
{
#ifdef HB_FM_STATISTICS
hb_strncpy( s_szFileName, szValue, sizeof( s_szFileName ) - 1 );
#else
HB_SYMBOL_UNUSED( szValue );
#endif
}
void hb_xsetinfo( const char * szValue )
{
#ifdef HB_FM_STATISTICS
hb_strncpy( s_szInfo, szValue, sizeof( s_szInfo ) - 1 );
#else
HB_SYMBOL_UNUSED( szValue );
#endif
}
void * hb_xalloc( ULONG ulSize ) /* allocates fixed memory, returns NULL on failure */
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL );
#ifdef HB_FM_NEED_INIT
if( !s_fInitedFM )
hb_xinit();
#endif
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
return pMem;
#ifdef HB_FM_STATISTICS
if( s_fStatistic )
{
HB_FM_LOCK
if( ! s_pFirstBlock )
{
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = pMem;
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
/* NOTE: PRG line number/procname is not very useful during hunting
* for memory leaks - this is why we are using the previously stored
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
pMem->uiProcLine = hb_tr_line_; /* C line number */
hb_strncpy( pMem->szProcName, hb_tr_file_, sizeof( pMem->szProcName ) - 1 );
}
else
{
hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine );
}
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
if( s_lMemoryMaxBlocks < s_lMemoryBlocks )
s_lMemoryMaxBlocks = s_lMemoryBlocks;
HB_FM_UNLOCK
#ifdef HB_PARANOID_MEM_CHECK
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
}
#endif /* HB_FM_STATISTICS */
HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ), 1 );
return HB_MEM_PTR( pMem );
}
void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exits on failure */
{
PHB_MEMINFO pMem;
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, NULL, NULL, NULL );
#ifdef HB_FM_NEED_INIT
if( !s_fInitedFM )
hb_xinit();
#endif
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
hb_errInternal( HB_EI_XGRABALLOC, NULL, NULL, NULL );
#ifdef HB_FM_STATISTICS
if( s_fStatistic )
{
HB_FM_LOCK
if( ! s_pFirstBlock )
{
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = pMem;
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
/* NOTE: PRG line number/procname is not very useful during hunting
* for memory leaks - this is why we are using the previously stored
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
pMem->uiProcLine = hb_tr_line_; /* C line number */
hb_strncpy( pMem->szProcName, hb_tr_file_, sizeof( pMem->szProcName ) - 1 );
}
else
{
hb_stackBaseProcInfo( pMem->szProcName, &pMem->uiProcLine );
}
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
if( s_lMemoryMaxBlocks < s_lMemoryBlocks )
s_lMemoryMaxBlocks = s_lMemoryBlocks;
HB_FM_UNLOCK
#ifdef HB_PARANOID_MEM_CHECK
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
}
#endif /* HB_FM_STATISTICS */
HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ), 1 );
return HB_MEM_PTR( pMem );
}
void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */
{
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
#if 0
/* disabled to make hb_xrealloc() ANSI-C realloc() compatible */
if( ! pMem )
hb_errInternal( HB_EI_XREALLOCNULL, NULL, NULL, NULL );
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
#endif
#ifdef HB_FM_STATISTICS
if( pMem == NULL )
{
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
return hb_xgrab( ulSize );
}
else if( ulSize == 0 )
{
hb_xfree( pMem );
return NULL;
}
else if( s_fStatistic )
{
PHB_MEMINFO pMemBlock;
ULONG ulMemSize;
pMemBlock = HB_FM_PTR( pMem );
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, NULL, NULL, NULL );
ulMemSize = pMemBlock->ulSize;
if( HB_FM_GETSIG( pMem, ulMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
HB_FM_CLRSIG( pMem, ulMemSize );
HB_FM_LOCK
#ifdef HB_PARANOID_MEM_CHECK
pMem = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMem )
{
if( ulSize > ulMemSize )
{
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulMemSize ) );
memset( ( BYTE * ) pMem + HB_ALLOC_SIZE( ulMemSize ), HB_MEMFILER, ulSize - ulMemSize );
}
else
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulSize ) );
}
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( ulMemSize ) );
free( pMemBlock );
#else
pMem = realloc( pMemBlock, HB_ALLOC_SIZE( ulSize ) );
#endif
s_lMemoryConsumed += ( ulSize - ulMemSize );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
if( pMem )
{
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
if( ( ( PHB_MEMINFO ) pMem )->pPrevBlock )
( ( PHB_MEMINFO ) pMem )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
if( ( ( PHB_MEMINFO ) pMem )->pNextBlock )
( ( PHB_MEMINFO ) pMem )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pMem;
if( s_pFirstBlock == pMemBlock )
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
if( s_pLastBlock == pMemBlock )
s_pLastBlock = ( PHB_MEMINFO ) pMem;
}
HB_FM_UNLOCK
}
else
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
#else
if( pMem == NULL )
{
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
pMem = malloc( HB_ALLOC_SIZE( ulSize ) );
}
else if( ulSize == 0 )
{
free( HB_FM_PTR( pMem ) );
return NULL;
}
else
{
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) );
}
if( !pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
#endif
return HB_MEM_PTR( pMem );
}
void hb_xfree( void * pMem ) /* frees fixed memory */
{
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xfree(%p)", pMem));
if( pMem )
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock = HB_FM_PTR( pMem );
if( s_fStatistic )
{
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if( HB_FM_GETSIG( pMem, pMemBlock->ulSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
HB_FM_LOCK
s_lMemoryConsumed -= pMemBlock->ulSize + sizeof( HB_COUNTER );
s_lMemoryBlocks--;
if( pMemBlock->pPrevBlock )
pMemBlock->pPrevBlock->pNextBlock = pMemBlock->pNextBlock;
else
s_pFirstBlock = pMemBlock->pNextBlock;
if( pMemBlock->pNextBlock )
pMemBlock->pNextBlock->pPrevBlock = pMemBlock->pPrevBlock;
else
s_pLastBlock = pMemBlock->pPrevBlock;
HB_FM_UNLOCK
pMemBlock->u32Signature = 0;
HB_FM_CLRSIG( pMem, pMemBlock->ulSize );
#ifdef HB_PARANOID_MEM_CHECK
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( pMemBlock->ulSize ) );
#endif
}
free( ( void * ) pMemBlock );
#else
free( HB_FM_PTR( pMem ) );
#endif
}
else
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
/* increment reference counter */
#undef hb_xRefInc
void hb_xRefInc( void * pMem )
{
HB_ATOM_INC( HB_COUNTER_PTR( pMem ) );
}
/* decrement reference counter, return TRUE when 0 reached */
#undef hb_xRefDec
BOOL hb_xRefDec( void * pMem )
{
return HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0;
}
/* decrement reference counter and free the block when 0 reached */
#undef hb_xRefFree
void hb_xRefFree( void * pMem )
{
#ifdef HB_FM_STATISTICS
if( s_fStatistic && HB_FM_PTR( pMem )->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 )
hb_xfree( pMem );
#else
if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 )
free( HB_FM_PTR( pMem ) );
#endif
}
/* return number of references */
#undef hb_xRefCount
HB_COUNTER hb_xRefCount( void * pMem )
{
return HB_ATOM_GET( HB_COUNTER_PTR( pMem ) );
}
/* reallocates memory, create copy if reference counter greater then 1 */
#undef hb_xRefResize
void * hb_xRefResize( void * pMem, ULONG ulSave, ULONG ulSize, ULONG * pulAllocated )
{
#ifdef HB_FM_STATISTICS
if( HB_ATOM_GET( HB_COUNTER_PTR( pMem ) ) > 1 )
{
void * pMemNew = memcpy( hb_xgrab( ulSize ), pMem, HB_MIN( ulSave, ulSize ) );
if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 )
hb_xfree( pMem );
*pulAllocated = ulSize;
return pMemNew;
}
else if( ulSize <= *pulAllocated )
return pMem;
*pulAllocated = ulSize;
return hb_xrealloc( pMem, ulSize );
#else
if( HB_ATOM_GET( HB_COUNTER_PTR( pMem ) ) > 1 )
{
void * pMemNew = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMemNew )
{
HB_ATOM_SET( HB_COUNTER_PTR( HB_MEM_PTR( pMemNew ) ), 1 );
memcpy( HB_MEM_PTR( pMemNew ), pMem, HB_MIN( ulSave, ulSize ) );
if( HB_ATOM_DEC( HB_COUNTER_PTR( pMem ) ) == 0 )
free( HB_FM_PTR( pMem ) );
*pulAllocated = ulSize;
return HB_MEM_PTR( pMemNew );
}
}
else if( ulSize <= *pulAllocated )
return pMem;
else
{
*pulAllocated = ulSize;
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) );
if( pMem )
return HB_MEM_PTR( pMem );
}
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
return NULL;
#endif
}
/* NOTE: Debug function, it will always return 0 when HB_FM_STATISTICS is
not defined, don't use it for final code [vszakats] */
ULONG hb_xsize( void * pMem ) /* returns the size of an allocated memory block */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xsize(%p)", pMem));
#ifdef HB_FM_STATISTICS
return HB_FM_BLOCKSIZE( pMem );
#else
HB_SYMBOL_UNUSED( pMem );
return 0;
#endif
}
void hb_xinit( void ) /* Initialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xinit()"));
#ifdef HB_FM_NEED_INIT
if( !s_fInitedFM )
{
#ifdef HB_FM_STATISTICS
char buffer[ 5 ];
if( hb_getenv_buffer( "HB_FM_STAT", buffer, sizeof( buffer ) ) )
{
if( hb_stricmp( "yes", buffer ) == 0 )
s_fStatistic = TRUE;
else if( hb_stricmp( "no", buffer ) == 0 )
s_fStatistic = FALSE;
}
#ifndef HB_FM_STATISTICS_DYN_OFF
else
s_fStatistic = TRUE; /* enabled by default */
#endif /* HB_FM_STATISTICS_DYN_OFF */
#endif /* HB_FM_STATISTICS */
#if defined( HB_FM_HEAP_INIT )
s_hProcessHeap = GetProcessHeap();
#endif
s_fInitedFM = TRUE;
}
#endif /* HB_FM_NEED_INIT */
}
/* Returns pointer to string containing printable version
of pMem memory block */
#ifdef HB_FM_STATISTICS
static char * hb_mem2str( char * membuffer, void * pMem, UINT uiSize )
{
BYTE *cMem = ( BYTE * ) pMem;
UINT uiIndex, uiPrintable;
uiPrintable = 0;
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
if( ( cMem[ uiIndex ] & 0x60 ) != 0 )
uiPrintable++;
if( uiPrintable * 100 / uiSize > 70 ) /* more then 70% printable chars */
{
/* format as string of original chars */
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
if( cMem[ uiIndex ] >= ' ' )
membuffer[ uiIndex ] = cMem[ uiIndex ];
else
membuffer[ uiIndex ] = '.';
membuffer[ uiIndex ] = '\0';
}
else
{
/* format as hex */
for( uiIndex = 0; uiIndex < uiSize; uiIndex++ )
{
int lownibble, hinibble;
hinibble = cMem[ uiIndex ] >> 4;
lownibble = cMem[ uiIndex ] & 0x0F;
membuffer[ uiIndex * 2 ] = hinibble <= 9 ?
( '0' + hinibble ) : ( 'A' + hinibble - 10 );
membuffer[ uiIndex * 2 + 1 ] = lownibble <= 9 ?
( '0' + lownibble ) : ( 'A' + lownibble - 10 );
}
membuffer[ uiIndex * 2 ] = '\0';
}
return membuffer;
}
#define HB_MAX_MEM2STR_BLOCK 256
void hb_xexit( void ) /* Deinitialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xexit()"));
if( s_lMemoryBlocks || hb_cmdargCheck( "INFO" ) )
{
char membuffer[ HB_MAX_MEM2STR_BLOCK * 2 + 1 ]; /* multiplied by 2 to allow hex format */
PHB_MEMINFO pMemBlock;
USHORT ui;
char buffer[ 100 ];
FILE * hLog = NULL;
if( s_lMemoryBlocks && s_szFileName[ 0 ] )
hLog = hb_fopen( s_szFileName, "a+" );
hb_conOutErr( hb_conNewLine(), 0 );
hb_conOutErr( "----------------------------------------", 0 );
hb_conOutErr( hb_conNewLine(), 0 );
hb_snprintf( buffer, sizeof( buffer ), HB_I_("Total memory allocated: %li bytes (%li block(s))"), s_lMemoryMaxConsumed, s_lMemoryMaxBlocks );
hb_conOutErr( buffer, 0 );
if( s_lMemoryBlocks )
{
if( hLog )
{
char szTime[ 9 ];
int iYear, iMonth, iDay;
hb_dateToday( &iYear, &iMonth, &iDay );
hb_dateTimeStr( szTime );
fprintf( hLog, HB_I_("Application Memory Allocation Report - %s\n"), hb_cmdargARGVN( 0 ) );
fprintf( hLog, HB_I_("Terminated at: %04d.%02d.%02d %s\n"), iYear, iMonth, iDay, szTime );
if( s_szInfo[ 0 ] )
fprintf( hLog, HB_I_("Info: %s\n"), s_szInfo );
fprintf( hLog, "%s\n", buffer );
}
hb_conOutErr( hb_conNewLine(), 0 );
hb_snprintf( buffer, sizeof( buffer ), HB_I_("Warning, memory allocated but not released: %li bytes (%li block(s))"), s_lMemoryConsumed, s_lMemoryBlocks );
hb_conOutErr( buffer, 0 );
if( hLog )
fprintf( hLog, "%s\n", buffer );
}
hb_conOutErr( hb_conNewLine(), 0 );
for( ui = 1, pMemBlock = s_pFirstBlock; pMemBlock; pMemBlock = pMemBlock->pNextBlock, ++ui )
{
HB_TRACE( HB_TR_ERROR, ( "Block %i (size %lu) %s(%i), \"%s\"", ui,
pMemBlock->ulSize, pMemBlock->szProcName, pMemBlock->uiProcLine,
hb_mem2str( membuffer, ( char * ) HB_MEM_PTR( pMemBlock ),
HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) ) );
if( hLog )
{
fprintf( hLog, HB_I_("Block %i %p (size %lu) %s(%i), \"%s\"\n"), ui,
( char * ) HB_MEM_PTR( pMemBlock ),
pMemBlock->ulSize, pMemBlock->szProcName, pMemBlock->uiProcLine,
hb_mem2str( membuffer, ( char * ) HB_MEM_PTR( pMemBlock ),
HB_MIN( pMemBlock->ulSize, HB_MAX_MEM2STR_BLOCK ) ) );
}
}
if( hLog )
{
fprintf( hLog, "------------------------------------------------------------------------\n");
fclose( hLog );
}
}
#if defined( HB_FM_DL_ALLOC )
# if defined( HB_FM_DLMT_ALLOC )
hb_mspace_cleanup();
# elif defined( USE_DL_PREFIX )
dlmalloc_destroy();
# else
malloc_trim( 0 );
# endif
#endif
}
#else
void hb_xexit( void ) /* Deinitialize fixed memory subsystem */
{
HB_TRACE(HB_TR_DEBUG, ("hb_xexit()"));
#if defined( HB_FM_DL_ALLOC )
# if defined( HB_FM_DLMT_ALLOC )
hb_mspace_cleanup();
# elif defined( USE_DL_PREFIX )
dlmalloc_destroy();
# else
malloc_trim( 0 );
# endif
#endif
}
#endif
ULONG hb_xquery( USHORT uiMode )
{
ULONG ulResult;
HB_TRACE(HB_TR_DEBUG, ("hb_xquery(%hu)", uiMode));
/* TODO: Return the correct values instead of 9999 [vszakats] */
switch( uiMode )
{
case HB_MEM_CHAR: /* (Free Variable Space [KB]) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_BLOCK: /* (Largest String [KB]) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = HB_MIN( memorystatus.dwAvailPhys, ULONG_MAX ) / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = HB_MIN( ulSysInfo, ULONG_MAX ) / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_RUN: /* (RUN Memory [KB]) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_VM: /* UNDOCUMENTED! (Virtual Memory [KB]) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailVirtual / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_TOTAVAILMEM, QSV_TOTAVAILMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_EMS: /* UNDOCUMENTED! (Free Expanded Memory [KB]) (?) */
#if defined(HB_OS_WIN) || defined(HB_OS_OS2)
ulResult = 0;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_FM: /* UNDOCUMENTED! (Fixed Memory/Heap [KB]) (?) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwTotalPhys / 1024;
}
#elif defined(HB_OS_OS2)
{
ULONG ulSysInfo = 0;
if( DosQuerySysInfo( QSV_MAXPRMEM, QSV_MAXPRMEM, &ulSysInfo, sizeof( ULONG ) ) != NO_ERROR )
ulResult = 0;
else
ulResult = ulSysInfo / 1024;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_FMSEGS: /* UNDOCUMENTED! (Segments in Fixed Memory/Heap) (?) */
#if defined(HB_OS_WIN) || defined(HB_OS_OS2)
ulResult = 1;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_SWAP: /* UNDOCUMENTED! (Free Swap Memory [KB]) */
#if defined(HB_OS_WIN)
{
MEMORYSTATUS memorystatus;
GlobalMemoryStatus( &memorystatus );
ulResult = memorystatus.dwAvailPageFile / 1024;
}
#elif defined(HB_OS_OS2)
{
/* NOTE: There is no way to know how much a swap file can grow on an
OS/2 system. I think we should return free space on DASD
media which contains swap file [maurilio.longo] */
ulResult = 9999;
}
#else
ulResult = 9999;
#endif
break;
case HB_MEM_CONV: /* UNDOCUMENTED! (Free Conventional [KB]) */
#if defined(HB_OS_WIN) || defined(HB_OS_OS2)
ulResult = 0;
#else
ulResult = 9999;
#endif
break;
case HB_MEM_EMSUSED: /* UNDOCUMENTED! (Used Expanded Memory [KB]) (?) */
ulResult = 0;
break;
case HB_MEM_USED: /* Harbour extension (Memory used [bytes]) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryConsumed;
#else
ulResult = 0;
#endif
break;
case HB_MEM_BLOCKS: /* Harbour extension (Memory blocks used) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryBlocks;
#else
ulResult = 0;
#endif
break;
case HB_MEM_USEDMAX: /* Harbour extension (Maximum memory used [bytes]) */
#ifdef HB_FM_STATISTICS
ulResult = s_lMemoryMaxConsumed;
#else
ulResult = 0;
#endif
break;
case HB_MEM_STACKITEMS: /* Harbour extension (Total items allocated for the stack) */
{
HB_STACK_TLS_PRELOAD
ulResult = hb_stackTotalItems();
break;
}
case HB_MEM_STACK: /* Harbour extension (Total memory size used by the stack [bytes]) */
{
HB_STACK_TLS_PRELOAD
ulResult = hb_stackTotalItems() * sizeof( HB_ITEM );
break;
}
case HB_MEM_STACK_TOP : /* Harbour extension (Total items currently on the stack) */
{
HB_STACK_TLS_PRELOAD
ulResult = hb_stackTopOffset( );
break;
}
default:
ulResult = 0;
}
return ulResult;
}
#if defined( __cplusplus ) && defined( HB_FM_STATISTICS )
void * operator new( size_t nSize )
{
return hb_xgrab( nSize );
}
void operator delete( void * p )
{
hb_xfree( p );
}
#endif
Reference in New Issue View Git Blame Copy Permalink