Vertex vertex_delete(String key, Vertex t)
{
if (vertex_isempty(t))
return t;
else if (strcmp(key, t->name) < 0){
if (vertex_isempty(t->left))
return t;
else{
t->left = vertex_delete(key, t->left);
return t;
}}
else if (strcmp(key, t->name) > 0){
if (vertex_isempty(t->right))
return t;
else{
t->right = vertex_delete(key, t->right);
return t;
}}
else if ((vertex_isempty(t->right)) && (vertex_isempty(t->left)))
return vertex_empty();
else if (vertex_isempty(t->left))
return t->right;
else if (vertex_isempty(t->right))
return t->left;
else{
t->name = min_name(t->right);
t->right = deletemin(t->right);
return t;
}
}
// Deleting a node
void bstree::del(int x,nodeptr &p)
{
nodeptr d;
if (p==NULL)
cout<<"\nElement not found";
else if ( x < p->element)
del(x,p->left);
else if (x > p->element)
del(x,p->right);
else if ((p->left == NULL) && (p->right == NULL))
{
d=p;
free(d);
p=NULL;
cout<<"\nElement deleted !";
}
else if (p->left == NULL)
{
d=p;
free(d);
p=p->right;
cout<<"\nElement deleted !";
}
else if (p->right == NULL)
{
d=p;
p=p->left;
free(d);
cout<<"\nElement deleted !";
}
else
p->element = deletemin(p->right);
}
void
deletemin (avltree ** n, void **dataptr)
{
avltree *temp;
short dif;
if ((*n)->left != NULL) /* keep going for leftmost node */
deletemin (&(*n)->left, dataptr);
else
{ /* leftmost node found */
*dataptr = (*n)->data; /* get pointer to data */
temp = *n;
*n = (*n)->right; /* return pointer to right subtree */
free (temp); /* of leftmost node */
}
if (*n != NULL)
{
fixheight (*n);
dif = difference (*n);
if (dif > 1) /* deletion caused left subtree to be too high */
balanceleft (n, -1);
else if (dif < -1) /* deletion caused right subtree to be too high */
balanceright (n, -1);
}
}
template<typename T, typename KEY> void RBTree<T, KEY>::deletemin()
{
if (pRoot) // check if the tree is empty.
{
if (!isRed(pRoot->pLeft)) // Root contains only one node. Both its left and right child are black.
pRoot->color = RED;
pRoot = deletemin(pRoot);
if (pRoot)
pRoot->color = BLACK;
}
}
Vertex deletemin(Vertex t){
if (vertex_isempty(t->left))
if (vertex_isempty(t->right))
return vertex_empty();
else
return t->right;
else{
t->left = deletemin(t->left);
return t;
}
}
Btree deletemin(Btree t){
if (btree_isempty(t->left))
if (btree_isempty(t->right))
return btree_empty();
else
return t->right;
else{
t->left = deletemin(t->left);
return t;
}
}
int IntervallTree_bed::deletemin(Leaf * &p) {
int c;
std::cout << "inside deltemin\n" << std::endl;
if (p->left == NULL) {
//c = p->get_value();
p = p->right;
return c;
} else {
c = deletemin(p->left);
return c;
}
}
Btree btree_delete(String key, Btree t)
{
if (btree_isempty(t))
return t;
else if (strcmp(key, t->key) < 0){
if (btree_isempty(t->left))
return t;
else{
t->left = btree_delete(key, t->left);
return t;
}}
else if (strcmp(key, t->key) > 0){
if (btree_isempty(t->right))
return t;
else{
t->right = btree_delete(key, t->right);
return t;
}}
else if ((btree_isempty(t->right)) && (btree_isempty(t->left))){
free(t->key);
free(t->value);
free(t);
return btree_empty();
}
else if (btree_isempty(t->left)){
Btree p = t->right;
free(t->key);
free(t->value);
free(t);
return p;
}
else if (btree_isempty(t->right)){
Btree p = t->left;
free(t->key);
free(t->value);
free(t);
return p;
}
else{
Btree p;
p->key = min_key(t->right);
p->value = min_val(t->right);
p->right = deletemin(t->right);
free(t->key);
free(t->value);
free(t);
return p;
}
}
template<typename T, typename KEY> RBTNode<T, KEY> *RBTree<T, KEY>::deletemin(RBTNode<T, KEY> *h)
{
if (h->pLeft == NULL)
{
// be careful here hasn't check if the h is empty.
//std::cout << "Delete min " << h->key << std::endl;
delete h;
return NULL;
}
if (!isRed(h->pLeft) && !isRed(h->pLeft->pLeft))
h = MoveRedLeft(h);
h->pLeft = deletemin(h->pLeft);
if (isRed(h->pRight))
h = RotateLeft(h);
return h;
}
int bstree::deletemin(nodeptr &p)
{
int c;
cout<<"inside deltemin";
if (p->left == NULL)
{
c=p->element;
p=p->right;
return c;
}
else
{
c=deletemin(p->left);
return c;
}
}
template<typename T, typename KEY> RBTNode<T, KEY> *RBTree<T, KEY>::deleteone(RBTNode<T, KEY> *h, KEY Key)
{
// Delete a node.
// However will be not sure Key exists in the tree. Check if the Key exists before deleting.
if (Key < h->key)
{
if (!isRed(h->pLeft) && !isRed(h->pLeft->pLeft))
h = MoveRedLeft(h);
h->pLeft = deleteone(h->pLeft, Key);
}
else{
if (isRed(h->pLeft))
h = RotateRight(h);
if ((Key == h->key) && !(h->pRight) )
{
//std::cout << "Delete one specified node: " << h->key << ", value: " << h->value << std::endl;
delete h;
return NULL;
}
if (!isRed(h->pRight) && !isRed(h->pRight->pLeft))
h = MoveRedRight(h);
if (Key == h->key)
{
//std::cout << "To delete " << h->key << ", delete subtree's min node" << std::endl;
RBTNode<T, KEY> *temp = getmin(h->pRight);
h->value = temp->value;
h->key = temp->key;
h->pRight = deletemin(h->pRight);
}
else
h->pRight = deleteone(h->pRight, Key);
}
if (isRed(h->pRight))
h = RotateLeft(h);
return h;
}
void* test(void *data) {
int unext, last = -1;
val_t val = 0;
pval_t pval = 0;
thread_data_t *d = (thread_data_t *)data;
/* Create transaction */
TM_THREAD_ENTER(d->id);
set_cpu(the_cores[d->id]);
/* Wait on barrier */
ssalloc_init();
PF_CORRECTION;
seeds = seed_rand();
#ifdef PIN
int id = d->id;
int cpu = 40*(id/40) + 4*(id%10) + (id%40)/10;
// printf("Pinning %d to %d\n",id,cpu);
pin(pthread_self(), cpu);
// pin(pthread_self(), id);
#endif
#ifdef PAPI
if (PAPI_OK != PAPI_start_counters(g_events, G_EVENT_COUNT))
{
printf("Problem starting counters 1.");
}
#endif
barrier_cross(d->barrier);
/* Is the first op an update? */
unext = (rand_range_re(&d->seed, 100) - 1 < d->update);
#ifdef DISTRIBUTION_EXPERIMENT
while (1)
#else
while (*running)
#endif
{
if (d->es) { // event simulator experiment
if (d->lin) {
if (!empty(d->linden_set)) {
d->nb_remove++;
pval_t pval = deletemin(d->linden_set, d);
d->nb_removed++;
// printf("%d %d\n", pval, deps[pval][0]);
int i = 0;
val_t dep;
while ((dep = deps[pval][i]) != -1 && i < MAX_DEPS) {
d->nb_add++;
if (insert(d->linden_set, dep, dep)) {
d->nb_added++;
}
i++;
}
}
} else {
if (d->set->head->next[0]->next[0] != NULL) {// set not empty
d->nb_remove++;
if (d->sl) { // spray list
if (spray_delete_min(d->set, &val, d)) {
d->nb_removed++;
} else {
continue;
}
} else if (d->pq) { // lotan_shavit pq
if (lotan_shavit_delete_min(d->set, &val, d)) {
d->nb_removed++;
// continue; // TODO: maybe try remove this to simulate task handling (dependency checks still occur)
} else {
continue;
}
}
// struct timespec ten_usec;
// ten_usec.tv_sec = 0;
// ten_usec.tv_nsec = 10000;
// nanosleep(&ten_usec, NULL);
// dependency handling
int i = 0;
val_t dep;
while ((dep = deps[val][i]) != -1 && i < MAX_DEPS) {
if (!sl_contains(d->set, dep, TRANSACTIONAL)) { // dependent has been removed, need to add it again
if (sl_add(d->set, dep, TRANSACTIONAL)) { // check if insert actually succeeded (otherwise someone else did it first)
d->nb_added++;
}
d->nb_add++;
}
i++;
}
}
}
} else { // not event simulator
if (unext) { // update
if (last < 0) { // add
val = rand_range_re(&d->seed, d->range);
if (d->lin) {
pval = val;
insert(d->linden_set, pval, pval);
d->nb_added++;
last = pval;
} else { // not linden
if (sl_add(d->set, val, TRANSACTIONAL)) {
d->nb_added++;
last = val;
}
}
d->nb_add++;
} else { // remove
if (d->pq) {
if (lotan_shavit_delete_min(d->set, &val, d)) {
d->nb_removed++;
if (d->first_remove == -1) {
d->first_remove = val;
}
}
last = -1;
}
else if (d->sl) {
if (spray_delete_min(d->set, &val, d)) {
d->nb_removed++;
if (d->first_remove == -1) {
d->first_remove = val;
}
last = -1;
}
}
else if (d->lin) {
if ((pval = deletemin(d->linden_set, d))) {
d->nb_removed++;
if (d->first_remove == -1) {
d->first_remove = pval;
}
last = -1;
}
}
else if (d->alternate) { // alternate mode (default)
if (sl_remove(d->set, last, TRANSACTIONAL)) {
d->nb_removed++;
if (d->first_remove == -1) {
d->first_remove = val;
}
}
last = -1;
} else {
/* Random computation only in non-alternated cases */
val = rand_range_re(&d->seed, d->range);
/* Remove one random value */
if (sl_remove_succ(d->set, val, TRANSACTIONAL)) {
d->nb_removed++;
if (d->first_remove == -1) {
d->first_remove = val;
}
/* Repeat until successful, to avoid size variations */
last = -1;
}
}
d->nb_remove++;
}
} else { // read
if (d->alternate) {
if (d->update == 0) {
if (last < 0) {
val = d->first;
last = val;
} else { // last >= 0
val = rand_range_re(&d->seed, d->range);
last = -1;
}
} else { // update != 0
if (last < 0) {
val = rand_range_re(&d->seed, d->range);
//last = val;
} else {
val = last;
}
}
} else val = rand_range_re(&d->seed, d->range);
PF_START(2);
if (sl_contains(d->set, val, TRANSACTIONAL))
d->nb_found++;
PF_STOP(2);
d->nb_contains++;
}
/* Is the next op an update? */
if (d->effective) { // a failed remove/add is a read-only tx
unext = ((100 * (d->nb_added + d->nb_removed))
< (d->update * (d->nb_add + d->nb_remove + d->nb_contains)));
} else { // remove/add (even failed) is considered as an update
unext = (rand_range_re(&d->seed, 100) - 1 < d->update);
}
}
#ifdef DISTRIBUTION_EXPERIMENT
if (d->first_remove != -1) {
break; //only one run
}
#endif
}
#ifdef PAPI
if (PAPI_OK != PAPI_read_counters(g_values[d->id], G_EVENT_COUNT))
{
printf("Problem reading counters 2.");
}
#endif
/* Free transaction */
TM_THREAD_EXIT();
PF_PRINT;
return NULL;
}
int main(int argc, char *argv[])
{
int incpus,ncpus,cpuid,modidx,width,y,x,nextx,tsizelen;
uint64_t msize,modulus,nin;
char c,*tsizearg,inbase[64];
uint64_t skipunder, nnewillcnt, newstates[3];
int i,nnew,noutfiles;
statebuf *mb;
statecnt sn;
jtset *jts;
goin *gin;
goout *go;
assert(sizeof(uint64_t)==8);
if (argc!=9 && argc!=10) {
printf("usage: %s width modulo_index y x incpus ncpus cpuid maxtreesize[kKmMgG] [lastfile]\n",argv[0]);
exit(1);
}
setwidth(width = atoi(argv[1]));
modidx = atoi(argv[2]);
if (modidx < 0 || modidx >= NMODULI) {
printf ("modulo_index %d not in range [0,%d)\n", modidx, NMODULI);
exit(1);
}
modulus = -(uint64_t)modulusdeltas[modidx];
y = atoi(argv[3]);
x = atoi(argv[4]);
nextx = (x+1) % width;
incpus = atoi(argv[5]);
ncpus = atoi(argv[6]);
if (ncpus < 1 || ncpus > MAXCPUS) {
printf ("#cpus %d not in range [0,%d]\n", ncpus, MAXCPUS);
exit(1);
}
cpuid = atoi(argv[7]);
if (cpuid < 0 || cpuid >= ncpus) {
printf("cpuid %d not in range [0,%d]\n", ncpus, ncpus-1);
exit(1);
}
tsizelen = strlen(tsizearg = argv[8]);
if (!isdigit(c = tsizearg[tsizelen-1]))
tsizearg[tsizelen-1] = '\0';
msize = atol(tsizearg);
if (c == 'k' || c == 'K')
msize *= 1000LL;
if (c == 'm' || c == 'M')
msize *= 1000000LL;
if (c == 'g' || c == 'G')
msize *= 1000000000LL;
if (msize < 1000000LL) {
printf("memsize %jd too small for comfort.\n", (intmax_t)msize);
exit(1);
}
if (argc > 9) {
assert(sscanf(argv[9],"%d.%lo", &noutfiles, &skipunder) == 2);
noutfiles++;
printf("skipping %d output files and states up to %jo\n", noutfiles, (uintmax_t)skipunder);
skipunder++;
} else {
noutfiles = 0;
skipunder = 0L;
}
sprintf(inbase,"%d.%d/yx.%02d.%02d",width,modidx,y,x);
gin = openstreams(inbase, incpus, ncpus, cpuid, modulus, skipunder);
go = goinit(width, modidx, modulus, y+!nextx, nextx, ncpus, cpuid);
nnewillcnt = nin = 0LL;
jts = jtalloc(msize, modulus, LOCBITS);
if (nstreams(gin)) {
for (; (mb = minstream(gin))->state != FINALSTATE; nin++,deletemin(gin)) {
sn.cnt = mb->cnt;
// printf("expanding %jo\n", (uintmax_t)mb->state);
nnew = expandstate(mb->state, x, newstates);
for (i=0; i<nnew; i++) {
sn.state = newstates[i];
//printf("inserting %jo\n", (uintmax_t)sn.state);
jtinsert(jts, &sn);
}
if (nnew < 3) // nnew == 2
modadd(modulus, &nnewillcnt, mb->cnt);
if (jtfull(jts))
dumpstates(go, jts, noutfiles++, mb->state);
}
}
dumpstates(go, jts, noutfiles++, FINALSTATE);
jtfree(jts);
printf("(%d,%d) size %ju xsize %ju mod ",y,x,(uintmax_t)nin,(uintmax_t)totalread(gin));
if (modulus)
printf("%ju",(uintmax_t)modulus);
else printf("18446744073709551616");
printf("\nnewillegal %ju ", (uintmax_t)nnewillcnt);
printf( "needy %ju ", (uintmax_t)needywritten(go));
printf( "legal %ju ", (uintmax_t)legalwritten(go));
printf("at (%d,%d)\n",y+(nextx==0),nextx);
assert(cpuid != 0 || skipunder != 0L || nin > 0); // crash if cpu0 processes no states
return 0;
}
