gdk_bbp.c

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

	if (r < 0)
		return r;
	if (BBPvalid(-i)) {
		r = stream_printf(s, "~%s", BBPname(-i));
		if (r < 0)
			return r;
	}
	return stream_printf(s, ", %s, %d ]\n", BBP_physical(i), BBP_lastused(i));
}

int
BBPdir(int cnt, bat *subcommit)
{
	FILE *fp = NULL;
	stream *s = NULL;
	bat i=0, j=1;

	if (GDKdebug & 17)
		THRprintf(GDKout, "#BBPdir: writing BBP.dir (%d bats).\n", (int) BBPsize);
	IODEBUG {
		THRprintf(GDKout, "#BBPdir start oid=");
		OIDwrite(GDKout);
		THRprintf(GDKout, "\n");
	}
	fp = (FILE *) GDKfilelocate("BBP", "wb", "dir");
	if (fp)
		s = file_wastream(fp, "BBP.dir");
	if (s && 
	    stream_printf(s, "%d %d\n", SIZEOF_SIZE_T, SIZEOF_OID) >= 0 &&
	    OIDwrite(s) == 0 &&
	    stream_printf(s, " BBPsize=%d\n", (int) BBPsize) >= 0)
	{
		for (i = 1; i < BBPsize; i++) {
			int mask = BBPPERSISTENT; /* BBP.dir consists of all persisnet bats */

			/* but for subcommits, all except the bats in the list retain their existent mode */
			if (subcommit) {
				while(j < cnt && subcommit[j] < i) j++;  
				if (j < cnt && subcommit[j] != i) mask = BBPEXISTING;
			}

			/* write the entry */
			if (BBP_status(i) & mask) { 
				if (new_bbpentry(s, i) < 0) break;
				IODEBUG new_bbpentry(GDKerr, i);
			}
		}
	}
	if (s) {
		stream_close(s);
		stream_destroy(s);
	} else if (fp) {
		fclose(fp);
	}
	IODEBUG THRprintf(GDKout, "#BBPdir end\n");

	if (i < BBPsize) {
		GDKsyserror("BBPdir failed:\n");
		return -1;
	}
	return 0;
}



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


#line 787 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_bbp.mx"
static INLINE bat
BBP_find(str nme, int lock)
{
	bat i = BBPnamecheck(nme);

	if (i > 0) {
		/* for tmp_X BATs, we already know X */
		str s = BBP_logical(i);

		if (i >= BBPsize || s == NULL || strcmp(s, nme)) {
			i = 0;
		}
	} else if (*nme != '.') {
		/* must lock since hash-lookup traverses other BATs */
		if (lock)
			gdk_set_lock(GDKcacheLock, "BBPindex");
		for (i = BBP_hash[strHash(nme) & BBP_mask]; i; i = BBP_next(i)) {
			if (strcmp(BBP_logical(i), nme) == 0)
				break;
		}
		if (lock)
			gdk_unset_lock(GDKcacheLock, "BBPindex");
	}
	return i;
}

bat
BBPindex(str nme)
{
	return BBP_find(nme, TRUE);
}

BATstore *
BBPgetdesc(bat i)
{
	BAT *b = NULL;

	if (i < 0)
		i = -i;
	if (i != bat_nil && i < BBPsize && i && BBP_logical(i)) {
		str nme = BBP_physical(i);

		b = BBP_cache(i);
		if (b == NULL) 
			b = (BAT *) BBP_desc(i);
		if (b == NULL && nme) {
			int lock = locked_by ? BBP_getpid() != locked_by : 1;

			b = BATloaddesc(nme);
			IODEBUG THRprintf(GDKout, "#BATloaddesc(%s) = %d\n", nme, (b==NULL)?-1:0); 
			if (b == NULL) {
				GDKerror("BBPgetdesc: deleting illegal bat(%d) %s\n", i, nme);
				BBPclear(i);
			} else if (BBP_desc(i) == NULL) {
				if (lock)
					gdk_set_lock(GDKswapLock[i & BBPLOCKMASK], "BBPgetdesc");
				BBP_desc(i) = (BATstore *) b;
				if (lock)
					gdk_unset_lock(GDKswapLock[i & BBPLOCKMASK], "BBPgetdesc");
			}
		}
		if (b)
			BBP_lastused(i) = BBPLASTUSED(BBPstamp());
	}
	return (BATstore *) b;
}

