// share is count of read accessors
// grant write lock when share == 0
-typedef struct {
- volatile unsigned char mutex;
- volatile unsigned char exclusive:1;
- volatile unsigned char pending:1;
- volatile ushort share;
+volatile typedef struct {
+ unsigned char mutex[1];
+ unsigned char exclusive:1;
+ unsigned char pending:1;
+ ushort share;
} BtSpinLatch;
// hash table entries
uint min; // next key offset
unsigned char bits:7; // page size in bits
unsigned char free:1; // page is on free chain
- unsigned char lvl:5; // level of page
+ unsigned char lvl:6; // level of page
unsigned char kill:1; // page is being deleted
unsigned char dirty:1; // page has deleted keys
- unsigned char posted:1; // page fence is posted
unsigned char right[BtId]; // page number to right
} *BtPage;
do {
// obtain latch mutex
#ifdef unix
- if( __sync_lock_test_and_set(&latch->mutex, 1) )
+ if( __sync_lock_test_and_set(latch->mutex, 1) )
continue;
#else
- if( _InterlockedExchange8(&latch->mutex, 1) )
+ if( _InterlockedExchange8(latch->mutex, 1) )
continue;
#endif
// see if exclusive request is granted or pending
latch->share++;
#ifdef unix
- __sync_lock_release (&latch->mutex);
+ *latch->mutex = 0;
#else
- _InterlockedExchange8(&latch->mutex, 0);
+ _InterlockedExchange8(latch->mutex, 0);
#endif
if( prev )
do {
#ifdef unix
- if( __sync_lock_test_and_set(&latch->mutex, 1) )
+ if( __sync_lock_test_and_set(latch->mutex, 1) )
continue;
#else
- if( _InterlockedExchange8(&latch->mutex, 1) )
+ if( _InterlockedExchange8(latch->mutex, 1) )
continue;
#endif
if( prev = !(latch->share | latch->exclusive) )
else
latch->pending = 1;
#ifdef unix
- __sync_lock_release (&latch->mutex);
+ *latch->mutex = 0;
#else
- _InterlockedExchange8(&latch->mutex, 0);
+ _InterlockedExchange8(latch->mutex, 0);
#endif
if( prev )
return;
uint prev;
#ifdef unix
- if( __sync_lock_test_and_set(&latch->mutex, 1) )
+ if( __sync_lock_test_and_set(latch->mutex, 1) )
return 0;
#else
- if( _InterlockedExchange8(&latch->mutex, 1) )
+ if( _InterlockedExchange8(latch->mutex, 1) )
return 0;
#endif
// take write access if all bits are clear
latch->exclusive = 1;
#ifdef unix
- __sync_lock_release (&latch->mutex);
+ *latch->mutex = 0;
#else
- _InterlockedExchange8(&latch->mutex, 0);
+ _InterlockedExchange8(latch->mutex, 0);
#endif
return prev;
}
void bt_spinreleasewrite(BtSpinLatch *latch)
{
#ifdef unix
- while( __sync_lock_test_and_set(&latch->mutex, 1) )
+ while( __sync_lock_test_and_set(latch->mutex, 1) )
sched_yield();
#else
- while( _InterlockedExchange8(&latch->mutex, 1) )
+ while( _InterlockedExchange8(latch->mutex, 1) )
SwitchToThread();
#endif
latch->exclusive = 0;
#ifdef unix
- __sync_lock_release (&latch->mutex);
+ *latch->mutex = 0;
#else
- _InterlockedExchange8(&latch->mutex, 0);
+ _InterlockedExchange8(latch->mutex, 0);
#endif
}
void bt_spinreleaseread(BtSpinLatch *latch)
{
#ifdef unix
- while( __sync_lock_test_and_set(&latch->mutex, 1) )
+ while( __sync_lock_test_and_set(latch->mutex, 1) )
sched_yield();
#else
- while( _InterlockedExchange8(&latch->mutex, 1) )
+ while( _InterlockedExchange8(latch->mutex, 1) )
SwitchToThread();
#endif
latch->share--;
#ifdef unix
- __sync_lock_release (&latch->mutex);
+ *latch->mutex = 0;
#else
- _InterlockedExchange8(&latch->mutex, 0);
+ _InterlockedExchange8(latch->mutex, 0);
#endif
}
close (mgr->idx);
free (mgr->pool);
free (mgr->hash);
- free (mgr->latch);
+ free ((void *)mgr->latch);
free (mgr);
#else
FlushFileBuffers(mgr->idx);
CloseHandle(mgr->idx);
GlobalFree (mgr->pool);
GlobalFree (mgr->hash);
- GlobalFree (mgr->latch);
+ GlobalFree ((void *)mgr->latch);
GlobalFree (mgr);
#endif
}
void bt_close (BtDb *bt)
{
#ifdef unix
- if ( bt->mem )
+ if( bt->mem )
free (bt->mem);
#else
- if ( bt->mem)
+ if( bt->mem)
VirtualFree (bt->mem, 0, MEM_RELEASE);
#endif
free (bt);
reuse = 0;
}
#ifdef unix
- if ( pwrite(bt->mgr->idx, page, bt->mgr->page_size, new_page << bt->mgr->page_bits) < bt->mgr->page_size )
+ if( pwrite(bt->mgr->idx, page, bt->mgr->page_size, new_page << bt->mgr->page_bits) < bt->mgr->page_size )
return bt->err = BTERR_wrt, 0;
// if writing first page of pool block, zero last page in the block
- if ( !reuse && bt->mgr->poolmask > 0 && (new_page & bt->mgr->poolmask) == 0 )
+ if( !reuse && bt->mgr->poolmask > 0 && (new_page & bt->mgr->poolmask) == 0 )
{
// use zero buffer to write zeros
- if ( pwrite(bt->mgr->idx,bt->zero, bt->mgr->page_size, (new_page | bt->mgr->poolmask) << bt->mgr->page_bits) < bt->mgr->page_size )
+ if( pwrite(bt->mgr->idx,bt->zero, bt->mgr->page_size, (new_page | bt->mgr->poolmask) << bt->mgr->page_bits) < bt->mgr->page_size )
return bt->err = BTERR_wrt, 0;
}
#else
// re-read and re-lock root after determining actual level of root
if( set->page->lvl != drill) {
- if ( set->page_no != ROOT_page )
+ if( set->page_no != ROOT_page )
return bt->err = BTERR_struct, 0;
drill = set->page->lvl;
ptr = keyptr(set->page, slot);
else
{
- if ( !bt->err )
+ if( !bt->err )
bt->err = BTERR_ovflw;
return bt->err;
}
return slotptr(bt->cursor,slot)->tod;
}
-
#ifdef STANDALONE
+#ifndef unix
+double getCpuTime(int type)
+{
+FILETIME crtime[1];
+FILETIME xittime[1];
+FILETIME systime[1];
+FILETIME usrtime[1];
+SYSTEMTIME timeconv[1];
+double ans = 0;
+
+ memset (timeconv, 0, sizeof(SYSTEMTIME));
+
+ switch( type ) {
+ case 0:
+ GetSystemTimeAsFileTime (xittime);
+ FileTimeToSystemTime (xittime, timeconv);
+ ans = (double)timeconv->wDayOfWeek * 3600 * 24;
+ break;
+ case 1:
+ GetProcessTimes (GetCurrentProcess(), crtime, xittime, systime, usrtime);
+ FileTimeToSystemTime (usrtime, timeconv);
+ break;
+ case 2:
+ GetProcessTimes (GetCurrentProcess(), crtime, xittime, systime, usrtime);
+ FileTimeToSystemTime (systime, timeconv);
+ break;
+ }
+
+ ans += (double)timeconv->wHour * 3600;
+ ans += (double)timeconv->wMinute * 60;
+ ans += (double)timeconv->wSecond;
+ ans += (double)timeconv->wMilliseconds / 1000;
+ return ans;
+}
+#else
+#include <time.h>
+#include <sys/resource.h>
+
+double getCpuTime(int type)
+{
+struct rusage used[1];
+struct timeval tv[1];
+
+ switch( type ) {
+ case 0:
+ gettimeofday(tv, NULL);
+ return (double)tv->tv_sec + (double)tv->tv_usec / 1000000;
+
+ case 1:
+ getrusage(RUSAGE_SELF, used);
+ return (double)used->ru_utime.tv_sec + (double)used->ru_utime.tv_usec / 1000000;
+
+ case 2:
+ getrusage(RUSAGE_SELF, used);
+ return (double)used->ru_stime.tv_sec + (double)used->ru_stime.tv_usec / 1000000;
+ }
+
+ return 0;
+}
+#endif
+
void bt_latchaudit (BtDb *bt)
{
ushort idx, hashidx;
uid next, page_no;
BtLatchSet *latch;
-BtPool *pool;
-BtPage page;
BtKey ptr;
#ifdef unix
+ if( *(uint *)(bt->mgr->latchmgr->lock) )
+ fprintf(stderr, "Alloc page locked\n");
+ *(uint *)(bt->mgr->latchmgr->lock) = 0;
+
for( idx = 1; idx < bt->mgr->latchmgr->latchdeployed; idx++ ) {
latch = bt->mgr->latchsets + idx;
- if( *(ushort *)latch->readwr ) {
- fprintf(stderr, "latchset %d r/w locked for page %.8x\n", idx, latch->page_no);
- *(ushort *)latch->readwr = 0;
- }
- if( *(ushort *)latch->access ) {
- fprintf(stderr, "latchset %d access locked for page %.8x\n", idx, latch->page_no);
- *(ushort *)latch->access = 0;
- }
- if( *(ushort *)latch->parent ) {
- fprintf(stderr, "latchset %d parent locked for page %.8x\n", idx, latch->page_no);
- *(ushort *)latch->parent = 0;
- }
- if( *(ushort *)latch->busy ) {
- fprintf(stderr, "latchset %d busy locked for page %.8x\n", idx, latch->page_no);
- *(ushort *)latch->parent = 0;
- }
+ if( *(uint *)latch->readwr )
+ fprintf(stderr, "latchset %d rwlocked for page %.8x\n", idx, latch->page_no);
+ *(uint *)latch->readwr = 0;
+
+ if( *(uint *)latch->access )
+ fprintf(stderr, "latchset %d accesslocked for page %.8x\n", idx, latch->page_no);
+ *(uint *)latch->access = 0;
+
+ if( *(uint *)latch->parent )
+ fprintf(stderr, "latchset %d parentlocked for page %.8x\n", idx, latch->page_no);
+ *(uint *)latch->parent = 0;
+
if( latch->pin ) {
fprintf(stderr, "latchset %d pinned for page %.8x\n", idx, latch->page_no);
latch->pin = 0;
}
for( hashidx = 0; hashidx < bt->mgr->latchmgr->latchhash; hashidx++ ) {
+ if( *(uint *)(bt->mgr->latchmgr->table[hashidx].latch) )
+ fprintf(stderr, "hash entry %d locked\n", hashidx);
+
+ *(uint *)(bt->mgr->latchmgr->table[hashidx].latch) = 0;
+
if( idx = bt->mgr->latchmgr->table[hashidx].slot ) do {
latch = bt->mgr->latchsets + idx;
- if( latch->hash != hashidx ) {
+ if( *(uint *)latch->busy )
+ fprintf(stderr, "latchset %d busylocked for page %.8x\n", idx, latch->page_no);
+ *(uint *)latch->busy = 0;
+ if( latch->hash != hashidx )
fprintf(stderr, "latchset %d wrong hashidx\n", idx);
- latch->hash = hashidx;
- }
+ if( latch->pin )
+ fprintf(stderr, "latchset %d pinned for page %.8x\n", idx, latch->page_no);
} while( idx = latch->next );
}
{
int idx, cnt, len, slot, err;
int segsize, bits = 16;
+double start, stop;
#ifdef unix
pthread_t *threads;
-timer start, stop;
#else
-time_t start[1], stop[1];
HANDLE *threads;
#endif
-double real_time;
ThreadArg *args;
uint poolsize = 0;
+float elapsed;
int num = 0;
char key[1];
BtMgr *mgr;
exit(0);
}
-#ifdef unix
- gettimeofday(&start, NULL);
-#else
- time(start);
-#endif
+ start = getCpuTime(0);
if( argc > 3 )
bits = atoi(argv[3]);
#ifdef unix
for( idx = 0; idx < cnt; idx++ )
pthread_join (threads[idx], NULL);
- gettimeofday(&stop, NULL);
- real_time = 1000.0 * ( stop.tv_sec - start.tv_sec ) + 0.001 * (stop.tv_usec - start.tv_usec );
#else
WaitForMultipleObjects (cnt, threads, TRUE, INFINITE);
for( idx = 0; idx < cnt; idx++ )
CloseHandle(threads[idx]);
- time (stop);
- real_time = 1000 * (*stop - *start);
#endif
- fprintf(stderr, " Time to complete: %.2f seconds\n", real_time/1000);
+ elapsed = getCpuTime(0) - start;
+ fprintf(stderr, " real %dm%.3fs\n", (int)(elapsed/60), elapsed - (int)(elapsed/60)*60);
+ elapsed = getCpuTime(1);
+ fprintf(stderr, " user %dm%.3fs\n", (int)(elapsed/60), elapsed - (int)(elapsed/60)*60);
+ elapsed = getCpuTime(2);
+ fprintf(stderr, " sys %dm%.3fs\n", (int)(elapsed/60), elapsed - (int)(elapsed/60)*60);
+
bt_mgrclose (mgr);
}
projects / btree / blobdiff