freem/src/global_bltin.c - diff

Return to global_bltin.c CVS log

Up to [Coherent Logic Development] / freem / src

Diff for /freem/src/global_bltin.c between versions 1.17 and 1.20

version 1.17, 2025/04/11 14:21:03	version 1.20, 2025/04/11 18:24:32
Line 24	Line 24
* along with FreeM. If not, see <https://www.gnu.org/licenses/>.	* along with FreeM. If not, see <https://www.gnu.org/licenses/>.
*	*
* $Log$	* $Log$
	* Revision 1.20 2025/04/11 18:24:32 snw
	* Fix bug in memory cache
	*
	* Revision 1.19 2025/04/11 16:52:05 snw
	* Fix indentation in global handler
	*
	* Revision 1.18 2025/04/11 16:23:18 snw
	* Avoid re-reading the same block consecutively when possible
	*
* Revision 1.17 2025/04/11 14:21:03 snw	* Revision 1.17 2025/04/11 14:21:03 snw
* Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block	* Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block
*	*
Line 139 static void panic (void);	Line 148 static void panic (void);
#define DATA 8	#define DATA 8

#if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)	#if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)
long time ();	long time ();
#endif	#endif

inline long gbl_path(char key, char buf)	inline long gbl_path(char key, char buf)
Line 323 int gbl_write_header(global_handle *g, g	Line 332 int gbl_write_header(global_handle *g, g
return FALSE;	return FALSE;
}	}

if (g->locked == FALSE) gbl_lock (g, 1);	gbl_lock (g, 1);
old_position = lseek (g->fd, 0, SEEK_CUR);	old_position = lseek (g->fd, 0, SEEK_CUR);
lseek (g->fd, 0, SEEK_SET);	lseek (g->fd, 0, SEEK_SET);

Line 333 int gbl_write_header(global_handle *g, g	Line 342 int gbl_write_header(global_handle *g, g
}	}

lseek (g->fd, old_position, SEEK_SET);	lseek (g->fd, old_position, SEEK_SET);
if (g->locked == TRUE) gbl_unlock (g);	gbl_unlock (g);

gbl_read_header (g, &g->header);	gbl_read_header (g, &g->header);

