int set_contains(intset_t *set, val_t val, int transactional) { int result = 0; void *v; v = (void *)val; switch(transactional) { case 0: result = rbtree_contains(set, v); break; case 1: /* Normal transaction */ TX_START(NL); result = TMrbtree_contains(set, (void *)val); TX_END; break; case 2: case 3: case 4: /* Elastic transaction */ TX_START(EL); result = TMrbtree_contains(set, (void *)val); TX_END; break; default: result=0; printf("number %d do not correspond to elasticity.\n", transactional); exit(1); } return result; }
int set_remove(intset_t *set, val_t val, int transactional) { int result = 0; node_t *next; void *v; next = NULL; v = (void *) val; switch(transactional) { case 0: /* Unprotected */ result = rbtree_delete(set, (void *)val); break; case 1: case 2: case 3: /* Normal transaction */ TX_START(NL); result = TMrbtree_delete(set, (void *)val); TX_END; break; case 4: /* Elastic transaction */ TX_START(EL); result = TMrbtree_delete(set, (void *)val); TX_END; break; default: result=0; printf("number %d do not correspond to elasticity.\n", transactional); exit(1); } return result; }
/* * Adding to the rbtree may require rotations (at least in this implementation) * This operation requires strong dependencies between numerous transactional * operations, hence, the use of normal transaction is necessary for safety. */ int set_add(intset_t *set, val_t val, int transactional) { int result = 0; switch(transactional) { case 0: result = rbtree_insert(set, (void *)val, (void *)val); break; case 1: case 2: case 3: case 4: TX_START(NL); result = TMrbtree_insert(set, (void *)val, (void *)val); TX_END; break; default: result=0; printf("number %d do not correspond to elasticity.\n", transactional); exit(1); } return result; }
int set_remove(intset_t *set, val_t val, int transactional) { int result = 0; #ifdef DEBUG printf("++> set_remove(%d)\n", (int)val); IO_FLUSH; #endif #ifdef SEQUENTIAL /* Unprotected */ node_t *prev, *next; prev = set->head; next = prev->next; while (next->val < val) { prev = next; next = prev->next; } result = (next->val == val); if (result) { prev->next = next->next; free(next); } #elif defined STM node_t *prev, *next; val_t v; node_t *n; TX_START(EL); prev = set->head; next = (node_t *)TX_LOAD(&prev->next); while (1) { v = TX_LOAD((uintptr_t *) &next->val); if (v >= val) break; prev = next; next = (node_t *)TX_LOAD(&prev->next); } result = (v == val); if (result) { n = (node_t *)TX_LOAD(&next->next); TX_STORE(&prev->next, n); FREE(next, sizeof(node_t)); } TX_END; #elif defined LOCKFREE result = harris_delete(set, val); #endif return result; }
int set_add(intset_t *set, val_t val, int transactional) { int result = 0; #ifdef DEBUG printf("++> set_add(%d)\n", (int)val); IO_FLUSH; #endif if (!transactional) { result = set_seq_add(set, val); } else { #ifdef SEQUENTIAL /* Unprotected */ result = set_seq_add(set, val); #elif defined STM node_t *prev, *next; val_t v; TX_START(EL); prev = set->head; next = (node_t *)TX_LOAD(&prev->next); while (1) { v = TX_LOAD((uintptr_t *) &next->val); if (v >= val) break; prev = next; next = (node_t *)TX_LOAD(&prev->next); } result = (v != val); if (result) { TX_STORE(&prev->next, new_node(val, next, transactional)); } TX_END; #elif defined LOCKFREE result = harris_insert(set, val); #endif } return result; }
/*! \brief Configures baud rate (refer datasheet) */ void initUART(void) { // Not necessary; initialize anyway DDRD |= _BV(PD1); DDRD &= ~_BV(PD0); // Set baud rate; lower byte and top nibble UBRR0H = ((_UBRR) & 0xF00); UBRR0L = (uint8_t) ((_UBRR) & 0xFF); TX_START(); RX_START(); // Set frame format = 8-N-1 UCSR0C = (_DATA << UCSZ00); }
int set_contains(intset_t *set, val_t val, int transactional) { int result; #ifdef DEBUG printf("++> set_contains(%d)\n", (int)val); IO_FLUSH; #endif #ifdef SEQUENTIAL node_t *prev, *next; prev = set->head; next = prev->next; while (next->val < val) { prev = next; next = prev->next; } result = (next->val == val); #elif defined STM node_t *prev, *next; val_t v = 0; TX_START(EL); prev = set->head; next = (node_t *)TX_LOAD(&prev->next); while (1) { v = TX_LOAD((uintptr_t *) &next->val); if (v >= val) break; prev = next; next = (node_t *)TX_LOAD(&prev->next); } TX_END; result = (v == val); #elif defined LOCKFREE result = harris_find(set, val); #endif return result; }
int set_move(intset_t *set, val_t val1, val_t val2, int transactional) { int result; if(transactional != 0) { TX_START(NL); } result = 0; if(!set_contains(set, val2, transactional)) { if(set_remove(set, val1, transactional)) { set_add(set, val2, transactional); result = 1; } } if(transactional != 0) { TX_END; } return result; }
int probe(gen_state_t *state, FILE *out) { rvm_txid_t txid; probe_state_t *pstate; assert(state->phase == PROBE); if(state->pstate == NULL) { TX_START(txid); state->pstate = rvm_alloc(cfg, sizeof(probe_state_t)); CHECK_ERROR(state->pstate == NULL, ("Failed to allocate probe state\n")); pstate = (probe_state_t*)state->pstate; pstate->curStartNode = state->start_list; pstate->cur_kmr = state->start_list->kmerPtr; pstate->posInContig = 0; pstate->floc = 0; pstate->nkmer_proc = 0; TX_COMMIT(txid); printf("Allocated probe state\n"); } else { pstate = (probe_state_t*)state->pstate; printf("Probe restarting from kmer %ld\n", pstate->nkmer_proc); /* Seek to the correct output location in file */ fseek(out, pstate->floc, SEEK_SET); } char unpackedKmer[KMER_LENGTH+1]; while (pstate->curStartNode != NULL ) { /* Starting a new contig. This may not be true if we are recovering from a failure. */ if(pstate->posInContig == 0) { TX_START(txid); pstate->cur_kmr = pstate->curStartNode->kmerPtr; /* Need to unpack the seed first */ unpackSequence((unsigned char*) pstate->cur_kmr->kmer, (unsigned char*) unpackedKmer, KMER_LENGTH); /* Initialize current contig with the seed content */ memcpy(pstate->cur_contig, unpackedKmer, KMER_LENGTH * sizeof(char)); pstate->posInContig = KMER_LENGTH; pstate->nkmer_proc++; if(pstate->nkmer_proc % PRINT_FREQ == 0) printf("Probe kmer %ld\n", pstate->nkmer_proc); if(pstate->nkmer_proc % cp_freq == 0) { TX_COMMIT(txid); } if(pstate->nkmer_proc % fa_freq == 0) { printf("Simulating probe failure after %ldth kmer\n", pstate->nkmer_proc); exit(EXIT_FAILURE); } } /* Keep adding bases until we find a terminal node */ char right_ext = pstate->cur_kmr->r_ext; while (right_ext != 'F') { TX_START(txid); pstate->cur_contig[pstate->posInContig] = right_ext; pstate->posInContig++; /* At position cur_contig[posInContig-KMER_LENGTH] starts the * last k-mer in the current contig */ unsigned char *nextKmer = (unsigned char *) &(pstate->cur_contig[pstate->posInContig - KMER_LENGTH]); pstate->cur_kmr = lookup_kmer(state->tbl, nextKmer); CHECK_ERROR(pstate->cur_kmr == NULL, ("Couldn't find kmer %ld in hash table\n", pstate->nkmer_proc)); right_ext = pstate->cur_kmr->r_ext; pstate->nkmer_proc++; if(pstate->nkmer_proc % PRINT_FREQ == 0) printf("Probe kmer %ld\n", pstate->nkmer_proc); if(pstate->nkmer_proc % cp_freq == 0) { TX_COMMIT(txid); } if(pstate->nkmer_proc % fa_freq == 0) { printf("Simulating probe failure after %ldth kmer\n", pstate->nkmer_proc); exit(EXIT_FAILURE); } } /* Move on to the next contig */ /* Print the contig since we have found the corresponding terminal node */ pstate->cur_contig[pstate->posInContig] = '\0'; pstate->floc += fprintf(out,"%s\n", pstate->cur_contig); /* Move to the next start node in the list */ pstate->curStartNode = pstate->curStartNode->next; pstate->posInContig = 0; } return 1; }