gdk_utils.c

这个是内存数据库中的一个管理工具

#line 41 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
#include "monetdb_config.h"

#ifndef GDK_NOLINK
#include "gdk.h"

#else /* GDK_NOLINK */

#undef GDKmalloc
#undef GDKrealloc
#undef GDKfree

#define GDKmalloc(size)	malloc(size)
#define GDKrealloc(buf,size)	realloc(buf,size)
#define GDKfree(buf)	free(buf)
#endif

int gdk_alloc_map = 1;
char GDKdbfarmStr[PATHLENGTH] = { "dbfarm" };
char GDKdbnameStr[PATHLENGTH] = { 0 };

BAT *GDKenv = NULL;

#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif

#ifdef HAVE_FTIME
#include <sys/timeb.h>
#endif

#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#ifdef HAVE_PWD_H
# include <pwd.h>
#endif

#ifdef NATIVE_WIN32
#define chdir _chdir
#endif


#line 90 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"


#line 106 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"

static int
GDKenvironment(str dbname, str dbfarm)
{
	if (dbname == 0) {
		fprintf(stdout, "!GDKenvironment: database name missing.\n");
		return 0;
	}
	if (dbfarm == 0) {
		fprintf(stdout, "!GDKenvironment: dbfarm missing.\n");
		return 0;
	}

	if (!MT_path_absolute(dbfarm)) {
		fprintf(stdout, "!GDKenvironment: wrong directory %s.\n", dbfarm);
		return 0;
	}

	strncpy(GDKdbnameStr, dbname, PATHLENGTH);
	strncpy(GDKdbfarmStr, dbfarm, PATHLENGTH);
	return 1;
}



#line 133 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
char *
GDKgetenv(const char *name)
{
	BUN b = BUNfnd(GDKenv, (ptr) name);

	if (b)
		return BUNtail(GDKenv, b);
	return NULL;
}



#line 147 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int
GDKgetenv_isyes(const char *name)
{
	char *val = GDKgetenv(name);

	if (val && strcasecmp(val, "yes") == 0) {
		return 1;
	}
	return 0;
}



#line 162 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void
GDKsetenv(str name, str value)
{
	BUNins(GDKenv, name, value, FALSE);
	BATfakeCommit(GDKenv);
}



#line 170 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"



#line 186 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
#define GDKLOCK	".gdk_lock"

static FILE *GDKlockFile = 0;

#define GDKLOGOFF	"LOGOFF"
#define GDKFOUNDDEAD	"FOUND	DEAD"
#define GDKLOGON	"LOGON"
#define GDKCRASH	"CRASH"



#line 199 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
/* VARARGS */
void
GDKlog(const char *format, ...)
{
	va_list ap;
	char *p = 0, buf[1024];
	int mustopen = GDKgetHome();
	time_t tm = time(0);

	if (!MT_initialized()) 
		return;

	va_start(ap, format);
	vsprintf(buf, format, ap);
	va_end(ap);

	/* remove forbidden characters from message */
	for (p = buf; (p = strchr(p, '\n')) != NULL; *p = ' ')
		;
	for (p = buf; (p = strchr(p, '@')) != NULL; *p = ' ')
		;

	fseek(GDKlockFile, 0, SEEK_END);
#ifndef HAVE_GETUID
#define getuid() 0
#endif
	fprintf(GDKlockFile, "USR=%d PID=%d TIME=%s @ %s", 
		(int) getuid(), (int) getpid(), ctime(&tm),buf);
	fflush(GDKlockFile);

	if (mustopen)
		GDKunlockHome();
}



#line 234 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"


#line 240 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
#ifndef NATIVE_WIN32
#include <signal.h>
#if 0 /* these are unused */
static RETSIGTYPE
BATSIGignore(int nr)
{
	GDKsyserror("! ERROR signal %d caught by thread %lx\n", nr, (size_t) MT_getpid());
}

