/** * Update and normalize atsi performance information * * @param address the address to update */ void GAS_normalization_update_property (struct ATS_Address *address) { const struct GNUNET_ATS_Properties *prop = &address->properties; struct PropertyRange range; LOG (GNUNET_ERROR_TYPE_DEBUG, "Updating properties for peer `%s'\n", GNUNET_i2s (&address->peer)); GAS_plugin_solver_lock (); update_avg (prop->delay.rel_value_us, &address->norm_delay); update_avg (prop->distance, &address->norm_distance); update_avg (prop->utilization_in, &address->norm_utilization_in); update_avg (prop->utilization_in, &address->norm_utilization_out); init_range (&range); GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses, &find_min_max_it, &range); if (0 != memcmp (&range, &property_range, sizeof (struct PropertyRange))) { /* limits changed, (re)normalize all addresses */ property_range = range; GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses, &normalize_address, NULL); GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses, ¬ify_change, NULL); } else { /* renormalize just this one address */ normalize_address (NULL, &address->peer, address); notify_change (NULL, &address->peer, address); } GAS_plugin_solver_unlock (); }
int pfctl_update_qstats(int dev, struct pf_altq_node **root) { struct pf_altq_node *node; struct pfioc_altq pa; struct pfioc_qstats pq; u_int32_t mnr, nr; struct queue_stats qstats; static u_int32_t last_ticket; memset(&pa, 0, sizeof(pa)); memset(&pq, 0, sizeof(pq)); memset(&qstats, 0, sizeof(qstats)); if (ioctl(dev, DIOCGETALTQS, &pa)) { warn("DIOCGETALTQS"); return (-1); } /* if a new set is found, start over */ if (pa.ticket != last_ticket && *root != NULL) { pfctl_free_altq_node(*root); *root = NULL; } last_ticket = pa.ticket; mnr = pa.nr; for (nr = 0; nr < mnr; ++nr) { pa.nr = nr; if (ioctl(dev, DIOCGETALTQ, &pa)) { warn("DIOCGETALTQ"); return (-1); } if (pa.altq.qid > 0) { pq.nr = nr; pq.ticket = pa.ticket; pq.buf = &qstats.data; pq.nbytes = sizeof(qstats.data); if (ioctl(dev, DIOCGETQSTATS, &pq)) { warn("DIOCGETQSTATS"); return (-1); } if ((node = pfctl_find_altq_node(*root, pa.altq.qname, pa.altq.ifname)) != NULL) { memcpy(&node->qstats.data, &qstats.data, sizeof(qstats.data)); update_avg(node); } else { pfctl_insert_altq_node(root, pa.altq, qstats); } } } return (mnr); }
void Histogram::add(double value, int rank) { assert(rank>=0); if(value < 0){ if(value >= -DOUBLE_EPSILON){ cout << "warning: negative double value " << value << " changed to 0.0f" << endl; value = 0.0f; } else { cerr << "error: rank " << my_rank << ", add a negative value " << value << " into histogram" << endl; cerr << toString() << endl; exit(0); } } if (num_elems == 0) { double bin_size = (value != 0.0) ? (2.0 * value)/num_bins : 1.0; for (int i=0; i < num_bins; i++) { HistoBin *bin = new HistoBin(i*bin_size, (i+1) * bin_size); bins.push_back(bin); } } num_elems++; // maintain min/max values. update_min(value, rank); update_max(value, rank); update_avg(value, 1); // put the value in the histogram int binIdx = find_bin(value); if(binIdx != -1){ bins[binIdx]->add(value); } else { double tail_start = bins[num_bins-1]->getEnd(); double tail_end = 2 * value - tail_start; /*if(tail_end < tail_start){ cout << "tail_end: " << tail_end << endl; cout << "tail_start: " << tail_start << endl; cout << "value: " << value << endl; cout << toString() << endl; while(1); }*/ assert(tail_end >= tail_start); HistoBin *tail = new HistoBin(tail_start, tail_end); tail->add(value); bins.push_back(tail); smooth(); } }
int main() { map<std::string, unsigned> b; std::unordered_map<std::string, unsigned> c; clock_t t, avg = 0.0; unsigned n = 1; unsigned tot = 100000, p = 0, m = 0, e = 0; while(tot--) { std::ifstream input("pride_book.txt"); std::string word; t = clock(); std::cout << t << " , "; while(input >> word) b[word] += 1; std::cout << clock() << "\n"; t = clock() - t; avg = (avg == 0.0) ? t : update_avg(avg, t, n++); std::cout << "Avg: " << avg; if ((float)t < (float)avg) { m++; std::cout << " - "; } else if ((float)t > (float)avg) { p++; std::cout << " + "; } else { e++; std::cout << " = "; } std::cout.flush(); } std::cout << "Plus: " << p << " Minus: " << m << " Equal: " << e << "\n"; }
void pfctl_insert_altq_node(struct pf_altq_node **root, const struct pf_altq altq, const struct queue_stats qstats) { struct pf_altq_node *node; node = calloc(1, sizeof(struct pf_altq_node)); if (node == NULL) err(1, "pfctl_insert_altq_node: calloc"); memcpy(&node->altq, &altq, sizeof(struct pf_altq)); memcpy(&node->qstats, &qstats, sizeof(qstats)); node->next = node->children = NULL; if (*root == NULL) *root = node; else if (!altq.parent[0]) { struct pf_altq_node *prev = *root; while (prev->next != NULL) prev = prev->next; prev->next = node; } else { struct pf_altq_node *parent; parent = pfctl_find_altq_node(*root, altq.parent, altq.ifname); if (parent == NULL) errx(1, "parent %s not found", altq.parent); if (parent->children == NULL) parent->children = node; else { struct pf_altq_node *prev = parent->children; while (prev->next != NULL) prev = prev->next; prev->next = node; } } update_avg(node); }
int pfctl_update_qstats(int dev, struct pf_altq_node **root) { struct pf_altq_node *node; struct pfioc_altq pa; struct pfioc_qstats pq; u_int32_t mnr, nr; struct queue_stats qstats; static u_int32_t last_ticket; memset(&pa, 0, sizeof(pa)); memset(&pq, 0, sizeof(pq)); memset(&qstats, 0, sizeof(qstats)); if (ioctl(dev, DIOCGETALTQS, &pa)) { warn("DIOCGETALTQS"); return (-1); } /* if a new set is found, start over */ if (pa.ticket != last_ticket && *root != NULL) { pfctl_free_altq_node(*root); *root = NULL; } last_ticket = pa.ticket; mnr = pa.nr; for (nr = 0; nr < mnr; ++nr) { pa.nr = nr; if (ioctl(dev, DIOCGETALTQ, &pa)) { warn("DIOCGETALTQ"); return (-1); } #ifdef __FreeBSD__ if (pa.altq.qid > 0 && !(pa.altq.local_flags & PFALTQ_FLAG_IF_REMOVED)) { #else if (pa.altq.qid > 0) { #endif pq.nr = nr; pq.ticket = pa.ticket; pq.buf = &qstats.data; pq.nbytes = sizeof(qstats.data); if (ioctl(dev, DIOCGETQSTATS, &pq)) { warn("DIOCGETQSTATS"); return (-1); } if ((node = pfctl_find_altq_node(*root, pa.altq.qname, pa.altq.ifname)) != NULL) { memcpy(&node->qstats.data, &qstats.data, sizeof(qstats.data)); update_avg(node); } else { pfctl_insert_altq_node(root, pa.altq, qstats); } } #ifdef __FreeBSD__ else if (pa.altq.local_flags & PFALTQ_FLAG_IF_REMOVED) { memset(&qstats.data, 0, sizeof(qstats.data)); if ((node = pfctl_find_altq_node(*root, pa.altq.qname, pa.altq.ifname)) != NULL) { memcpy(&node->qstats.data, &qstats.data, sizeof(qstats.data)); update_avg(node); } else { pfctl_insert_altq_node(root, pa.altq, qstats); } } #endif } return (mnr); } void pfctl_insert_altq_node(struct pf_altq_node **root, const struct pf_altq altq, const struct queue_stats qstats) { struct pf_altq_node *node; node = calloc(1, sizeof(struct pf_altq_node)); if (node == NULL) err(1, "pfctl_insert_altq_node: calloc"); memcpy(&node->altq, &altq, sizeof(struct pf_altq)); memcpy(&node->qstats, &qstats, sizeof(qstats)); node->next = node->children = NULL; if (*root == NULL) *root = node; else if (!altq.parent[0]) { struct pf_altq_node *prev = *root; while (prev->next != NULL) prev = prev->next; prev->next = node; } else { struct pf_altq_node *parent; parent = pfctl_find_altq_node(*root, altq.parent, altq.ifname); if (parent == NULL) errx(1, "parent %s not found", altq.parent); if (parent->children == NULL) parent->children = node; else { struct pf_altq_node *prev = parent->children; while (prev->next != NULL) prev = prev->next; prev->next = node; } } update_avg(node); } struct pf_altq_node * pfctl_find_altq_node(struct pf_altq_node *root, const char *qname, const char *ifname) { struct pf_altq_node *node, *child; for (node = root; node != NULL; node = node->next) { if (!strcmp(node->altq.qname, qname) && !(strcmp(node->altq.ifname, ifname))) return (node); if (node->children != NULL) { child = pfctl_find_altq_node(node->children, qname, ifname); if (child != NULL) return (child); } } return (NULL); } void pfctl_print_altq_node(int dev, const struct pf_altq_node *node, unsigned int level, int opts) { const struct pf_altq_node *child; if (node == NULL) return; print_altq(&node->altq, level, NULL, NULL); if (node->children != NULL) { printf("{"); for (child = node->children; child != NULL; child = child->next) { printf("%s", child->altq.qname); if (child->next != NULL) printf(", "); } printf("}"); } printf("\n"); if (opts & PF_OPT_VERBOSE) pfctl_print_altq_nodestat(dev, node); if (opts & PF_OPT_DEBUG) printf(" [ qid=%u ifname=%s ifbandwidth=%s ]\n", node->altq.qid, node->altq.ifname, rate2str((double)(node->altq.ifbandwidth))); for (child = node->children; child != NULL; child = child->next) pfctl_print_altq_node(dev, child, level + 1, opts); } void pfctl_print_altq_nodestat(int dev, const struct pf_altq_node *a) { if (a->altq.qid == 0) return; #ifdef __FreeBSD__ if (a->altq.local_flags & PFALTQ_FLAG_IF_REMOVED) return; #endif switch (a->altq.scheduler) { case ALTQT_CBQ: print_cbqstats(a->qstats); break; case ALTQT_PRIQ: print_priqstats(a->qstats); break; case ALTQT_HFSC: print_hfscstats(a->qstats); break; } } void print_cbqstats(struct queue_stats cur) { printf(" [ pkts: %10llu bytes: %10llu " "dropped pkts: %6llu bytes: %6llu ]\n", (unsigned long long)cur.data.cbq_stats.xmit_cnt.packets, (unsigned long long)cur.data.cbq_stats.xmit_cnt.bytes, (unsigned long long)cur.data.cbq_stats.drop_cnt.packets, (unsigned long long)cur.data.cbq_stats.drop_cnt.bytes); printf(" [ qlength: %3d/%3d borrows: %6u suspends: %6u ]\n", cur.data.cbq_stats.qcnt, cur.data.cbq_stats.qmax, cur.data.cbq_stats.borrows, cur.data.cbq_stats.delays); if (cur.avgn < 2) return; printf(" [ measured: %7.1f packets/s, %s/s ]\n", cur.avg_packets / STAT_INTERVAL, rate2str((8 * cur.avg_bytes) / STAT_INTERVAL)); }
/* * Checks h/w handshake lines for "go" status. Count the number of times it * was "stop". In UART_HANDSHAKE_AUTO mode, after a limit is reached force * the status to "go". */ static boolean_t is_hw_tx_handshake_go(mon_serial_device_t *p_device) { /* Modem Status Register image */ uart_msr_t msr; /* flags transmit "go" by h/w handshake */ boolean_t hw_handshake_go; if ((p_device->handshake_mode == UART_HANDSHAKE_AUTO) || (p_device->handshake_mode == UART_HANDSHAKE_HW)) { /* Read the h/w handshake signals */ msr.data = hw_read_port_8(p_device->io_base + UART_REGISTER_MSR); hw_handshake_go = (msr.bits.cts == 1) && (msr.bits.dsr == 1); if (hw_handshake_go) { /* Other side set h/w handshake to "go". Reset the counter. */ update_avg(&p_device->hw_handshake_stopped_count_avg, p_device->hw_handshake_stopped_count); p_device->hw_handshake_stopped_count = 0; } else if (p_device->hw_handshake_stopped_count >= hw_handshake_stopped_limit) { /* Other side has indicated h/w handshake "stop" for too long. */ if (p_device->handshake_mode == UART_HANDSHAKE_AUTO) { /* In auto mode, assume the h/w handshake is stuck and force */ /* the status to "go" */ hw_handshake_go = TRUE; p_device->num_chars_hw_handshake_auto_go++; if (p_device->hw_handshake_stopped_count == hw_handshake_stopped_limit) { /* Update the statistic only on the first character */ /* we decided to auto-go */ update_avg( &p_device->hw_handshake_stopped_count_avg, p_device->hw_handshake_stopped_count); p_device->hw_handshake_stopped_count++; } } } else { /* Increment the stop count and update the statistics */ if (p_device->hw_handshake_stopped_count == 0) { /* We just stopped, increment the stops statistics counter */ p_device->num_chars_hw_handshake_stopped++; } p_device->hw_handshake_stopped_count++; update_max(&p_device->hw_handshake_stopped_count_max, p_device->hw_handshake_stopped_count); } } else { /* No h/w handshake, always "go" */ hw_handshake_go = TRUE; } return hw_handshake_go; }
/* * Updates the running average and maximum of a counter * p_max - Maximum * p_avg - Running average, as uint16_t.uint16_t * count - New input */ static void update_max_and_avg(uint32_t *p_max, uint32_t *p_avg, uint32_t count) { update_max(p_max, count); update_avg(p_avg, count); }