str
BBPlogical(bat bid, str buf)
{
	if (buf == NULL) {
		return NULL;
	} else if (BBPcheck(bid, "BBPlogical")) {
		if (bid < 0 && BBP_logical(bid) == NULL)
			bid = -bid;
		strcpy(buf, BBP_logical(bid));
	} else {
		*buf = 0;
	}
	return buf;
}

str
BBPphysical(bat bid, str buf)
{
	if (buf == NULL) {
		return NULL;
	} else if (BBPcheck(bid, "BBPphysical")) {
		strcpy(buf, BBP_physical(ABS(bid)));
	} else {
		*buf = 0;
	}
	return buf;
}



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


#line 893 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_bbp.mx"
static INLINE str
BBPsubdir_recursive(str s, bat i)
{
	i >>= 6;
	if (i >= 64) {
		s = BBPsubdir_recursive(s, i);
		*s++ = DIR_SEP;
	}
	i &= 63;
	*s++ = '0' + (i >> 3);
	*s++ = '0' + (i & 7);
	return s;
}

static INLINE void
BBPgetsubdir(str s, bat i)
{
	if (i >= 64) {
		s = BBPsubdir_recursive(s, i);
	}
	*s = 0;
}

bat
BBPinsert(BAT *b)
{
	int lock = locked_by ? BBP_getpid() != locked_by : 1;
	str s;
	long_str dirname;
	bat i;

	/* ciritical section: get a new BBP entry */
	if (lock) {
	        gdk_set_lock(GDKtrimLock, "BBPreplace");
		gdk_set_lock(GDKcacheLock, "BBPinsert");
        }

	/* find an empty slot */
	if (BBP_free <= 0) {
		if (++BBPsize >= BBPlimit) {
			BBPextend(BATMARGIN, TRUE);
		} else {
			BBP_free = BBPsize - 1;
		}
	}
	i = BBP_free;
	BBP_free = BBP_next(BBP_free);

	if (lock) {
		gdk_unset_lock(GDKcacheLock, "BBPinsert");
	        gdk_unset_lock(GDKtrimLock, "BBPreplace");
        }
	/* rest of the work outside the lock , as GDKstrdup/GDKmalloc may trigger a BBPtrim */

	/* fill in basic BBP fields for the new bat */

	if (++BBP_curstamp < 0)
		BBP_curstamp = 0;
	b->batCacheid = i;
	b->batStamp = BBP_curstamp;
	b->creator_tid = BBP_getpid();

	BBP_status_set(i, BBPDELETING, "BBPentry");
	BBP_cache(i) = NULL;
	BBP_desc(i) = NULL;
	BBP_refs(i) = 1;	/* new bats have 1 pin */
	BBP_lrefs(i) = 0;	/* ie. no logical refs */

	if( BBP[ABS(i)].bak[(i)<0] == NULL ){
		s = BBPtmpname(dirname, 64, i);
		BBP_logical(i) = GDKstrdup(s);
		BBP[ABS(i)].bak[(i)<0] = BBP_logical(i);
	} else 
		BBP_logical(i) =  BBP[ABS(i)].bak[(i)<0];
	BBP_logical(-i) = NULL;

	/* Keep the physical location around forever */
	if( BBP_physical(i) == NULL){
		BBPgetsubdir(dirname, i);
		BBP_physical(i) = (str) GDKmalloc(strlen(dirname) + strLen(BATgetId(b)) - 4 + 1);
		GDKfilepath(BBP_physical(i), dirname, BATgetId(b) + 4, NULL);

	BATDEBUG THRprintf(GDKout, "#%d = new %s(%s,%s)\n", (int) i, BATgetId(b), ATOMname(b->htype), ATOMname(b->ttype));
	}

	return i;
}