static RETSIGTYPE
BATSIGabort(int nr)
{
	GDKfatal("BATSIGabort: signal %d caught by thread %lx\n", nr, (size_t) MT_getpid());
}
#endif

static RETSIGTYPE
BATSIGinterrupt(int nr)
{
	GDKexit(nr);
}

#ifdef SIGCHLD
static RETSIGTYPE
BATSIGchild(int nr)
{
	int status;

	(void) nr;

	while (waitpid(-1, &status, WNOHANG) > 0)
		;
	PARDEBUG THRprintf(GDKerr, "CHILD EXITED \n");

	(void) signal(SIGPIPE, BATSIGchild);
}
#endif


static RETSIGTYPE
BATSIGcrash(int nr)
{
	static int crash = 0;

	if (!crash++) {
		GDKerror("BATSIGcrash: Mserver internal error (%s), please restart.\n" "(One potential cause could be that your disk might be full...)\n",
#ifdef SIGBUS
			 nr == SIGBUS ? "Bus error" :
#endif
			 (nr == SIGSEGV ? "Segmentation fault" : "unknown"));
		GDKlog(GDKCRASH);
		MT_global_exit(1);
	}
}

static int
BATSIGinit(void)
{
#ifdef SIGBUS
	(void) signal(SIGBUS, BATSIGcrash);
#endif
	(void) signal(SIGSEGV, BATSIGcrash);
#ifdef SIGCHLD
	(void) signal(SIGCHLD, BATSIGchild);
#endif
/* HACK to pacify compiler */
#if (defined(__INTEL_COMPILER) && (SIZEOF_VOID_P > SIZEOF_INT))
#undef  SIG_IGN			/*((__sighandler_t)1 ) */
#define SIG_IGN   ((__sighandler_t)1L)
#endif

#ifdef SIGPIPE
	(void) signal(SIGPIPE, SIG_IGN);
#endif
#ifdef __SIGRTMIN
	(void) signal(__SIGRTMIN + 1, SIG_IGN);
#endif
#ifdef SIGHUP
	(void) signal(SIGHUP, MT_global_exit);
#endif
#ifdef SIGINT
	(void) signal(SIGINT, BATSIGinterrupt);
#endif
#ifdef SIGTERM
	(void) signal(SIGTERM, BATSIGinterrupt);
#endif
	return 0;
}
#endif	/* NATIVE_WIN32 */



#line 331 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"


#line 377 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
size_t GDK_mem_maxsize = GDK_VM_MAXSIZE;
size_t GDK_mem_bigsize = 1<<20;
size_t GDK_vm_minsize = GDK_VM_MAXSIZE;
size_t GDK_vm_maxsize = GDK_VM_MAXSIZE;

int GDK_vm_allocs = 0;
int GDK_mem_allocs = 0;

/* at least each 50M of memory increase, BBPtrim is run */
#define CHKMEM(meminc, vminc) do {					\
	int memchk = (meminc>0 && (++GDK_mem_allocs>=1000 || meminc>LL_CONSTANT(50000))); \
	int vmchk = (vminc>0 && (++GDK_vm_allocs>=10 || vminc>LL_CONSTANT(5000000))); \
	if (memchk || vmchk) GDKmemchk(memchk, vmchk);			\
} while (0)

#define SEG_SIZE(x,y)   ((x)+(((x)&((1<<(y))-1))?(1<<(y))-((x)&((1<<(y))-1)):0))
#define MAX_BIT         ((int) (sizeof(ssize_t)<<3))

/* histogram update macro */
#define GDKmallidx(idx,size)				\
	{						\
		int _mask;				\
		if (size < 128) {			\
			_mask = (1<<6);			\
			idx = 7;			\
		} else {				\
			_mask = (1<<(MAX_BIT-1));	\
			idx = MAX_BIT;			\
		}					\
		while(idx-- > 4) {			\
			if (_mask&size) break;		\
			_mask >>=1;			\
		}					\
	}

