void inittime() { /* start the time clock at zero */ sttime = 0.; sttime = get_cputime(); }
int main(int ac, char **av) { double srt; double pollrate; int ch; char buf[64]; int monbat; srt = 8.0; /* time for samples - 8 seconds */ pollrate = 1.0; /* polling rate in seconds */ while ((ch = getopt(ac, av, "b:cdefh:l:p:r:tu:B:L:P:QT:")) != -1) { switch(ch) { case 'b': BackLightPct = strtol(optarg, NULL, 10); break; case 'c': AdjustCstate = 1; break; case 'd': DebugOpt = 1; break; case 'e': HasPerfbias = 1; break; case 'f': AdjustCpuFreq = 0; break; case 'h': HighestCpuFreq = strtol(optarg, NULL, 10); break; case 'l': LowestCpuFreq = strtol(optarg, NULL, 10); break; case 'p': Hysteresis = (int)strtol(optarg, NULL, 10); break; case 'r': pollrate = strtod(optarg, NULL); break; case 't': TurboOpt = 0; break; case 'u': TriggerUp = (double)strtol(optarg, NULL, 10) / 100; break; case 'B': BatLifeMin = strtol(optarg, NULL, 10); break; case 'L': BatShutdownLingerSet = strtol(optarg, NULL, 10); if (BatShutdownLingerSet < 0) BatShutdownLingerSet = 0; break; case 'P': BatLifePollIntvl = strtol(optarg, NULL, 10); break; case 'Q': BatShutdownAudioAlert = 0; break; case 'T': srt = strtod(optarg, NULL); break; default: usage(); /* NOT REACHED */ } } ac -= optind; av += optind; setlinebuf(stdout); /* Get number of cpus */ get_ncpus(); if (0 > Hysteresis || Hysteresis > 99) { fprintf(stderr, "Invalid hysteresis value\n"); exit(1); } if (0 > TriggerUp || TriggerUp > 1) { fprintf(stderr, "Invalid load limit value\n"); exit(1); } if (BackLightPct > 100 || BackLightPct <= 0) { fprintf(stderr, "Invalid backlight setting, ignore\n"); BackLightPct = 100; } TriggerDown = TriggerUp - (TriggerUp * (double) Hysteresis / 100); /* * Make sure powerd is not already running. */ PowerFd = open("/var/run/powerd.pid", O_CREAT|O_RDWR, 0644); if (PowerFd < 0) { fprintf(stderr, "Cannot create /var/run/powerd.pid, " "continuing anyway\n"); } else { if (flock(PowerFd, LOCK_EX|LOCK_NB) < 0) { fprintf(stderr, "powerd is already running\n"); exit(1); } } /* * Demonize and set pid */ if (DebugOpt == 0) { daemon(0, 0); openlog("powerd", LOG_CONS | LOG_PID, LOG_DAEMON); } if (PowerFd >= 0) { ftruncate(PowerFd, 0); snprintf(buf, sizeof(buf), "%d\n", (int)getpid()); write(PowerFd, buf, strlen(buf)); } /* Do we need to monitor battery life? */ if (BatLifePollIntvl <= 0) monbat = 0; else monbat = has_battery(); /* Do we have perfbias(4)? */ if (HasPerfbias) HasPerfbias = has_perfbias(); /* Could we adjust C-state? */ if (AdjustCstate) AdjustCstate = probe_cstate(); /* * Wait hw.acpi.cpu.px_dom* sysctl to be created by kernel. * * Since hw.acpi.cpu.px_dom* creation is queued into ACPI * taskqueue and ACPI taskqueue is shared across various * ACPI modules, any delay in other modules may cause * hw.acpi.cpu.px_dom* to be created at quite a later time * (e.g. cmbat module's task could take quite a lot of time). */ for (;;) { /* Prime delta cputime calculation. */ get_cputime(pollrate); /* Wait for all cpus to appear */ if (acpi_get_cpupwrdom()) break; usleep((int)(pollrate * 1000000.0)); } /* * Catch some signals so that max performance could be restored. */ signal(SIGINT, sigintr); signal(SIGTERM, sigintr); /* Initialize performance states */ init_perf(); srt = srt / pollrate; /* convert to sample count */ if (DebugOpt) printf("samples for downgrading: %5.2f\n", srt); /* * Monitoring loop */ while (!stopped) { /* * Monitor performance */ get_cputime(pollrate); mon_perf(srt); /* * Monitor battery */ if (monbat) monbat = mon_battery(); usleep((int)(pollrate * 1000000.0)); } /* * Set to maximum performance if killed. */ syslog(LOG_INFO, "killed, setting max and exiting"); restore_perf(); restore_backlight(); exit(0); }
int main (int argc, char *argv[]) { struct stats s, s0; int print = 0; FILE *fp = fopen(STATS_FILE, "rb"); if (fp != NULL) { fread(&s0, sizeof(struct stats), 1, fp); fclose(fp); print = 1; } get_times(&s); get_temp(&s); get_mail(&s); get_cputime(&s); get_power(&s); get_mem(&s); get_txrx(&s); if (print) { int i; double temp = 1e-3*s.temp; double charge = 100*s.charge_now/s.charge_full; double tx = (s.tx-s0.tx)/(s.t-s0.t); double rx = (s.rx-s0.rx)/(s.t-s0.t); double mem = s.mem*9.5367431640625e-07; double cpu_pct[MAX_CPUS]; for (i=0; i < s.n_cpus; i++) { double idle = s.cpu_idle[i] - s0.cpu_idle[i]; double total = s.cpu_total[i] - s0.cpu_total[i]; cpu_pct[i] = 1-idle/total; } fputs(" [", stdout); begin_color(color_bar); fputs(th_spc, stdout); for (i=0; i < s.n_cpus; i++) { print_bar(cpu_pct[i]); fputs(th_spc, stdout); } end_color(); fputc(']', stdout); begin_color (color_div); fputs(spc, stdout); fputs(divider, stdout); end_color(); begin_color_coded (temp, LO_TEMP, HI_TEMP); num_print (temp, 3, degc); end_color(); begin_color (color_div); fputs(spc, stdout); fputs(divider, stdout); fputs(spc, stdout); end_color(); begin_color_coded (mem, LO_MEM, HI_MEM); num_print (mem, 4, "MB"); end_color(); begin_color (color_div); fputs(spc, stdout); fputs(divider, stdout); fputs(spc, stdout); end_color(); begin_color (s.ac_connected ? "cyan" : "red"); fputs(s.ac_connected ? acon : acoff, stdout); fputc(' ', stdout); end_color(); begin_color_coded (100-charge, LO_CHARGE, HI_CHARGE); num_print (charge, 3, "%"); end_color(); begin_color (color_div); fputs(spc, stdout); fputs(divider, stdout); end_color(); begin_color_coded (tx, LO_RATE, HI_RATE); num_print (tx, 0, "B/s "); end_color(); begin_color (color_up); fputs(up, stdout); end_color(); begin_color_coded (rx, LO_RATE, HI_RATE); fputs(spc, stdout); num_print (rx, 0, "B/s "); end_color(); begin_color (color_down); fputs(down, stdout); end_color(); fputs(spc, stdout); begin_color (color_div); fputs(divider, stdout); fputs(spc, stdout); end_color(); if (s.gmail) { begin_color (color_mail); printf ("%2d/g", s.gmail); end_color(); } if (s.uiucmail) { begin_color (color_mail); printf ("%2d/u", s.uiucmail); end_color(); } if (s.uiucmail || s.gmail) { fputs(spc, stdout); begin_color (color_div); fputs(divider, stdout); fputs(spc, stdout); end_color(); } begin_color (color_date); fputs(s.date, stdout); end_color(); fputs(spc, stdout); begin_color (color_div); fputs(divider, stdout); end_color(); } fp = fopen(STATS_FILE, "wb"); fwrite(&s, sizeof(struct stats), 1, fp); fclose(fp); return 0; }
void itime() { apush(createreal(get_cputime())); }
int main(int argc, char** argv) { // Parameters std::string filename = "system.dat"; float temperature = 1.0f; float epsilon = 0; uint64_t seed = 0; int phi_card = 0; // Get parameters for(int i = 1; i < argc; i++) { if(strlen(argv[i]) != 2 || argv[i][0] != '-' || i+1 == argc) { std::cout << "Invalid option " << argv[i] << std::endl; return EXIT_FAILURE; } switch(argv[i][1]) { case 'o': // Output file filename = argv[i+1]; break; case 't': // Temperature temperature = std::stof(argv[i+1]); break; case 'e': // Epsilon epsilon = std::stof(argv[i+1]); break; case 's': // RNG Seed seed = std::stoull(argv[i+1]); break; case 'p': // Numer of Phi card to use phi_card = std::stoi(argv[i+1]); break; default: std::cout << "Invalid option " << argv[i] << std::endl; return EXIT_FAILURE; } i++; } // Required timesteps std::set<uint64_t> times; uint64_t maxT = 10000000; for(uint64_t j = 1; j <= maxT/10; j*=10) { times.insert(j); for(uint64_t i = 1; i < maxT; i+=(i+1)/2) times.insert(j+i); } size_t system_size = 2*4*N*N*N; std::cout << "Timesteps to save: " << times.size() << std::endl; std::cout << "Space required: " << times.size()*system_size/1024/1024 << " MB" << std::endl; // Info float field = epsilon * temperature; std::cout << "Temperature: " << temperature << std::endl; std::cout << "Field: " << field << std::endl; std::cout << "Seed: " << seed << std::endl; std::cout << "Dimension: " << N << "^3" << std::endl; // Initialize uint32_t* systemState = (uint32_t*)_mm_malloc(system_size, 64); uint32_t* system0; #pragma offload target(mic:phi_card) \ in(systemState : length(2*N*N*N) ALLOC) \ nocopy(system0) { system0 = (uint32_t*)_mm_malloc(sizeof(uint32_t)*(N*N*N*4 + OFFSET), ALIGN); uint32_t* system1 = system0 + N*N*N + OFFSET/4; uint32_t* field0 = system1 + N*N*N + OFFSET/4; uint32_t* field1 = field0 + N*N*N + OFFSET/4; setParameters(temperature, field); randomize(system0, seed++); randomize(system1, seed++); randomize(field0, seed++); randomize(field1, seed++); } // Open output file SystemManager mgr; mgr.CreateFile(filename, N, 2*4); mgr.SetParameters(temperature, field); // Set precision std::cout.precision(2); std::cout << std::fixed; // Start simulation times.insert(0); auto prev = times.begin(); uint64_t maxTime = *times.rbegin(); double startTime = get_cputime(); for(auto it = std::next(prev); it != times.end(); ++it) { // Necessary steps for next system uint64_t steps = *it - *prev; prev = it; // Do steps #pragma offload target(mic:phi_card) \ out(systemState : length(2*N*N*N) REUSE) \ nocopy(system0) { uint32_t* system1 = system0 + N*N*N + OFFSET/4; uint32_t* field0 = system1 + N*N*N + OFFSET/4; uint32_t* field1 = field0 + N*N*N + OFFSET/4; for(uint64_t i = 0; i < steps; ++i) { spinFlip(system0, system1, field0, seed++); spinFlip(system1, system0, field1, seed++); } // Rearrange system for output for(unsigned int z = 0; z < N; z++) for(unsigned int y = 0; y < N; y++) for(unsigned int x = 0; x < N; x++) { if((x+y+z)%2) { systemState[2*(z*N*N + y*N + x)] = system0[z*N*N + y*N + x]; systemState[2*(z*N*N + y*N + x)+1] = system1[z*N*N + y*N + x]; } else { systemState[2*(z*N*N + y*N + x)] = system1[z*N*N + y*N + x]; systemState[2*(z*N*N + y*N + x)+1] = system0[z*N*N + y*N + x]; } } } // Write out system mgr.SaveSystem(*it, reinterpret_cast<const char*>(systemState), system_size); // Statistics std::cout << "\r" << *it * 100.f/maxTime << "% finished" << std::flush; } double stopTime = get_cputime(); double delta = stopTime-startTime; double timePerSpin = delta/64/N/N/N/maxTime; std::cout << "\r" << 100.0 << "% finished" << std::endl; std::cout << "Elapsed time: " << delta << std::endl; std::cout << "Time per spin: " << timePerSpin*1E12 << " ps" << std::endl; // Free memory #pragma offload target(mic:phi_card) \ out(systemState : length(2*N*N*N) FREE) \ nocopy(system0) { _mm_free(system0); } }