greg/stasis-aries-wal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Error handling for linked list.

Browse source
This commit is contained in:
Sears Russell 2005-02-22 23:11:03 +00:00
parent 41fb85eef0
commit 29dacbe7ed
2 changed files with 217 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
lladd/operations/linkedListNTA.h
View file

@ -29,23 +29,23 @@ typedef struct {
recordid listRoot; recordid listRoot;
} lladd_linkedList_iterator; } lladd_linkedList_iterator;
int TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize); compensated_function int TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize);
int TlinkedListFind(int xid, recordid list, const byte * key, int keySize, byte ** value); compensated_function int TlinkedListFind(int xid, recordid list, const byte * key, int keySize, byte ** value);
int TlinkedListRemove(int xid, recordid list, const byte * key, int keySize); compensated_function int TlinkedListRemove(int xid, recordid list, const byte * key, int keySize);
int TlinkedListMove(int xid, recordid start_list, recordid end_list, const byte *key, int keySize); compensated_function int TlinkedListMove(int xid, recordid start_list, recordid end_list, const byte *key, int keySize);
/** The linked list iterator can tolerate the concurrent removal of values that /** The linked list iterator can tolerate the concurrent removal of values that
it has already returned. In the presence of such removals, the iterator it has already returned. In the presence of such removals, the iterator
will return the keys and values present in the list as it existed when next() will return the keys and values present in the list as it existed when next()
was first called. was first called.
@return a new iterator initialized to the head of the list. */ @return a new iterator initialized to the head of the list. */
lladd_linkedList_iterator * TlinkedListIterator(int xid, recordid list, int keySize, int valueSize); compensated_function lladd_linkedList_iterator * TlinkedListIterator(int xid, recordid list, int keySize, int valueSize);
/** @return 1 if there was another entry to be iterated over. 0 otherwise. /** @return 1 if there was another entry to be iterated over. 0 otherwise.
If this function returns 1, the caller must free() the malloced memory If this function returns 1, the caller must free() the malloced memory
returned via the key and value arguments.*/ returned via the key and value arguments.*/
int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int * keySize, byte ** value, int * valueSize); compensated_function int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int * keySize, byte ** value, int * valueSize);
recordid TlinkedListCreate(int xid, int keySize, int ValueSize); compensated_function recordid TlinkedListCreate(int xid, int keySize, int ValueSize);
void TlinkedListDelete(int xid, recordid list); compensated_function void TlinkedListDelete(int xid, recordid list);
Operation getLinkedListInsert(); Operation getLinkedListInsert();
Operation getLinkedListRemove(); Operation getLinkedListRemove();
#endif //__LINKED_LIST_NTA_H #endif //__LINKED_LIST_NTA_H

135
src/lladd/operations/linkedListNTA.c
View file

