gdk_utils.c

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

	return GDKreallocmax(blk, size, &size, 1);
}


char *
GDKstrdup(const char *s)
{
	int l = strLen(s);
	char *n = (char *) GDKmalloc(l);

	memcpy(n, s, l);
	return n;
}




#line 1219 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void
GDKvminc(size_t len)
{
	
#line 563 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) 0;
		size_t _vmdelta = (size_t) SEG_SIZE(len,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKvminc");
		GDK_mem_cursize += _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]++;
		}
#endif
		GDK_vm_cursize += _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKvminc");
	}



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

	CHKMEM(0, len);
}

void *
GDKmmap(char *path, int mode, off_t off, size_t len)
{
	void *ret = MT_mmap(path, mode, off, len);

	if (ret == (void *) -1L) {
		GDKmemfail("GDKmmap", len, 0, BBPTRIM_ALL);
		ret = MT_mmap(path, mode, off, len);
		if (ret != (void *) -1L) {
			THRprintf(GDKout, "#GDKmmap: recovery ok. Continuing..\n");
		}
	}
	if (ret != (void *) -1L) {
		MT_alloc_register(ret, len, 'M');
		GDKvminc(len);
	}
	return (void *) ret;
}

int
GDKmunmap(void *addr, size_t size)
{
	int ret;

	MT_alloc_register(addr, size, 'm');
	ret = MT_munmap(addr, size);
	if (ret == 0) {
		
#line 582 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) 0;
		size_t _vmdelta = (size_t) SEG_SIZE(size,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKunmap");
		GDK_mem_cursize -= _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]--;
		}
#endif
		GDK_vm_cursize -= _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKunmap");
	}


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

	}
	return ret;
}




#line 1264 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void *
GDKvmalloc(size_t size, size_t * maxsize, int emergency)
{
	void *ret = MT_vmalloc(size, maxsize);

	if (ret == NULL) {
		GDKmemfail("GDKvmalloc", size, BBPTRIM_ALL, BBPTRIM_ALL);
		ret = MT_vmalloc(size, maxsize);
		if (ret == NULL) {
			if (emergency == 0)
				return NULL;
			MT_alloc_print();
			GDKfatal("GDKvmalloc: failed for %u bytes", size);
		} else {
			THRprintf(GDKout, "#GDKvmalloc(" SZFMT "): recovery ok. Continuing..\n", size);
		}
	}
	if (ret != NULL) {
		
#line 563 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) size;
		size_t _vmdelta = (size_t) SEG_SIZE(*maxsize,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKvmalloc");
		GDK_mem_cursize += _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]++;
		}
#endif
		GDK_vm_cursize += _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKvmalloc");
	}



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

		CHKMEM(size, *maxsize);
	}
	return ret;
}

void *
GDKvmrealloc(void *pold, size_t oldsize, size_t newsize, size_t oldmax, size_t * newmax, int emergency)
{
	void *ret = MT_vmrealloc(pold, oldsize, newsize, oldmax, newmax);

	if (ret == NULL) {
		GDKmemfail("GDKvrealloc", newsize, BBPTRIM_ALL, BBPTRIM_ALL);
		ret = MT_vmrealloc(pold, oldsize, newsize, oldmax, newmax);
		if (ret == NULL) {
			if (emergency == 0)
				return NULL;
			MT_alloc_print();
			GDKfatal("GDKvrealloc: failed for %u bytes (from %u)", newsize, oldsize);
		} else {
			THRprintf(GDKout, "#GDKvmrealloc(" SZFMT "): recovery ok. Continuing..\n", newsize);
		}
	}
	if (ret != NULL) {
		
#line 582 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) oldsize;
		size_t _vmdelta = (size_t) SEG_SIZE(oldmax,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKvmrealloc");
		GDK_mem_cursize -= _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]--;
		}
#endif
		GDK_vm_cursize -= _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKvmrealloc");
	}


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

		
#line 563 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) newsize;
		size_t _vmdelta = (size_t) SEG_SIZE(*newmax,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKvmrealloc");
		GDK_mem_cursize += _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]++;
		}
#endif
		GDK_vm_cursize += _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKvmrealloc");
	}



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

		CHKMEM(newsize, *newmax);
	}
	return ret;
}

