static int stats_file_update_cache(struct stats_file *file) { struct stats_record *it, *end; update_max_nr_entries(file); update_nr_entries(file); update_first(file); update_last(file); file->home_first = NULL; file->roaming_first = NULL; end = get_iterator_end(file); for (it = get_iterator_begin(file); it != end; it = get_next(file, it)) { if (!file->home_first && it->roaming == 0) file->home_first = it; if (!file->roaming_first && it->roaming == 1) file->roaming_first = it; if (file->home_first && file->roaming_first) break; } return 0; }
static void stats_file_update_cache(struct stats_file *file) { update_first(file); update_last(file); update_home(file); update_roaming(file); }
virtual update_result update(intptr_t tid, const T* val) { update_result child_result = children_[child_idx(tid)]->update(child_tid(tid), val); intptr_t other_version = children_[1-child_idx(tid)]->get_version(); bool tt = false; do { intptr_t my_version = get_version(); value my_value; if (!history_.get(my_version, &my_value)) break; if (my_value.child_versions[child_idx(tid)] >= child_result.version && my_value.child_versions[1-child_idx(tid)] >= other_version) break; value new_value; new_value.child_versions[0] = children_[0]->get(&new_value.child_values[0]); new_value.child_versions[1] = children_[1]->get(&new_value.child_values[1]); if (new_value.child_versions[0] == INVALID_VERSION || new_value.child_versions[1] == INVALID_VERSION) break; update_last(my_version % thread_count_); if (history_.publish(tid, my_version+1, &new_value)) { counter::inc_counter(counter::Parsum_OwnPublish, 1); break; } } while (true); counter::inc_counter(counter::Parsum_Update, 1); update_result result; bool ok = get_last(tid, &result); assert(ok); assert(result.update_count == child_result.update_count); return result; }
virtual bool get_last(intptr_t tid, update_result* output) { update_last(tid); latest_value last_value; intptr_t last_version = latest_[tid].get(&last_value); if (last_version == holder<latest_value>::INVALID_VERSION) return false; output->update_count = last_version; output->value_before = last_value.value_before; output->version = last_value.version; return true; }
/** * Calculate average b/t current data and last poll data * if last poll data exists */ static double get_last_avg(struct ceph_daemon *d, const char *ds_n, int index, double cur_sum, uint64_t cur_count) { double result = -1.1, sum_delt = 0.0; uint64_t count_delt = 0; int tmp_index = 0; if(d->last_idx > index) { if(strcmp(d->last_poll_data[index]->ds_name, ds_n) == 0) { tmp_index = index; } //test previous index else if((index > 0) && (strcmp(d->last_poll_data[index-1]->ds_name, ds_n) == 0)) { tmp_index = (index - 1); } else { tmp_index = backup_search_for_last_avg(d, ds_n); } if((tmp_index > -1) && (cur_count > d->last_poll_data[tmp_index]->last_count)) { sum_delt = (cur_sum - d->last_poll_data[tmp_index]->last_sum); count_delt = (cur_count - d->last_poll_data[tmp_index]->last_count); result = (sum_delt / count_delt); } } if(result == -1.1) { result = NAN; } if(update_last(d, ds_n, tmp_index, cur_sum, cur_count) == -ENOMEM) { return -ENOMEM; } return result; }
int main(int argc, char *argv[]) { process_queue *curr_process; process_queue *next_process; remote_service_server_init(); pthread_create(&msg_watcher, NULL, (void *)&msgq_watch, NULL); printf("message queue watching thread created\n"); if(pthread_mutex_init(&lock, NULL) != 0) { printf("mutex init failed\n"); } while(1) { /*iterate through the process queue and add and store result unlock and detach */ curr_process = queue; pthread_mutex_lock(&lock); if (curr_process != NULL && curr_process->requests != NULL) { do { // int shared_mem_identifier; shared_block *shared_mem; request_queue *request; request = curr_process->requests; shared_mem = request->shm; shared_mem->ret_val = shared_mem->arg0 + shared_mem->arg1; shared_mem->locked = 0; printf("request completed: %i + %i = %i\n", shared_mem->arg0, shared_mem->arg1, shared_mem->ret_val); shmdt(shared_mem); if (request->next != NULL) { curr_process->requests->next->last = request->last; curr_process->requests = request->next; free(request); } else { // queue empty if(curr_process == queue && curr_process == queue->last) { queue = NULL; }else if(curr_process == queue) // assign new node as queue head { queue = curr_process->next; queue->last = curr_process->last; }else if(curr_process == queue->last) { update_last(); } next_process = curr_process->next; free(curr_process->requests); free(curr_process); curr_process = next_process; printf("process node freed\n"); } } while (curr_process != NULL); } pthread_mutex_unlock(&lock); } }