@ -43,8 +43,8 @@
static pthread_mutex_t linked_list_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; static pthread_mutex_t linked_list_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static void __TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize); compensated_function static void __TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize);
static int __TlinkedListRemove(int xid, recordid list, const byte * key, int keySize); compensated_function static int __TlinkedListRemove(int xid, recordid list, const byte * key, int keySize);
typedef struct { typedef struct {
recordid list; recordid list;
int keySize; int keySize;
@ -67,12 +67,14 @@ compensated_function static int operateInsert(int xid, Page *p, lsn_t lsn, reco
valueSize = log->valueSize; valueSize = log->valueSize;
key = (byte*)(log+1); key = (byte*)(log+1);
value = ((byte*)(log+1))+keySize; value = ((byte*)(log+1))+keySize;
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
// printf("Operate insert called: rid.page = %d keysize = %d valuesize = %d %d {%d %d %d}\n", rid.page, log->keySize, log->valueSize, *(int*)key, value->page, value->slot, value->size); // printf("Operate insert called: rid.page = %d keysize = %d valuesize = %d %d {%d %d %d}\n", rid.page, log->keySize, log->valueSize, *(int*)key, value->page, value->slot, value->size);
// Skip writing the undo! Recovery will write a CLR after we're done, effectively // Skip writing the undo! Recovery will write a CLR after we're done, effectively
// wrapping this in a nested top action, so we needn't worry about that either. // wrapping this in a nested top action, so we needn't worry about that either.
__TlinkedListInsert(xid, log->list, key, keySize, value, valueSize); __TlinkedListInsert(xid, log->list, key, keySize, value, valueSize);
pthread_mutex_unlock(&linked_list_mutex); } compensate_ret(compensation_error());
// pthread_mutex_unlock(&linked_list_mutex);
return 0; return 0;
} }
@ -85,16 +87,21 @@ compensated_function static int operateRemove(int xid, Page *p, lsn_t lsn, reco
keySize = log->keySize; keySize = log->keySize;
key = (byte*)(log+1); key = (byte*)(log+1);
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
// printf("Operate remove called: %d\n", *(int*)key); // printf("Operate remove called: %d\n", *(int*)key);
// Don't call the version that writes an undo entry! // Don't call the version that writes an undo entry!
__TlinkedListRemove(xid, log->list, key, keySize); __TlinkedListRemove(xid, log->list, key, keySize);
pthread_mutex_unlock(&linked_list_mutex); } compensate_ret(compensation_error());
// pthread_mutex_unlock(&linked_list_mutex);
return 0; return 0;
} }
int TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize) { compensated_function int TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize) {
int ret = TlinkedListRemove(xid, list, key, keySize); int ret;
try_ret(compensation_error()) {
ret = TlinkedListRemove(xid, list, key, keySize);
} end_ret(compensation_error());
lladd_linkedListInsert_log * undoLog = malloc(sizeof(lladd_linkedListInsert_log) + keySize); lladd_linkedListInsert_log * undoLog = malloc(sizeof(lladd_linkedListInsert_log) + keySize);
@ -102,13 +109,15 @@ int TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, con
undoLog->keySize = keySize; undoLog->keySize = keySize;
memcpy(undoLog+1, key, keySize); memcpy(undoLog+1, key, keySize);
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
void * handle = TbeginNestedTopAction(xid, OPERATION_LINKED_LIST_INSERT, void * handle = TbeginNestedTopAction(xid, OPERATION_LINKED_LIST_INSERT,
(byte*)undoLog, sizeof(lladd_linkedListInsert_log) + keySize); (byte*)undoLog, sizeof(lladd_linkedListInsert_log) + keySize);
free(undoLog); free(undoLog);
__TlinkedListInsert(xid, list, key, keySize, value, valueSize); __TlinkedListInsert(xid, list, key, keySize, value, valueSize);
TendNestedTopAction(xid, handle); TendNestedTopAction(xid, handle);
pthread_mutex_unlock(&linked_list_mutex);
} compensate_ret(compensation_error());
// pthread_mutex_unlock(&linked_list_mutex);
return ret; return ret;
} }
@ -131,7 +140,7 @@ Operation getLinkedListRemove() {
}; };
return o; return o;
} }
static void __TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize) { compensated_function static void __TlinkedListInsert(int xid, recordid list, const byte * key, int keySize, const byte * value, int valueSize) {
//int ret = Tli nkedListRemove(xid, list, key, keySize); //int ret = Tli nkedListRemove(xid, list, key, keySize);
try { try {
@ -161,7 +170,7 @@ static void __TlinkedListInsert(int xid, recordid list, const byte * key, int ke
} end; } end;
} }
int TlinkedListFind(int xid, recordid list, const byte * key, int keySize, byte ** value) { compensated_function int TlinkedListFind(int xid, recordid list, const byte * key, int keySize, byte ** value) {
lladd_linkedList_entry * entry = malloc(list.size); lladd_linkedList_entry * entry = malloc(list.size);
@ -205,17 +214,21 @@ int TlinkedListFind(int xid, recordid list, const byte * key, int keySize, byte
int TlinkedListRemove(int xid, recordid list, const byte * key, int keySize) { compensated_function int TlinkedListRemove(int xid, recordid list, const byte * key, int keySize) {
byte * value; byte * value;
int valueSize; int valueSize;
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
int ret = TlinkedListFind(xid, list, key, keySize, &value); int ret;
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
ret = TlinkedListFind(xid, list, key, keySize, &value);
} end_action_ret(compensation_error());
if(ret != -1) { if(ret != -1) {
valueSize = ret; valueSize = ret;
} else { } else {
pthread_mutex_unlock(&linked_list_mutex); pthread_mutex_unlock(&linked_list_mutex);
return 0; return 0;
} }
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
int entrySize = sizeof(lladd_linkedListRemove_log) + keySize + valueSize; int entrySize = sizeof(lladd_linkedListRemove_log) + keySize + valueSize;
lladd_linkedListRemove_log * undoLog = malloc(entrySize); lladd_linkedListRemove_log * undoLog = malloc(entrySize);
@ -234,14 +247,19 @@ int TlinkedListRemove(int xid, recordid list, const byte * key, int keySize) {
__TlinkedListRemove(xid, list, key, keySize); __TlinkedListRemove(xid, list, key, keySize);
TendNestedTopAction(xid, handle); TendNestedTopAction(xid, handle);
pthread_mutex_unlock(&linked_list_mutex); } compensate_ret(compensation_error());
return 1; return 1;
} }
static int __TlinkedListRemove(int xid, recordid list, const byte * key, int keySize) { compensated_function static int __TlinkedListRemove(int xid, recordid list, const byte * key, int keySize) {
lladd_linkedList_entry * entry = malloc(list.size); lladd_linkedList_entry * entry = malloc(list.size);
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
Tread(xid, list, entry); Tread(xid, list, entry);
} end_action_ret(compensation_error());
if(entry->next.size == 0) { if(entry->next.size == 0) {
//Empty List. //Empty List.
free(entry); free(entry);
@ -252,7 +270,12 @@ static int __TlinkedListRemove(int xid, recordid list, const byte * key, int key
recordid lastRead = list; recordid lastRead = list;
recordid oldLastRead; recordid oldLastRead;
oldLastRead.size = -2; oldLastRead.size = -2;
int ret = 0;
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
while(1) { while(1) {
if(compensation_error()) { break; }
if(!memcmp(entry + 1, key, keySize)) { if(!memcmp(entry + 1, key, keySize)) {
// Bucket contains the entry of interest. // Bucket contains the entry of interest.
if(listRoot) { if(listRoot) {
@ -260,7 +283,7 @@ static int __TlinkedListRemove(int xid, recordid list, const byte * key, int key
memset(entry, 0, list.size); memset(entry, 0, list.size);
Tset(xid, lastRead, entry); Tset(xid, lastRead, entry);
} else { } else {
assert(entry->next.size == list.size); // Otherwise, sometihng strange is happening, or the list contains entries with variable sizes. assert(entry->next.size == list.size); // Otherwise, something strange is happening, or the list contains entries with variable sizes.
lladd_linkedList_entry * entry2 = malloc(list.size); lladd_linkedList_entry * entry2 = malloc(list.size);
Tread(xid, entry->next, entry2); Tread(xid, entry->next, entry2);
Tdealloc(xid, entry->next); // could break iterator, since it writes one entry ahead. Tdealloc(xid, entry->next); // could break iterator, since it writes one entry ahead.
@ -276,9 +299,11 @@ static int __TlinkedListRemove(int xid, recordid list, const byte * key, int key
Tdealloc(xid, lastRead); Tdealloc(xid, lastRead);
free (entry2); free (entry2);
} }
free(entry); // free(entry);
pthread_mutex_unlock(&linked_list_mutex); // pthread_mutex_unlock(&linked_list_mutex);
return 1; // return 1;
ret = 1;
break;
} else { // Entry doesn't match the key we're looking for. } else { // Entry doesn't match the key we're looking for.
if(entry->next.size != -1) { if(entry->next.size != -1) {
assert(entry->next.size == list.size); // Don't handle lists with variable length records for now assert(entry->next.size == list.size); // Don't handle lists with variable length records for now
@ -292,33 +317,45 @@ static int __TlinkedListRemove(int xid, recordid list, const byte * key, int key
} }
} }
free(entry); free(entry);
pthread_mutex_unlock(&linked_list_mutex); } compensate_ret(compensation_error());
return 0;
return ret;
} }
/*** @todo TlinkedListMove could be much faster, but this is good enough for a first pass */ /*** @todo TlinkedListMove could be much faster, but this is good enough for a first pass */
int TlinkedListMove(int xid, recordid start_list, recordid end_list, const byte *key, int keySize) { compensated_function int TlinkedListMove(int xid, recordid start_list, recordid end_list, const byte *key, int keySize) {
byte * value; byte * value = 0;
int ret;
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
int valueSize = TlinkedListFind(xid, start_list, key, keySize, &value); int valueSize = TlinkedListFind(xid, start_list, key, keySize, &value);
if(valueSize == -1) { if(valueSize != -1) {
pthread_mutex_unlock(&linked_list_mutex); // pthread_mutex_unlock(&linked_list_mutex);
return 0; // return 0;
ret = 0;
} else { } else {
TlinkedListRemove(xid, start_list, key, keySize); TlinkedListRemove(xid, start_list, key, keySize);
TlinkedListInsert(xid, end_list, key, keySize, value, valueSize); TlinkedListInsert(xid, end_list, key, keySize, value, valueSize);
free(value); // pthread_mutex_unlock(&linked_list_mutex);
pthread_mutex_unlock(&linked_list_mutex); // return 1;
return 1; ret = 1;
} }
if(value) { free(value); }
} compensate_ret(compensation_error());
return ret;
} }
recordid TlinkedListCreate(int xid, int keySize, int valueSize) { compensated_function recordid TlinkedListCreate(int xid, int keySize, int valueSize) {
recordid ret = Talloc(xid, sizeof(lladd_linkedList_entry) + keySize + valueSize); recordid ret;
try_ret(NULLRID) {
ret = Talloc(xid, sizeof(lladd_linkedList_entry) + keySize + valueSize);
byte * cleared = calloc(sizeof(lladd_linkedList_entry) + keySize + valueSize, sizeof(byte)); byte * cleared = calloc(sizeof(lladd_linkedList_entry) + keySize + valueSize, sizeof(byte));
Tset(xid, ret, cleared); Tset(xid, ret, cleared);
free(cleared); free(cleared);
} end_ret(NULLRID);
return ret; return ret;
} }
void TlinkedListDelete(int xid, recordid list) { compensated_function void TlinkedListDelete(int xid, recordid list) {
try {
lladd_linkedList_entry * entry = malloc(list.size); lladd_linkedList_entry * entry = malloc(list.size);
Tread(xid, list, entry); Tread(xid, list, entry);
@ -329,6 +366,7 @@ void TlinkedListDelete(int xid, recordid list) {
} }
while(entry->next.size != -1) { while(entry->next.size != -1) {
if(compensation_error()) { break; }
recordid nextEntry; recordid nextEntry;
Tread(xid, nextEntry, entry); Tread(xid, nextEntry, entry);
assert(!memcmp(&nextEntry, &(entry->next), sizeof(recordid))); assert(!memcmp(&nextEntry, &(entry->next), sizeof(recordid)));
@ -336,9 +374,10 @@ void TlinkedListDelete(int xid, recordid list) {
} }
free(entry); free(entry);
} end;
} }
lladd_linkedList_iterator * TlinkedListIterator(int xid, recordid list, int keySize, int valueSize) { compensated_function lladd_linkedList_iterator * TlinkedListIterator(int xid, recordid list, int keySize, int valueSize) {
lladd_linkedList_iterator * it = malloc(sizeof(lladd_linkedList_iterator)); lladd_linkedList_iterator * it = malloc(sizeof(lladd_linkedList_iterator));
it->keySize = keySize; it->keySize = keySize;
it->valueSize = valueSize; it->valueSize = valueSize;
@ -348,14 +387,20 @@ lladd_linkedList_iterator * TlinkedListIterator(int xid, recordid list, int keyS
return it; return it;
} }
int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int * keySize, byte **value, int * valueSize) { compensated_function int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int * keySize, byte **value, int * valueSize) {
if(it->next.size == -1) { free(it); return 0; } if(it->next.size == -1) { free(it); return 0; }
int done = 0;
int ret;
lladd_linkedList_entry * entry;
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
pthread_mutex_lock(&linked_list_mutex); pthread_mutex_lock(&linked_list_mutex);
if(it->first == -1) { if(it->first == -1) {
it->first = 1; it->first = 1;
} else if(it->first) { } else if(it->first) {
lladd_linkedList_entry * entry = malloc(it->next.size); entry = malloc(it->next.size);
Tread(xid, it->listRoot, entry); Tread(xid, it->listRoot, entry);
int listTouched; int listTouched;
listTouched = memcmp(&(entry->next), &(it->next), sizeof(recordid)); listTouched = memcmp(&(entry->next), &(it->next), sizeof(recordid));
@ -364,20 +409,29 @@ int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int *
//The root entry was removed. Reset the iterator. //The root entry was removed. Reset the iterator.
it->first = -1; it->first = -1;
it->next = it->listRoot; it->next = it->listRoot;
int ret = TlinkedListNext(xid, it, key, keySize, value, valueSize); ret = TlinkedListNext(xid, it, key, keySize, value, valueSize);
pthread_mutex_unlock(&linked_list_mutex); // pthread_mutex_unlock(&linked_list_mutex);
return ret; done = 1;
// return ret;
} else { } else {
//continue as normal. //continue as normal.
it->first = 0; it->first = 0;
} }
} }
} end_action_ret(compensation_error());
if(done) {
pthread_mutex_unlock(&linked_list_mutex);
return ret;
}
begin_action_ret(pthread_mutex_unlock, &linked_list_mutex, compensation_error()) {
assert(it->keySize + it->valueSize + sizeof(lladd_linkedList_entry) == it->next.size); assert(it->keySize + it->valueSize + sizeof(lladd_linkedList_entry) == it->next.size);
entry = malloc(it->next.size);
lladd_linkedList_entry * entry = malloc(it->next.size);
Tread(xid, it->next, entry); Tread(xid, it->next, entry);
int ret;
} end_action_ret(compensation_error());
if(entry->next.size) { if(entry->next.size) {
*keySize = it->keySize; *keySize = it->keySize;
*valueSize = it->valueSize; *valueSize = it->valueSize;
@ -397,6 +451,7 @@ int TlinkedListNext(int xid, lladd_linkedList_iterator * it, byte ** key, int *
ret = 0; ret = 0;
} }
free(entry); free(entry);
pthread_mutex_unlock(&linked_list_mutex); pthread_mutex_unlock(&linked_list_mutex);
return ret; return ret;
} }