void
BBPcacheit(BAT *b)
{
	int lock = locked_by ? BBP_getpid() != locked_by : 1;
	bat i = b->batCacheid;
	int mode;
	BAT *bm = (BAT *) GDKmalloc(sizeof(BAT));	/* alloc before lock to prevent trim problems */

	if (i) {
		assert(i > 0);
	} else {
		i = BBPinsert(b);	/* bat was not previously entered */
	}
	if (lock)
		gdk_set_lock(GDKswapLock[i & BBPLOCKMASK], "BBPcacheit");
	mode = (BBP_status(i) | BBPLOADED) & ~(BBPLOADING|BBPDELETING);
	BBP_status_set(i, mode, "BBPcacheit");
	BBP_lastused(i) = BBPLASTUSED(BBPstamp() + ((mode == BBPLOADED) ? 150 : 0));
	BBP_desc(i) = (BATstore *) b;

	/* fill in the mirror record */
	bm->GDKversion = b->GDKversion;
	bm->batCacheid = -i;
	bm->batBuns = b->batBuns;
	bm->dims.headtype = b->dims.tailtype;
	bm->dims.tailtype = b->dims.headtype;
	bm->dims.headloc = b->dims.tailloc;
	bm->dims.tailloc = b->dims.headloc;
	bm->dims.headkey = b->dims.tailkey;
	bm->dims.tailkey = b->dims.headkey;
	bm->dims.headvarsized = b->dims.tailvarsized;
	bm->dims.tailvarsized = b->dims.headvarsized;
	bm->dims.bunwidth = b->dims.bunwidth;
	bm->dims.bunshift = b->dims.bunshift;
	bm->dims.hseq = b->dims.tseq;
	bm->dims.tseq = b->dims.hseq;
	bm->H = b->T;
	bm->T = b->H;
	bm->P = b->P;
	bm->U = b->U;
	bm->hhash = b->thash;
	bm->thash = b->hhash;

	/* cache it! */
	BBP_cache(i) = b;
	BBP_cache(-i) = bm;

	if (lock)
		gdk_unset_lock(GDKswapLock[i & BBPLOCKMASK], "BBPcacheit");
}



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

void
BBPuncacheit(bat i)
{
	BBPuncacheit_(i, FALSE);
}

static void
BBPuncacheit_(bat i, int unloaddesc)
{
	if (i < 0)
		i = -i;
	if (BBPcheck(i, "BBPuncacheit")) {
		BAT *b = (BAT *) BBP_desc(i);

		if (b) {
			if (BBP_cache(i)) {
				BATDEBUG THRprintf(GDKout, "#uncache %d (%s)\n", (int) i, BBPname(i));

				BBP_cache(i) = BBP_cache(-i) = NULL;

				/* clearing bits can be done without the lock */
				BBP_status_off(i, BBPLOADED, "BBPuncacheit");
			}
			if (unloaddesc) {
				BBP_desc(i) = NULL;
				BATdestroy(b);
			}
		}
	}
}



#line 1071 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_bbp.mx"
static INLINE void 
bbpclear(bat i) 
{
		BATDEBUG {
			THRprintf(GDKout, "#clear %d (%s)\n", (int) i, BBPname(i));
		}
		BBPuncacheit_(i, TRUE);
		if (BBPtmpcheck(BBP_logical(i)) == 0) {
			BBP_delete(i);
		}
		if (BBP_logical(-i)) {
			BBP_delete(-i);
			if( BBP_logical(-i) != BBP[ABS(i)].bak[(-i)<0])
				GDKfree(BBP_logical(-i));
			BBP_logical(-i) = NULL;
		}
		if( BBP_logical(i) != BBP[ABS(i)].bak[(i)<0])
			GDKfree(BBP_logical(i));
		BBP_logical(i) = NULL;
		BBP_status_set(i, 0, "BBPclear");
		BBP_refs(i) = 0;
		BBP_lrefs(i) = 0;
		BBP_next(i) = BBP_free;
		BBP_free = i;
}

