| #include <stdint.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <cpuinfo.h> |
| #include <arm/linux/api.h> |
| #if defined(__ANDROID__) |
| #include <arm/android/api.h> |
| #endif |
| #include <arm/api.h> |
| #include <arm/midr.h> |
| #include <linux/api.h> |
| #include <cpuinfo/internal-api.h> |
| #include <cpuinfo/log.h> |
| |
| static inline bool bitmask_all(uint32_t bitfield, uint32_t mask) { |
| return (bitfield & mask) == mask; |
| } |
| |
| /* |
| * Assigns logical processors to clusters of cores using heuristic based on the typical configuration of clusters for |
| * 5, 6, 8, and 10 cores: |
| * - 5 cores (ARM32 Android only): 2 clusters of 4+1 cores |
| * - 6 cores: 2 clusters of 4+2 cores |
| * - 8 cores: 2 clusters of 4+4 cores |
| * - 10 cores: 3 clusters of 4+4+2 cores |
| * |
| * The function must be called after parsing OS-provided information on core clusters. |
| * Its purpose is to detect clusters of cores when OS-provided information is lacking or incomplete, i.e. |
| * - Linux kernel is not configured to report information in sysfs topology leaf. |
| * - Linux kernel reports topology information only for online cores, and only cores on one cluster are online, e.g.: |
| * - Exynos 8890 has 8 cores in 4+4 clusters, but only the first cluster of 4 cores is reported, and cluster |
| * configuration of logical processors 4-7 is not reported (all remaining processors 4-7 form cluster 1) |
| * - MT6797 has 10 cores in 4+4+2, but only the first cluster of 4 cores is reported, and cluster configuration |
| * of logical processors 4-9 is not reported (processors 4-7 form cluster 1, and processors 8-9 form cluster 2). |
| * |
| * Heuristic assignment of processors to the above pre-defined clusters fails if such assignment would contradict |
| * information provided by the operating system: |
| * - Any of the OS-reported processor clusters is different than the corresponding heuristic cluster. |
| * - Processors in a heuristic cluster have no OS-provided cluster siblings information, but have known and different |
| * minimum/maximum frequency. |
| * - Processors in a heuristic cluster have no OS-provided cluster siblings information, but have known and different |
| * MIDR components. |
| * |
| * If the heuristic assignment of processors to clusters of cores fails, all processors' clusters are unchanged. |
| * |
| * @param usable_processors - number of processors in the @p processors array with CPUINFO_LINUX_FLAG_VALID flags. |
| * @param max_processors - number of elements in the @p processors array. |
| * @param[in,out] processors - processor descriptors with pre-parsed POSSIBLE and PRESENT flags, minimum/maximum |
| * frequency, MIDR infromation, and core cluster (package siblings list) information. |
| * |
| * @retval true if the heuristic successfully assigned all processors into clusters of cores. |
| * @retval false if known details about processors contradict the heuristic configuration of core clusters. |
| */ |
| bool cpuinfo_arm_linux_detect_core_clusters_by_heuristic( |
| uint32_t usable_processors, |
| uint32_t max_processors, |
| struct cpuinfo_arm_linux_processor processors[restrict static max_processors]) |
| { |
| uint32_t cluster_processors[3]; |
| switch (usable_processors) { |
| case 10: |
| cluster_processors[0] = 4; |
| cluster_processors[1] = 4; |
| cluster_processors[2] = 2; |
| break; |
| case 8: |
| cluster_processors[0] = 4; |
| cluster_processors[1] = 4; |
| break; |
| case 6: |
| cluster_processors[0] = 4; |
| cluster_processors[1] = 2; |
| break; |
| #if defined(__ANDROID__) && CPUINFO_ARCH_ARM |
| case 5: |
| /* |
| * The only processor with 5 cores is Leadcore L1860C (ARMv7, mobile), |
| * but this configuration is not too unreasonable for a virtualized ARM server. |
| */ |
| cluster_processors[0] = 4; |
| cluster_processors[1] = 1; |
| break; |
| #endif |
| default: |
| return false; |
| } |
| |
| /* |
| * Assignment of processors to core clusters is done in two passes: |
| * 1. Verify that the clusters proposed by heuristic are compatible with known details about processors. |
| * 2. If verification passed, update core clusters for the processors. |
| */ |
| |
| uint32_t cluster = 0; |
| uint32_t expected_cluster_processors = 0; |
| uint32_t cluster_start, cluster_flags, cluster_midr, cluster_max_frequency, cluster_min_frequency; |
| bool expected_cluster_exists; |
| for (uint32_t i = 0; i < max_processors; i++) { |
| if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) { |
| if (expected_cluster_processors == 0) { |
| /* Expect this processor to start a new cluster */ |
| |
| expected_cluster_exists = !!(processors[i].flags & CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER); |
| if (expected_cluster_exists) { |
| if (processors[i].package_leader_id != i) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "processor %"PRIu32" is expected to start a new cluster #%"PRIu32" with %"PRIu32" cores, " |
| "but system siblings lists reported it as a sibling of processor %"PRIu32, |
| i, cluster, cluster_processors[cluster], processors[i].package_leader_id); |
| return false; |
| } |
| } else { |
| cluster_flags = 0; |
| } |
| |
| cluster_start = i; |
| expected_cluster_processors = cluster_processors[cluster++]; |
| } else { |
| /* Expect this processor to belong to the same cluster as processor */ |
| |
| if (expected_cluster_exists) { |
| /* |
| * The cluster suggested by the heuristic was already parsed from system siblings lists. |
| * For all processors we expect in the cluster, check that: |
| * - They have pre-assigned cluster from siblings lists (CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER flag). |
| * - They were assigned to the same cluster based on siblings lists |
| * (package_leader_id points to the first processor in the cluster). |
| */ |
| |
| if ((processors[i].flags & CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER) == 0) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "processor %"PRIu32" is expected to belong to the cluster of processor %"PRIu32", " |
| "but system siblings lists did not report it as a sibling of processor %"PRIu32, |
| i, cluster_start, cluster_start); |
| return false; |
| } |
| if (processors[i].package_leader_id != cluster_start) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "processor %"PRIu32" is expected to belong to the cluster of processor %"PRIu32", " |
| "but system siblings lists reported it to belong to the cluster of processor %"PRIu32, |
| i, cluster_start, cluster_start); |
| return false; |
| } |
| } else { |
| /* |
| * The cluster suggest by the heuristic was not parsed from system siblings lists. |
| * For all processors we expect in the cluster, check that: |
| * - They have no pre-assigned cluster from siblings lists. |
| * - If their min/max CPU frequency is known, it is the same. |
| * - If any part of their MIDR (Implementer, Variant, Part, Revision) is known, it is the same. |
| */ |
| |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "processor %"PRIu32" is expected to be unassigned to any cluster, " |
| "but system siblings lists reported it to belong to the cluster of processor %"PRIu32, |
| i, processors[i].package_leader_id); |
| return false; |
| } |
| |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MIN_FREQUENCY) { |
| if (cluster_flags & CPUINFO_LINUX_FLAG_MIN_FREQUENCY) { |
| if (cluster_min_frequency != processors[i].min_frequency) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "minimum frequency of processor %"PRIu32" (%"PRIu32" KHz) is different than of its expected cluster (%"PRIu32" KHz)", |
| i, processors[i].min_frequency, cluster_min_frequency); |
| return false; |
| } |
| } else { |
| cluster_min_frequency = processors[i].min_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MIN_FREQUENCY; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MAX_FREQUENCY) { |
| if (cluster_flags & CPUINFO_LINUX_FLAG_MAX_FREQUENCY) { |
| if (cluster_max_frequency != processors[i].max_frequency) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "maximum frequency of processor %"PRIu32" (%"PRIu32" KHz) is different than of its expected cluster (%"PRIu32" KHz)", |
| i, processors[i].max_frequency, cluster_max_frequency); |
| return false; |
| } |
| } else { |
| cluster_max_frequency = processors[i].max_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MAX_FREQUENCY; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_IMPLEMENTER_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_IMPLEMENTER_MASK)) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "CPU Implementer of processor %"PRIu32" (0x%02"PRIx32") is different than of its expected cluster (0x%02"PRIx32")", |
| i, midr_get_implementer(processors[i].midr), midr_get_implementer(cluster_midr)); |
| return false; |
| } |
| } else { |
| cluster_midr = midr_copy_implementer(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_IMPLEMENTER; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_VARIANT) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_VARIANT) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_VARIANT_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_VARIANT_MASK)) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "CPU Variant of processor %"PRIu32" (0x%"PRIx32") is different than of its expected cluster (0x%"PRIx32")", |
| i, midr_get_variant(processors[i].midr), midr_get_variant(cluster_midr)); |
| return false; |
| } |
| } else { |
| cluster_midr = midr_copy_variant(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_VARIANT; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_PART) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_PART) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_PART_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_PART_MASK)) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "CPU Part of processor %"PRIu32" (0x%03"PRIx32") is different than of its expected cluster (0x%03"PRIx32")", |
| i, midr_get_part(processors[i].midr), midr_get_part(cluster_midr)); |
| return false; |
| } |
| } else { |
| cluster_midr = midr_copy_part(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_PART; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_REVISION) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_REVISION) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_REVISION_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_REVISION_MASK)) { |
| cpuinfo_log_debug( |
| "heuristic detection of core clusters failed: " |
| "CPU Revision of processor %"PRIu32" (0x%"PRIx32") is different than of its expected cluster (0x%"PRIx32")", |
| i, midr_get_revision(cluster_midr), midr_get_revision(processors[i].midr)); |
| return false; |
| } |
| } else { |
| cluster_midr = midr_copy_revision(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_REVISION; |
| } |
| } |
| } |
| } |
| expected_cluster_processors--; |
| } |
| } |
| |
| /* Verification passed, assign all processors to new clusters */ |
| cluster = 0; |
| expected_cluster_processors = 0; |
| for (uint32_t i = 0; i < max_processors; i++) { |
| if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) { |
| if (expected_cluster_processors == 0) { |
| /* Expect this processor to start a new cluster */ |
| |
| cluster_start = i; |
| expected_cluster_processors = cluster_processors[cluster++]; |
| } else { |
| /* Expect this processor to belong to the same cluster as processor */ |
| |
| if (!(processors[i].flags & CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER)) { |
| cpuinfo_log_debug("assigned processor %"PRIu32" to cluster of processor %"PRIu32" based on heuristic", |
| i, cluster_start); |
| } |
| |
| processors[i].package_leader_id = cluster_start; |
| processors[i].flags |= CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER; |
| } |
| expected_cluster_processors--; |
| } |
| } |
| return true; |
| } |
| |
| /* |
| * Assigns logical processors to clusters of cores in sequential manner: |
| * - Clusters detected from OS-provided information are unchanged: |
| * - Processors assigned to these clusters stay assigned to the same clusters |
| * - No new processors are added to these clusters |
| * - Processors without pre-assigned cluster are clustered in one sequential scan: |
| * - If known details (min/max frequency, MIDR components) of a processor are compatible with a preceeding |
| * processor, without pre-assigned cluster, the processor is assigned to the cluster of the preceeding processor. |
| * - If known details (min/max frequency, MIDR components) of a processor are not compatible with a preceeding |
| * processor, the processor is assigned to a newly created cluster. |
| * |
| * The function must be called after parsing OS-provided information on core clusters, and usually is called only |
| * if heuristic assignment of processors to clusters (cpuinfo_arm_linux_cluster_processors_by_heuristic) failed. |
| * |
| * Its purpose is to detect clusters of cores when OS-provided information is lacking or incomplete, i.e. |
| * - Linux kernel is not configured to report information in sysfs topology leaf. |
| * - Linux kernel reports topology information only for online cores, and all cores on some of the clusters are offline. |
| * |
| * Sequential assignment of processors to clusters always succeeds, and upon exit, all usable processors in the |
| * @p processors array have cluster information. |
| * |
| * @param max_processors - number of elements in the @p processors array. |
| * @param[in,out] processors - processor descriptors with pre-parsed POSSIBLE and PRESENT flags, minimum/maximum |
| * frequency, MIDR infromation, and core cluster (package siblings list) information. |
| * |
| * @retval true if the heuristic successfully assigned all processors into clusters of cores. |
| * @retval false if known details about processors contradict the heuristic configuration of core clusters. |
| */ |
| void cpuinfo_arm_linux_detect_core_clusters_by_sequential_scan( |
| uint32_t max_processors, |
| struct cpuinfo_arm_linux_processor processors[restrict static max_processors]) |
| { |
| uint32_t cluster_flags = 0; |
| uint32_t cluster_processors = 0; |
| uint32_t cluster_start, cluster_midr, cluster_max_frequency, cluster_min_frequency; |
| for (uint32_t i = 0; i < max_processors; i++) { |
| if ((processors[i].flags & (CPUINFO_LINUX_FLAG_VALID | CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER)) == CPUINFO_LINUX_FLAG_VALID) { |
| if (cluster_processors == 0) { |
| goto new_cluster; |
| } |
| |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MIN_FREQUENCY) { |
| if (cluster_flags & CPUINFO_LINUX_FLAG_MIN_FREQUENCY) { |
| if (cluster_min_frequency != processors[i].min_frequency) { |
| cpuinfo_log_info( |
| "minimum frequency of processor %"PRIu32" (%"PRIu32" KHz) is different than of preceeding cluster (%"PRIu32" KHz); " |
| "processor %"PRIu32" starts to a new cluster", |
| i, processors[i].min_frequency, cluster_min_frequency, i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_min_frequency = processors[i].min_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MIN_FREQUENCY; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MAX_FREQUENCY) { |
| if (cluster_flags & CPUINFO_LINUX_FLAG_MAX_FREQUENCY) { |
| if (cluster_max_frequency != processors[i].max_frequency) { |
| cpuinfo_log_debug( |
| "maximum frequency of processor %"PRIu32" (%"PRIu32" KHz) is different than of preceeding cluster (%"PRIu32" KHz); " |
| "processor %"PRIu32" starts a new cluster", |
| i, processors[i].max_frequency, cluster_max_frequency, i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_max_frequency = processors[i].max_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MAX_FREQUENCY; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_IMPLEMENTER_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_IMPLEMENTER_MASK)) { |
| cpuinfo_log_debug( |
| "CPU Implementer of processor %"PRIu32" (0x%02"PRIx32") is different than of preceeding cluster (0x%02"PRIx32"); " |
| "processor %"PRIu32" starts to a new cluster", |
| i, midr_get_implementer(processors[i].midr), midr_get_implementer(cluster_midr), i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_midr = midr_copy_implementer(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_IMPLEMENTER; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_VARIANT) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_VARIANT) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_VARIANT_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_VARIANT_MASK)) { |
| cpuinfo_log_debug( |
| "CPU Variant of processor %"PRIu32" (0x%"PRIx32") is different than of its expected cluster (0x%"PRIx32")" |
| "processor %"PRIu32" starts to a new cluster", |
| i, midr_get_variant(processors[i].midr), midr_get_variant(cluster_midr), i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_midr = midr_copy_variant(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_VARIANT; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_PART) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_PART) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_PART_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_PART_MASK)) { |
| cpuinfo_log_debug( |
| "CPU Part of processor %"PRIu32" (0x%03"PRIx32") is different than of its expected cluster (0x%03"PRIx32")" |
| "processor %"PRIu32" starts to a new cluster", |
| i, midr_get_part(processors[i].midr), midr_get_part(cluster_midr), i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_midr = midr_copy_part(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_PART; |
| } |
| } |
| |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_REVISION) { |
| if (cluster_flags & CPUINFO_ARM_LINUX_VALID_REVISION) { |
| if ((cluster_midr & CPUINFO_ARM_MIDR_REVISION_MASK) != (processors[i].midr & CPUINFO_ARM_MIDR_REVISION_MASK)) { |
| cpuinfo_log_debug( |
| "CPU Revision of processor %"PRIu32" (0x%"PRIx32") is different than of its expected cluster (0x%"PRIx32")" |
| "processor %"PRIu32" starts to a new cluster", |
| i, midr_get_revision(cluster_midr), midr_get_revision(processors[i].midr), i); |
| goto new_cluster; |
| } |
| } else { |
| cluster_midr = midr_copy_revision(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_REVISION; |
| } |
| } |
| |
| /* All checks passed, attach processor to the preceeding cluster */ |
| cluster_processors++; |
| processors[i].package_leader_id = cluster_start; |
| processors[i].flags |= CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER; |
| cpuinfo_log_debug("assigned processor %"PRIu32" to preceeding cluster of processor %"PRIu32, i, cluster_start); |
| continue; |
| |
| new_cluster: |
| /* Create a new cluster starting with processor i */ |
| cluster_start = i; |
| processors[i].package_leader_id = i; |
| processors[i].flags |= CPUINFO_LINUX_FLAG_PACKAGE_CLUSTER; |
| cluster_processors = 1; |
| |
| /* Copy known information from processor to cluster, and set the flags accordingly */ |
| cluster_flags = 0; |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MIN_FREQUENCY) { |
| cluster_min_frequency = processors[i].min_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MIN_FREQUENCY; |
| } |
| if (processors[i].flags & CPUINFO_LINUX_FLAG_MAX_FREQUENCY) { |
| cluster_max_frequency = processors[i].max_frequency; |
| cluster_flags |= CPUINFO_LINUX_FLAG_MAX_FREQUENCY; |
| } |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) { |
| cluster_midr = midr_copy_implementer(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_IMPLEMENTER; |
| } |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_VARIANT) { |
| cluster_midr = midr_copy_variant(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_VARIANT; |
| } |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_PART) { |
| cluster_midr = midr_copy_part(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_PART; |
| } |
| if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_REVISION) { |
| cluster_midr = midr_copy_revision(cluster_midr, processors[i].midr); |
| cluster_flags |= CPUINFO_ARM_LINUX_VALID_REVISION; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Counts the number of logical processors in each core cluster. |
| * This function should be called after all processors are assigned to core clusters. |
| * |
| * @param max_processors - number of elements in the @p processors array. |
| * @param[in,out] processors - processor descriptors with pre-parsed POSSIBLE and PRESENT flags, |
| * and decoded core cluster (package_leader_id) information. |
| * The function expects the value of processors[i].package_processor_count to be zero. |
| * Upon return, processors[i].package_processor_count will contain the number of logical |
| * processors in the respective core cluster. |
| */ |
| void cpuinfo_arm_linux_count_cluster_processors( |
| uint32_t max_processors, |
| struct cpuinfo_arm_linux_processor processors[restrict static max_processors]) |
| { |
| /* First pass: accumulate the number of processors at the group leader's package_processor_count */ |
| for (uint32_t i = 0; i < max_processors; i++) { |
| if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) { |
| const uint32_t package_leader_id = processors[i].package_leader_id; |
| processors[package_leader_id].package_processor_count += 1; |
| } |
| } |
| /* Second pass: copy the package_processor_count from the group leader processor */ |
| for (uint32_t i = 0; i < max_processors; i++) { |
| if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) { |
| const uint32_t package_leader_id = processors[i].package_leader_id; |
| processors[i].package_processor_count = processors[package_leader_id].package_processor_count; |
| } |
| } |
| } |
