1 #include <stddef.h>
2 #include <stdint.h>
3 #include <stdlib.h>
4 #include <string.h>
5
6 #include <cpuinfo.h>
7 #include <cpuinfo/internal-api.h>
8 #include <cpuinfo/log.h>
9 #include <linux/api.h>
10 #include <x86/api.h>
11 #include <x86/linux/api.h>
12
bit_mask(uint32_t bits)13 static inline uint32_t bit_mask(uint32_t bits) {
14 return (UINT32_C(1) << bits) - UINT32_C(1);
15 }
16
bitmask_all(uint32_t bitfield,uint32_t mask)17 static inline bool bitmask_all(uint32_t bitfield, uint32_t mask) {
18 return (bitfield & mask) == mask;
19 }
20
min(uint32_t a,uint32_t b)21 static inline uint32_t min(uint32_t a, uint32_t b) {
22 return a < b ? a : b;
23 }
24
cmp(uint32_t a,uint32_t b)25 static inline int cmp(uint32_t a, uint32_t b) {
26 return (a > b) - (a < b);
27 }
28
cmp_x86_linux_processor(const void * ptr_a,const void * ptr_b)29 static int cmp_x86_linux_processor(const void* ptr_a, const void* ptr_b) {
30 const struct cpuinfo_x86_linux_processor* processor_a = (const struct cpuinfo_x86_linux_processor*)ptr_a;
31 const struct cpuinfo_x86_linux_processor* processor_b = (const struct cpuinfo_x86_linux_processor*)ptr_b;
32
33 /* Move usable processors towards the start of the array */
34 const bool usable_a = bitmask_all(processor_a->flags, CPUINFO_LINUX_FLAG_VALID);
35 const bool usable_b = bitmask_all(processor_b->flags, CPUINFO_LINUX_FLAG_VALID);
36 if (usable_a != usable_b) {
37 return (int)usable_b - (int)usable_a;
38 }
39
40 /* Compare based on APIC ID (i.e. processor 0 < processor 1) */
41 const uint32_t id_a = processor_a->apic_id;
42 const uint32_t id_b = processor_b->apic_id;
43 return cmp(id_a, id_b);
44 }
45
cpuinfo_x86_count_objects(uint32_t linux_processors_count,const struct cpuinfo_x86_linux_processor linux_processors[restrict static linux_processors_count],const struct cpuinfo_x86_processor processor[restrict static1],uint32_t valid_processor_mask,uint32_t llc_apic_bits,uint32_t cores_count_ptr[restrict static1],uint32_t clusters_count_ptr[restrict static1],uint32_t packages_count_ptr[restrict static1],uint32_t l1i_count_ptr[restrict static1],uint32_t l1d_count_ptr[restrict static1],uint32_t l2_count_ptr[restrict static1],uint32_t l3_count_ptr[restrict static1],uint32_t l4_count_ptr[restrict static1])46 static void cpuinfo_x86_count_objects(
47 uint32_t linux_processors_count,
48 const struct cpuinfo_x86_linux_processor linux_processors[restrict static linux_processors_count],
49 const struct cpuinfo_x86_processor processor[restrict static 1],
50 uint32_t valid_processor_mask,
51 uint32_t llc_apic_bits,
52 uint32_t cores_count_ptr[restrict static 1],
53 uint32_t clusters_count_ptr[restrict static 1],
54 uint32_t packages_count_ptr[restrict static 1],
55 uint32_t l1i_count_ptr[restrict static 1],
56 uint32_t l1d_count_ptr[restrict static 1],
57 uint32_t l2_count_ptr[restrict static 1],
58 uint32_t l3_count_ptr[restrict static 1],
59 uint32_t l4_count_ptr[restrict static 1]) {
60 const uint32_t core_apic_mask =
61 ~(bit_mask(processor->topology.thread_bits_length) << processor->topology.thread_bits_offset);
62 const uint32_t package_apic_mask = core_apic_mask &
63 ~(bit_mask(processor->topology.core_bits_length) << processor->topology.core_bits_offset);
64 const uint32_t llc_apic_mask = ~bit_mask(llc_apic_bits);
65 const uint32_t cluster_apic_mask = package_apic_mask | llc_apic_mask;
66
67 uint32_t cores_count = 0, clusters_count = 0, packages_count = 0;
68 uint32_t l1i_count = 0, l1d_count = 0, l2_count = 0, l3_count = 0, l4_count = 0;
69 uint32_t last_core_id = UINT32_MAX, last_cluster_id = UINT32_MAX, last_package_id = UINT32_MAX;
70 uint32_t last_l1i_id = UINT32_MAX, last_l1d_id = UINT32_MAX;
71 uint32_t last_l2_id = UINT32_MAX, last_l3_id = UINT32_MAX, last_l4_id = UINT32_MAX;
72 for (uint32_t i = 0; i < linux_processors_count; i++) {
73 if (bitmask_all(linux_processors[i].flags, valid_processor_mask)) {
74 const uint32_t apic_id = linux_processors[i].apic_id;
75 cpuinfo_log_debug(
76 "APID ID %" PRIu32 ": system processor %" PRIu32,
77 apic_id,
78 linux_processors[i].linux_id);
79
80 /* All bits of APIC ID except thread ID mask */
81 const uint32_t core_id = apic_id & core_apic_mask;
82 if (core_id != last_core_id) {
83 last_core_id = core_id;
84 cores_count++;
85 }
86 /* All bits of APIC ID except thread ID and core ID
87 * masks */
88 const uint32_t package_id = apic_id & package_apic_mask;
89 if (package_id != last_package_id) {
90 last_package_id = package_id;
91 packages_count++;
92 }
93 /* Bits of APIC ID which are part of either LLC or
94 * package ID mask */
95 const uint32_t cluster_id = apic_id & cluster_apic_mask;
96 if (cluster_id != last_cluster_id) {
97 last_cluster_id = cluster_id;
98 clusters_count++;
99 }
100 if (processor->cache.l1i.size != 0) {
101 const uint32_t l1i_id = apic_id & ~bit_mask(processor->cache.l1i.apic_bits);
102 if (l1i_id != last_l1i_id) {
103 last_l1i_id = l1i_id;
104 l1i_count++;
105 }
106 }
107 if (processor->cache.l1d.size != 0) {
108 const uint32_t l1d_id = apic_id & ~bit_mask(processor->cache.l1d.apic_bits);
109 if (l1d_id != last_l1d_id) {
110 last_l1d_id = l1d_id;
111 l1d_count++;
112 }
113 }
114 if (processor->cache.l2.size != 0) {
115 const uint32_t l2_id = apic_id & ~bit_mask(processor->cache.l2.apic_bits);
116 if (l2_id != last_l2_id) {
117 last_l2_id = l2_id;
118 l2_count++;
119 }
120 }
121 if (processor->cache.l3.size != 0) {
122 const uint32_t l3_id = apic_id & ~bit_mask(processor->cache.l3.apic_bits);
123 if (l3_id != last_l3_id) {
124 last_l3_id = l3_id;
125 l3_count++;
126 }
127 }
128 if (processor->cache.l4.size != 0) {
129 const uint32_t l4_id = apic_id & ~bit_mask(processor->cache.l4.apic_bits);
130 if (l4_id != last_l4_id) {
131 last_l4_id = l4_id;
132 l4_count++;
133 }
134 }
135 }
136 }
137 *cores_count_ptr = cores_count;
138 *clusters_count_ptr = clusters_count;
139 *packages_count_ptr = packages_count;
140 *l1i_count_ptr = l1i_count;
141 *l1d_count_ptr = l1d_count;
142 *l2_count_ptr = l2_count;
143 *l3_count_ptr = l3_count;
144 *l4_count_ptr = l4_count;
145 }
146
cpuinfo_x86_linux_init(void)147 void cpuinfo_x86_linux_init(void) {
148 struct cpuinfo_x86_linux_processor* x86_linux_processors = NULL;
149 struct cpuinfo_processor* processors = NULL;
150 struct cpuinfo_core* cores = NULL;
151 struct cpuinfo_cluster* clusters = NULL;
152 struct cpuinfo_package* packages = NULL;
153 const struct cpuinfo_processor** linux_cpu_to_processor_map = NULL;
154 const struct cpuinfo_core** linux_cpu_to_core_map = NULL;
155 struct cpuinfo_cache* l1i = NULL;
156 struct cpuinfo_cache* l1d = NULL;
157 struct cpuinfo_cache* l2 = NULL;
158 struct cpuinfo_cache* l3 = NULL;
159 struct cpuinfo_cache* l4 = NULL;
160
161 const uint32_t max_processors_count = cpuinfo_linux_get_max_processors_count();
162 cpuinfo_log_debug("system maximum processors count: %" PRIu32, max_processors_count);
163
164 const uint32_t max_possible_processors_count =
165 1 + cpuinfo_linux_get_max_possible_processor(max_processors_count);
166 cpuinfo_log_debug("maximum possible processors count: %" PRIu32, max_possible_processors_count);
167 const uint32_t max_present_processors_count = 1 + cpuinfo_linux_get_max_present_processor(max_processors_count);
168 cpuinfo_log_debug("maximum present processors count: %" PRIu32, max_present_processors_count);
169
170 uint32_t valid_processor_mask = 0;
171 uint32_t x86_linux_processors_count = max_processors_count;
172 if (max_present_processors_count != 0) {
173 x86_linux_processors_count = min(x86_linux_processors_count, max_present_processors_count);
174 valid_processor_mask = CPUINFO_LINUX_FLAG_PRESENT;
175 } else {
176 valid_processor_mask = CPUINFO_LINUX_FLAG_PROC_CPUINFO;
177 }
178 if (max_possible_processors_count != 0) {
179 x86_linux_processors_count = min(x86_linux_processors_count, max_possible_processors_count);
180 valid_processor_mask |= CPUINFO_LINUX_FLAG_POSSIBLE;
181 }
182
183 x86_linux_processors = calloc(x86_linux_processors_count, sizeof(struct cpuinfo_x86_linux_processor));
184 if (x86_linux_processors == NULL) {
185 cpuinfo_log_error(
186 "failed to allocate %zu bytes for descriptions of %" PRIu32 " x86 logical processors",
187 x86_linux_processors_count * sizeof(struct cpuinfo_x86_linux_processor),
188 x86_linux_processors_count);
189 return;
190 }
191
192 if (max_possible_processors_count != 0) {
193 cpuinfo_linux_detect_possible_processors(
194 x86_linux_processors_count,
195 &x86_linux_processors->flags,
196 sizeof(struct cpuinfo_x86_linux_processor),
197 CPUINFO_LINUX_FLAG_POSSIBLE);
198 }
199
200 if (max_present_processors_count != 0) {
201 cpuinfo_linux_detect_present_processors(
202 x86_linux_processors_count,
203 &x86_linux_processors->flags,
204 sizeof(struct cpuinfo_x86_linux_processor),
205 CPUINFO_LINUX_FLAG_PRESENT);
206 }
207
208 if (!cpuinfo_x86_linux_parse_proc_cpuinfo(x86_linux_processors_count, x86_linux_processors)) {
209 cpuinfo_log_error("failed to parse processor information from /proc/cpuinfo");
210 return;
211 }
212
213 for (uint32_t i = 0; i < x86_linux_processors_count; i++) {
214 if (bitmask_all(x86_linux_processors[i].flags, valid_processor_mask)) {
215 x86_linux_processors[i].flags |= CPUINFO_LINUX_FLAG_VALID;
216 }
217 }
218
219 struct cpuinfo_x86_processor x86_processor;
220 memset(&x86_processor, 0, sizeof(x86_processor));
221 cpuinfo_x86_init_processor(&x86_processor);
222 char brand_string[48];
223 cpuinfo_x86_normalize_brand_string(x86_processor.brand_string, brand_string);
224
225 uint32_t processors_count = 0;
226 for (uint32_t i = 0; i < x86_linux_processors_count; i++) {
227 if (bitmask_all(x86_linux_processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) {
228 x86_linux_processors[i].linux_id = i;
229 processors_count++;
230 }
231 }
232
233 qsort(x86_linux_processors,
234 x86_linux_processors_count,
235 sizeof(struct cpuinfo_x86_linux_processor),
236 cmp_x86_linux_processor);
237
238 processors = calloc(processors_count, sizeof(struct cpuinfo_processor));
239 if (processors == NULL) {
240 cpuinfo_log_error(
241 "failed to allocate %zu bytes for descriptions of %" PRIu32 " logical processors",
242 processors_count * sizeof(struct cpuinfo_processor),
243 processors_count);
244 goto cleanup;
245 }
246
247 uint32_t llc_apic_bits = 0;
248 if (x86_processor.cache.l4.size != 0) {
249 llc_apic_bits = x86_processor.cache.l4.apic_bits;
250 } else if (x86_processor.cache.l3.size != 0) {
251 llc_apic_bits = x86_processor.cache.l3.apic_bits;
252 } else if (x86_processor.cache.l2.size != 0) {
253 llc_apic_bits = x86_processor.cache.l2.apic_bits;
254 } else if (x86_processor.cache.l1d.size != 0) {
255 llc_apic_bits = x86_processor.cache.l1d.apic_bits;
256 }
257 uint32_t packages_count = 0, clusters_count = 0, cores_count = 0;
258 uint32_t l1i_count = 0, l1d_count = 0, l2_count = 0, l3_count = 0, l4_count = 0;
259 cpuinfo_x86_count_objects(
260 x86_linux_processors_count,
261 x86_linux_processors,
262 &x86_processor,
263 valid_processor_mask,
264 llc_apic_bits,
265 &cores_count,
266 &clusters_count,
267 &packages_count,
268 &l1i_count,
269 &l1d_count,
270 &l2_count,
271 &l3_count,
272 &l4_count);
273
274 cpuinfo_log_debug("detected %" PRIu32 " cores", cores_count);
275 cpuinfo_log_debug("detected %" PRIu32 " clusters", clusters_count);
276 cpuinfo_log_debug("detected %" PRIu32 " packages", packages_count);
277 cpuinfo_log_debug("detected %" PRIu32 " L1I caches", l1i_count);
278 cpuinfo_log_debug("detected %" PRIu32 " L1D caches", l1d_count);
279 cpuinfo_log_debug("detected %" PRIu32 " L2 caches", l2_count);
280 cpuinfo_log_debug("detected %" PRIu32 " L3 caches", l3_count);
281 cpuinfo_log_debug("detected %" PRIu32 " L4 caches", l4_count);
282
283 linux_cpu_to_processor_map = calloc(x86_linux_processors_count, sizeof(struct cpuinfo_processor*));
284 if (linux_cpu_to_processor_map == NULL) {
285 cpuinfo_log_error(
286 "failed to allocate %zu bytes for mapping entries of %" PRIu32 " logical processors",
287 x86_linux_processors_count * sizeof(struct cpuinfo_processor*),
288 x86_linux_processors_count);
289 goto cleanup;
290 }
291
292 linux_cpu_to_core_map = calloc(x86_linux_processors_count, sizeof(struct cpuinfo_core*));
293 if (linux_cpu_to_core_map == NULL) {
294 cpuinfo_log_error(
295 "failed to allocate %zu bytes for mapping entries of %" PRIu32 " cores",
296 x86_linux_processors_count * sizeof(struct cpuinfo_core*),
297 x86_linux_processors_count);
298 goto cleanup;
299 }
300
301 cores = calloc(cores_count, sizeof(struct cpuinfo_core));
302 if (cores == NULL) {
303 cpuinfo_log_error(
304 "failed to allocate %zu bytes for descriptions of %" PRIu32 " cores",
305 cores_count * sizeof(struct cpuinfo_core),
306 cores_count);
307 goto cleanup;
308 }
309
310 clusters = calloc(clusters_count, sizeof(struct cpuinfo_cluster));
311 if (clusters == NULL) {
312 cpuinfo_log_error(
313 "failed to allocate %zu bytes for descriptions of %" PRIu32 " core clusters",
314 clusters_count * sizeof(struct cpuinfo_cluster),
315 clusters_count);
316 goto cleanup;
317 }
318
319 packages = calloc(packages_count, sizeof(struct cpuinfo_package));
320 if (packages == NULL) {
321 cpuinfo_log_error(
322 "failed to allocate %zu bytes for descriptions of %" PRIu32 " physical packages",
323 packages_count * sizeof(struct cpuinfo_package),
324 packages_count);
325 goto cleanup;
326 }
327
328 if (l1i_count != 0) {
329 l1i = calloc(l1i_count, sizeof(struct cpuinfo_cache));
330 if (l1i == NULL) {
331 cpuinfo_log_error(
332 "failed to allocate %zu bytes for descriptions of %" PRIu32 " L1I caches",
333 l1i_count * sizeof(struct cpuinfo_cache),
334 l1i_count);
335 goto cleanup;
336 }
337 }
338 if (l1d_count != 0) {
339 l1d = calloc(l1d_count, sizeof(struct cpuinfo_cache));
340 if (l1d == NULL) {
341 cpuinfo_log_error(
342 "failed to allocate %zu bytes for descriptions of %" PRIu32 " L1D caches",
343 l1d_count * sizeof(struct cpuinfo_cache),
344 l1d_count);
345 goto cleanup;
346 }
347 }
348 if (l2_count != 0) {
349 l2 = calloc(l2_count, sizeof(struct cpuinfo_cache));
350 if (l2 == NULL) {
351 cpuinfo_log_error(
352 "failed to allocate %zu bytes for descriptions of %" PRIu32 " L2 caches",
353 l2_count * sizeof(struct cpuinfo_cache),
354 l2_count);
355 goto cleanup;
356 }
357 }
358 if (l3_count != 0) {
359 l3 = calloc(l3_count, sizeof(struct cpuinfo_cache));
360 if (l3 == NULL) {
361 cpuinfo_log_error(
362 "failed to allocate %zu bytes for descriptions of %" PRIu32 " L3 caches",
363 l3_count * sizeof(struct cpuinfo_cache),
364 l3_count);
365 goto cleanup;
366 }
367 }
368 if (l4_count != 0) {
369 l4 = calloc(l4_count, sizeof(struct cpuinfo_cache));
370 if (l4 == NULL) {
371 cpuinfo_log_error(
372 "failed to allocate %zu bytes for descriptions of %" PRIu32 " L4 caches",
373 l4_count * sizeof(struct cpuinfo_cache),
374 l4_count);
375 goto cleanup;
376 }
377 }
378
379 const uint32_t core_apic_mask =
380 ~(bit_mask(x86_processor.topology.thread_bits_length) << x86_processor.topology.thread_bits_offset);
381 const uint32_t package_apic_mask = core_apic_mask &
382 ~(bit_mask(x86_processor.topology.core_bits_length) << x86_processor.topology.core_bits_offset);
383 const uint32_t llc_apic_mask = ~bit_mask(llc_apic_bits);
384 const uint32_t cluster_apic_mask = package_apic_mask | llc_apic_mask;
385
386 uint32_t processor_index = UINT32_MAX, core_index = UINT32_MAX, cluster_index = UINT32_MAX,
387 package_index = UINT32_MAX;
388 uint32_t l1i_index = UINT32_MAX, l1d_index = UINT32_MAX, l2_index = UINT32_MAX, l3_index = UINT32_MAX,
389 l4_index = UINT32_MAX;
390 uint32_t cluster_id = 0, core_id = 0, smt_id = 0;
391 uint32_t last_apic_core_id = UINT32_MAX, last_apic_cluster_id = UINT32_MAX, last_apic_package_id = UINT32_MAX;
392 uint32_t last_l1i_id = UINT32_MAX, last_l1d_id = UINT32_MAX;
393 uint32_t last_l2_id = UINT32_MAX, last_l3_id = UINT32_MAX, last_l4_id = UINT32_MAX;
394 for (uint32_t i = 0; i < x86_linux_processors_count; i++) {
395 if (bitmask_all(x86_linux_processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) {
396 const uint32_t apic_id = x86_linux_processors[i].apic_id;
397 processor_index++;
398 smt_id++;
399
400 /* All bits of APIC ID except thread ID mask */
401 const uint32_t apid_core_id = apic_id & core_apic_mask;
402 if (apid_core_id != last_apic_core_id) {
403 core_index++;
404 core_id++;
405 smt_id = 0;
406 }
407 /* Bits of APIC ID which are part of either LLC or
408 * package ID mask */
409 const uint32_t apic_cluster_id = apic_id & cluster_apic_mask;
410 if (apic_cluster_id != last_apic_cluster_id) {
411 cluster_index++;
412 cluster_id++;
413 }
414 /* All bits of APIC ID except thread ID and core ID
415 * masks */
416 const uint32_t apic_package_id = apic_id & package_apic_mask;
417 if (apic_package_id != last_apic_package_id) {
418 package_index++;
419 core_id = 0;
420 cluster_id = 0;
421 }
422
423 /* Initialize logical processor object */
424 processors[processor_index].smt_id = smt_id;
425 processors[processor_index].core = cores + core_index;
426 processors[processor_index].cluster = clusters + cluster_index;
427 processors[processor_index].package = packages + package_index;
428 processors[processor_index].linux_id = x86_linux_processors[i].linux_id;
429 processors[processor_index].apic_id = x86_linux_processors[i].apic_id;
430
431 if (apid_core_id != last_apic_core_id) {
432 /* new core */
433 cores[core_index] = (struct cpuinfo_core){
434 .processor_start = processor_index,
435 .processor_count = 1,
436 .core_id = core_id,
437 .cluster = clusters + cluster_index,
438 .package = packages + package_index,
439 .vendor = x86_processor.vendor,
440 .uarch = x86_processor.uarch,
441 .cpuid = x86_processor.cpuid,
442 };
443 clusters[cluster_index].core_count += 1;
444 packages[package_index].core_count += 1;
445 last_apic_core_id = apid_core_id;
446 } else {
447 /* another logical processor on the same core */
448 cores[core_index].processor_count++;
449 }
450
451 if (apic_cluster_id != last_apic_cluster_id) {
452 /* new cluster */
453 clusters[cluster_index].processor_start = processor_index;
454 clusters[cluster_index].processor_count = 1;
455 clusters[cluster_index].core_start = core_index;
456 clusters[cluster_index].cluster_id = cluster_id;
457 clusters[cluster_index].package = packages + package_index;
458 clusters[cluster_index].vendor = x86_processor.vendor;
459 clusters[cluster_index].uarch = x86_processor.uarch;
460 clusters[cluster_index].cpuid = x86_processor.cpuid;
461 packages[package_index].cluster_count += 1;
462 last_apic_cluster_id = apic_cluster_id;
463 } else {
464 /* another logical processor on the same cluster
465 */
466 clusters[cluster_index].processor_count++;
467 }
468
469 if (apic_package_id != last_apic_package_id) {
470 /* new package */
471 packages[package_index].processor_start = processor_index;
472 packages[package_index].processor_count = 1;
473 packages[package_index].core_start = core_index;
474 packages[package_index].cluster_start = cluster_index;
475 cpuinfo_x86_format_package_name(
476 x86_processor.vendor, brand_string, packages[package_index].name);
477 last_apic_package_id = apic_package_id;
478 } else {
479 /* another logical processor on the same package
480 */
481 packages[package_index].processor_count++;
482 }
483
484 linux_cpu_to_processor_map[x86_linux_processors[i].linux_id] = processors + processor_index;
485 linux_cpu_to_core_map[x86_linux_processors[i].linux_id] = cores + core_index;
486
487 if (x86_processor.cache.l1i.size != 0) {
488 const uint32_t l1i_id = apic_id & ~bit_mask(x86_processor.cache.l1i.apic_bits);
489 processors[i].cache.l1i = &l1i[l1i_index];
490 if (l1i_id != last_l1i_id) {
491 /* new cache */
492 last_l1i_id = l1i_id;
493 l1i[++l1i_index] = (struct cpuinfo_cache){
494 .size = x86_processor.cache.l1i.size,
495 .associativity = x86_processor.cache.l1i.associativity,
496 .sets = x86_processor.cache.l1i.sets,
497 .partitions = x86_processor.cache.l1i.partitions,
498 .line_size = x86_processor.cache.l1i.line_size,
499 .flags = x86_processor.cache.l1i.flags,
500 .processor_start = processor_index,
501 .processor_count = 1,
502 };
503 } else {
504 /* another processor sharing the same
505 * cache */
506 l1i[l1i_index].processor_count += 1;
507 }
508 processors[i].cache.l1i = &l1i[l1i_index];
509 } else {
510 /* reset cache id */
511 last_l1i_id = UINT32_MAX;
512 }
513 if (x86_processor.cache.l1d.size != 0) {
514 const uint32_t l1d_id = apic_id & ~bit_mask(x86_processor.cache.l1d.apic_bits);
515 processors[i].cache.l1d = &l1d[l1d_index];
516 if (l1d_id != last_l1d_id) {
517 /* new cache */
518 last_l1d_id = l1d_id;
519 l1d[++l1d_index] = (struct cpuinfo_cache){
520 .size = x86_processor.cache.l1d.size,
521 .associativity = x86_processor.cache.l1d.associativity,
522 .sets = x86_processor.cache.l1d.sets,
523 .partitions = x86_processor.cache.l1d.partitions,
524 .line_size = x86_processor.cache.l1d.line_size,
525 .flags = x86_processor.cache.l1d.flags,
526 .processor_start = processor_index,
527 .processor_count = 1,
528 };
529 } else {
530 /* another processor sharing the same
531 * cache */
532 l1d[l1d_index].processor_count += 1;
533 }
534 processors[i].cache.l1d = &l1d[l1d_index];
535 } else {
536 /* reset cache id */
537 last_l1d_id = UINT32_MAX;
538 }
539 if (x86_processor.cache.l2.size != 0) {
540 const uint32_t l2_id = apic_id & ~bit_mask(x86_processor.cache.l2.apic_bits);
541 processors[i].cache.l2 = &l2[l2_index];
542 if (l2_id != last_l2_id) {
543 /* new cache */
544 last_l2_id = l2_id;
545 l2[++l2_index] = (struct cpuinfo_cache){
546 .size = x86_processor.cache.l2.size,
547 .associativity = x86_processor.cache.l2.associativity,
548 .sets = x86_processor.cache.l2.sets,
549 .partitions = x86_processor.cache.l2.partitions,
550 .line_size = x86_processor.cache.l2.line_size,
551 .flags = x86_processor.cache.l2.flags,
552 .processor_start = processor_index,
553 .processor_count = 1,
554 };
555 } else {
556 /* another processor sharing the same
557 * cache */
558 l2[l2_index].processor_count += 1;
559 }
560 processors[i].cache.l2 = &l2[l2_index];
561 } else {
562 /* reset cache id */
563 last_l2_id = UINT32_MAX;
564 }
565 if (x86_processor.cache.l3.size != 0) {
566 const uint32_t l3_id = apic_id & ~bit_mask(x86_processor.cache.l3.apic_bits);
567 processors[i].cache.l3 = &l3[l3_index];
568 if (l3_id != last_l3_id) {
569 /* new cache */
570 last_l3_id = l3_id;
571 l3[++l3_index] = (struct cpuinfo_cache){
572 .size = x86_processor.cache.l3.size,
573 .associativity = x86_processor.cache.l3.associativity,
574 .sets = x86_processor.cache.l3.sets,
575 .partitions = x86_processor.cache.l3.partitions,
576 .line_size = x86_processor.cache.l3.line_size,
577 .flags = x86_processor.cache.l3.flags,
578 .processor_start = processor_index,
579 .processor_count = 1,
580 };
581 } else {
582 /* another processor sharing the same
583 * cache */
584 l3[l3_index].processor_count += 1;
585 }
586 processors[i].cache.l3 = &l3[l3_index];
587 } else {
588 /* reset cache id */
589 last_l3_id = UINT32_MAX;
590 }
591 if (x86_processor.cache.l4.size != 0) {
592 const uint32_t l4_id = apic_id & ~bit_mask(x86_processor.cache.l4.apic_bits);
593 processors[i].cache.l4 = &l4[l4_index];
594 if (l4_id != last_l4_id) {
595 /* new cache */
596 last_l4_id = l4_id;
597 l4[++l4_index] = (struct cpuinfo_cache){
598 .size = x86_processor.cache.l4.size,
599 .associativity = x86_processor.cache.l4.associativity,
600 .sets = x86_processor.cache.l4.sets,
601 .partitions = x86_processor.cache.l4.partitions,
602 .line_size = x86_processor.cache.l4.line_size,
603 .flags = x86_processor.cache.l4.flags,
604 .processor_start = processor_index,
605 .processor_count = 1,
606 };
607 } else {
608 /* another processor sharing the same
609 * cache */
610 l4[l4_index].processor_count += 1;
611 }
612 processors[i].cache.l4 = &l4[l4_index];
613 } else {
614 /* reset cache id */
615 last_l4_id = UINT32_MAX;
616 }
617 }
618 }
619
620 /* Commit changes */
621 cpuinfo_processors = processors;
622 cpuinfo_cores = cores;
623 cpuinfo_clusters = clusters;
624 cpuinfo_packages = packages;
625 cpuinfo_cache[cpuinfo_cache_level_1i] = l1i;
626 cpuinfo_cache[cpuinfo_cache_level_1d] = l1d;
627 cpuinfo_cache[cpuinfo_cache_level_2] = l2;
628 cpuinfo_cache[cpuinfo_cache_level_3] = l3;
629 cpuinfo_cache[cpuinfo_cache_level_4] = l4;
630
631 cpuinfo_processors_count = processors_count;
632 cpuinfo_cores_count = cores_count;
633 cpuinfo_clusters_count = clusters_count;
634 cpuinfo_packages_count = packages_count;
635 cpuinfo_cache_count[cpuinfo_cache_level_1i] = l1i_count;
636 cpuinfo_cache_count[cpuinfo_cache_level_1d] = l1d_count;
637 cpuinfo_cache_count[cpuinfo_cache_level_2] = l2_count;
638 cpuinfo_cache_count[cpuinfo_cache_level_3] = l3_count;
639 cpuinfo_cache_count[cpuinfo_cache_level_4] = l4_count;
640 cpuinfo_max_cache_size = cpuinfo_compute_max_cache_size(&processors[0]);
641
642 cpuinfo_global_uarch = (struct cpuinfo_uarch_info){
643 .uarch = x86_processor.uarch,
644 .cpuid = x86_processor.cpuid,
645 .processor_count = processors_count,
646 .core_count = cores_count,
647 };
648
649 cpuinfo_linux_cpu_max = x86_linux_processors_count;
650 cpuinfo_linux_cpu_to_processor_map = linux_cpu_to_processor_map;
651 cpuinfo_linux_cpu_to_core_map = linux_cpu_to_core_map;
652
653 __sync_synchronize();
654
655 cpuinfo_is_initialized = true;
656
657 processors = NULL;
658 cores = NULL;
659 clusters = NULL;
660 packages = NULL;
661 l1i = l1d = l2 = l3 = l4 = NULL;
662 linux_cpu_to_processor_map = NULL;
663 linux_cpu_to_core_map = NULL;
664
665 cleanup:
666 free(x86_linux_processors);
667 free(processors);
668 free(cores);
669 free(clusters);
670 free(packages);
671 free(l1i);
672 free(l1d);
673 free(l2);
674 free(l3);
675 free(l4);
676 free(linux_cpu_to_processor_map);
677 free(linux_cpu_to_core_map);
678 }
679