| #include <stddef.h> | |
| #include <stdint.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <arm/linux/api.h> | |
| #include <cpuinfo.h> | |
| #if defined(__ANDROID__) | |
| #include <arm/android/api.h> | |
| #endif | |
| #include <arm/api.h> | |
| #include <arm/midr.h> | |
| #include <cpuinfo/internal-api.h> | |
| #include <cpuinfo/log.h> | |
| #include <linux/api.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 information, 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 preceding processor, without pre-assigned cluster, the | |
| * processor is assigned to the cluster of the preceding processor. | |
| * - If known details (min/max frequency, MIDR components) of a processor are | |
| * not compatible with a preceding 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 information, 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 preceding 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 preceding 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 preceding 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 preceding | |
| * 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 preceding 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; | |
| } | |
| } | |
| } |