void
GDKvmfree(void *blk, size_t size, size_t maxsize)
{
	MT_vmfree(blk, maxsize);
	
#line 582 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	{
		size_t _memdelta = (size_t) size;
		size_t _vmdelta = (size_t) SEG_SIZE(maxsize,MT_VMUNITLOG);

		gdk_set_lock(GDKthreadLock, "GDKvmfree");
		GDK_mem_cursize -= _memdelta;
#ifdef GDK_VM_KEEPHISTO
		{
			int _idx;
			GDKmallidx(_idx, _vmdelta);
			GDK_vm_nallocs[_idx]--;
		}
#endif
		GDK_vm_cursize -= _vmdelta;
		gdk_unset_lock(GDKthreadLock, "GDKvmfree");
	}


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

}



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



#line 1344 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int GDKtime_startsec, GDKrecovery = 0;



#line 1350 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void
GDKprotect(void)
{
	int i;

	if (GDKprotected == 0) {
		TMDEBUG printf("# GDKlocks created\n");

		MT_init_lock(GDKthreadLock);
		for (i = 0; i <= BBPLOCKMASK; i++) {
			MT_init_lock(GDKswapLock[i]);
			MT_init_lock(GDKhashLock[i]);
		}
		MT_init_lock(GDKcacheLock);
		MT_init_lock(GDKunloadLock);
		MT_init_cond(GDKunloadCond);
		MT_init_lock(GDKtrimLock);
		MT_init_lock(GDKtmLock);
		GDKprotected = 1;
	}
}

#ifndef WIN32
static void
GDKvmtrim(void *limit)
{
	int wt = 1;

	do {
		stream *fp = NULL;

		MT_sleep_ms(wt ? 5000 : 500);
		MEMDEBUG {
			fp = GDKout;
			THRprintf(fp, "#GDKvmtrim(" LLFMT ")\n", (long long) *(size_t *) limit);
		}
		wt = !MT_mmap_trim(*(size_t *) limit, fp);
	} while (!GDKstopped);
}
#endif

int
GDKinit(char *dbname, char *dbfarm, int alloc_map)
{
	gdk_alloc_map = alloc_map;
	errno = 0;
	if (!GDKenvironment(dbname, dbfarm))
		return 0;

	stream_init();
	MT_init_posix(alloc_map);
	THRinit();
#ifndef NATIVE_WIN32
	BATSIGinit();
#endif
	GDKlockHome();

	/* init time */
#ifdef HAVE_GETTIMEOFDAY
	{
		struct timeval tp;

		gettimeofday(&tp, NULL);
		GDKtime_startsec = tp.tv_sec;
	}
#else
#ifdef HAVE_FTIME
	{
		struct timeb tb;

		ftime(&tb);
		GDKtime_startsec = (int) tb.time;
	}
#endif
#endif

	if (GDKembedded)
		GDKprotected = 0;

	/* Mserver intends to rob 95% of all memory as a default */
	GDK_vm_minsize = GDK_mem_maxsize = (size_t) ((double) MT_npages() * (double) MT_pagesize() * 0.815);

	GDKmemchk(TRUE, TRUE);
	GDKremovedir(DELDIR);
	BBPinit();
	GDKenv = BATnew(TYPE_str, TYPE_str, 100);
	if (GDKenv == NULL)
		GDKfatal("GDKinit: Could not create environment BAT");
	BATrename(GDKenv, "monet_environment");
	BATmode(GDKenv, TRANSIENT);
#ifndef WIN32
	if (!GDKembedded) {
		MT_Id t;

		MT_create_thread(&t, GDKvmtrim, &GDK_mem_maxsize);
	}
#endif
	return 1;
}



#line 1458 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int GDKstopped = 1;



#line 1464 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void
GDKexit(int status)
{
	gdk_set_lock(GDKthreadLock, "GDKexit");
	if (GDKstopped == 0) {
		GDKstopped++;	/* shouldn't there be a lock here? */
		GDKnrofthreads = 0;
		gdk_unset_lock(GDKthreadLock, "GDKexit");

		/* Kill all threads except myself */
		if (status == 0) {
			MT_Id pid = MT_getpid();
			Thread t, s;

			for (t = GDKthreads, s = t + THREADS; t < s; t++) {
				if (t->pid) {
					MT_Id victim = t->pid;

					if (t->pid != pid)
						MT_kill_thread(victim);
				}
			}
		}
		(void) GDKgetHome();
		BBPexit();
		GDKlog(GDKLOGOFF);
		GDKunlockHome();
		MT_global_exit(status);
	}
	gdk_unset_lock(GDKthreadLock, "GDKexit");
}



