1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #ifndef _CPU_FREQUENCY_H
22 #define _CPU_FREQUENCY_H
23
24 #ifdef __cplusplus
25 extern "C"
26 {
27 #endif
28
29 #include <alloca.h>
30 #include <unistd.h> /* processor_info_t */
31 #include <fcntl.h>
32
33 typedef unsigned char uint8_t;
34
35 #define MAXSTRLEN 1024
36 /*
37 * This file provide the api to detect Intel CPU frequency variation features
38 */
39
40 #define COL_CPUFREQ_NONE 0x0000
41 #define COL_CPUFREQ_SCALING 0x0001
42 #define COL_CPUFREQ_TURBO 0x0002
43
44 #if defined(__i386__) || defined(__x86_64)
45 // XXXX This is a rough table to estimate frequency increment due to intel turbo boost.
46 // CPU with different stepping and different core number have different turbo increment.
47 // It is used internally here, and is not implemented on SPARC
48
49 // YLM: one can use cputrack to estimate max turbo frequency
50 // example: for a cpu-bound app that runs for > 10 seconds, count cycles for 10 seconds:
51 // cputrack -T 10 -v -c cpu_clk_unhalted.thread_p a.out
52
53 static int
54 get_max_turbo_freq (int model)
55 {
56 switch (model)
57 {
58 // Nehalem
59 case 30:// Core i7-870: 2/2/4/5
60 return 2 * 133333;
61 case 26:// Xeon L5520: 1/1/1/2
62 return 2 * 133333;
63 case 46:// Xeon E7540: 2
64 return 2 * 133333;
65 // Westmere
66 case 37:// Core i5-520M: 2/4
67 return 2 * 133333;
68 case 44:// Xeon E5620: 1/1/2/2
69 return 2 * 133333;
70 case 47:// Xeon E7-2820: 1/1/1/2
71 return 1 * 133333;
72 // Sandy Bridge
73 case 42:// Core i5-2500: 1/2/3/4
74 return 3 * 100000;
75 // http://ark.intel.com/products/64584/Intel-Xeon-Processor-E5-2660-20M-Cache-2_20-GHz-8_00-GTs-Intel-QPI
76 case 45:// Xeon E5-2660 GenuineIntel 206D7 family 6 model 45 step 7 clock 2200 MHz
77 return 8 * 100000;
78 // Ivy Bridge
79 case 58:// Core i7-3770: 3/4/5/5
80 return 4 * 100000;
81 case 62:// Xeon E5-2697: 3/3/3/3/3/3/3/4/5/6/7/8
82 return 7 * 100000;
83 // Haswell
84 case 60:
85 return 789000; // empirically we see 3189 MHz - 2400 MHz
86 case 63:
87 return 1280000; // empirically we see 3580 MHz - 2300 MHz for single-threaded
88 // return 500000; // empirically we see 2800 MHz - 2300 MHz for large throughput
89 // Broadwell
90 // where are these values listed?
91 // maybe try https://en.wikipedia.org/wiki/Broadwell_%28microarchitecture%29#Server_processors
92 case 61:
93 return 400000;
94 case 71:
95 return 400000;
96 case 79:
97 return 950000; // empirically we see (3550-2600) MHz for single-threaded on x6-2a
98 case 85:
99 return 1600000; // X7: empirically see ~3.7GHz with single thread, baseline is 2.1Ghz Return 3,700,000-2,100,000
100 case 31: // Nehalem?
101 case 28: // Atom
102 case 69: // Haswell
103 case 70: // Haswell
104 case 78: // Skylake
105 case 94: // Skylake
106 default:
107 return 0;
108 }
109 }
110 #endif
111
112 /*
113 * parameter: mode, pointer to a 8bit mode indicator
114 * return: max cpu frequency in MHz
115 */
116 //YXXX Updating this function? Check similar cut/paste code in:
117 // collctrl.cc::Coll_Ctrl()
118 // collector.c::log_header_write()
119 // cpu_frequency.h::get_cpu_frequency()
120
121 static int
122 get_cpu_frequency (uint8_t *mode)
123 {
124 int ret_freq = 0;
125 if (mode != NULL)
126 *mode = COL_CPUFREQ_NONE;
127 FILE *procf = fopen ("/proc/cpuinfo", "r");
128 if (procf != NULL)
129 {
130 char temp[1024];
131 int cpu = -1;
132 #if defined(__i386__) || defined(__x86_64)
133 int model = -1;
134 int family = -1;
135 #endif
136 while (fgets (temp, 1024, procf) != NULL)
137 {
138 if (strncmp (temp, "processor", strlen ("processor")) == 0)
139 {
140 char *val = strchr (temp, ':');
141 cpu = val ? atoi (val + 1) : -1;
142 }
143 #if defined(__i386__) || defined(__x86_64)
144 else if (strncmp (temp, "model", strlen ("model")) == 0
145 && strstr (temp, "name") == 0)
146 {
147 char *val = strchr (temp, ':');
148 model = val ? atoi (val + 1) : -1;
149 }
150 else if (strncmp (temp, "cpu family", strlen ("cpu family")) == 0)
151 {
152 char *val = strchr (temp, ':');
153 family = val ? atoi (val + 1) : -1;
154 }
155 #endif
156 else if (strncmp (temp, "cpu MHz", strlen ("cpu MHz")) == 0)
157 {
158 char *val = strchr (temp, ':');
159 int mhz = val ? atoi (val + 1) : 0; /* reading it as int is fine */
160 char scaling_freq_file[MAXSTRLEN + 1];
161 snprintf (scaling_freq_file, sizeof (scaling_freq_file),
162 "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_driver", cpu);
163 int intel_pstate = 0;
164 int no_turbo = 0;
165 if (access (scaling_freq_file, R_OK) == 0)
166 {
167 FILE *cpufreqd = fopen (scaling_freq_file, "r");
168 if (cpufreqd != NULL)
169 {
170 if (fgets (temp, 1024, cpufreqd) != NULL
171 && strncmp (temp, "intel_pstate", sizeof ("intel_pstate") - 1) == 0)
172 intel_pstate = 1;
173 fclose (cpufreqd);
174 }
175 }
176 snprintf (scaling_freq_file, sizeof (scaling_freq_file),
177 "/sys/devices/system/cpu/intel_pstate/no_turbo");
178 if (access (scaling_freq_file, R_OK) == 0)
179 {
180 FILE *pstatent = fopen (scaling_freq_file, "r");
181 if (pstatent != NULL)
182 {
183 if (fgets (temp, 1024, pstatent) != NULL)
184 if (strncmp (temp, "1", sizeof ("1") - 1) == 0)
185 no_turbo = 1;
186 fclose (pstatent);
187 }
188 }
189
190 snprintf (scaling_freq_file, sizeof (scaling_freq_file),
191 "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_governor", cpu);
192 int frequency_scaling = 0;
193 int turbo_mode = 0;
194 if (access (scaling_freq_file, R_OK) == 0)
195 {
196 FILE *cpufreqf = fopen (scaling_freq_file, "r");
197 if (cpufreqf != NULL)
198 {
199 if (fgets (temp, 1024, cpufreqf) != NULL)
200 {
201 int ondemand = 0;
202 if (strncmp (temp, "ondemand", sizeof ("ondemand") - 1) == 0)
203 ondemand = 1;
204 int performance = 0;
205 if (strncmp (temp, "performance", sizeof ("performance") - 1) == 0)
206 performance = 1;
207 int powersave = 0;
208 if (strncmp (temp, "powersave", sizeof ("powersave") - 1) == 0)
209 powersave = 1;
210 if (intel_pstate || ondemand || performance)
211 {
212 snprintf (scaling_freq_file, sizeof (scaling_freq_file),
213 "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_max_freq", cpu);
214 if (access (scaling_freq_file, R_OK) == 0)
215 {
216 FILE * cpufreqf_max;
217 if ((cpufreqf_max = fopen (scaling_freq_file, "r")) != NULL)
218 {
219 if (fgets (temp, 1024, cpufreqf_max) != NULL)
220 {
221 int tmpmhz = atoi (temp);
222 snprintf (scaling_freq_file, sizeof (scaling_freq_file),
223 "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_available_frequencies", cpu);
224 if (intel_pstate)
225 {
226 frequency_scaling = 1;
227 turbo_mode = !no_turbo;
228 if (powersave)
229 // the system might have been relatively cold
230 // so we might do better with scaling_max_freq
231 mhz = (int) (((double) tmpmhz / 1000.0) + 0.5);
232 }
233 else if (access (scaling_freq_file, R_OK) == 0)
234 {
235 FILE * cpufreqf_ava;
236 if ((cpufreqf_ava = fopen (scaling_freq_file, "r")) != NULL)
237 {
238 if (fgets (temp, 1024, cpufreqf_ava) != NULL)
239 {
240 if (strchr (temp, ' ') != strrchr (temp, ' ') && ondemand)
241 frequency_scaling = 1;
242 if (tmpmhz > 1000)
243 {
244 #if defined(__i386__) || defined(__x86_64)
245 if (family == 6)
246 {
247 // test turbo mode
248 char non_turbo_max_freq[1024];
249 snprintf (non_turbo_max_freq, sizeof (non_turbo_max_freq),
250 "%d", tmpmhz - 1000);
251 if (strstr (temp, non_turbo_max_freq))
252 {
253 turbo_mode = 1;
254 tmpmhz = (tmpmhz - 1000) + get_max_turbo_freq (model);
255 }
256 }
257 #endif
258 }
259 }
260 fclose (cpufreqf_ava);
261 }
262 mhz = (int) (((double) tmpmhz / 1000.0) + 0.5);
263 }
264 }
265 fclose (cpufreqf_max);
266 }
267 }
268 }
269 }
270 fclose (cpufreqf);
271 }
272 }
273 if (mhz > ret_freq)
274 ret_freq = mhz;
275 if (frequency_scaling && mode != NULL)
276 *mode |= COL_CPUFREQ_SCALING;
277 if (turbo_mode && mode != NULL)
278 *mode |= COL_CPUFREQ_TURBO;
279 }
280 else if (strncmp (temp, "Cpu", 3) == 0 && temp[3] != '\0' &&
281 strncmp (strchr (temp + 1, 'C') ? strchr (temp + 1, 'C') : (temp + 4), "ClkTck", 6) == 0)
282 { // sparc-Linux
283 char *val = strchr (temp, ':');
284 if (val)
285 {
286 unsigned long long freq;
287 sscanf (val + 2, "%llx", &freq);
288 int mhz = (unsigned int) (((double) freq) / 1000000.0 + 0.5);
289 if (mhz > ret_freq)
290 ret_freq = mhz;
291 }
292 }
293 }
294 fclose (procf);
295 }
296 return ret_freq;
297 }
298
299 #ifdef __cplusplus
300 }
301 #endif
302
303 #endif /*_CPU_FREQUENCY_H*/