static GList * cpufreq_monitor_libcpufreq_get_available_frequencies (CPUFreqMonitor *monitor) { GList *list = NULL; guint cpu; CPUFreqFrequencyList *freqs, *freq; g_object_get (G_OBJECT (monitor), "cpu", &cpu, NULL); freqs = cpufreq_get_available_frequencies (cpu); if (!freqs) return NULL; for (freq = freqs; freq; freq = freq->next) { gchar *frequency; frequency = g_strdup_printf ("%lu", freq->frequency); if (!g_list_find_custom (list, frequency, compare)) list = g_list_prepend (list, frequency); else g_free (frequency); } cpufreq_put_available_frequencies (freqs); return g_list_sort (list, compare); }
static guint cpufreq_selector_libcpufreq_get_valid_frequency (CPUFreqSelectorLibcpufreq *selector, guint frequency) { guint cpu; gint dist = G_MAXINT; guint retval = 0; CPUFreqFrequencyList *freqs, *freq; g_object_get (G_OBJECT (selector), "cpu", &cpu, NULL); freqs = cpufreq_get_available_frequencies (cpu); if (!freqs) return 0; for (freq = freqs; freq; freq = freq->next) { guint current_dist; if (freq->frequency == frequency) { cpufreq_put_available_frequencies (freqs); return frequency; } current_dist = abs (freq->frequency - frequency); if (current_dist < dist) { dist = current_dist; retval = freq->frequency; } } return retval; }
int single_freq_init (actuator_t *act) { int err; struct cpufreq_policy *policy; struct cpufreq_available_frequencies *freq_list; freq_scaler_data_t *data; unsigned long freq_min, freq_max; act->data = data = malloc(sizeof(freq_scaler_data_t)); fail_if(!data, "cannot allocate freq data block"); err = cpufreq_get_hardware_limits(act->core, &freq_min, &freq_max); fail_if(err, "cannot get cpufreq hardware limits"); act->min = freq_min; act->max = freq_max; policy = cpufreq_get_policy(act->core); fail_if(!policy, "cannot get cpufreq policy"); if (strcmp(policy->governor, "userspace") != 0) { err = cpufreq_modify_policy_governor(act->core, "userspace"); policy = cpufreq_get_policy(act->core); fail_if (strcmp(policy->governor, "userspace") != 0, "cannot set cpufreq policy to userspace"); } freq_list = cpufreq_get_available_frequencies(act->core); data->freq_count = create_freq_array(freq_list, &data->freq_array); fail_if(data->freq_count < 1, "cannot get frequency list"); act->value = act->set_value = cpufreq_get_freq_kernel(act->core); data->cur_index = get_freq_index(data, act->value); return 0; fail: return -1; }
JNIEXPORT jlongArray JNICALL Java_platforms_x86_X86_1DVFS_getAvailableFrequencies (JNIEnv *env, jobject obj, jint cpu) { struct cpufreq_available_frequencies *available_freqs, *first = NULL; jlongArray freqs; jlong c_freqs[16]; int i = 0, length = 0; jclass cls; jfieldID fid; available_freqs = cpufreq_get_available_frequencies((unsigned int)cpu); if (available_freqs) first = available_freqs->first; /* First grab the number of available frequencies */ while (available_freqs) { length++; available_freqs = available_freqs->next; } freqs = (*env)->NewLongArray(env, (jsize) length); if (!first) { cls = (*env)->GetObjectClass(env, obj); fid = (*env)->GetFieldID(env, cls, "minFreq", "J"); (*env)->SetLongField(env, obj, fid, 1); (*env)->DeleteLocalRef(env, cls); return freqs; } available_freqs = first; while (available_freqs) { c_freqs[i] = (jlong)available_freqs->frequency; i++; available_freqs = available_freqs->next; } // move from the temp structure to the java structure (*env)->SetLongArrayRegion(env, freqs, 0, length, c_freqs); /* Free local references */ cpufreq_put_available_frequencies(first); return freqs; }
int main(int argc, char **argv) { struct cpufreq_available_frequencies *freq_list; int core_count; int i, j; unsigned long *states, *state; int state_count; int opt; int skip_redundant = 0; int skip_unoptimal = 0; char *state_file_name = NULL; int skip_equivalent = 0; while ((opt = getopt(argc, argv, "rpf:u")) != -1) switch (opt) { case 'r': skip_redundant = 1; break; case 'p': skip_unoptimal = 1; break; case 'f': state_file_name = optarg; break; case 'u': skip_equivalent = 1; break; default: fprintf(stderr, "Usage: %s [-r] [-p] [-f file] [-u]\n", argv[0]); exit(1); } if (state_file_name) { states = read_states_file(state_file_name, &state_count, &core_count); } else { int freq_count; unsigned long *freq_array; core_count = get_core_count(); freq_list = cpufreq_get_available_frequencies(0); freq_count = create_freq_array(freq_list, &freq_array); states = create_machine_states(&state_count, core_count, freq_count, freq_array); } qsort(states, state_count, STATE_SIZE(core_count), compare_states_on_speed); printf("speed\tpower"); for (j = 0; j < core_count; j++) printf("\tcore%d", j); printf("\n"); for (i = 0, state = states; i < state_count; i++, state+=STATE_LEN(core_count)) { if (skip_redundant && redundant_state(state, core_count)) continue; if (skip_equivalent && drop_equivalent(state, i, states, state_count, core_count)) continue; if (skip_unoptimal && !pareto_optimal(state, i, states, state_count, core_count)) continue; printf("%lu\t%lu", state[SPEED_IDX], state[POWER_IDX]); for (j = 0; j < core_count; j++) printf("\t%lu", state[CORE_IDX(j)]); printf("\n"); } return 0; }
int main(int argc, char** argv) { int n = 0; int i; const int MAX = atoi(argv[1]); const int CORES = atoi(argv[2]); int ncpus=0; int apps[1024]; /**/ extern char *optarg; extern int optind, opterr, optopt; int ret = 0, cont = 1; unsigned int cpu = 0; //unsigned int cpu_defined = 0; unsigned long min_available_freq = 0; unsigned long max_available_freq = 0; unsigned long current_freq = 0; unsigned long initial_freq = 0; struct cpufreq_available_frequencies *freqs; int retr =0; setlinebuf(stdout); ncpus=get_cpus(); if(!CORES){ CORES == ncpus; } if (CORES > ncpus){ printf("Wrong number of inital cores"); exit(2); } ret= get_hardware_limits(cpu); min_available_freq = min; max_available_freq = max; ret= set_policy(CORES); freqs = cpufreq_get_available_frequencies(0); /*if (freqs==null){ goto out; }*/ current = get_available_freqs_size(freqs); unsigned long* available_freqs = (unsigned long *) malloc(current*sizeof(unsigned long)); ret = store_available_freqs( freqs, available_freqs, current); int current_counter = get_init_frequency(available_freqs, cpu); /*if (ret!=0){ goto out; }*/ current_freq = cpufreq_get_freq_kernel(cpu); if(getenv("HEARTBEAT_ENABLED_DIR") == NULL) { fprintf(stderr, "ERROR: need to define environment variable HEARTBEAT_ENABLED_DIR (see README)\n"); return 1; } heart_data_t* records = (heart_data_t*) malloc(MAX*sizeof(heart_data_t)); int last_tag = -1; while(n == 0) { n = get_heartbeat_apps(apps); } printf("apps[0] = %d\n", apps[0]); // For this test we only allow one heartbeat enabled app // assert(n==1); if (n>1) { printf("too many apps!!!!!!!!!!!!!!\n"); exit(2); } /* sleep(5);*/ #if 1 int rc = heart_rate_monitor_init(&heart, apps[0]); if (rc != 0) printf("Error attaching memory\n"); printf("buffer depth is %lld\n", (long long int) heart.state->buffer_depth); i = 0; printf(" rate interval is %f - %f\n", hrm_get_min_rate(&heart), hrm_get_max_rate(&heart)); printf("beat\trate\tfreq\tcores\ttact\twait\n"); int64_t window_size = hrm_get_window_size(&heart); int wait_for = (int) window_size; int current_beat = 0; int current_beat_prev= 0; int nprocs = 1; unsigned int set_freq = min; // return 1; while(current_beat < MAX) { int rc = -1; heartbeat_record_t record; char command[256]; while (rc != 0 || record.window_rate == 0.0000 ){ rc = hrm_get_current(&heart, &record); current_beat = record.beat; } if(current_beat_prev == current_beat) continue; /* printf(" rc: %d, current_beat:%d \n", rc,current_beat);*/ /*Situation where doesn't happen nothing*/ if( current_beat < wait_for){ current_beat_prev= current_beat; /* printf("I am in situation wait_for\n");*/ current_freq = cpufreq_get_freq_kernel(0); print_status(&record, wait_for, current_freq, '.', CORES); continue; } /* printf("Current beat is %d, wait_for = %d, %f\n", current_beat, wait_for, record.window_rate);*/ /*Situation where frequency is up-scaled*/ if(record.window_rate < hrm_get_min_rate(&heart)) { wait_for = current_beat + window_size; if (current_counter > 0){ int cpu; current_counter--; set_freq = get_speed(available_freqs[current_counter]); for (cpu=0; cpu <=CORES; cpu++) { /* sprintf(command, "cpufreq-set -c %d -f %luMHZ", cpu,set_freq);*/ /* printf("Executing %s\n", command);*/ /* system(command);*/ cpufreq_set_frequency(cpu, available_freqs[current_counter]); } current_freq = cpufreq_get_freq_kernel(0); print_status(&record, wait_for, current_freq, '+', CORES); } else { current_freq = cpufreq_get_freq_kernel(0); print_status(&record, wait_for, current_freq, 'M', CORES); } } /*Situation where frequency is downscaled*/ else if(record.window_rate > hrm_get_max_rate(&heart)) { wait_for = current_beat + window_size; if (current_counter < current){ current_counter++; set_freq = get_speed(available_freqs[current_counter]); for (cpu=0; cpu <=CORES; cpu++) { /* sprintf(command, " cpufreq-set -c %d -f %uMHZ", cpu,set_freq);*/ /* printf("Executing %s\n", command);*/ /*system(command);*/ cpufreq_set_frequency(cpu, available_freqs[current_counter]); } current_freq = cpufreq_get_freq_kernel(0); print_status(&record, wait_for, current_freq, '-', CORES); } else { current_freq = cpufreq_get_freq_kernel(0); print_status(&record, wait_for, current_freq, 'm', CORES); } } else { wait_for = current_beat+1; print_status(&record, wait_for, current_freq, '=', CORES); } current_beat_prev= current_beat; records[i].tag = current_beat; records[i].rate = record.window_rate; i++; } //printf("System: Global heart rate: %f, Current heart rate: %f\n", heart.global_heartrate, heart.window_heartrate); /* for(i = 0; i < MAX; i++) { printf("%d, %f\n", records[i].tag, records[i].rate); }*/ heart_rate_monitor_finish(&heart); #endif return 0; }
void print_cpu(unsigned int cpu, unsigned int n_cpus) { int i; char str[MAXLEN]; char premark[MAXLEN]; char postmark[MAXLEN]; unsigned long curfreq, freq; struct cpufreq_available_frequencies* freqs; struct cpufreq_available_governors* govs; struct cpufreq_policy* policy; if (cpu + 1 == n_cpus) // last cpu column printf("<item label='cpu %u'/>\n", cpu); else if (cpu + 1 < n_cpus) { printf("<menu label='cpu %u' id='obcpufreq-cpu%u'>\n", cpu, cpu + 1); print_cpu(cpu + 1, n_cpus); printf("</menu>\n"); } printf(SEPARATOR); curfreq = cpufreq_get_freq_kernel(cpu); policy = cpufreq_get_policy(cpu); // print available governors govs = cpufreq_get_available_governors(cpu); if (govs) { printf("<menu label='governors' id='obcpufreq-governors%u'>\n", cpu); for (; govs; govs = govs->next) { premark[0] = ' '; premark[1] = '\0'; if (!strcmp(govs->governor, policy->governor)) premark[0] = '*'; printf(" <item label='%s%s'><action name='Execute'><command>" CPUFREQ_SET " --cpu %u -g %s</command></action></item>\n", premark, govs->governor, cpu, govs->governor); } printf("</menu>\n"); cpufreq_put_available_governors(govs); } else printf("<item label='%s'/>\n", "no available governors"); printf(SEPARATOR); // print available freqs freqs = cpufreq_get_available_frequencies(cpu); if (freqs) { for (i = 0; freqs; freqs = freqs->next, i++) { freq = freqs->frequency; get_human_speed(str, freq); premark[0] = ' '; premark[1] = '\0'; if (freq == curfreq) premark[0] = '*'; postmark[0] = '\0'; if (policy) { if (freq == policy->max && freq == policy->min) strcpy(postmark, " (max,min)"); else if (freq == policy->max) strcpy(postmark, " (max)"); else if (freq == policy->min) strcpy(postmark, " (min)"); } printf("<menu label='%s%s%s' id='obcpufreq-freq%d'>\n" " <item label='set as max'><action name='Execute'><command>" CPUFREQ_SET " --cpu %u --max %lu</command></action></item>\n" " <item label='set as min'><action name='Execute'><command>" CPUFREQ_SET " --cpu %u --min %lu</command></action></item>\n</menu>\n", premark, str, postmark, i, cpu, freqs->frequency, cpu, freqs->frequency); } cpufreq_put_available_frequencies(freqs); } else printf("<item label='%s'/>\n", "no available freqs"); cpufreq_put_policy(policy); return; }