void syncronize(unsigned BaseAddress) { unsigned secondcount = 0; unsigned previouscount = 0; unsigned timeout = 500; secondcount = total_count(BaseAddress); do { previouscount = secondcount; DELAY(1); secondcount = total_count(BaseAddress); } while ((secondcount != previouscount) && timeout--); }
int main() { int choice,n; printf("\n1. Push\n2. Pop\n3. Display\n4.Count\n5.Exit"); while (1) { printf("\nEnter your choice "); scanf("%d",&choice); switch(choice) { case 1: printf("Enter data : "); scanf("%d", &n); push(n); break; case 2: pop(); break; case 3: disp(); break; case 4: total_count(); break; case 5: exit(1); default : printf("Wrong entry please enter correct choice !!! "); break; } } }
void BytecodePairHistogram::print(float cutoff) { ResourceMark rm; GrowableArray<HistoEntry*>* profile = sorted_array(_counters, number_of_pairs); // print profile int tot = total_count(profile); int abs_sum = 0; tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789 tty->print_cr("Histogram of %d executed bytecode pairs:", tot); tty->cr(); tty->print_cr(" absolute relative codes 1st bytecode 2nd bytecode"); tty->print_cr("----------------------------------------------------------------------"); int i = profile->length(); while (i-- > 0) { HistoEntry* e = profile->at(i); int abs = e->count(); float rel = abs * 100.0F / tot; if (cutoff <= rel) { int c1 = e->index() % number_of_codes; int c2 = e->index() / number_of_codes; tty->print_cr("%10d %6.3f%% %02x %02x %-19s %s", abs, rel, c1, c2, name_for(c1), name_for(c2)); abs_sum += abs; } } tty->print_cr("----------------------------------------------------------------------"); float rel_sum = abs_sum * 100.0F / tot; tty->print_cr("%10d %6.3f%% (cutoff = %.3f%%)", abs_sum, rel_sum, cutoff); tty->cr(); }
void BytecodeHistogram::print(float cutoff) { ResourceMark rm; GrowableArray<HistoEntry*>* profile = sorted_array(_counters, Bytecodes::number_of_codes); // print profile int tot = total_count(profile); int abs_sum = 0; tty->cr(); //0123456789012345678901234567890123456789012345678901234567890123456789 tty->print_cr("Histogram of %d executed bytecodes:", tot); tty->cr(); tty->print_cr(" absolute relative code name"); tty->print_cr("----------------------------------------------------------------------"); int i = profile->length(); while (i-- > 0) { HistoEntry* e = profile->at(i); int abs = e->count(); float rel = abs * 100.0F / tot; if (cutoff <= rel) { tty->print_cr("%10d %7.2f%% %02x %s", abs, rel, e->index(), name_for(e->index())); abs_sum += abs; } } tty->print_cr("----------------------------------------------------------------------"); float rel_sum = abs_sum * 100.0F / tot; tty->print_cr("%10d %7.2f%% (cutoff = %.2f%%)", abs_sum, rel_sum, cutoff); tty->cr(); }
void netlist_t::print_stats() const { if (nperftime_t::enabled) { std::vector<size_t> index; for (size_t i=0; i<m_devices.size(); i++) index.push_back(i); std::sort(index.begin(), index.end(), [&](size_t i1, size_t i2) { return m_devices[i1]->m_stat_total_time.total() < m_devices[i2]->m_stat_total_time.total(); }); nperftime_t::type total_time(0); uint_least64_t total_count(0); for (auto & j : index) { auto entry = m_devices[j].get(); log().verbose("Device {1:20} : {2:12} {3:12} {4:15} {5:12}", entry->name(), entry->m_stat_call_count(), entry->m_stat_total_time.count(), entry->m_stat_total_time.total(), entry->m_stat_inc_active()); total_time += entry->m_stat_total_time.total(); total_count += entry->m_stat_total_time.count(); } nperftime_t overhead; nperftime_t test; overhead.start(); for (int j=0; j<100000;j++) { test.start(); test.stop(); } overhead.stop(); nperftime_t::type total_overhead = overhead() * static_cast<nperftime_t::type>(total_count) / static_cast<nperftime_t::type>(200000); log().verbose("Queue Pushes {1:15}", queue().m_prof_call()); log().verbose("Queue Moves {1:15}", queue().m_prof_sortmove()); log().verbose("Total loop {1:15}", m_stat_mainloop()); /* Only one serialization should be counted in total time */ /* But two are contained in m_stat_mainloop */ log().verbose("Total devices {1:15}", total_time); log().verbose(""); log().verbose("Take the next lines with a grain of salt. They depend on the measurement implementation."); log().verbose("Total overhead {1:15}", total_overhead); nperftime_t::type overhead_per_pop = (m_stat_mainloop()-2*total_overhead - (total_time - total_overhead)) / static_cast<nperftime_t::type>(queue().m_prof_call()); log().verbose("Overhead per pop {1:11}", overhead_per_pop ); log().verbose(""); for (auto &entry : m_devices) { if (entry->m_stat_inc_active() > 3 * entry->m_stat_total_time.count()) log().verbose("HINT({}, NO_DEACTIVATE)", entry->name()); } } }
void BytecodeHistogram::print(float cutoff) { jlong total = total_count(); jlong absolute_sum = 0; SortedHistogramEntry* sorted_histogram = NEW_GLOBAL_HEAP_ARRAY(SortedHistogramEntry, Bytecodes::number_of_java_codes, "BytecodeHistogram"); for (int i = 0; i < Bytecodes::number_of_java_codes; i++) { sorted_histogram[i].count = counter_at(i); sorted_histogram[i].code = (Bytecodes::Code) i; } jvm_qsort(sorted_histogram, Bytecodes::number_of_java_codes, sizeof(SortedHistogramEntry), compare_entries); tty->cr(); tty->print_cr("Histogram of executed bytecodes:"); tty->cr(); tty->print_cr(" absolute relative code name"); tty->print_cr("----------------------------------------------------------------------"); if (total > 0) { for (int i = 0; i < Bytecodes::number_of_java_codes; i++) { Bytecodes::Code code = sorted_histogram[i].code; jlong count = sorted_histogram[i].count; if (Bytecodes::is_defined(code)) { jlong absolute = count; float relative = jvm_fdiv(jvm_fmul(jvm_l2f(absolute), 100.0F), jvm_l2f(total)); if (!jvm_fcmpg(cutoff, relative)) { tty->print_cr(FLL " %7.2f%% 0x%02x %s", absolute, jvm_f2d(relative), code, Bytecodes::name(Bytecodes::cast(code))); absolute_sum += absolute; } } } } tty->print_cr("----------------------------------------------------------------------"); if (total > 0) { float relative_sum = jvm_fdiv(jvm_fmul(jvm_l2f(absolute_sum), 100.0F), jvm_l2f(total)); tty->print_cr(FLL " %7.2f%% cutoff = %.2f%%", absolute_sum, jvm_f2d(relative_sum), jvm_f2d(cutoff)); tty->print_cr(FLL " %7.2f%% total", total, 100.0, 0.0); } tty->cr(); FREE_GLOBAL_HEAP_ARRAY(sorted_histogram, "BytecodeHistogram"); }
void gooda::convert_to_afdo(const gooda::gooda_report& report, gooda::afdo_data& data, boost::program_options::variables_map& vm){ bool lbr; if(vm.count("auto")){ auto total_count_lbr = total_count(report, BB_EXEC); lbr = total_count_lbr > 0; } else { lbr = vm.count("lbr"); } //Choose the correct counter std::string counter_name = lbr ? BB_EXEC : UNHALTED_CORE_CYCLES; //Verify that the file has the correct column if(!vm.count("auto") && total_count(report, counter_name) == 0){ throw gooda::gooda_exception("The file is not valid for the current mode"); } //Empty each cache inlining_cache.clear(); discriminator_cache.clear(); auto filter = get_process_filter(report, vm, counter_name); log::emit<log::Debug>() << "Filter by \"" << filter << "\"" << log::endl; for(std::size_t i = 0; i < report.functions(); ++i){ auto& line = report.hotspot_function(i); //Only if the function passes the filters if(filter.empty() || line.get_string(report.get_hotspot_file().column(PROCESS)) == filter){ auto string_cycles = line.get_string(report.get_hotspot_file().column(counter_name)); //Some functions are filled empty by Gooda for some reason //In some case, it means 0, in that case, it is not a problem to ignore it either, cause not really hotspot if(string_cycles.empty()){ continue; } gooda::afdo_function function; function.i = i; function.executable_file = get_application_file(report, i); function.name = line.get_string(report.get_hotspot_file().column(FUNCTION_NAME)); if(lbr){ function.total_count = line.get_counter(report.get_hotspot_file().column(SW_INST_RETIRED)); } else { auto count = report.get_hotspot_file().multiplex_line().get_double(report.get_hotspot_file().column(UNHALTED_CORE_CYCLES)) * line.get_counter(report.get_hotspot_file().column(UNHALTED_CORE_CYCLES)); function.total_count = static_cast<gcov_type>(count); } //We need the asm file to continue if(!report.has_asm_file(function.i)){ continue; } //Check that the function file is correctly set auto& file = report.asm_file(function.i); bool invalid = false; for(std::size_t j = 0; j < file.lines(); ++j){ auto& line = file.line(j); //Basic Block have no file if(boost::starts_with(line.get_string(file.column(DISASSEMBLY)), "Basic Block")){ continue; } //Line without addresses have special meaning if(line.get_string(file.column(ADDRESS)).empty()){ continue; } //Gooda does not always found the source file of a function //In that case, declare the function as invalid and return quickly auto princ_file = line.get_string(file.column(PRINC_FILE)); if(princ_file == "null"){ log::emit<log::Warning>() << function.name << " is invalid (null file)" << log::endl; invalid = true; break; } if(princ_file.empty()){ log::emit<log::Warning>() << function.name << " is invalid (empty file)" << log::endl; invalid = true; break; } } if(invalid){ continue; } //Add the function data.functions.push_back(std::move(function)); } } //Update function names (replace unmangled with mangled names) update_function_names(report, data, vm); //Fill the inlining cache (gets inlined function names) fill_inlining_cache(report, data, vm); //Fill the discriminator cache (gets the discriminators of each lines) fill_discriminator_cache(report, data, vm); //Generate the inline stacks for(auto& function : data.functions){ //Collect function.file and function.entry_count auto bbs = collect_basic_blocks(report, function, lbr); if(lbr){ lbr_annotate(report, function, bbs); } else { ca_annotate(report, function, bbs); } } //Prune uncounted functions prune_uncounted_functions(data); //Strip current directory from paths strip_paths(data); //Fill the file name table with the strings from the AFDO profile fill_file_name_table(data); //Compute the working set compute_working_set(report, data, vm, lbr); //Set the sizes of the different sections compute_lengths(data); //Note: No need to fill the modules because it is not used by GCC //It will be automatically written empty by the AFDO generator }
double pulse_measure(unsigned BaseAddress) { #define TIMEOUTVAL 150000 unsigned firstcount = 0; unsigned secondcount = 0; unsigned previouscount = 0; unsigned time = 0; unsigned long timeout; unsigned one, two; OUTPORTB(BaseAddress + 3, 0xB4); // 1011 0100 ctr2 mode2 OUTPORTB(BaseAddress + 2, 0xFF); // write 65535 to counters OUTPORTB(BaseAddress + 2, 0xFF); OUTPORTB(BaseAddress + 3, 0x72); // 0111 0010 ctr1 mode2 DELAY(1); OUTPORTB(BaseAddress + 3, 0x70); // 0111 0000 ctr1 mode2 DELAY(1); OUTPORTB(BaseAddress + 3, 0x74); // 0111 0100 ctr1 mode2 OUTPORTB(BaseAddress + 1, 0xFF); // write 65535 to counters OUTPORTB(BaseAddress + 1, 0xFF); firstcount = total_count(BaseAddress); // read the counter timeout = 0; do { previouscount = firstcount; firstcount = total_count(BaseAddress); timeout++; } while ((firstcount != previouscount) && (timeout < TIMEOUTVAL)); // check to see if the counts are changing one = count2(BaseAddress); if (timeout < TIMEOUTVAL) timeout = 0; do { secondcount = total_count(BaseAddress); timeout++; } while ((firstcount == secondcount) && (timeout < TIMEOUTVAL)); // check to see if counts are stable if (timeout < TIMEOUTVAL) timeout = 0; do { previouscount = secondcount; DELAY(1); secondcount = total_count(BaseAddress); timeout++; } while ((secondcount != previouscount) && (timeout < TIMEOUTVAL)); // check to see if counts are changing two = count2(BaseAddress); if (timeout < TIMEOUTVAL) { time = firstcount - secondcount; return(time); // return the counts for the pulse } else return 0; }
void netlist_t::print_stats() const { if (nperftime_t<NL_KEEP_STATISTICS>::enabled) { std::vector<size_t> index; for (size_t i=0; i < m_state->m_devices.size(); i++) index.push_back(i); std::sort(index.begin(), index.end(), [&](size_t i1, size_t i2) { return m_state->m_devices[i1].second->m_stat_total_time.total() < m_state->m_devices[i2].second->m_stat_total_time.total(); }); nperftime_t<NL_KEEP_STATISTICS>::type total_time(0); nperftime_t<NL_KEEP_STATISTICS>::ctype total_count(0); for (auto & j : index) { auto entry = m_state->m_devices[j].second.get(); log().verbose("Device {1:20} : {2:12} {3:12} {4:15} {5:12}", entry->name(), entry->m_stat_call_count(), entry->m_stat_total_time.count(), entry->m_stat_total_time.total(), entry->m_stat_inc_active()); total_time += entry->m_stat_total_time.total(); total_count += entry->m_stat_total_time.count(); } log().verbose("Total calls : {1:12} {2:12} {3:12}", total_count, total_time, total_time / static_cast<decltype(total_time)>(total_count)); nperftime_t<NL_KEEP_STATISTICS> overhead; nperftime_t<NL_KEEP_STATISTICS> test; { auto overhead_guard(overhead.guard()); for (int j=0; j<100000;j++) { auto test_guard(test.guard()); } } nperftime_t<NL_KEEP_STATISTICS>::type total_overhead = overhead() * static_cast<nperftime_t<NL_KEEP_STATISTICS>::type>(total_count) / static_cast<nperftime_t<NL_KEEP_STATISTICS>::type>(200000); log().verbose("Queue Pushes {1:15}", m_queue.m_prof_call()); log().verbose("Queue Moves {1:15}", m_queue.m_prof_sortmove()); log().verbose("Queue Removes {1:15}", m_queue.m_prof_remove()); log().verbose("Queue Retimes {1:15}", m_queue.m_prof_retime()); log().verbose("Total loop {1:15}", m_stat_mainloop()); /* Only one serialization should be counted in total time */ /* But two are contained in m_stat_mainloop */ log().verbose("Total devices {1:15}", total_time); log().verbose(""); log().verbose("Take the next lines with a grain of salt. They depend on the measurement implementation."); log().verbose("Total overhead {1:15}", total_overhead); nperftime_t<NL_KEEP_STATISTICS>::type overhead_per_pop = (m_stat_mainloop()-2*total_overhead - (total_time - total_overhead)) / static_cast<nperftime_t<NL_KEEP_STATISTICS>::type>(m_queue.m_prof_call()); log().verbose("Overhead per pop {1:11}", overhead_per_pop ); log().verbose(""); auto trigger = total_count * 200 / 1000000; // 200 ppm for (auto &entry : m_state->m_devices) { auto ep = entry.second.get(); // Factor of 3 offers best performace increase if (ep->m_stat_inc_active() > 3 * ep->m_stat_total_time.count() && ep->m_stat_inc_active() > trigger) log().verbose("HINT({}, NO_DEACTIVATE) // {} {} {}", ep->name(), static_cast<double>(ep->m_stat_inc_active()) / static_cast<double>(ep->m_stat_total_time.count()), ep->m_stat_inc_active(), ep->m_stat_total_time.count()); } } }