Line 445 short gbl_open(global_handle *g, short a	Line 454 short gbl_open(global_handle *g, short a
}	}
else {	else {
g->opened = TRUE;	g->opened = TRUE;
result = gbl_read_header (g, &g->header);	result = gbl_read_header (g, &g->header);

if (result == GBL_HDR_OK) {	if (result == GBL_HDR_OK) {
	/* initialize last_block_accessed cache */
	g->last_block_accessed = (char *) calloc (g->header.block_size, sizeof (char));
	NULLPTRCHK(g->last_block_accessed,"gbl_open");

g->opened = TRUE;	g->opened = TRUE;
}	}
else {	else {
Line 479 short gbl_open(global_handle *g, short a	Line 492 short gbl_open(global_handle *g, short a

int gbl_read_block(global_handle g, unsigned long blocknum, char block)	int gbl_read_block(global_handle g, unsigned long blocknum, char block)
{	{
	struct stat gstat;
unsigned long hdr_offset;	unsigned long hdr_offset;
hdr_offset = sizeof (global_header);	hdr_offset = sizeof (global_header);

Line 486 int gbl_read_block(global_handle *g, uns	Line 500 int gbl_read_block(global_handle *g, uns
return FALSE;	return FALSE;
}	}

gbl_lock (g, 1);
lseek (g->fd, hdr_offset + ((long) blocknum * (long) (g->header.block_size)), SEEK_SET);
read (g->fd, block, g->header.block_size);
g->last_block = blocknum;
g->use_count++;	g->use_count++;
g->read_ops++;
gbl_unlock (g);	if (!g->locked) gbl_lock (g, 1);
	fstat (g->fd, &gstat);

	if ((g->last_block == blocknum) &&
	(g->have_cached_block) &&
	(g->cached_block_num == blocknum) &&
	(gstat.st_mtime < g->last_read_time)) {
	/* the global has not been modified since the last read; grab from memory */
	g->memory_reads++;
	memcpy (block, g->last_block_accessed, g->header.block_size);
	}
	else {
	/* have to go out to disk */
	lseek (g->fd, hdr_offset + ((long) blocknum * (long) (g->header.block_size)), SEEK_SET);
	read (g->fd, block, g->header.block_size);

	/* update cache */
	memcpy (g->last_block_accessed, block, g->header.block_size);
	g->have_cached_block = TRUE;
	g->cached_block_num = blocknum;
	g->last_block = blocknum;
	g->read_ops++;
	}

	g->last_read_time = time (0L);
	g->use_count++;

	if (g->locked) gbl_unlock (g);

return TRUE;	return TRUE;
} /* gbl_read_block() */	} /* gbl_read_block() */
Line 507 int gbl_write_block(global_handle *g, un	Line 544 int gbl_write_block(global_handle *g, un
return FALSE;	return FALSE;
}	}

if (!g->locked) {	gbl_lock (g, 1);
gbl_lock (g, 1);
}

for (;;) {	for (;;) {

Line 528 int gbl_write_block(global_handle *g, un	Line 563 int gbl_write_block(global_handle *g, un

}	}

gbl_update_tid (g);	gbl_update_tid (g);
	gbl_unlock (g);
if (g->locked) {
gbl_unlock (g);
}

return TRUE;	return TRUE;
}	}
Line 578 global_handle gbl_handle(char key)	Line 610 global_handle gbl_handle(char key)
g->use_count = 1;	g->use_count = 1;
g->locked = FALSE;	g->locked = FALSE;
g->age = time (0L);	g->age = time (0L);
	g->last_read_time = 0;
g->last_block = 0;	g->last_block = 0;
g->opened = FALSE;	g->opened = FALSE;
g->fd = 0;	g->fd = 0;
Line 586 global_handle gbl_handle(char key)	Line 619 global_handle gbl_handle(char key)
g->cache_hits = 0;	g->cache_hits = 0;
g->read_ops = 0;	g->read_ops = 0;
g->write_ops = 0;	g->write_ops = 0;
	g->memory_reads = 0;
	g->have_cached_block = FALSE;
	g->last_block_accessed = NULL;

strcpy (g->global_name, global_name);	strcpy (g->global_name, global_name);
gbl_path (key, g->global_path);	gbl_path (key, g->global_path);
Line 704 void global_bltin (short action, char *k	Line 740 void global_bltin (short action, char *k
static char block[BLOCKLEN];	static char block[BLOCKLEN];
static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */	static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */
static int tryfast; /* try fast access if get_sym on */	static int tryfast; /* try fast access if get_sym on */
/* previous global */	/* previous global */

int iresult;	int iresult;

Line 1123 reopen:	Line 1159 reopen:

if (action == get_sym) {	if (action == get_sym) {

tfast0:	tfast0:
gbl_lock (g, 3);	gbl_lock (g, 3);

if (g->fast_path > 0) goto tfast1; /* try again last block */	if (g->fast_path > 0) goto tfast1; /* try again last block */
Line 1133 reopen:	Line 1169 reopen:
for (;;) {	for (;;) {


tfast1:	tfast1:
gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);

/* temporarily disabled	/* temporarily disabled
Line 1227 reopen:	Line 1263 reopen:
addr += UNSIGN (block[addr]) + 2; /* skip key */	addr += UNSIGN (block[addr]) + 2; /* skip key */

if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {	if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
merr_raise (DBDGD);	merr_raise (DBDGD);
goto quit;	goto quit;
}	}

addr += PLEN; /* skip data */	addr += PLEN; /* skip data */
g->last_block = blknbr;	g->last_block = blknbr;
g->fast_path = 1;	g->fast_path = 1;

if (merr () == INRPT) goto quit;	if (merr () == INRPT) goto quit;

}	}
} /* end of get_sym */	} /* end of get_sym */
Line 1319 k_again: /* entry point for repeated	Line 1355 k_again: /* entry point for repeated

datal = stlen (data);	datal = stlen (data);
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (found != 2) { /* new entry */	if (found != 2) { /* new entry */

Line 1345 k_again: /* entry point for repeated	Line 1381 k_again: /* entry point for repeated
}	}


s10: {	s10:
	{
long len; /* insert key */	long len; /* insert key */
char key0[256];	char key0[256];

Line 1496 s10: {	Line 1533 s10: {
goto splitd;	goto splitd;
}	}

s20:	s20:

i = offset;	i = offset;
k = addr + olddatal;	k = addr + olddatal;
Line 1556 s20:	Line 1593 s20:

/* get following entry, eventually in the next blk */	/* get following entry, eventually in the next blk */
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (addr >= offset) {	if (addr >= offset) {

Line 1691 s20:	Line 1728 s20:

while (i < keyl) if (compactkey[i++] & 01)	while (i < keyl) if (compactkey[i++] & 01)

j1++;	j1++;
i = 0;	i = 0;
j = 0;	j = 0;
k = 0;	k = 0;
Line 1724 s20:	Line 1761 s20:
while ((ch = UNSIGN (scratch[i++])) != g_EOL) {	while ((ch = UNSIGN (scratch[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */


if (ch0 == DEL) {	if (ch0 == DEL) {
Line 1804 s20:	Line 1841 s20:

addr = 0;	addr = 0;
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
}	}

}	}
Line 1871 s20:	Line 1908 s20:
while ((ch = UNSIGN (key0[i++])) != g_EOL) {	while ((ch = UNSIGN (key0[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */


if (ch0 == DEL) {	if (ch0 == DEL) {
Line 1948 s20:	Line 1985 s20:
}	}

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */

if (ch0 == DEL) {	if (ch0 == DEL) {

Line 1993 s20:	Line 2030 s20:

case kill_sym: /* search and destroy */	case kill_sym: /* search and destroy */

killo: /* entry from killone section */	killo: /* entry from killone section */
offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);	offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);

i = 0;	i = 0;
Line 2038 killo: /* entry from killone section	Line 2075 killo: /* entry from killone section
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr += (2 + PLEN); /* skip previous entry */	addr += (2 + PLEN); /* skip previous entry */
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
traceadr[trx] = addr;	traceadr[trx] = addr;

if (addr < offset) break;	if (addr < offset) break;

traceadr[trx] = 0;	traceadr[trx] = 0;
traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +	traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

}	}

Line 2055 killo: /* entry from killone section	Line 2092 killo: /* entry from killone section
gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
addr = 0;	addr = 0;
k = UNSIGN (block[0]);	k = UNSIGN (block[0]);
stcpy0 (key0, &block[2], k);	stcpy0 (key0, &block[2], k);
Line 2144 killo: /* entry from killone section	Line 2181 killo: /* entry from killone section
if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */	if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */

long left,	long left,
right;	right;
char block0[BLOCKLEN];	char block0[BLOCKLEN];

p_empty: /* entry if pointer block goes empty */	p_empty: /* entry if pointer block goes empty */

left = UNSIGN (block[LLPTR]) * 65536 +	left = UNSIGN (block[LLPTR]) * 65536 +
UNSIGN (block[LLPTR + 1]) * 256 +	UNSIGN (block[LLPTR + 1]) * 256 +
UNSIGN (block[LLPTR + 2]);	UNSIGN (block[LLPTR + 2]);
right = UNSIGN (block[RLPTR]) * 65536 +	right = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

if (left) {	if (left) {

Line 2195 p_empty: /* entry if pointer block goes	Line 2232 p_empty: /* entry if pointer block goes

gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
freecnt = UNSIGN (block[addr]) + 2 + PLEN;	freecnt = UNSIGN (block[addr]) + 2 + PLEN;

/* delete key */	/* delete key */
Line 2268 p_empty: /* entry if pointer block goes	Line 2305 p_empty: /* entry if pointer block goes
j = block[begadr + 1];	j = block[begadr + 1];
k = 0;	k = 0;
if (begadr)	if (begadr)
while (key0[k] == key1[k])	while (key0[k] == key1[k])
k++; /* new key_offset */	k++; /* new key_offset */
if (k < j) {	if (k < j) {
ch = j - k; /* space requirement */	ch = j - k; /* space requirement */
block[begadr] = i + ch; /* new key_length */	block[begadr] = i + ch; /* new key_length */
block[begadr + 1] = k; /* new key_offset */	block[begadr + 1] = k; /* new key_offset */
i = offset;	i = offset;
j = i + ch;	j = i + ch;
offset = j;	offset = j;
begadr++;	begadr++;
while (i > begadr)	while (i > begadr)
block[j--] = block[i--];	block[j--] = block[i--];
stcpy0 (&block[begadr + 1], &key0[k], ch);	stcpy0 (&block[begadr + 1], &key0[k], ch);
}	}
}	}
block[OFFS] = offset / 256;	block[OFFS] = offset / 256;
Line 2298 p_empty: /* entry if pointer block goes	Line 2335 p_empty: /* entry if pointer block goes

break;	break;

zinv:	zinv:

{	{
long len;	long len;
Line 2316 zinv:	Line 2353 zinv:
gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);

addr = UNSIGN (block[OFFS]) * 256 +	addr = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

}	}

Line 2391 zinv:	Line 2428 zinv:
while ((ch = UNSIGN (scratch[i++])) != g_EOL) {	while ((ch = UNSIGN (scratch[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */

if (ch0 == DEL) {	if (ch0 == DEL) {

Line 2437 zinv:	Line 2474 zinv:

case zdata: /* nonstandard data function */	case zdata: /* nonstandard data function */

{	{
long counties[128];	long counties[128];
char key0[256];	char key0[256];
int icnt, icnt0, len;	int icnt, icnt0, len;

i = 0;	i = 0;

while (i < 128) counties[i++] = 0L; /* init count; */	while (i < 128) counties[i++] = 0L; /* init count; */

if (found == 2) { /* ... advance to next entry */	if (found == 2) { /* ... advance to next entry */
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr += 2; /* skip key */	addr += 2; /* skip key */
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr++; /* skip data */	addr++; /* skip data */

counties[0] = 1L;	counties[0] = 1L;
}	}

offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);	offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
icnt = 0;	icnt = 0;
i = 0;	i = 0;

while ((ch = compactkey[i++]) != g_EOL) {	while ((ch = compactkey[i++]) != g_EOL) {

if (ch & 01) {
icnt++;
}

	if (ch & 01) {
	icnt++;
}	}

len = i - 1;	}
i = 0;

while (i < addr) { /* compute offset complete key */	len = i - 1;
	i = 0;

	while (i < addr) { /* compute offset complete key */

icnt0 = UNSIGN (block[i++]);	icnt0 = UNSIGN (block[i++]);
icnt0 += (j = UNSIGN (block[i++]));	icnt0 += (j = UNSIGN (block[i++]));

while (j < icnt0) key0[j++] = block[i++];	while (j < icnt0) key0[j++] = block[i++];

key0[j] = g_EOL;	key0[j] = g_EOL;
i += UNSIGN (block[i]);	i += UNSIGN (block[i]);

i++; /* skip data */	i++; /* skip data */

}	}

for (;;) { /* is it still a descendant ??? */	for (;;) { /* is it still a descendant ??? */

if (addr >= offset) { /* look in next block */	if (addr >= offset) { /* look in next block */

if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {	if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
break; /* no next block */	break; /* no next block */
}	}

gbl_read_block (g, blknbr, block);	gbl_read_block (g, blknbr, block);

addr = 0;	addr = 0;
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

}	}

i = UNSIGN (block[addr++]);	i = UNSIGN (block[addr++]);
i += (j = UNSIGN (block[addr++]));	i += (j = UNSIGN (block[addr++]));

while (j < i) key0[j++] = block[addr++];	while (j < i) key0[j++] = block[addr++];

addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr++; /* skip data */	addr++; /* skip data */
icnt0 = 0;	icnt0 = 0;
i = 0;	i = 0;

while (i < j) if (key0[i++] & 01)	while (i < j) if (key0[i++] & 01)

icnt0++;	icnt0++;

if (icnt0 <= icnt) break;	if (icnt0 <= icnt) break;

i = 0;	i = 0;

while (i < len) {	while (i < len) {

if (key0[i] != compactkey[i]) break;	if (key0[i] != compactkey[i]) break;

i++;	i++;

}	}

if (i < len) break;	if (i < len) break;

counties[icnt0 - icnt]++;	counties[icnt0 - icnt]++;

}	}

i = 128;	i = 128;

while (counties[--i] == 0L);	while (counties[--i] == 0L);

lintstr (data, counties[0]);	lintstr (data, counties[0]);

j = 1;	j = 1;
tmp1[0] = ',';	tmp1[0] = ',';

while (j <= i) {	while (j <= i) {
lintstr (&tmp1[1], counties[j++]);	lintstr (&tmp1[1], counties[j++]);
stcat (data, tmp1);	stcat (data, tmp1);
}

}	}

	}

break;	break;

case getinc:	case getinc:

{	{
int setopsav;	int setopsav;

setopsav = setop;	setopsav = setop;
setop = '+';	setop = '+';
data[0] = '1';	data[0] = '1';
data[1] = EOL;	data[1] = EOL;

global (set_sym, key, data);	global (set_sym, key, data);

setop = setopsav;	setop = setopsav;

return;	return;
}	}

case killone:	case killone:
	{
{	if (found == 2) goto killo; /* entry found use normal kill routine */
if (found == 2) goto killo; /* entry found use normal kill routine */

goto quit;	goto quit;
}	}

case merge_sym:

printf("MERGE NOT IMPLEMENTED FOR GLOBALS\n");

#ifdef DEBUG_GBL

int loop;

printf ("DEBUG MERGE: ");
printf ("[key] is [");

for (loop = 0; key[loop] != EOL; loop++) printf ("%c", (key[loop] == DELIM) ? '!' : key[loop]);

printf ("]\r\n");
printf ("[data] is [");

for(loop = 0; data[loop] != EOL; loop++) printf ("%c", (data[loop] == DELIM) ? '!' : data[loop]);

printf("]\r\n");

#endif
return;

default:	default:

Line 2628 splitd: /* split data block in two se	Line 2641 splitd: /* split data block in two se

if (addr >= offset) {	if (addr >= offset) {
long right,	long right,
right1,	right1,
right2;	right2;

right = UNSIGN (block[RLPTR]);	right = UNSIGN (block[RLPTR]);
right1 = UNSIGN (block[RLPTR + 1]);	right1 = UNSIGN (block[RLPTR + 1]);
Line 2702 splitd: /* split data block in two se	Line 2715 splitd: /* split data block in two se
}	}

/* other is *always* zero !!!	/* other is *always* zero !!!
* if (other=left65536+left1256+left2) up-date RL-PTR of LL-block	* if (other=left65536+left1256+left2) up-date RL-PTR of LL-block
* { char block0[BLOCKLEN];	* { char block0[BLOCKLEN];
* lseek(filedes,(long)other*(long)(BLOCKLEN),0);	* lseek(filedes,(long)other*(long)(BLOCKLEN),0);
* read(filedes,block0,BLOCKLEN);	* read(filedes,block0,BLOCKLEN);
* block0[RLPTR ]=blknbr/65536;	* block0[RLPTR ]=blknbr/65536;
* block0[RLPTR+1]=blknbr%65536/256;	* block0[RLPTR+1]=blknbr%65536/256;
* block0[RLPTR+2]=blknbr%256;	* block0[RLPTR+2]=blknbr%256;
* lseek(filedes,(long)other*(long)(BLOCKLEN),0);	* lseek(filedes,(long)other*(long)(BLOCKLEN),0);
* write(filedes,block0,BLOCKLEN);	* write(filedes,block0,BLOCKLEN);
* }	* }
*/	*/

goto spltex;	goto spltex;

Line 2794 splitd: /* split data block in two se	Line 2807 splitd: /* split data block in two se

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
block0[RLPTR + 2] = block[RLPTR + 2];	block0[RLPTR + 2] = block[RLPTR + 2];
Line 2831 splitd: /* split data block in two se	Line 2844 splitd: /* split data block in two se
/* save old block away and make new block the current block */	/* save old block away and make new block the current block */
/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
block0[RLPTR + 2] = block[RLPTR + 2];	block0[RLPTR + 2] = block[RLPTR + 2];
Line 2925 static void splitp (global_handle *g, ch	Line 2938 static void splitp (global_handle *g, ch

/* update number of blocks ! */	/* update number of blocks ! */
i = UNSIGN (block0[NRBLK]) * 65536 +	i = UNSIGN (block0[NRBLK]) * 65536 +
UNSIGN (block0[NRBLK + 1]) * 256 +	UNSIGN (block0[NRBLK + 1]) * 256 +
UNSIGN (block0[NRBLK + 2]) + 1;	UNSIGN (block0[NRBLK + 2]) + 1;

block0[NRBLK] = i / 65536;	block0[NRBLK] = i / 65536;
block0[NRBLK + 1] = i % 65536 / 256;	block0[NRBLK + 1] = i % 65536 / 256;
Line 2992 static void splitp (global_handle *g, ch	Line 3005 static void splitp (global_handle *g, ch

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
block0[RLPTR + 2] = block[RLPTR + 2];	block0[RLPTR + 2] = block[RLPTR + 2];
Line 3028 static void splitp (global_handle *g, ch	Line 3041 static void splitp (global_handle *g, ch

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
Line 3102 static void update (global_handle *g, ch	Line 3115 static void update (global_handle *g, ch
j = oldkeyl - keyl;	j = oldkeyl - keyl;

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (j > 0) { /* surplus space */	if (j > 0) { /* surplus space */

Line 3176 static void insert (global_handle *g, ch	Line 3189 static void insert (global_handle *g, ch
gbl_read_block (g, blk, block);	gbl_read_block (g, blk, block);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (traceadr[trx + 1] != (-1)) {	if (traceadr[trx + 1] != (-1)) {
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
Line 3246 static void b_free (global_handle *g, un	Line 3259 static void b_free (global_handle *g, un
gbl_read_block (g, free, block0);	gbl_read_block (g, free, block0);

other = UNSIGN (block0[RLPTR]) * 65536 +	other = UNSIGN (block0[RLPTR]) * 65536 +
UNSIGN (block0[RLPTR + 1]) * 256 +	UNSIGN (block0[RLPTR + 1]) * 256 +
UNSIGN (block0[RLPTR + 2]);	UNSIGN (block0[RLPTR + 2]);

if (other == 0) break;	if (other == 0) break;

Line 3263 static void b_free (global_handle *g, un	Line 3276 static void b_free (global_handle *g, un
offset -= PLEN;	offset -= PLEN;
other = UNSIGN (block0[offset]) * 65536 +	other = UNSIGN (block0[offset]) * 65536 +

UNSIGN (block0[offset + 1]) * 256 +	UNSIGN (block0[offset + 1]) * 256 +
UNSIGN (block0[offset + 2]);	UNSIGN (block0[offset + 2]);

block0[offset] = 0;	block0[offset] = 0;
block0[offset + 1] = 0;	block0[offset + 1] = 0;
Line 3388 static void scandblk (char *block, long	Line 3401 static void scandblk (char *block, long
char key0[256];	char key0[256];

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

while (i < offset) {	while (i < offset) {

Line 3716 void gbl_dump_stat(void)	Line 3729 void gbl_dump_stat(void)
int hit_pct;	int hit_pct;
unsigned long access_total;	unsigned long access_total;
unsigned long hit_total;	unsigned long hit_total;
	unsigned long mem_reads_total;

	mem_reads_total = 0;
printf ("\r\nFreeM Global Statistics [PID %d]\r\n\r\n", pid);	printf ("\r\nFreeM Global Statistics [PID %d]\r\n\r\n", pid);

printf ("%-20s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "READS", "WRITES", "SLOW PTHCT", "AGE", "LAST BLK", "FILE");	printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "READS", "WRITES", "MEMREADS", "SLOW PTHCT", "AGE", "LAST BLK", "FILE");
printf ("%-20s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "=====", "======", "==========", "===", "========", "====");	printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "=====", "======", "========", "==========", "===", "========", "====");

access_total = 0;	access_total = 0;
ct = 0;	ct = 0;
for (g = global_handles_head; g != NULL; g = g->next) {	for (g = global_handles_head; g != NULL; g = g->next) {
printf ("%-20s%-10ld%-10ld%-10ld%-12ld%-20ld%-10ld%s\r\n",	printf ("%-20s%-10ld%-10ld%-10ld%-10ld%-12ld%-20ld%-10ld%s\r\n",
g->global_name,	g->global_name,
g->use_count,	g->use_count,
g->read_ops,	g->read_ops,
g->write_ops,	g->write_ops,
	g->memory_reads,
g->cache_misses,	g->cache_misses,
g->age,	g->age,
g->last_block,	g->last_block,
g->global_path);	g->global_path);
ct++;	ct++;
	mem_reads_total += g->memory_reads;
access_total += g->use_count;	access_total += g->use_count;
}	}
if (!ct) printf ("<no globals opened in this pid>\r\n");	if (!ct) printf ("<no globals opened in this pid>\r\n");
Line 3745 void gbl_dump_stat(void)	Line 3762 void gbl_dump_stat(void)

printf ("\r\nTotal accesses: %ld\r\n", access_total);	printf ("\r\nTotal accesses: %ld\r\n", access_total);
printf ("Fast path hits %ld\t(%d%%)\r\n", hit_total, hit_pct);	printf ("Fast path hits %ld\t(%d%%)\r\n", hit_total, hit_pct);
printf ("Fast path misses: %ld\t(%d%%)\r\n", gbl_cache_misses, miss_pct);	printf ("Fast path misses: %ld\t(%d%%)\r\n", gbl_cache_misses, miss_pct);
	printf ("Disk reads avoided: %ld\r\n", mem_reads_total);

}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.17
changed lines
	Added in v.1.20