void
BBPclear(bat i)
{
	int lock = locked_by ? BBP_getpid() != locked_by : 1;

	if (BBPcheck(i, "BBPclear")) {
		if (lock)
			gdk_set_lock(GDKcacheLock, "BBPclear");
		bbpclear(ABS(i));
		if (lock)
			gdk_unset_lock(GDKcacheLock, "BBPclear");
	}
}



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


#line 1132 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_bbp.mx"
int
BBPrename(bat bid, str nme)
{
	BAT *b = BBPdescriptor(bid);
	long_str dirname;
	bat tmpid = 0, i;

	if (b == NULL)
		return 0;

	/* If name stays same, do nothing */
	if (BBP_logical(bid) && strcmp(BBP_logical(bid), nme) == 0)
		return 0;

	BBPgetsubdir(dirname, ABS(bid));

	if ((tmpid = BBPnamecheck(nme)) && (bid < 0 || tmpid != bid)) {
		return BBPRENAME_ILLEGAL;
	}
	if (strlen(dirname) + strLen(nme) + 1 >= IDLENGTH) {
		return BBPRENAME_LONG;
	}
	gdk_set_lock(GDKtrimLock, "BBPrename");
	gdk_set_lock(GDKcacheLock, "BBPrename");
	i = BBP_find(nme, FALSE);
	if (i != 0) {
		gdk_unset_lock(GDKcacheLock, "BBPrename");
		gdk_unset_lock(GDKtrimLock, "BBPrename");
		return BBPRENAME_ALREADY;
	}
	BBP_notrim = BBP_getpid();

	/* carry through the name change */
	if (BBP_logical(bid) && BBPtmpcheck(BBP_logical(bid)) == 0) {
		BBP_delete(bid);
	}
	if( BBP_logical(bid) != BBP[ABS(bid)].bak[(bid)<0])
		GDKfree(BBP_logical(bid));
	BBP_logical(bid) = GDKstrdup(nme);
	if (tmpid == 0) {
		BBP_insert(bid);
	}
	b->batDirtydesc = 1;
	if (b->batPersistence == PERSISTENT) {
		int lock = locked_by ? BBP_getpid() != locked_by : 1;

		if (lock)
			gdk_set_lock(GDKswapLock[i & BBPLOCKMASK], "BBPrename");
		BBP_status_on(ABS(bid), BBPRENAMED, "BBPrename");
		if (lock)
			gdk_unset_lock(GDKswapLock[i & BBPLOCKMASK], "BBPrename");
		BBPdirty(1);
	}
	gdk_unset_lock(GDKcacheLock, "BBPrename");
	BBP_notrim = 0;
	gdk_unset_lock(GDKtrimLock, "BBPrename");
	return 0;
}



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



#line 1213 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_bbp.mx"
static INLINE void
BBPspin(bat i, str s, int event)
{
	if (BBPcheck(i, "BBPspin") && (BBP_status(i) & event)) {
		lng spin = LL_CONSTANT(0);

		while (BBP_status(i) & event) {
			MT_sleep_ms(1);
			spin++;
		}
		BATDEBUG THRprintf(GDKout, "#BBPspin(%d,%s,%d): " LLFMT " loops\n", (int) i, s, event, spin);
	}
}

static INLINE int
incref(bat i, int logical, int lock)
{
	int refs = 0;

	if (i == bat_nil) {
		/* Stefan: May this happen? Or should we better call GDKerror(), here? */
		/* GDKerror("BBPincref() called with bat_nil!\n"); */
		return refs;