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

get rid of variables named "new"

Browse source
This commit is contained in:
Rusty Sears 2012-12-04 16:22:08 -08:00
parent 286370a3f1
commit cafe26e728
7 changed files with 68 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
benchmarks/lsn_bench_common.h
View file

@ -9,14 +9,14 @@ void alloc_rids(long long num_rids, recordid ** slow, recordid ** fast) {
int xid = Tbegin(); int xid = Tbegin();
byte * old = stasis_malloc(PAGE_SIZE, byte); byte * old_page = stasis_malloc(PAGE_SIZE, byte);
byte * new = stasis_malloc(PAGE_SIZE, byte); byte * new_page = stasis_malloc(PAGE_SIZE, byte);
for(long long i = 0; i < num_rids; ) { for(long long i = 0; i < num_rids; ) {
pageid_t pid = TpageAlloc(xid); pageid_t pid = TpageAlloc(xid);
Page * p = loadPage(xid, pid); Page * p = loadPage(xid, pid);
writelock(p->rwlatch,0); writelock(p->rwlatch,0);
memcpy(old, p->memAddr, PAGE_SIZE); memcpy(old_page, p->memAddr, PAGE_SIZE);
stasis_page_slotted_lsn_free_initialize_page(p); stasis_page_slotted_lsn_free_initialize_page(p);
while(i < num_rids && while(i < num_rids &&
( (
@ -35,14 +35,14 @@ void alloc_rids(long long num_rids, recordid ** slow, recordid ** fast) {
assert((*slow)[i].size != -1); assert((*slow)[i].size != -1);
i++; i++;
} }
memcpy(new, p->memAddr, PAGE_SIZE); memcpy(new_page, p->memAddr, PAGE_SIZE);
memcpy(p->memAddr, old, PAGE_SIZE); memcpy(p->memAddr, old_page, PAGE_SIZE);
unlock(p->rwlatch); unlock(p->rwlatch);
releasePage(p); releasePage(p);
TpageSet(xid, pid, new); TpageSet(xid, pid, new_page);
} }
free(old); free(old_page);
free(new); free(new_page);
Tcommit(xid); Tcommit(xid);
} }

4
src/apps/cht/cht_server.c
View file

@ -58,11 +58,11 @@ static state_name do_work(void * dfaSet, StateMachine * stateMachine, Message *
{ {
case CREATE: case CREATE:
{ {
recordid new = ThashCreate(ht_xid, VARIABLE_LENGTH, VARIABLE_LENGTH); recordid new_rid = ThashCreate(ht_xid, VARIABLE_LENGTH, VARIABLE_LENGTH);
ThashInsert(ht_xid, app_state_cht->ht_ht, ThashInsert(ht_xid, app_state_cht->ht_ht,
(byte*)&(__header_ptr(m)->hashTable), sizeof(clusterHashTable_t), (byte*)&(__header_ptr(m)->hashTable), sizeof(clusterHashTable_t),
(byte*)&new, sizeof(recordid)); (byte*)&new_rid, sizeof(recordid));
DEBUG("Created local slice of global hash table %d\n", (__header_ptr(m)->hashTable)); DEBUG("Created local slice of global hash table %d\n", (__header_ptr(m)->hashTable));
//Tcommit(app_state_cht->ht_xid); //Tcommit(app_state_cht->ht_xid);

36
src/libdfa/monotree.c
View file

@ -86,7 +86,7 @@ void init_MonoTree(MonoTree * rb, int size) {
StateMachine * allocMachine(MonoTree * rb/*, state_machine_id id*/) { StateMachine * allocMachine(MonoTree * rb/*, state_machine_id id*/) {
StateMachine * new; StateMachine * new_sm;
if(rb->high_water_mark >= rb->size) { if(rb->high_water_mark >= rb->size) {
compactBuffer(rb); compactBuffer(rb);
@ -94,24 +94,24 @@ StateMachine * allocMachine(MonoTree * rb/*, state_machine_id id*/) {
if(rb->high_water_mark >= rb->size) { if(rb->high_water_mark >= rb->size) {
return (StateMachine *)0; return (StateMachine *)0;
} }
new = &(rb->buffer[rb->high_water_mark]); new_sm = &(rb->buffer[rb->high_water_mark]);
rb->high_water_mark++; rb->high_water_mark++;
new->machine_id = rb->next_id; new_sm->machine_id = rb->next_id;
new->mutex = malloc(sizeof(pthread_mutex_t)); new_sm->mutex = malloc(sizeof(pthread_mutex_t));
new->sleepCond = malloc(sizeof(pthread_cond_t)); new_sm->sleepCond = malloc(sizeof(pthread_cond_t));
pthread_mutex_init(new->mutex, NULL); pthread_mutex_init(new_sm->mutex, NULL);
pthread_cond_init(new->sleepCond, NULL); pthread_cond_init(new_sm->sleepCond, NULL);
rb->next_id++; rb->next_id++;
new->current_state = START_STATE; new_sm->current_state = START_STATE;
return new; return new_sm;
} }
StateMachine * insertMachine(MonoTree * rb, state_machine_id id) { StateMachine * insertMachine(MonoTree * rb, state_machine_id id) {
int new_index; int new_index;
StateMachine * new; StateMachine * new_sm;
int insertion_point; int insertion_point;
/* allocMachine is much less expensive than insertMachine, so this /* allocMachine is much less expensive than insertMachine, so this
check is probably worth the trouble check is probably worth the trouble
@ -148,15 +148,15 @@ StateMachine * insertMachine(MonoTree * rb, state_machine_id id) {
} }
} }
new = &(rb->buffer[insertion_point]); new_sm = &(rb->buffer[insertion_point]);
new->machine_id = id; new_sm->machine_id = id;
new->current_state = START_STATE; new_sm->current_state = START_STATE;
new->mutex = malloc(sizeof(pthread_mutex_t)); new_sm->mutex = malloc(sizeof(pthread_mutex_t));
new->sleepCond = malloc(sizeof(pthread_cond_t)); new_sm->sleepCond = malloc(sizeof(pthread_cond_t));
pthread_mutex_init(new->mutex, NULL); pthread_mutex_init(new_sm->mutex, NULL);
pthread_cond_init(new->sleepCond, NULL); pthread_cond_init(new_sm->sleepCond, NULL);
return new; return new_sm;
} }

24
src/libdfa/smash.c
View file

@ -75,29 +75,29 @@ void * _getSmash (smash_t * smash, state_machine_id id) {
} }
StateMachine * _insertSmash(smash_t * smash, state_machine_id id) { StateMachine * _insertSmash(smash_t * smash, state_machine_id id) {
StateMachine * new; StateMachine * new_sm;
if(smash->contents+1 == smash->size) { if(smash->contents+1 == smash->size) {
return NULL; return NULL;
} }
smash->contents++; smash->contents++;
new = malloc(sizeof (StateMachine)); new_sm = malloc(sizeof (StateMachine));
new->machine_id = id; new_sm->machine_id = id;
new->mutex = malloc(sizeof(pthread_mutex_t)); new_sm->mutex = malloc(sizeof(pthread_mutex_t));
new->sleepCond = malloc(sizeof(pthread_cond_t)); new_sm->sleepCond = malloc(sizeof(pthread_cond_t));
new->pending = 0; new_sm->pending = 0;
pthread_mutex_init(new->mutex, NULL); pthread_mutex_init(new_sm->mutex, NULL);
pthread_cond_init(new->sleepCond, NULL); pthread_cond_init(new_sm->sleepCond, NULL);
new->current_state = START_STATE; new_sm->current_state = START_STATE;
/* printf("Insert %ld\n", id); */ /* printf("Insert %ld\n", id); */
ThashInsert(smash->xid, smash->hash, (byte*)&id, sizeof(state_machine_id), (byte*)new, sizeof(StateMachine)); ThashInsert(smash->xid, smash->hash, (byte*)&id, sizeof(state_machine_id), (byte*)new_sm, sizeof(StateMachine));
pblHtInsert(smash->memHash, &id, sizeof(state_machine_id), new); pblHtInsert(smash->memHash, &id, sizeof(state_machine_id), new_sm);
/* Tcommit(smash->xid); /* Tcommit(smash->xid);
smash->xid = Tbegin(); */ smash->xid = Tbegin(); */
return new; return new_sm;
} }

14
src/pobj/hash.c
View file

@ -90,12 +90,12 @@ hash_insert (struct hash *h, unsigned long key, unsigned long val)
{ {
unsigned long bucket_mask = h->bucket_mask; unsigned long bucket_mask = h->bucket_mask;
int bucket_index = (int) (key & bucket_mask); int bucket_index = (int) (key & bucket_mask);
struct hash_item *new; struct hash_item *new_item;
debug_start (); debug_start ();
new = (struct hash_item *) XMALLOC (sizeof (struct hash_item)); new_item = (struct hash_item *) XMALLOC (sizeof (struct hash_item));
if (! new) { if (! new_item) {
debug ("allocation failed"); debug ("allocation failed");
debug_end (); debug_end ();
return -1; return -1;
@ -104,10 +104,10 @@ hash_insert (struct hash *h, unsigned long key, unsigned long val)
debug ("inserting %lu->%lu (%p->%p) to bucket %d", debug ("inserting %lu->%lu (%p->%p) to bucket %d",
key, val, (void *) key, (void *) val, bucket_index); key, val, (void *) key, (void *) val, bucket_index);
new->key = key; new_item->key = key;
new->val = val; new_item->val = val;
new->next = h->table[bucket_index]; new_item->next = h->table[bucket_index];
h->table[bucket_index] = new; h->table[bucket_index] = new_item;
debug_end (); debug_end ();
return 0; return 0;

10
src/stasis/logger/filePool.c
View file

@ -564,19 +564,19 @@ int stasis_log_file_pool_truncate(struct stasis_log_t* log, lsn_t lsn) {
fp->dead_filenames[dead_offset + i][0] = 0; fp->dead_filenames[dead_offset + i][0] = 0;
strcat(fp->dead_filenames[dead_offset + i], fp->live_filenames[i]); strcat(fp->dead_filenames[dead_offset + i], fp->live_filenames[i]);
strcat(fp->dead_filenames[dead_offset + i], "~"); strcat(fp->dead_filenames[dead_offset + i], "~");
char * old = build_path(fp->dirname, fp->live_filenames[i]); char * old_path = build_path(fp->dirname, fp->live_filenames[i]);
char * new = build_path(fp->dirname, fp->dead_filenames[dead_offset + i]); char * new_path = build_path(fp->dirname, fp->dead_filenames[dead_offset + i]);
// TODO This is the only place where we hold the latch while going to disk. // TODO This is the only place where we hold the latch while going to disk.
// Rename should be fast, but we're placing a lot of faith in the filesystem. // Rename should be fast, but we're placing a lot of faith in the filesystem.
int err = rename(old, new); int err = rename(old_path, new_path);
if(err) { if(err) {
perror("could not rename file"); perror("could not rename file");
assert(err == -1); assert(err == -1);
abort(); abort();
} }
close(fp->ro_fd[i]); close(fp->ro_fd[i]);
free(old); free(old_path);
free(new); free(new_path);
} }
fp->dead_count += chunk; fp->dead_count += chunk;
for(int i = 0; i < (fp->live_count - chunk); i++) { for(int i = 0; i < (fp->live_count - chunk); i++) {

32
test/stasis/check_operations.c
View file

@ -574,8 +574,8 @@ START_TEST(operation_lsn_free) {
Page * p = loadPage(xid,pid); Page * p = loadPage(xid,pid);
stasis_page_slotted_lsn_free_initialize_page(p); stasis_page_slotted_lsn_free_initialize_page(p);
// XXX hack! // XXX hack!
byte * old = stasis_malloc(PAGE_SIZE, byte); byte * old_page = stasis_malloc(PAGE_SIZE, byte);
memcpy(old, p->memAddr, PAGE_SIZE); memcpy(old_page, p->memAddr, PAGE_SIZE);
int fortyTwo = 42; int fortyTwo = 42;
for(int i = 0; i < 100; i++) { for(int i = 0; i < 100; i++) {
rid[i] = stasis_record_alloc_begin(xid, p, sizeof(int)); rid[i] = stasis_record_alloc_begin(xid, p, sizeof(int));
@ -583,13 +583,13 @@ START_TEST(operation_lsn_free) {
stasis_record_write(xid, p, rid[i], (const byte*)&fortyTwo); stasis_record_write(xid, p, rid[i], (const byte*)&fortyTwo);
stasis_page_lsn_write(xid, p, -1); stasis_page_lsn_write(xid, p, -1);
} }
byte * new = stasis_malloc(PAGE_SIZE, byte); byte * new_page = stasis_malloc(PAGE_SIZE, byte);
memcpy(new, p->memAddr, PAGE_SIZE); memcpy(new_page, p->memAddr, PAGE_SIZE);
memcpy(p->memAddr, old, PAGE_SIZE); memcpy(p->memAddr, old_page, PAGE_SIZE);
releasePage(p); releasePage(p);
TpageSet(xid, pid, new); TpageSet(xid, pid, new_page);
free(old); free(old_page);
free(new); free(new_page);
Tcommit(xid); Tcommit(xid);
} }
{ {
@ -638,8 +638,8 @@ START_TEST(operation_reorderable) {
Page * p = loadPage(xid,pid); Page * p = loadPage(xid,pid);
stasis_page_slotted_lsn_free_initialize_page(p); stasis_page_slotted_lsn_free_initialize_page(p);
// XXX hack! // XXX hack!
byte * old = stasis_malloc(PAGE_SIZE, byte); byte * old_page = stasis_malloc(PAGE_SIZE, byte);
memcpy(old, p->memAddr, PAGE_SIZE); memcpy(old_page, p->memAddr, PAGE_SIZE);
int fortyTwo = 42; int fortyTwo = 42;
for(int i = 0; i < 100; i++) { for(int i = 0; i < 100; i++) {
rid[i] = stasis_record_alloc_begin(xid, p, sizeof(int)); rid[i] = stasis_record_alloc_begin(xid, p, sizeof(int));
@ -647,13 +647,13 @@ START_TEST(operation_reorderable) {
stasis_record_write(xid, p, rid[i], (const byte*)&fortyTwo); stasis_record_write(xid, p, rid[i], (const byte*)&fortyTwo);
stasis_page_lsn_write(xid, p, -1); stasis_page_lsn_write(xid, p, -1);
} }
byte * new = stasis_malloc(PAGE_SIZE, byte); byte * new_page = stasis_malloc(PAGE_SIZE, byte);
memcpy(new, p->memAddr, PAGE_SIZE); memcpy(new_page, p->memAddr, PAGE_SIZE);
memcpy(p->memAddr, old, PAGE_SIZE); memcpy(p->memAddr, old_page, PAGE_SIZE);
releasePage(p); releasePage(p);
TpageSet(xid, pid, new); TpageSet(xid, pid, new_page);
free(old); free(old_page);
free(new); free(new_page);
Tcommit(xid); Tcommit(xid);
} }
{ {