2004-06-24 21:10:31 +00:00
|
|
|
/*---
|
|
|
|
This software is copyrighted by the Regents of the University of
|
|
|
|
California, and other parties. The following terms apply to all files
|
|
|
|
associated with the software unless explicitly disclaimed in
|
|
|
|
individual files.
|
|
|
|
|
|
|
|
The authors hereby grant permission to use, copy, modify, distribute,
|
|
|
|
and license this software and its documentation for any purpose,
|
|
|
|
provided that existing copyright notices are retained in all copies
|
|
|
|
and that this notice is included verbatim in any distributions. No
|
|
|
|
written agreement, license, or royalty fee is required for any of the
|
|
|
|
authorized uses. Modifications to this software may be copyrighted by
|
|
|
|
their authors and need not follow the licensing terms described here,
|
|
|
|
provided that the new terms are clearly indicated on the first page of
|
|
|
|
each file where they apply.
|
|
|
|
|
|
|
|
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
|
|
|
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
|
|
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
|
|
|
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
|
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
|
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
|
|
|
|
NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, AND
|
|
|
|
THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
|
|
|
|
MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
|
|
|
|
|
|
GOVERNMENT USE: If you are acquiring this software on behalf of the
|
|
|
|
U.S. government, the Government shall have only "Restricted Rights" in
|
|
|
|
the software and related documentation as defined in the Federal
|
|
|
|
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you are
|
|
|
|
acquiring the software on behalf of the Department of Defense, the
|
|
|
|
software shall be classified as "Commercial Computer Software" and the
|
|
|
|
Government shall have only "Restricted Rights" as defined in Clause
|
|
|
|
252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
|
|
|
|
authors grant the U.S. Government and others acting in its behalf
|
|
|
|
permission to use and distribute the software in accordance with the
|
|
|
|
terms specified in this license.
|
|
|
|
---*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <check.h>
|
|
|
|
|
2004-07-14 20:49:18 +00:00
|
|
|
#include <lladd/transactional.h>
|
|
|
|
/*#include <lladd/logger/logEntry.h> */
|
2004-07-14 21:25:59 +00:00
|
|
|
#include "../../src/lladd/logger/logHandle.h"
|
2006-04-07 03:40:40 +00:00
|
|
|
#include <lladd/logger/logger2.h>
|
2006-05-25 00:02:46 +00:00
|
|
|
#include "../../src/lladd/logger/logWriter.h"
|
2004-06-24 21:10:31 +00:00
|
|
|
|
2004-07-06 01:22:18 +00:00
|
|
|
#include "../../src/lladd/latches.h"
|
|
|
|
#include <sched.h>
|
2004-07-04 00:46:49 +00:00
|
|
|
#include <assert.h>
|
2004-07-01 00:53:36 +00:00
|
|
|
#include "../check_includes.h"
|
2006-04-14 03:45:26 +00:00
|
|
|
#include <lladd/truncation.h>
|
2004-07-04 00:46:49 +00:00
|
|
|
|
2006-10-03 01:51:14 +00:00
|
|
|
void simulateBufferManagerCrash();
|
|
|
|
extern int numActiveXactions;
|
2004-07-04 00:46:49 +00:00
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
#define LOG_NAME "check_logWriter.log"
|
|
|
|
|
2006-04-14 03:45:26 +00:00
|
|
|
//static int logType = LOG_TO_MEMORY;
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
static void setup_log() {
|
|
|
|
int i;
|
|
|
|
lsn_t prevLSN = -1;
|
2006-04-07 03:40:40 +00:00
|
|
|
int xid = 42;
|
2006-04-14 03:45:26 +00:00
|
|
|
deleteLogWriter();
|
|
|
|
lladd_enableAutoTruncation = 0;
|
2004-07-14 20:49:18 +00:00
|
|
|
Tinit();
|
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
for(i = 0 ; i < 1000; i++) {
|
|
|
|
LogEntry * e = allocCommonLogEntry(prevLSN, xid, XBEGIN);
|
2006-04-11 02:20:21 +00:00
|
|
|
const LogEntry * f;
|
2004-06-24 21:10:31 +00:00
|
|
|
recordid rid;
|
|
|
|
byte * args = (byte*)"Test 123.";
|
2004-07-06 01:22:18 +00:00
|
|
|
long args_size = 10; /* Including null */
|
2004-06-24 21:10:31 +00:00
|
|
|
unsigned long preImage = 42;
|
|
|
|
|
|
|
|
rid.page = 0;
|
|
|
|
rid.slot = 0;
|
|
|
|
rid.size = sizeof(unsigned long);
|
|
|
|
|
2006-09-27 20:35:30 +00:00
|
|
|
LogWrite(e);
|
2004-06-24 21:10:31 +00:00
|
|
|
prevLSN = e->LSN;
|
2006-04-07 03:40:40 +00:00
|
|
|
|
|
|
|
f = LogReadLSN(prevLSN);
|
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
fail_unless(sizeofLogEntry(e) == sizeofLogEntry(f), "Log entry changed size!!");
|
|
|
|
fail_unless(0 == memcmp(e,f,sizeofLogEntry(e)), "Log entries did not agree!!");
|
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry (e);
|
|
|
|
FreeLogEntry (f);
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
e = allocUpdateLogEntry(prevLSN, xid, 1, rid, args, args_size, (byte*) &preImage);
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2006-09-27 20:35:30 +00:00
|
|
|
LogWrite(e);
|
2004-06-24 21:10:31 +00:00
|
|
|
prevLSN = e->prevLSN;
|
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
LogEntry * g = allocCLRLogEntry(100, 1, 200, rid, 0); //prevLSN);
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2006-09-27 20:35:30 +00:00
|
|
|
LogWrite(g);
|
2006-04-11 02:20:21 +00:00
|
|
|
assert (g->type == CLRLOG);
|
|
|
|
prevLSN = g->LSN;
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry (e);
|
|
|
|
FreeLogEntry (g);
|
2004-06-24 21:10:31 +00:00
|
|
|
}
|
2006-04-14 03:45:26 +00:00
|
|
|
// truncationDeinit();
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
@test
|
|
|
|
|
|
|
|
Quick test of log writer and log handler. Not very extensive.
|
|
|
|
Just writes out 3000 log entries, checks that 1000 of them make
|
|
|
|
sense, and then closes, opens and iterates over the resulting log
|
|
|
|
file to make sure that it contains 3000 entries, and none of its
|
|
|
|
builtin assertions fail.
|
|
|
|
|
|
|
|
In particular, logWriter checks to make sure that each log entry's
|
|
|
|
size matches the size that it recorded before the logEntry. Also,
|
|
|
|
when checking the 1000 of 3000 entries, this test uses
|
2006-04-07 03:40:40 +00:00
|
|
|
LogReadLSN, which tests the logWriter's ability to succesfully
|
2004-06-24 21:10:31 +00:00
|
|
|
manipulate LSN's.
|
|
|
|
|
|
|
|
@todo Test logHandle more thoroughly. (Still need to test the guard mechanism.)
|
|
|
|
|
|
|
|
*/
|
2006-10-03 01:51:14 +00:00
|
|
|
START_TEST(loggerTest)
|
2004-06-24 21:10:31 +00:00
|
|
|
{
|
2006-04-11 02:20:21 +00:00
|
|
|
const LogEntry * e;
|
2004-06-24 21:10:31 +00:00
|
|
|
LogHandle h;
|
|
|
|
int i = 0;
|
2004-07-14 20:49:18 +00:00
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
setup_log();
|
|
|
|
h = getLogHandle();
|
|
|
|
|
|
|
|
while((e = nextInLog(&h))) {
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(e);
|
2004-06-24 21:10:31 +00:00
|
|
|
i++;
|
2006-10-04 04:21:53 +00:00
|
|
|
assert(i < 4000);
|
2004-06-24 21:10:31 +00:00
|
|
|
}
|
|
|
|
|
2006-10-04 04:21:53 +00:00
|
|
|
assert(i == 3000);
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
deleteLogWriter();
|
2006-04-07 03:40:40 +00:00
|
|
|
LogDeinit();
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
|
|
|
/**
|
|
|
|
@test
|
|
|
|
Checks for a bug ecountered during devlopment. What happens when
|
|
|
|
previousInTransaction is called immediately after the handle is
|
|
|
|
allocated? */
|
|
|
|
|
|
|
|
START_TEST(logHandleColdReverseIterator) {
|
2006-04-11 02:20:21 +00:00
|
|
|
const LogEntry * e;
|
2006-03-28 20:14:04 +00:00
|
|
|
setup_log();
|
2004-06-24 21:10:31 +00:00
|
|
|
LogHandle lh = getLogHandle();
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
|
|
|
|
while(((e = nextInLog(&lh)) && (i < 100)) ) {
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(e);
|
2004-06-24 21:10:31 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = 0;
|
2006-04-07 03:40:40 +00:00
|
|
|
// printf("getLogHandle(%ld)\n", e->LSN);
|
|
|
|
lh = getLSNHandle(e->LSN); // was 'getLogHandle...'
|
2004-06-24 21:10:31 +00:00
|
|
|
while((e = previousInTransaction(&lh))) {
|
|
|
|
i++;
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(e);
|
2004-06-24 21:10:31 +00:00
|
|
|
}
|
|
|
|
/* printf("i = %d\n", i); */
|
2006-04-07 03:40:40 +00:00
|
|
|
// assert(i == 1);
|
|
|
|
assert(i < 4); /* We should almost immediately hit a clr that goes to the beginning of the log... */
|
|
|
|
// fail_unless( i == 1 , NULL);
|
|
|
|
LogDeinit();
|
|
|
|
deleteLogWriter();
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
END_TEST
|
|
|
|
|
2004-07-01 00:53:36 +00:00
|
|
|
/**
|
|
|
|
@test
|
|
|
|
|
|
|
|
Build a simple log, truncate it, and then test the logWriter routines against it.
|
|
|
|
*/
|
2006-10-03 01:51:14 +00:00
|
|
|
START_TEST(loggerTruncate) {
|
2006-04-11 02:20:21 +00:00
|
|
|
const LogEntry * le;
|
|
|
|
const LogEntry * le2;
|
|
|
|
const LogEntry * le3 = NULL;
|
|
|
|
const LogEntry * tmp;
|
2006-03-28 20:14:04 +00:00
|
|
|
setup_log();
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
LogHandle lh = getLogHandle();
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while(i < 234) {
|
|
|
|
i++;
|
|
|
|
le = nextInLog(&lh);
|
|
|
|
}
|
|
|
|
|
|
|
|
le2 = nextInLog(&lh);
|
|
|
|
i = 0;
|
|
|
|
while(i < 23) {
|
|
|
|
i++;
|
|
|
|
le3 = nextInLog(&lh);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-04-07 03:40:40 +00:00
|
|
|
// truncateLog(le->LSN);
|
|
|
|
LogTruncate(le->LSN);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
2006-04-07 03:40:40 +00:00
|
|
|
tmp = LogReadLSN(le->LSN);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
fail_unless(NULL != tmp, NULL);
|
|
|
|
fail_unless(tmp->LSN == le->LSN, NULL);
|
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(tmp);
|
2006-04-07 03:40:40 +00:00
|
|
|
tmp = LogReadLSN(le2->LSN);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
fail_unless(NULL != tmp, NULL);
|
|
|
|
fail_unless(tmp->LSN == le2->LSN, NULL);
|
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(tmp);
|
2006-04-07 03:40:40 +00:00
|
|
|
tmp = LogReadLSN(le3->LSN);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
fail_unless(NULL != tmp, NULL);
|
|
|
|
fail_unless(tmp->LSN == le3->LSN, NULL);
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(tmp);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
lh = getLogHandle();
|
|
|
|
|
|
|
|
i = 0;
|
2006-04-07 03:40:40 +00:00
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(le);
|
|
|
|
FreeLogEntry(le2);
|
|
|
|
FreeLogEntry(le3);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
while((le = nextInLog(&lh))) {
|
2006-10-04 04:21:53 +00:00
|
|
|
if(le->type != INTERNALLOG) {
|
|
|
|
i++;
|
|
|
|
}
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(le);
|
2004-07-01 00:53:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-04-07 03:40:40 +00:00
|
|
|
assert(i == (3000 - 234 + 1));
|
|
|
|
// fail_unless(i == (3000 - 234 + 1), NULL);
|
2004-07-01 00:53:36 +00:00
|
|
|
|
2006-04-07 03:40:40 +00:00
|
|
|
LogDeinit();
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
} END_TEST
|
|
|
|
|
2006-04-14 03:45:26 +00:00
|
|
|
#define ENTRIES_PER_THREAD 200
|
2004-07-04 00:46:49 +00:00
|
|
|
|
|
|
|
pthread_mutex_t random_mutex;
|
|
|
|
|
2006-04-14 03:45:26 +00:00
|
|
|
lsn_t truncated_to = 4;
|
|
|
|
//pthread_mutex_t truncated_to_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
|
2006-11-10 19:32:44 +00:00
|
|
|
#define NO_CONCURRENCY
|
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
pthread_mutex_t big = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
#endif
|
2004-07-04 00:46:49 +00:00
|
|
|
static void* worker_thread(void * arg) {
|
2006-03-20 23:11:46 +00:00
|
|
|
long key = *(int*)arg;
|
|
|
|
long i = 0;
|
2004-07-04 00:46:49 +00:00
|
|
|
|
2006-04-14 03:45:26 +00:00
|
|
|
lsn_t lsns[ENTRIES_PER_THREAD];
|
2004-07-04 00:46:49 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* fail_unless(NULL != le, NULL); */
|
|
|
|
|
|
|
|
while(i < ENTRIES_PER_THREAD) {
|
2006-04-11 02:20:21 +00:00
|
|
|
LogEntry * le = allocCommonLogEntry(-1, -1, XBEGIN);
|
2004-07-04 00:46:49 +00:00
|
|
|
int threshold;
|
2006-03-20 23:11:46 +00:00
|
|
|
long entry;
|
|
|
|
int needToTruncate = 0;
|
2006-04-14 03:45:26 +00:00
|
|
|
lsn_t myTruncVal = 0;
|
2004-07-04 00:46:49 +00:00
|
|
|
pthread_mutex_lock(&random_mutex);
|
|
|
|
|
|
|
|
threshold = (int) (2000.0*random()/(RAND_MAX+1.0));
|
2006-03-20 23:11:46 +00:00
|
|
|
entry = (long) (ENTRIES_PER_THREAD*random()/(RAND_MAX+1.0));
|
|
|
|
|
|
|
|
if(threshold < 3) {
|
|
|
|
if(i > 10) {
|
|
|
|
needToTruncate = 1;
|
|
|
|
if(lsns[i - 10] > truncated_to) {
|
|
|
|
truncated_to = lsns[i - 10];
|
2006-04-14 03:45:26 +00:00
|
|
|
myTruncVal = truncated_to;
|
2006-03-20 23:11:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-07-04 00:46:49 +00:00
|
|
|
|
|
|
|
pthread_mutex_unlock(&random_mutex);
|
|
|
|
|
2006-04-14 03:45:26 +00:00
|
|
|
if(needToTruncate) {
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
pthread_mutex_lock(&big);
|
|
|
|
#endif
|
2006-04-14 03:45:26 +00:00
|
|
|
LogTruncate(myTruncVal);
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
pthread_mutex_unlock(&big);
|
|
|
|
#endif
|
2006-04-14 03:45:26 +00:00
|
|
|
assert(LogTruncationPoint() >= myTruncVal);
|
|
|
|
}
|
2004-07-04 00:46:49 +00:00
|
|
|
|
|
|
|
if(threshold < 3) {
|
|
|
|
} else {
|
|
|
|
le->xid = i+key;
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
pthread_mutex_lock(&big);
|
|
|
|
#endif
|
2006-09-27 20:35:30 +00:00
|
|
|
LogWrite(le);
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
pthread_mutex_unlock(&big);
|
|
|
|
#endif
|
2006-03-20 23:11:46 +00:00
|
|
|
//printf("reportedLSN: %ld\n", le->LSN);
|
2004-07-04 00:46:49 +00:00
|
|
|
lsns[i] = le->LSN;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
/* fail_unless(1, NULL); */
|
2006-03-20 23:11:46 +00:00
|
|
|
pthread_mutex_lock(&random_mutex);
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
//pthread_mutex_lock(&big);
|
|
|
|
#endif
|
2006-03-20 23:11:46 +00:00
|
|
|
if(lsns[entry] > truncated_to && entry < i) {
|
2006-04-07 03:40:40 +00:00
|
|
|
/*printf("X %d\n", (LogReadLSN(lsns[entry])->xid == entry+key)); fflush(stdout); */
|
2006-10-04 04:21:53 +00:00
|
|
|
lsn_t lsn = lsns[entry];
|
2006-04-14 03:45:26 +00:00
|
|
|
pthread_mutex_unlock(&random_mutex);
|
2006-10-04 04:21:53 +00:00
|
|
|
|
|
|
|
const LogEntry * e = LogReadLSN(lsn);
|
|
|
|
|
2006-04-07 03:40:40 +00:00
|
|
|
assert(e->xid == entry+key);
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(e);
|
2006-04-07 03:40:40 +00:00
|
|
|
/* fail_unless(LogReadLSN(lsns[entry])->xid == entry+key, NULL); */
|
2006-03-20 23:11:46 +00:00
|
|
|
} else {
|
|
|
|
pthread_mutex_unlock(&random_mutex);
|
2004-07-04 00:46:49 +00:00
|
|
|
}
|
2006-11-10 19:32:44 +00:00
|
|
|
#ifdef NO_CONCURRENCY
|
|
|
|
//pthread_mutex_unlock(&big);
|
|
|
|
#endif
|
2004-07-04 00:46:49 +00:00
|
|
|
/* fail_unless(1, NULL); */
|
|
|
|
|
|
|
|
/* Try to interleave requests as much as possible */
|
2004-07-06 01:22:18 +00:00
|
|
|
/*pthread_yield(); */
|
|
|
|
sched_yield();
|
2006-04-11 02:20:21 +00:00
|
|
|
FreeLogEntry(le);
|
2004-07-04 00:46:49 +00:00
|
|
|
}
|
|
|
|
|
2006-04-11 02:20:21 +00:00
|
|
|
|
2004-07-04 00:46:49 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-03 01:51:14 +00:00
|
|
|
START_TEST(loggerCheckWorker) {
|
2004-07-04 00:46:49 +00:00
|
|
|
int four = 4;
|
|
|
|
|
|
|
|
pthread_mutex_init(&random_mutex, NULL);
|
|
|
|
|
|
|
|
Tinit();
|
|
|
|
worker_thread(&four);
|
|
|
|
Tdeinit();
|
|
|
|
|
|
|
|
} END_TEST
|
|
|
|
|
2006-10-03 01:51:14 +00:00
|
|
|
START_TEST(loggerCheckThreaded) {
|
2004-07-13 23:48:20 +00:00
|
|
|
|
2004-10-04 05:24:12 +00:00
|
|
|
#define THREAD_COUNT 100
|
2004-07-04 00:46:49 +00:00
|
|
|
pthread_t workers[THREAD_COUNT];
|
|
|
|
int i;
|
|
|
|
pthread_mutex_init(&random_mutex, NULL);
|
|
|
|
|
|
|
|
Tinit();
|
|
|
|
|
|
|
|
for(i = 0; i < THREAD_COUNT; i++) {
|
2004-07-13 23:48:20 +00:00
|
|
|
pthread_create(&workers[i], NULL, worker_thread, &i);
|
2005-03-10 03:19:04 +00:00
|
|
|
// printf("%d", i); fflush(stdout);
|
2004-07-04 00:46:49 +00:00
|
|
|
}
|
2005-03-10 03:19:04 +00:00
|
|
|
// printf("\n\n\n\n\n");
|
2004-07-04 00:46:49 +00:00
|
|
|
for(i = 0; i < THREAD_COUNT; i++) {
|
|
|
|
pthread_join(workers[i], NULL);
|
2005-03-10 03:19:04 +00:00
|
|
|
// printf("%d", i); fflush(stdout);
|
2004-07-04 00:46:49 +00:00
|
|
|
}
|
|
|
|
Tdeinit();
|
|
|
|
|
|
|
|
} END_TEST
|
|
|
|
|
2006-10-04 04:21:53 +00:00
|
|
|
void reopenLogWorkload(int truncating) {
|
|
|
|
|
|
|
|
lladd_enableAutoTruncation = 0;
|
|
|
|
|
|
|
|
const int ENTRY_COUNT = 1000;
|
|
|
|
const int SYNC_POINT = 900;
|
|
|
|
lladd_enableAutoTruncation = 0;
|
2006-10-03 01:51:14 +00:00
|
|
|
|
|
|
|
numActiveXactions = 0;
|
2006-10-04 04:21:53 +00:00
|
|
|
dirtyPagesInit();
|
2007-03-04 00:36:45 +00:00
|
|
|
bufInit(BUFFER_MANAGER_REOPEN);
|
2006-10-03 01:51:14 +00:00
|
|
|
|
2006-10-04 04:21:53 +00:00
|
|
|
LogInit(loggerType);
|
|
|
|
int xid = 1;
|
|
|
|
TransactionLog l = LogTransBegin(xid);
|
|
|
|
lsn_t startLSN = 0;
|
|
|
|
|
|
|
|
LogEntry * entries[ENTRY_COUNT];
|
|
|
|
|
|
|
|
for(int i = 0; i < ENTRY_COUNT; i++) {
|
|
|
|
|
|
|
|
entries[i] = LogUpdate(&l, NULL, NULLRID, OPERATION_NOOP, NULL);
|
2006-10-03 01:51:14 +00:00
|
|
|
|
2006-10-04 04:21:53 +00:00
|
|
|
if(i == SYNC_POINT) {
|
|
|
|
if(truncating) {
|
|
|
|
// printf("Called LogTruncate()");
|
|
|
|
// fflush(stdout);
|
|
|
|
LogTruncate(entries[i]->LSN);
|
|
|
|
startLSN = entries[i]->LSN;
|
|
|
|
}
|
|
|
|
}
|
2006-10-03 01:51:14 +00:00
|
|
|
}
|
2006-10-04 04:21:53 +00:00
|
|
|
LogDeinit(loggerType);
|
|
|
|
|
|
|
|
LogInit(loggerType);
|
|
|
|
LogHandle h;
|
|
|
|
int i;
|
2006-10-03 01:51:14 +00:00
|
|
|
|
2006-10-04 04:21:53 +00:00
|
|
|
if(truncating) {
|
|
|
|
h = getLogHandle(); //getLSNHandle(startLSN);
|
|
|
|
i = SYNC_POINT;
|
|
|
|
} else {
|
|
|
|
h = getLogHandle();
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const LogEntry * e;
|
|
|
|
while((e = nextInLog(&h))) {
|
|
|
|
if(e->type != INTERNALLOG) {
|
|
|
|
assert(sizeofLogEntry(e) == sizeofLogEntry(entries[i]));
|
|
|
|
assert(!memcmp(e, entries[i], sizeofLogEntry(entries[i])));
|
|
|
|
assert(i < ENTRY_COUNT);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(i == (ENTRY_COUNT));
|
|
|
|
|
|
|
|
LogEntry * entries2[ENTRY_COUNT];
|
|
|
|
for(int i = 0; i < ENTRY_COUNT; i++) {
|
|
|
|
entries2[i] = LogUpdate(&l, NULL, NULLRID, OPERATION_NOOP, NULL);
|
|
|
|
if(i == SYNC_POINT) {
|
|
|
|
syncLog_LogWriter();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if(truncating) {
|
|
|
|
h = getLSNHandle(startLSN);
|
|
|
|
i = SYNC_POINT;
|
|
|
|
} else {
|
|
|
|
h = getLogHandle();
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while((e = nextInLog(&h))) {
|
|
|
|
if(e->type != INTERNALLOG) {
|
|
|
|
if( i < ENTRY_COUNT) {
|
|
|
|
assert(sizeofLogEntry(e) == sizeofLogEntry(entries[i]));
|
|
|
|
assert(!memcmp(e, entries[i], sizeofLogEntry(entries[i])));
|
|
|
|
} else {
|
|
|
|
assert(i < ENTRY_COUNT * 2);
|
|
|
|
assert(sizeofLogEntry(e) == sizeofLogEntry(entries2[i-ENTRY_COUNT]));
|
|
|
|
assert(!memcmp(e, entries2[i-ENTRY_COUNT], sizeofLogEntry(entries2[i-ENTRY_COUNT])));
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(i == (ENTRY_COUNT * 2));
|
|
|
|
|
|
|
|
lladd_enableAutoTruncation = 1;
|
2006-10-03 01:51:14 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
START_TEST(loggerReopenTest) {
|
2006-10-04 04:21:53 +00:00
|
|
|
|
|
|
|
reopenLogWorkload(0);
|
|
|
|
|
2006-10-03 01:51:14 +00:00
|
|
|
} END_TEST
|
|
|
|
|
|
|
|
START_TEST(loggerTruncateReopenTest) {
|
2006-10-04 04:21:53 +00:00
|
|
|
deleteLogWriter();
|
|
|
|
reopenLogWorkload(1);
|
|
|
|
/* reopenLogWorkload();
|
2006-10-03 01:51:14 +00:00
|
|
|
Tinit();
|
|
|
|
truncateNow();
|
|
|
|
Tdeinit();
|
|
|
|
Tinit();
|
2006-10-04 04:21:53 +00:00
|
|
|
Tdeinit(); */
|
2006-10-03 01:51:14 +00:00
|
|
|
} END_TEST
|
2004-07-04 00:46:49 +00:00
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
Suite * check_suite(void) {
|
|
|
|
Suite *s = suite_create("logWriter");
|
|
|
|
/* Begin a new test */
|
|
|
|
TCase *tc = tcase_create("writeNew");
|
2005-03-10 03:19:04 +00:00
|
|
|
tcase_set_timeout(tc, 0);
|
2004-06-24 21:10:31 +00:00
|
|
|
/* Sub tests are added, one per line, here */
|
2005-03-10 03:19:04 +00:00
|
|
|
|
2006-10-03 01:51:14 +00:00
|
|
|
tcase_add_test(tc, loggerTest);
|
2006-04-07 03:40:40 +00:00
|
|
|
tcase_add_test(tc, logHandleColdReverseIterator);
|
2006-10-03 01:51:14 +00:00
|
|
|
tcase_add_test(tc, loggerTruncate);
|
|
|
|
tcase_add_test(tc, loggerCheckWorker);
|
2006-10-04 04:21:53 +00:00
|
|
|
tcase_add_test(tc, loggerCheckThreaded);
|
2007-03-03 01:46:06 +00:00
|
|
|
if(loggerType != LOG_TO_MEMORY) {
|
2006-10-03 01:51:14 +00:00
|
|
|
tcase_add_test(tc, loggerReopenTest);
|
|
|
|
tcase_add_test(tc, loggerTruncateReopenTest);
|
2007-03-03 01:46:06 +00:00
|
|
|
}
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
/* --------------------------------------------- */
|
2004-07-01 00:53:36 +00:00
|
|
|
|
|
|
|
tcase_add_checked_fixture(tc, setup, teardown);
|
|
|
|
|
2004-06-24 21:10:31 +00:00
|
|
|
|
|
|
|
suite_add_tcase(s, tc);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "../check_setup.h"
|