int set_process_cpu_and_freq(const unsigned int cpu_index) {
// set the core-affinity
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(cpu_index, &cpu_set);
sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
// set CPU governor
unsigned long cpu_max = 0;
unsigned long cpu_min = 0;
unsigned long cpu_cur = 0;
if (cpufreq_cpu_exists(cpu_index) != 0) {
printf("Invalid CPU index!\n");
return -1;
}
if (cpufreq_get_hardware_limits(cpu_index, &cpu_min, &cpu_max) != 0) {
printf("Unable to get hardware limits!\n");
return -1;
}
if (cpufreq_set_frequency(cpu_index, cpu_max) != 0) {
printf("Unable to set frequency(%luMHz) Are u root?\n", cpu_max / 1000);
return -1;
}
cpu_cur = (cpufreq_get_freq_kernel(cpu_index) / 1000);
printf("Current CPU %u Frequency: %lu MHz\n\n", cpu_index, cpu_cur);
return 0;
}
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;
}
void uv_set_cpufreq(void) {
int s = 0, cpu = 0, skip = 0;
uint64_t cpu_cur = 0;
long cpu_togo = 0;
char *freq_str = NULL;
freq_str = getenv("NODE_CPU0_FREQ");
printf("%s ", freq_str);
if (freq_str) {
cpu_togo = atol(freq_str);
flex_mode = 0;
if (cpu_togo == 0) {
cpu_togo = 1200000;
flex_mode = 1;
freq = 0;
threshold = atoi(getenv("NODE_QUEUE_THRESHOLD"));
printf("FLEX MODE: threshold = %lu\n", threshold);
} else if (cpu_togo < 0) {
skip = 1;
printf("SKIP MODE ");
}
} else
cpu_togo = 3200000;
if (!skip)
s = cpufreq_set_frequency(cpu, cpu_togo);
if (s != 0) {
printf("ERROR: uv_set_cpufreq failed!\n");
}
cpu_cur = cpufreq_get_freq_kernel(cpu);
prog_start = uv__cputime();
printf("Current CPU Frequency: %luKHz\n", cpu_cur);
}
int single_freq_act (actuator_t *act)
{
int err = 0;
err = cpufreq_set_frequency(act->core, act->set_value);
/* warning: cpufreq_set_frequency tries sysfs first, then proc; this means that if
sysfs fails with EACCESS, the errno is then masked by the ENOENT from proc! */
act->value = cpufreq_get_freq_kernel(act->core);
return err;
}
static unsigned long get_init_frequency(unsigned long* available_freqs_array, int cpu1){
int i=0;
unsigned long curent_init_freq;
curent_init_freq = cpufreq_get_freq_kernel(cpu1);
while(available_freqs_array[i]!=curent_init_freq ){
i++;
}
return i;
}
int global_freq_act (actuator_t *act)
{
int err = 0;
int cpu;
for (cpu = 0; cpu < get_core_count(); cpu++)
err = err || cpufreq_set_frequency(cpu, act->set_value);
/* warning: cpufreq_set_frequency tries sysfs first, then proc; this means that if
sysfs fails with EACCESS, the errno is then masked by the ENOENT from proc! */
act->value = cpufreq_get_freq_kernel(0);
return err;
}
static gboolean
cpufreq_monitor_libcpufreq_run (CPUFreqMonitor *monitor)
{
guint cpu;
CPUFreqPolicy *policy;
g_object_get (G_OBJECT (monitor), "cpu", &cpu, NULL);
policy = cpufreq_get_policy (cpu);
if (!policy) {
/* Check whether it failed because
* cpu is not online.
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0)
if (!cpufreq_cpu_exists (cpu)) {
#else
if (cpupower_is_cpu_online (cpu)) {
#endif
g_object_set (G_OBJECT (monitor), "online", FALSE, NULL);
return TRUE;
}
return FALSE;
}
g_object_set (G_OBJECT (monitor),
"online", TRUE,
"governor", policy->governor,
"frequency", cpufreq_get_freq_kernel (cpu),
NULL);
cpufreq_put_policy (policy);
return TRUE;
}
static gint
compare (gconstpointer a, gconstpointer b)
{
gint aa, bb;
aa = atoi ((gchar *) a);
bb = atoi ((gchar *) b);
if (aa == bb)
return 0;
else if (aa > bb)
return -1;
else
return 1;
}
unsigned long cpufreq_get_freq_hardware(unsigned int cpu)
{
if (cpu >= MAX_CPUS) {
errno = ENOENT;
return -ENOENT;
}
if (geteuid() != 0) {
errno = EACCES;
return 0;
}
return cpufreq_get_freq_kernel(cpu);
}
static void read_khz() {
if (!gov_enable_current) {
/* otherwise it has already been read in this update step */
read_governors();
}
/* current freqs */
unsigned int cpu;
for ( cpu=0; cpu<ncpu; ++cpu ) {
khz[cpu] = cpufreq_get_freq_kernel(cpu);
/* max freq */
khz_max = khz[cpu] > khz_max ? khz[cpu] : khz_max;
}
}
GkrellmMonitor* gkrellm_init_plugin(void)
{
/* If this next call is made, the background and krell images for this
plugin can be custom themed by putting bg_meter.png or krell.png in the
subdirectory STYLE_NAME of the theme directory. Text colors (and
other things) can also be specified for the plugin with gkrellmrc
lines like: StyleMeter STYLE_NAME.textcolor orange black shadow
If no custom theming has been done, then all above calls using
style_id will be equivalent to style_id = DEFAULT_STYLE_ID.
*/
pGK = gkrellm_ticks();
style_id = gkrellm_add_meter_style(&plugin_mon, STYLE_NAME);
monitor = &plugin_mon;
/* determine number of cpus */
for( ncpu = 0; cpufreq_get_freq_kernel(ncpu)>0; ++ncpu )
;
ncpu = ncpu > NCPU_MAX ? NCPU_MAX : ncpu;
/* determine maximal frequency */
unsigned int cpu;
for ( cpu = 0; cpu<ncpu; ++cpu) {
unsigned long khz_min = 0;
unsigned long khz_max_i = 0;
cpufreq_get_hardware_limits( cpu, &khz_min, &khz_max_i );
khz_max = khz_max < khz_max_i ? khz_max_i : khz_max;
}
read_khz();
strcpy(empty, "");
if (gov_enable_current) {
read_governors();
} else {
for ( cpu=0; cpu<ncpu; ++cpu ) {
strcpy(governor[cpu], "");
}
}
return &plugin_mon;
}
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;
}
static void cpu_desc_summary (struct cpu_desc *cpudesc)
{
printf ("-= CPU Characteristics =-\n");
print_s("Architecture:", cpu_desc_get_architecture (cpudesc));
int cpu_mode = cpu_desc_get_mode (cpudesc);
if (cpu_mode)
{
char mbuf[32], *p = mbuf;
if (cpu_mode & MODE_32BIT)
{
strcpy (p, "32-bit, ");
p += 8;
}
if (cpu_mode & MODE_64BIT)
{
strcpy (p, "64-bit, ");
p += 8;
}
*(p - 2) = '\0';
print_s("CPU op-mode(s):", mbuf);
}
#if !defined(WORDS_BIGENDIAN)
print_s("Byte Order:", "Little Endian");
#else
print_s("Byte Order:", "Big Endian");
#endif
int cpu, ncpus = cpu_desc_get_ncpus (cpudesc);
print_d("CPU(s):", ncpus);
unsigned int nsockets, ncores, nthreads;
get_cputopology_read (&nsockets, &ncores, &nthreads);
print_u("Thread(s) per core:", nthreads);
print_u("Core(s) per socket:", ncores);
print_u("Socket(s):", nsockets);
print_s("Vendor ID:", cpu_desc_get_vendor (cpudesc));
print_s("CPU Family:", cpu_desc_get_family (cpudesc));
print_s("Model:", cpu_desc_get_model (cpudesc));
print_s("Model name:", cpu_desc_get_model_name (cpudesc));
for (cpu = 0; cpu < ncpus; cpu++)
{
printf ("-CPU%d-\n", cpu);
bool cpu_hot_pluggable = get_processor_is_hot_pluggable (cpu);
int cpu_online = get_processor_is_online (cpu);
print_s ("CPU is Hot Pluggable:", cpu_hot_pluggable ?
(cpu_online ? "yes (online)" : "yes (offline)") : "no");
unsigned long latency = cpufreq_get_transition_latency (cpu);
if (latency)
print_s("Maximum Transition Latency:",
cpufreq_duration_to_string (latency));
unsigned long freq_kernel = cpufreq_get_freq_kernel (cpu);
if (freq_kernel > 0)
print_s("Current CPU Frequency:", cpufreq_freq_to_string (freq_kernel));
struct cpufreq_available_frequencies *cpufreqs, *curr;
cpufreqs = curr = cpufreq_get_available_freqs (cpu);
if (curr)
{
print_key_s("Available CPU Frequencies:");
while (curr)
{
printf ("%s ",
cpufreq_freq_to_string
(cpufreq_get_available_freqs_value (curr)));
curr = cpufreq_get_available_freqs_next (curr);
}
printf ("\n");
cpufreq_available_frequencies_unref(cpufreqs);
}
unsigned long freq_min, freq_max;
if (0 == cpufreq_get_hardware_limits (cpu, &freq_min, &freq_max))
{
char *min_s = cpufreq_freq_to_string (freq_min),
*max_s = cpufreq_freq_to_string (freq_max);
print_range_s("Hardware Limits:", min_s, max_s);
free (min_s);
free (max_s);
}
char *freq_governor = cpufreq_get_governor (cpu);
if (freq_governor)
{
print_s ("CPU Freq Current Governor:", freq_governor);
free (freq_governor);
}
char *freq_governors = cpufreq_get_available_governors (cpu);
if (freq_governors)
{
print_s ("CPU Freq Available Governors:", freq_governors);
free (freq_governors);
}
char *freq_driver = cpufreq_get_driver (cpu);
if (freq_driver)
{
print_s ("CPU Freq Driver:", freq_driver);
free (freq_driver);
}
}
char *cpu_virtflag = cpu_desc_get_virtualization_flag (cpudesc);
if (cpu_virtflag)
print_s("Virtualization:", cpu_virtflag);
}
int main(int argc, char *argv[])
{
struct timespec ts,ts1;
int i,ncpu;
int idcpu;
unsigned long freq[8];
XEvent event;
char gov[20];
char drv[20],*ptr,*endptr;
char prg[LN_PATH];
ts.tv_sec=0;
ts.tv_nsec=DELAY;
prg[0]=0;
idcpu=0;
for(i=0;i<MAX_CPU;i++)
freq[i]=0;
if(argc >1)
{
for (i=1; i<=argc; i++)
{
if (!strcmp(argv[i], "-v"))
{
printf(WMCPUFREQ_VERSION);
exit(0);
}
if (!strcmp(argv[i], "-exe"))
{
if(strlen(argv[i+1]) < LN_PATH )
strcpy(prg,argv[i+1]);
break;
}
if (!strcmp(argv[i], "-cpuid"))
{
if(strlen(argv[i+1]) < LN_PATH )
idcpu=strtol(argv[i+1],&endptr,0);
printf("cpuid= %d \n",idcpu);
break;
}
printf("only -v, -exe, -cpuid supported \n");
exit(0);
}
}
/* basic checks */
if ( idcpu < 0 )
{
printf("cpuid < 0 \n");
exit(-1);
}
/* get driver name (guess all cpu have the same driver) */
ptr=cpufreq_get_driver(cpu);
if(!ptr)
{
printf("no driver found \n");
exit(-1);
}
strcpy(drv,ptr);
cpufreq_put_driver(ptr);
/* get number of cpu (0=cpu0, 1=cpu1 ...) */
ncpu=-1;
for(i=0;i<MAX_CPU;i++)
{
if( cpufreq_cpu_exists(idcpu+i) ==0)
{
printf("cpuid %d found\n",idcpu+i);
ncpu=i;
}
}
switch ( ncpu ) {
case -1:
printf("no cpuid found \n");
exit(-1);
case 0:
wm_xpm=wmcpufreq_master_xpm_1;
wm_bits=wmcpufreq_mask_bits_1;
break;
case 1:
wm_xpm=wmcpufreq_master_xpm_2;
wm_bits=wmcpufreq_mask_bits_2;
break;
case 2:
wm_xpm=wmcpufreq_master_3;
wm_bits=wmcpufreq_mask_3_bits;
break;
case 3:
wm_xpm=wmcpufreq_master_3;
wm_bits=wmcpufreq_mask_3_bits;
break;
default:
printf("no yet implemented: cpuid %d \n",ncpu);
exit(-1);
break;
}
/* guess every cpu has the same limits */
if(cpufreq_get_hardware_limits(cpu, &f_min, &f_max))
{
printf("can't determine hardware limits \n");
exit(-1);
}
openXwindow(argc,argv,
wm_xpm,
(char*)wm_bits,
wmcpufreq_mask_width,
wmcpufreq_mask_height);
while(1)
{
/* Process any pending X events */
while(XPending(display))
{
XNextEvent(display, &event);
switch(event.type)
{
case Expose:
RedrawWindow();
break;
case ButtonPress:
if(strlen(prg))
execCommand(prg);
break;
case ButtonRelease:
break;
}
}
RedrawWindow();
/* get info */
for(i=0;i<=ncpu;i++)
freq[i]=cpufreq_get_freq_kernel(i+idcpu);
policy=cpufreq_get_policy(cpu);
strcpy(gov,policy->governor);
max=policy->max;
min=policy->min;
cpufreq_put_policy(policy);
/* show info */
show_mhz(freq,ncpu);
if (ncpu==0)
show_driver(drv);
show_governor(gov);
/* delay */
nanosleep(&ts,&ts1);
}
}
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;
}