volatile size_t GDK_mallocedbytes_estimate = 0;
static ssize_t GDK_mem_cursize = 0;
static ssize_t GDK_vm_cursize = 0;

#ifdef GDK_MEM_TRACE
static int mtrace = 0;
#endif

size_t
GDKvm_heapsize(void)
{
#ifdef _CYGNUS_H_
	return ((size_t) (96 << 20));
#else
	size_t ret = GDKmem_heapsize();

#ifdef __linux__
	/* on linux, malloc may also use mmapped space, so the bytes-in-malloc may be much bigger than the sbrk() region */
	ret = MAX(GDK_mallocedbytes_estimate, ret);
#endif
	return ret;
#endif
}

size_t
GDKmem_heapsize(void)
{
	size_t heapsize = (MT_heapcur() - MT_heapbase);

	return (size_t) SEG_SIZE(heapsize, MT_VMUNITLOG);
}

size_t
GDKmem_inuse(void)
{
	/* RAM/swapmem that Monet is really using now */
	ssize_t mem_cursize = GDK_mem_cursize;
	size_t mem_mallocedbytes_estimate = GDK_mallocedbytes_estimate;

	if (mem_cursize < 0)
		mem_cursize = GDK_mem_cursize = 0;

	return mem_cursize + mem_mallocedbytes_estimate;
}

size_t
GDKmem_cursize(void)
{
	/* RAM/swapmem that Monet has claimed from OS */
	ssize_t mem_cursize = GDK_mem_cursize;

	if (mem_cursize < 0)
		mem_cursize = GDK_mem_cursize = 0;

	return mem_cursize + GDKmem_heapsize();
}

size_t
GDKvm_cursize(void)
{
	/* current Monet VM address space usage */
	ssize_t vm_cursize = GDK_vm_cursize;

	if (vm_cursize < 0)
		vm_cursize = GDK_vm_cursize = 0;

	return vm_cursize + GDKvm_heapsize();
}

#ifdef GDK_VM_KEEPHISTO
volatile ssize_t GDK_vm_nallocs[MAX_BIT] = { 0 };
#endif
#ifdef GDK_MEM_KEEPHISTO
volatile ssize_t GDK_nmallocs[MAX_BIT] = { 0 };
#endif

size_t
GDKmem_heapinuse(void)
{
	return GDK_mallocedbytes_estimate;
}

volatile int GDK_heapcheck_last = 0;
int mallinfo_ok = 1;

static INLINE void
GDKmem_heapcheck(int t)
{
	/* correct heap estimate with the real thing */
	if (mallinfo_ok) {
		struct mallinfo m = MT_mallinfo();
#if ((SIZEOF_VOID_P==8) && defined(HAVE_SIGNED_MALLINFO))
		if (m.usmblks < 0 || m.uordblks < 0 || m.hblkhd < 0) 
			mallinfo_ok = 0; /* incredible POSIX incompetence!! non-64-bit safe mallinfo */
		else 
#endif 
			GDK_mallocedbytes_estimate = (size_t) (m.usmblks + m.uordblks + m.hblkhd);
	}
	GDK_heapcheck_last = t;
}