#line 1500 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int GDKdebug = 0;
int GDKembedded = 0;
int GDKprotected = 0;

MT_Lock GDKthreadLock;
MT_Lock GDKswapLock[BBPLOCKMASK + 1];
MT_Lock GDKhashLock[BBPLOCKMASK + 1];
MT_Lock GDKcacheLock, GDKtrimLock;
MT_Lock GDKunloadLock;
MT_Lock GDKtmLock;
MT_Cond GDKunloadCond;



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



#line 1526 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
void
GDKlockHome(void)
{
	char *p = 0, buf[1024], host[PATHLENGTH];
	char GDKdirStr[PATHLENGTH];



#line 1535 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	/* The DIR_SEP at the end of the path is needed for a succesfull
	   call to GDKcreatedir */

	snprintf(GDKdirStr, PATHLENGTH, "%s%c%s%c", GDKdbfarmStr, DIR_SEP, GDKdbnameStr, DIR_SEP);

	if (chdir(GDKdirStr) < 0) {
		if (!GDKcreatedir(GDKdirStr) || chdir(GDKdirStr) < 0)
			GDKfatal("GDKlockHome: could not move to %s\n", GDKdirStr);
		GDKwarning("GDKlockHome: created directory %s\n", GDKdirStr);
	}
	if (GDKrecovery && unlink(GDKLOCK) < 0) {
		GDKfatal("GDKlockHome: unlock DB failed\n");
	}
	umask(0000);
	if (MT_lockf(GDKLOCK, F_TLOCK, 4, 1) < 0) {
		GDKlockFile = 0;
		GDKfatal("GDKlockHome: Database lock '%s' denied\n", GDKLOCK);
	}
	if ((GDKlockFile = fopen(GDKLOCK, "rb+")) == NULL) {
		GDKfatal("GDKlockHome: Could not open %s\n", GDKLOCK);
	}
	if (fgets(buf, 1024, GDKlockFile) && (p = strchr(buf, ':')))
		*p = 0;
	if (p) {
		sprintf(host, " from '%s'", buf);
	} else {
		GDKwarning("GDKlockHome: ignoring empty or invalid %s.\n", GDKLOCK);
		host[0] = 0;
	}


#line 1567 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	MT_init();
	OIDinit();


#line 1572 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	fseek(GDKlockFile, 0, SEEK_SET);
	ftruncate(fileno(GDKlockFile), 0);
	fflush(GDKlockFile);
	GDKlog(GDKLOGON);


#line 1579 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
	GDKstopped = 0;
}

void
GDKunlockHome(void)
{
	if (GDKlockFile) {
		MT_lockf(GDKLOCK, F_ULOCK, 4, 1);
		fclose(GDKlockFile);
		GDKlockFile = 0;
	}
}



#line 1595 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int
GDKgetHome(void)
{
	if (MT_initialized() == 0 || GDKlockFile)
		return 0;
	while ((GDKlockFile = fopen(GDKLOCK, "r+")) == NULL) {
		GDKerror("GDKgetHome: PANIC on open %s. sleep(1)\n", GDKLOCK);
		MT_sleep_ms(1000);
	}
	if (MT_lockf(GDKLOCK, F_TLOCK, 4, 1) < 0) {
		GDKwarning("GDKgetHome: blocking on lock '%s'.\n", GDKLOCK);
		MT_lockf(GDKLOCK, F_LOCK, 4, 1);
	}
	return 1;
}



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



#line 1628 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_utils.mx"
int GDKsilent = 0;
static int THRerrorcount[THREADDATA];

/* do the real work for GDKaddbuf below. */
static void
doGDKaddbuf(const char *prefix, const char *message, size_t messagelen, const char *suffix)
{
	char *buf = GDKerrbuf;

	THRerrorcount[THRgettid()]++;
	if (buf) {
		char *dst = buf + strlen(buf);
		size_t maxlen = GDKMAXERRLEN - (dst - buf) - 1;

		if (prefix && *prefix && dst < buf + GDKMAXERRLEN) {
			size_t preflen;

			strncpy(dst, prefix, maxlen);
			dst[maxlen] = '\0';
			preflen = strlen(dst);
			maxlen -= preflen;
			dst += preflen;