/* The shall be one task for each person. All person tasks shall be implemented by the same C function, called passenger_task. */ void passenger_task(void)//TODO { //printf("blaba\n"); int id; int length; int send_task_id; int current; int from; int to; int arrived; int n_travels=0; message_data_type msg; /* receive id */ si_message_receive((char *) &id, &length, &send_task_id);//TODO Ska vi skicka via usertask först? Sedan ändra till att ta emot msg printf("Person %d spawned as task %d \n", id, id_to_task_id(id)); /* message för att be om hisstur */ message_data_type travel_msg; travel_msg.type = TRAVEL_MESSAGE; travel_msg.id = id; current = random_level(); while (n_travels < 2) { arrived = 0; from = current; to = random_level(); travel_msg.from_floor = from; travel_msg.to_floor = to; si_message_send((char *) &travel_msg, sizeof(travel_msg), Lift_Task_Id); while(!arrived) { si_message_receive((char *) &msg, &length, &send_task_id); if(msg.type == TRAVEL_DONE_MESSAGE) { arrived = 1; } } current = to; n_travels++; si_wait_n_ms(TIME_TO_NEW_JOURNEY); } }
void skiplist_insert(struct skiplist* s, int key) { struct node *p,*q,*cur[32]; int i; volatile int level; q = s->head; for(i=s->level; i>=0; i--) { p = q->next[i]; while(p && p->key < key) { q = p; p = p->next[i]; } cur[i] = q; } level = random_level(); if(level > s->level) { s->level++; level = s->level; cur[level] = s->head; } p = node_create(key,level); for(i=level; i>=0; i--) { p->next[i] = cur[i]->next[i]; cur[i]->next[i] = p; } s->length++; }
void skiplist_insert(struct skiplist_node *header, int value) { static struct skiplist_node *should_update[MAX_LEVEL]; if (header == NULL) return; struct skiplist_node *p = header; int level = header->value; //header use this field to store current level int i; for (i = level; i >= 0; i--) { while (p->forward[i] && p->forward[i]->value < value) p = p->forward[i]; should_update[i] = p; } p = p->forward[0]; if (p == NULL || p->value != value) { int l = random_level(); if (l > level) { for (i = level + 1; i < l + 1; i++) should_update[i] = header; level = header->value = l; } struct skiplist_node *new_node = alloc_node(l + 1); new_node->value = value; for (i = 0; i < l + 1; i++) { new_node->forward[i] = should_update[i]->forward[i]; should_update[i]->forward[i] = new_node; } } }
static inline void skip_list_insert (skip_list_t sl, void * data) { skip_list_cell_t slc; int level; int i; if (skip_list_search (sl, data) != NULL) /* libsas specific: allow partials with same frequencies, so don't return. */ ; level = random_level (); if (sl->level < level) { for (i = sl->level; i < level; i++) sl->update[i] = sl->header; sl->level = level; } slc = skip_list_cell_make (sl, level, data); slc->prev = sl->update[0]->fwps[0]->prev; sl->update[0]->fwps[0]->prev = slc; for (i = 0; i < level; i++) { slc->fwps[i] = sl->update[i]->fwps[i]; sl->update[i]->fwps[i] = slc; } }
void insert(SkipSet* ss, int value) { int i; SkipNode* x = ss->header; SkipNode* update[MAX_LEVEL + 1]; memset(update, 0, MAX_LEVEL + 1); for(i = ss->level; i >= 0; i--) { while(x->forward[i] != NULL && x->forward[i]->value < value) { x = x->forward[i]; } update[i] = x; } x = x->forward[0]; if(x == NULL || x->value != value) { int lvl = random_level(); if(lvl > ss->level) { for(i = ss->level + 1; i <= lvl; i++) { update[i] = ss->header; } ss->level = lvl; } x = make_node(lvl, value); for(i = 0; i <= lvl; i++) { x->forward[i] = update[i]->forward[i]; update[i]->forward[i] = x; } } }
/* The shall be one task for each person. All person tasks shall be implemented by the same C function, called passenger_task. */ void passenger_task(void) { //printf("blaba\n"); int id; int length; int send_task_id; int current; int from; int to; /* receive id */ si_message_receive((char *) &id, &length, &send_task_id); current = random_level(); while (1) { from = current; to = random_level(); si_sem_wait(&mainlift->mutex); enter_floor(mainlift,id, current);//spawna si_sem_signal(&mainlift->mutex); printf("Passenger %d starting journey from %d to %d.\n", id, from, to); lift_travel(mainlift, id, from, to);//res current = to; printf("Passenger %d arrived at %d.\n", id, current); si_sem_wait(&mainlift->mutex); leave_floor(mainlift, id, current);//ta bort från våning si_sem_signal(&mainlift->mutex); si_wait_n_ms(TIME_TO_NEW_JOURNEY); } }
/*an array of pointers to the nodes that must be updated. */ void insert_skipnode(skipset* ss, const void* key, int key_sz, int (*compare_keys)(const void* key1, const void* key2)) { if(contains_skipnode(ss, key, compare_keys) != NULL) /*no duplicates allowed in set*/ return; int l = random_level(); /*level of new node*/ if(l > ss->level) ss->level = l; insert_node(ss->header, make_skipnode(ss, l, key, key_sz), l, compare_keys); }
//TODO: Switch to a more robust error handling policy extern int skip_insert(skip_t sl, unsigned int key, void *payload) { int i, rand_level; skip_node *x, *update[SKIP_MAX]; check_hard(sl, "Invalid Skip List"); check_hard(key, "Invalid Key"); check_hard(payload, " Empty payload"); x = sl->header; for (i = sl->level - 1; i >= 0; i--) { while (x->level[i].forward && // not end NULL default_compare(x->level[i].forward->key, key)) { x = x->level[i].forward; // log_warn("still in whleLoop"); } update[i] = x; sl->finger[i] = x; //log_warn("still in ForLoop"); } // make sure were not nulled x = (x->level[0].forward) ? x->level[0].forward : x; //TODO: Decide if we should warn, or reject an overwrite, //log_info(" %u, %u", x->key, key); if (x->key == key) { sl->free_func(x->payload); x->payload = payload; //log_warn("Key overwrite"); return 2; } else { rand_level = random_level(); if (rand_level > sl->level) { for (i = sl->level; i < rand_level; i++) { update[i] = sl->header; sl->finger[i] = sl->header; } sl->level = rand_level; //log_info("Lvl: %d",sl->level); } x = create_skip_node(rand_level, key, payload); for (i = 0 ; i < rand_level; i++) { x->level[i].forward = update[i]->level[i].forward; update[i]->level[i].forward = x; } //log_success("inserted key %u and data", key); sl->length++; return 1; } }
void vec_set(vec_t* const vec, const dim_t dim, const float value) { assert(vec != NULL); if (value == 0.0) { delete(vec, dim); return; } int i; vec_elem_t* x = vec->header; vec_elem_t* update[MAX_LEVEL + 1]; memset(update, 0, MAX_LEVEL + 1); for (i = vec->level; i >= 0; i--) { while (x->forward[i] != NULL && x->forward[i]->dim < dim) { x = x->forward[i]; } update[i] = x; } x = x->forward[0]; if (x == NULL || x->dim != dim) { int lvl = random_level(); if (lvl > vec->level) { for (i = vec->level + 1; i <= lvl; i++) { update[i] = vec->header; } vec->level = lvl; } x = make_node(lvl, dim, value); for (i = 0; i <= lvl; i++) { x->forward[i] = update[i]->forward[i]; update[i]->forward[i] = x; } } else // update existing element { x->value = value; } }
/* key: item key * data: item data * return: skip item or NULL when out of memory; * insert data item */ ITEM* LIST_Insert (LIST *list, void *key, void *data) { ITEM *header, **update, *x; int maxlevel, level, i, n; LIST_Compare compare; maxlevel = list->maxlevel; compare = list->compare; header = &list->header; update = list->update; level = list->level; x = header; for (i = level; i >= 0; i --) { if (compare) while (x->forward [i] && compare (x->forward [i]->key, key) < 0) x = x->forward [i]; else while (x->forward [i] && x->forward [i]->key < key) x = x->forward [i]; update [i] = x; } x = x->forward [0]; if (x && ((compare && compare (x->key, key) == 0) || ((!compare) && x->key == key))) x->data = data; else { n = random_level (maxlevel); if (n > level) { for (i = level + 1; i <= maxlevel; i ++) update [i] = header; list->level = n; } if(!(x = skip_item (list, key, data))) return NULL; for (i = 0; i <= n; i ++) { x->forward [i] = update [i]->forward [i]; update [i]->forward [i] = x; } list->size ++; } return x; }
/* Set a the key `key` to value `value` */ void skip_set(skiplist *list, int key, int value) { skipitem *item = list->header; skipitem *update[MAX_LEVELS]; int i, level = random_level(); if (skip_is_empty(list)) { for (i = 0; i < list->level; i++) update[i] = list->header; } else { for (i = list->level - 1; i >= 0; i--) { while ((item->next[i] != NULL) && (item->next[i]->key < key)) { item = item->next[i]; } /* Keep a list of the rightmost pointers to the various levels * before the key we're searching for (we need this list to * link the newly inserted item) */ update[i] = item; } item = item->next[0]; /* the key already exists, just update its value */ if (item && (item->key == key)) { item->value = value; return; } } /* if the new item's level is higher than the current list level * just update the level by one */ if (level > list->level) { update[list->level] = list->header; list->level++; level = list->level; } /* create the item and update the pointers */ item = skipitem_new(key, value, level); for (i = 0; i < level; i++) { item->next[i] = update[i]->next[i]; update[i]->next[i] = item; } }
static vlnode_t* vlmap_create_node(uint64_t version, uint8_t* key, int keylength, uint8_t* value, int valuelength) { int level = random_level(); vlnode_t* n = (vlnode_t*)calloc(1, sizeof(vlnode_t)+(level+1)*sizeof(vlnode_t*)+keylength+valuelength); n->keylength = keylength; n->valuelength = valuelength; n->created = version; n->level = level; n->next = (vlnode_t**)(n+sizeof(vlnode_t)); n->key = (uint8_t*)(n+sizeof(vlnode_t)+(level+1)*sizeof(vlnode_t*)); memcpy(n->key, key, keylength); if(value != NULL) { n->value = n->key+keylength; memcpy(n->value, value, valuelength); } return n; }
static olist_node_t *olist_add_entry_unlocked(olist_t *ol, void *data) { olist_node_t *update[OLIST_MAXLEVEL], *pos, *new_node; int i, level; pos = &ol->dumb; for (i=ol->level-1; i>=0; i--) { /* new data insert to front of equal elements */ while ( (pos->level[i].next != &ol->dumb) && (ol->cmp(pos->level[i].next->data, data)<0)) { pos = pos->level[i].next; } update[i] = pos; } level = random_level(); if (level > ol->level) { for (i = ol->level; i < level; i++) { update[i] = &ol->dumb; } ol->level = level; } new_node = malloc(sizeof(*new_node)); new_node->maxlevel = level; new_node->data = data; for (i = 0; i < OLIST_MAXLEVEL; i++) { //fprintf(stderr, "init level %d\n", i); if (i<level) { new_node->level[i].next = update[i]->level[i].next; new_node->level[i].prev = update[i]; update[i]->level[i].next->level[i].prev = new_node; update[i]->level[i].next = new_node; } else { new_node->level[i].next = NULL; new_node->level[i].prev = NULL; } } ol->length++; return new_node; }
static void caml_insert_global_root(struct global_root_list * rootlist, value * r) { struct global_root * update[NUM_LEVELS]; struct global_root * e, * f; int i, new_level; /* Init "cursor" to list head */ e = (struct global_root *) rootlist; /* Find place to insert new node */ for (i = rootlist->level; i >= 0; i--) { while (1) { f = e->forward[i]; if (f == NULL || f->root >= r) break; e = f; } update[i] = e; } e = e->forward[0]; /* If already present, don't do anything */ if (e != NULL && e->root == r) return; /* Insert additional element, updating list level if necessary */ new_level = random_level(); if (new_level > rootlist->level) { for (i = rootlist->level + 1; i <= new_level; i++) update[i] = (struct global_root *) rootlist; rootlist->level = new_level; } e = caml_stat_alloc(sizeof(struct global_root) + new_level * sizeof(struct global_root *)); e->root = r; for (i = 0; i <= new_level; i++) { e->forward[i] = update[i]->forward[i]; update[i]->forward[i] = e; } }
void insert(SkipSet *ss, int value) { int i; SkipNode *x = ss->header; SkipNode *update[MAX_LEVEL+1]; memset(update, 0, MAX_LEVEL+1); for(i=ss->level; i>=0; i--) { while(x->forward[i]!=NULL && x->forward[i]->value < value) { x = x->forward[i]; } update[i] = x; } // int j; // for(j=0; j<ss->level+1; j++) // printf("%d ", update[j]->value); // printf("\n"); x = x->forward[0]; if(x == NULL || x->value != value) { int lvl = random_level(); if(lvl > ss->level) { for(i=ss->level+1; i<=lvl; i++) { update[i] = ss->header; } ss->level = lvl; } x = make_node(lvl, value); for(i=0; i<=lvl; i++) { x->forward[i] = update[i]->forward[i]; update[i]->forward[i] = x; } } val[value] = 1; // for(j=0; j<ss->level+1; j++) // printf("%d ", update[j]->value); // printf("\n"); // print_skipset(ss); }
/* * Insert cache into the list */ static FcBool FcCacheInsert (FcCache *cache, struct stat *cache_stat) { FcCacheSkip **update[FC_CACHE_MAX_LEVEL]; FcCacheSkip *s, **next; int i, level; lock_cache (); /* * Find links along each chain */ next = fcCacheChains; for (i = fcCacheMaxLevel; --i >= 0; ) { for (; (s = next[i]); next = s->next) if (s->cache > cache) break; update[i] = &next[i]; } /* * Create new list element */ level = random_level (); if (level > fcCacheMaxLevel) { level = fcCacheMaxLevel + 1; update[fcCacheMaxLevel] = &fcCacheChains[fcCacheMaxLevel]; fcCacheMaxLevel = level; } s = malloc (sizeof (FcCacheSkip) + (level - 1) * sizeof (FcCacheSkip *)); if (!s) return FcFalse; s->cache = cache; s->size = cache->size; FcRefInit (&s->ref, 1); if (cache_stat) { s->cache_dev = cache_stat->st_dev; s->cache_ino = cache_stat->st_ino; s->cache_mtime = cache_stat->st_mtime; #ifdef HAVE_STRUCT_STAT_ST_MTIM s->cache_mtime_nano = cache_stat->st_mtim.tv_nsec; #else s->cache_mtime_nano = 0; #endif } else { s->cache_dev = 0; s->cache_ino = 0; s->cache_mtime = 0; s->cache_mtime_nano = 0; } /* * Insert into all fcCacheChains */ for (i = 0; i < level; i++) { s->next[i] = *update[i]; *update[i] = s; } unlock_cache (); return FcTrue; }
bool cskl_insert(cskiplist_t *cskl, void *value, mem_alloc m_alloc) { int max_height = cskl->max_height; int my_height = random_level(cskl->max_height); csklnode_t *preds[max_height]; csklnode_t *succs[max_height]; mcs_node_t mcs_nodes[max_height]; for (;;) { // Acquire pfq-rwlock before reading: pfq_rwlock_start_read(&cskl->pfq_lock); int found_layer= cskiplist_find_helper(cskl->compare, cskl, value, preds, succs, cskiplist_find_full); if (found_layer != NO_LAYER) { csklnode_t *node = succs[found_layer]; if (!node->marked) { while (!node->fully_linked); // Release pfq-rwlock before returning: pfq_rwlock_end_read(&cskl->pfq_lock); return false; } // node is marked for deletion by some other thread, so this thread needs // to try to insert again by going to the end of this for(;;) loop. As // this thread tries to insert again, there may be another the thread // that succeeds in inserting value before this thread gets a chance to. // Release pfq-rwlock before trying to insert again: pfq_rwlock_end_read(&cskl->pfq_lock); continue; } //-------------------------------------------------------------------------- // Acquire a lock on node's predecessor at each layer. // // valid condition: // no predecessor is marked // no successor is marked // each of my predecessors still points to the successor I recorded // // If the valid condition is not satisfied, unlock all of my predecessors // and retry. //-------------------------------------------------------------------------- int highestLocked = -1; csklnode_t *pred, *succ; csklnode_t *prevPred = NULL; bool valid = true; for (int layer = 0; valid && (layer < my_height); layer++) { pred=preds[layer]; succ=succs[layer]; if (pred != prevPred) { mcs_lock(&pred->lock, &mcs_nodes[layer]); highestLocked = layer; prevPred = pred; } valid = !pred->marked && !succ->marked && pred->nexts[layer] == succ; } if (!valid) { // unlock each of my predecessors, as necessary unlock_preds(preds, mcs_nodes, highestLocked); // Release pfq-rwlock before trying to insert again: pfq_rwlock_end_read(&cskl->pfq_lock); continue; } // allocate my node // csklnode_t *node = csklnode_new(value, my_height, max_height, m_alloc); csklnode_t *node = csklnode_malloc(value, my_height, max_height, m_alloc); // link it in at levels [0 .. my_height-1] for (int layer = 0; layer < my_height; layer++) { node->nexts[layer] = succs[layer]; preds[layer]->nexts[layer] = node; } // mark the node as usable node->fully_linked = true; // unlock each of my predecessors, as necessary unlock_preds(preds, mcs_nodes, highestLocked); // Release pfq-rwlock before returning: pfq_rwlock_end_read(&cskl->pfq_lock); return true; } }
static int set_add(intset_t *set, val_t val, thread_data_t *td) { int result, i; node_t *update[MAX_LEVEL + 1]; node_t *node, *next; level_t level, l; val_t v; # ifdef DEBUG printf("++> set_add(%d)\n", val); IO_FLUSH; # endif if (!td) { node = set->head; for (i = set->level; i >= 0; i--) { next = node->forward[i]; while (next->val < val) { node = next; next = node->forward[i]; } update[i] = node; } node = node->forward[0]; if (node->val == val) { result = 0; } else { l = random_level(set, main_seed); if (l > set->level) { for (i = set->level + 1; i <= l; i++) update[i] = set->head; set->level = l; } node = new_node(val, l, 0); for (i = 0; i <= l; i++) { node->forward[i] = update[i]->forward[i]; update[i]->forward[i] = node; } result = 1; } } else { TM_START(1, RW); v = VAL_MIN; /* Avoid compiler warning (should not be necessary) */ node = set->head; level = TM_LOAD(&set->level); for (i = level; i >= 0; i--) { next = (node_t *)TM_LOAD(&node->forward[i]); while (1) { v = TM_LOAD(&next->val); if (v >= val) break; node = next; next = (node_t *)TM_LOAD(&node->forward[i]); } update[i] = node; } if (v == val) { result = 0; } else { l = random_level(set, td->seed); if (l > level) { for (i = level + 1; i <= l; i++) update[i] = set->head; TM_STORE(&set->level, l); } node = new_node(val, l, 1); for (i = 0; i <= l; i++) { node->forward[i] = (node_t *)TM_LOAD(&update[i]->forward[i]); TM_STORE(&update[i]->forward[i], node); } result = 1; } TM_COMMIT; } return result; }