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;
}
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;
}
int set_cpufreq_governor(char *governor, unsigned int cpu)
{
dprintf("set %s as cpufreq governor\n", governor);
if (cpufreq_cpu_exists(cpu) != 0) {
perror("cpufreq_cpu_exists");
fprintf(stderr, "error: cpu %u does not exist\n", cpu);
return -1;
}
if (cpufreq_modify_policy_governor(cpu, governor) != 0) {
perror("cpufreq_modify_policy_governor");
fprintf(stderr, "error: unable to set %s governor\n", governor);
return -1;
}
return 0;
}
int cmd_freq_set(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
int ret = 0, cont = 1;
int double_parm = 0, related = 0, policychange = 0;
unsigned long freq = 0;
char gov[20];
unsigned int cpu;
struct cpufreq_policy new_pol = {
.min = 0,
.max = 0,
.governor = NULL,
};
/* parameter parsing */
do {
ret = getopt_long(argc, argv, "d:u:g:f:hr", set_opts, NULL);
switch (ret) {
case '?':
print_unknown_arg();
return -EINVAL;
case 'h':
freq_set_help();
return 0;
case -1:
cont = 0;
break;
case 'r':
if (related)
double_parm++;
related++;
break;
case 'd':
if (new_pol.min)
double_parm++;
policychange++;
new_pol.min = string_to_frequency(optarg);
if (new_pol.min == 0) {
print_unknown_arg();
return -EINVAL;
}
break;
case 'u':
if (new_pol.max)
double_parm++;
policychange++;
new_pol.max = string_to_frequency(optarg);
if (new_pol.max == 0) {
print_unknown_arg();
return -EINVAL;
}
break;
case 'f':
if (freq)
double_parm++;
freq = string_to_frequency(optarg);
if (freq == 0) {
print_unknown_arg();
return -EINVAL;
}
break;
case 'g':
if (new_pol.governor)
double_parm++;
policychange++;
if ((strlen(optarg) < 3) || (strlen(optarg) > 18)) {
print_unknown_arg();
return -EINVAL;
}
if ((sscanf(optarg, "%s", gov)) != 1) {
print_unknown_arg();
return -EINVAL;
}
new_pol.governor = gov;
break;
}
} while (cont);
/* parameter checking */
if (double_parm) {
printf("the same parameter was passed more than once\n");
return -EINVAL;
}
if (freq && policychange) {
printf(_("the -f/--freq parameter cannot be combined with -d/--min, -u/--max or\n"
"-g/--governor parameters\n"));
return -EINVAL;
}
if (!freq && !policychange) {
printf(_("At least one parameter out of -f/--freq, -d/--min, -u/--max, and\n"
"-g/--governor must be passed\n"));
return -EINVAL;
}
/* Default is: set all CPUs */
if (bitmask_isallclear(cpus_chosen))
bitmask_setall(cpus_chosen);
/* Also set frequency settings for related CPUs if -r is passed */
if (related) {
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
struct cpufreq_affected_cpus *cpus;
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
cpus = cpufreq_get_related_cpus(cpu);
if (!cpus)
break;
while (cpus->next) {
bitmask_setbit(cpus_chosen, cpus->cpu);
cpus = cpus->next;
}
cpufreq_put_related_cpus(cpus);
}
}
/* loop over CPUs */
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
printf(_("Setting cpu: %d\n"), cpu);
ret = do_one_cpu(cpu, &new_pol, freq, policychange);
if (ret)
break;
}
if (ret)
print_error();
return ret;
}
int cmd_idle_info(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
int ret = 0, cont = 1, output_param = 0, verbose = 1;
unsigned int cpu = 0;
do {
ret = getopt_long(argc, argv, "os", info_opts, NULL);
if (ret == -1)
break;
switch (ret) {
case '?':
output_param = '?';
cont = 0;
break;
case 's':
verbose = 0;
break;
case -1:
cont = 0;
break;
case 'o':
if (output_param) {
output_param = -1;
cont = 0;
break;
}
output_param = ret;
break;
}
} while (cont);
switch (output_param) {
case -1:
printf(_("You can't specify more than one "
"output-specific argument\n"));
cpuidle_exit(EXIT_FAILURE);
case '?':
printf(_("invalid or unknown argument\n"));
cpuidle_exit(EXIT_FAILURE);
}
/* Default is: show output of CPU 0 only */
if (bitmask_isallclear(cpus_chosen))
bitmask_setbit(cpus_chosen, 0);
if (output_param == 0)
cpuidle_general_output();
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
switch (output_param) {
case 'o':
proc_cpuidle_cpu_output(cpu);
break;
case 0:
printf("\n");
cpuidle_cpu_output(cpu, verbose);
break;
}
}
return EXIT_SUCCESS;
}
int cmd_set(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
unsigned int cpu;
union {
struct {
int perf_bias:1;
};
int params;
} params;
int perf_bias = 0;
int ret = 0;
setlocale(LC_ALL, "");
textdomain(PACKAGE);
params.params = 0;
/* parameter parsing */
while ((ret = getopt_long(argc, argv, "b:",
set_opts, NULL)) != -1) {
switch (ret) {
case 'b':
if (params.perf_bias)
print_wrong_arg_exit();
perf_bias = atoi(optarg);
if (perf_bias < 0 || perf_bias > 15) {
printf(_("--perf-bias param out "
"of range [0-%d]\n"), 15);
print_wrong_arg_exit();
}
params.perf_bias = 1;
break;
default:
print_wrong_arg_exit();
}
};
if (!params.params)
print_wrong_arg_exit();
/* Default is: set all CPUs */
if (bitmask_isallclear(cpus_chosen))
bitmask_setall(cpus_chosen);
/* loop over CPUs */
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
if (params.perf_bias) {
ret = msr_intel_set_perf_bias(cpu, perf_bias);
if (ret) {
fprintf(stderr, _("Error setting perf-bias "
"value on CPU %d\n"), cpu);
break;
}
}
}
return ret;
}
int cmd_set(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
unsigned int cpu;
union {
struct {
int sched_mc:1;
int sched_smt:1;
int perf_bias:1;
};
int params;
} params;
int sched_mc = 0, sched_smt = 0, perf_bias = 0;
int ret = 0;
setlocale(LC_ALL, "");
textdomain(PACKAGE);
params.params = 0;
while ((ret = getopt_long(argc, argv, "m:s:b:",
set_opts, NULL)) != -1) {
switch (ret) {
case 'b':
if (params.perf_bias)
print_wrong_arg_exit();
perf_bias = atoi(optarg);
if (perf_bias < 0 || perf_bias > 15) {
printf(_("--perf-bias param out "
"of range [0-%d]\n"), 15);
print_wrong_arg_exit();
}
params.perf_bias = 1;
break;
case 'm':
if (params.sched_mc)
print_wrong_arg_exit();
sched_mc = atoi(optarg);
if (sched_mc < 0 || sched_mc > 2) {
printf(_("--sched-mc param out "
"of range [0-%d]\n"), 2);
print_wrong_arg_exit();
}
params.sched_mc = 1;
break;
case 's':
if (params.sched_smt)
print_wrong_arg_exit();
sched_smt = atoi(optarg);
if (sched_smt < 0 || sched_smt > 2) {
printf(_("--sched-smt param out "
"of range [0-%d]\n"), 2);
print_wrong_arg_exit();
}
params.sched_smt = 1;
break;
default:
print_wrong_arg_exit();
}
};
if (!params.params)
print_wrong_arg_exit();
if (params.sched_mc) {
ret = sysfs_set_sched("mc", sched_mc);
if (ret)
fprintf(stderr, _("Error setting sched-mc %s\n"),
(ret == -ENODEV) ? "not supported" : "");
}
if (params.sched_smt) {
ret = sysfs_set_sched("smt", sched_smt);
if (ret)
fprintf(stderr, _("Error setting sched-smt %s\n"),
(ret == -ENODEV) ? "not supported" : "");
}
if (bitmask_isallclear(cpus_chosen))
bitmask_setall(cpus_chosen);
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
if (params.perf_bias) {
ret = msr_intel_set_perf_bias(cpu, perf_bias);
if (ret) {
fprintf(stderr, _("Error setting perf-bias "
"value on CPU %d\n"), cpu);
break;
}
}
}
return ret;
}
int cmd_info(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
unsigned int cpu;
union {
struct {
int perf_bias:1;
};
int params;
} params = {};
int ret = 0;
setlocale(LC_ALL, "");
textdomain(PACKAGE);
/* parameter parsing */
while ((ret = getopt_long(argc, argv, "b", set_opts, NULL)) != -1) {
switch (ret) {
case 'b':
if (params.perf_bias)
print_wrong_arg_exit();
params.perf_bias = 1;
break;
default:
print_wrong_arg_exit();
}
};
if (!params.params)
params.params = 0x7;
/* Default is: show output of CPU 0 only */
if (bitmask_isallclear(cpus_chosen))
bitmask_setbit(cpus_chosen, 0);
/* Add more per cpu options here */
if (!params.perf_bias)
return ret;
if (params.perf_bias) {
if (!run_as_root) {
params.perf_bias = 0;
printf(_("Intel's performance bias setting needs root privileges\n"));
} else if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_PERF_BIAS)) {
printf(_("System does not support Intel's performance"
" bias setting\n"));
params.perf_bias = 0;
}
}
/* loop over CPUs */
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
printf(_("analyzing CPU %d:\n"), cpu);
if (params.perf_bias) {
ret = msr_intel_get_perf_bias(cpu);
if (ret < 0) {
fprintf(stderr,
_("Could not read perf-bias value[%d]\n"), ret);
exit(EXIT_FAILURE);
} else
printf(_("perf-bias: %d\n"), ret);
}
}
return 0;
}
int cmd_info(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr, optopt;
unsigned int cpu;
union {
struct {
int sched_mc:1;
int sched_smt:1;
int perf_bias:1;
};
int params;
} params = {};
int ret = 0;
setlocale(LC_ALL, "");
textdomain(PACKAGE);
while ((ret = getopt_long(argc, argv, "msb", set_opts, NULL)) != -1) {
switch (ret) {
case 'b':
if (params.perf_bias)
print_wrong_arg_exit();
params.perf_bias = 1;
break;
case 'm':
if (params.sched_mc)
print_wrong_arg_exit();
params.sched_mc = 1;
break;
case 's':
if (params.sched_smt)
print_wrong_arg_exit();
params.sched_smt = 1;
break;
default:
print_wrong_arg_exit();
}
};
if (!params.params)
params.params = 0x7;
if (bitmask_isallclear(cpus_chosen))
bitmask_setbit(cpus_chosen, 0);
if (params.sched_mc) {
ret = sysfs_get_sched("mc");
printf(_("System's multi core scheduler setting: "));
if (ret < 0)
printf(_("not supported\n"));
else
printf("%d\n", ret);
}
if (params.sched_smt) {
ret = sysfs_get_sched("smt");
printf(_("System's thread sibling scheduler setting: "));
if (ret < 0)
printf(_("not supported\n"));
else
printf("%d\n", ret);
}
if (!params.perf_bias)
return ret;
if (params.perf_bias) {
if (!run_as_root) {
params.perf_bias = 0;
printf(_("Intel's performance bias setting needs root privileges\n"));
} else if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_PERF_BIAS)) {
printf(_("System does not support Intel's performance"
" bias setting\n"));
params.perf_bias = 0;
}
}
for (cpu = bitmask_first(cpus_chosen);
cpu <= bitmask_last(cpus_chosen); cpu++) {
if (!bitmask_isbitset(cpus_chosen, cpu) ||
cpufreq_cpu_exists(cpu))
continue;
printf(_("analyzing CPU %d:\n"), cpu);
if (params.perf_bias) {
ret = msr_intel_get_perf_bias(cpu);
if (ret < 0) {
printf(_("Could not read perf-bias value\n"));
break;
} else
printf(_("perf-bias: %d\n"), ret);
}
}
return ret;
}
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);
}
}