#line 599 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
static void
GDKmemdump(void)
{
	struct mallinfo m = MT_mallinfo();

	THRprintf(GDKout, "\n#mallinfo.arena = " SSZFMT "\n", (ssize_t) m.arena);
	THRprintf(GDKout, "#mallinfo.ordblks = " SSZFMT "\n", (ssize_t) m.ordblks);
	THRprintf(GDKout, "#mallinfo.smblks = " SSZFMT "\n", (ssize_t) m.smblks);
	THRprintf(GDKout, "#mallinfo.hblkhd = " SSZFMT "\n", (ssize_t) m.hblkhd);
	THRprintf(GDKout, "#mallinfo.hblks = " SSZFMT "\n", (ssize_t) m.hblks);
	THRprintf(GDKout, "#mallinfo.usmblks = " SSZFMT "\n", (ssize_t) m.usmblks);
	THRprintf(GDKout, "#mallinfo.fsmblks = " SSZFMT "\n", (ssize_t) m.fsmblks);
	THRprintf(GDKout, "#mallinfo.uordblks = " SSZFMT "\n", (ssize_t) m.uordblks);
	THRprintf(GDKout, "#mallinfo.fordblks = " SSZFMT "\n", (ssize_t) m.fordblks);
#ifdef GDK_MEM_KEEPHISTO
	{
		int i;

		THRprintf(GDKout, "#memory histogram\n");
		for (i = 3; i < GDK_HISTO_MAX_BIT - 1; i++) {
			size_t j = 1 << i;

			THRprintf(GDKout, "# " SZFMT " " SZFMT "\n", j, GDK_nmallocs[i]);
		}
	}
#endif
#ifdef GDK_VM_KEEPHISTO
	{
		int i;

		THRprintf(GDKout, "\n#virtual memory histogram\n");
		for (i = 12; i < GDK_HISTO_MAX_BIT - 1; i++) {
			size_t j = 1 << i;

			THRprintf(GDKout, "# " SZFMT " " SZFMT "\n", j, GDK_vm_nallocs[i]);
		}
	}
#endif
}


static void
GDKmemchk(int memchk, int vmchk)
{
	size_t memtarget = GDKmem_inuse();
	size_t vmtarget = GDKvm_cursize();

	MEMDEBUG {
		/* Protect from being called recursivly because THRprintf
		   allocates memory */
		static int printing[THREADS];
		int tid = THRgettid();

		if (!printing[tid - 1]) {
			printing[tid - 1] = TRUE;
			THRprintf(GDKout, "#GDKmemchk (memcur=" SZFMT ",memmax=" SZFMT ") (vmcur=" SZFMT ",vmmax=" SZFMT ")\n", memtarget, GDK_mem_maxsize, GDKvm_cursize(), GDK_vm_maxsize);
			printing[tid - 1] = FALSE;
		}
	}
	memtarget = (memchk && memtarget > GDK_mem_maxsize) ? memtarget - GDK_mem_maxsize : 0;
	vmtarget = (vmchk && vmtarget > GDK_vm_maxsize) ? vmtarget - GDK_vm_maxsize : 0;
	if (memtarget > 0 || vmtarget > 0) {
		if (memtarget > 0) {
			int t = GDKms();

			/* check max every 10 secs, and only if its incorrectness bothers us (i.e. causes BBPtrim) */
			if ((t - GDK_heapcheck_last) > 10000) {
				GDKmem_heapcheck(t);	/* correct thread-unsafe estimate */
			}
		}
		BBPtrim(memtarget, vmtarget);
		GDK_mem_allocs = GDK_vm_allocs = 0;
	} else {
		if (memchk)
			GDK_mem_allocs = 0;
		if (vmchk)
			GDK_vm_allocs = 0;
	}
}



#line 680 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"



#line 692 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
#ifdef GDK_MEM_TRACE

static BAT *stackBat = NULL;
static BAT *memBat = NULL;
typedef ptr mem_t;

char *
stack_test(int i, int j)
{
	if (--i == 0)
		return (char *) GDKmalloc(j);

	return stack_test(i, j);
}


void
mtrace_test()
{
	char *t = stack_test(1, 1);

	GDKfree(t);
	GDKfree(t);		/* double delete */
	t = stack_test(2, 2);
	t = GDKrealloc(t, 20);	/* leaked */
}


static int
GDKmtrace(bit *enable)
{
	if (*enable) {
		if (memBat == NULL) {
			memBat = BATnew(TYPE_ptr, TYPE_int, 16384);
			if (memBat == NULL)
				return GDK_FAIL;
			stackBat = BATnew(TYPE_ptr, TYPE_ptr, 16384);