system_topology.h File Reference

#include <stdint.h>
#include <stdbool.h>

Go to the source code of this file.

Data Structures
struct	AffinityInfo
struct	CacheInfo
struct	CacheTopology
struct	CPUInfo
struct	MemoryInfo
struct	MemorySlot
struct	NetworkInterface
struct	NetworkTopology
struct	NUMANode
struct	NUMATopology
struct	PCIeDevice
struct	PCIeTopology
struct	Recommendation
struct	RecommendationList
struct	SystemTopology

Macros
#define	MAX_CACHE_LEVELS   4
#define	MAX_CPUS   256
#define	MAX_MEMORY_SLOTS   16
#define	MAX_NICS   8
#define	MAX_NUMA_NODES   8
#define	MAX_PCIE_DEVICES   32
#define	MAX_RECOMMENDATIONS   32
#define	MAX_STR_LEN   256

Enumerations
enum	RecommendationCategory {   REC_CATEGORY_MEMORY , REC_CATEGORY_CPU , REC_CATEGORY_NETWORK , REC_CATEGORY_AFFINITY ,   REC_CATEGORY_PCIE }
enum	RecommendationPriority { REC_PRIORITY_LOW , REC_PRIORITY_MEDIUM , REC_PRIORITY_HIGH , REC_PRIORITY_CRITICAL }

Functions
int	topology_discover (SystemTopology *topo)
int	topology_discover_affinity (AffinityInfo *aff)
int	topology_discover_cache (CacheTopology *cache)
int	topology_discover_cpu (CPUInfo *cpu)
int	topology_discover_memory (MemoryInfo *mem)
int	topology_discover_network (NetworkTopology *net)
int	topology_discover_numa (NUMATopology *numa)
int	topology_discover_pcie (PCIeTopology *pcie)
float	topology_estimate_memory_bandwidth (const MemoryInfo *mem)
float	topology_estimate_network_training_time (const NetworkTopology *net, uint64_t model_size_mb)
int	topology_generate_recommendations (const SystemTopology *topo, RecommendationList *recs)
void	topology_print_affinity (const AffinityInfo *aff)
void	topology_print_cache (const CacheTopology *cache, int logical_cores)
void	topology_print_cpu (const CPUInfo *cpu)
void	topology_print_distributed_potential (const SystemTopology *topo)
void	topology_print_memory (const MemoryInfo *mem)
void	topology_print_network (const NetworkTopology *net)
void	topology_print_numa (const NUMATopology *numa, int sockets)
void	topology_print_pcie (const PCIeTopology *pcie)
void	topology_print_recommendations (const RecommendationList *recs)
void	topology_print_summary (const SystemTopology *topo)

Macro Definition Documentation

MAX_CACHE_LEVELS

#define MAX_CACHE_LEVELS   4

Definition at line 24 of file system_topology.h.

MAX_CPUS

#define MAX_CPUS   256

Definition at line 23 of file system_topology.h.

MAX_MEMORY_SLOTS

#define MAX_MEMORY_SLOTS   16

Definition at line 27 of file system_topology.h.

MAX_NICS

#define MAX_NICS   8

Definition at line 25 of file system_topology.h.

MAX_NUMA_NODES

#define MAX_NUMA_NODES   8

Definition at line 22 of file system_topology.h.

MAX_PCIE_DEVICES

#define MAX_PCIE_DEVICES   32

Definition at line 26 of file system_topology.h.

MAX_RECOMMENDATIONS

#define MAX_RECOMMENDATIONS   32

Definition at line 280 of file system_topology.h.

MAX_STR_LEN

#define MAX_STR_LEN   256

Definition at line 28 of file system_topology.h.

Enumeration Type Documentation

RecommendationCategory

enum RecommendationCategory

Enumerator
REC_CATEGORY_MEMORY
REC_CATEGORY_CPU
REC_CATEGORY_NETWORK
REC_CATEGORY_AFFINITY
REC_CATEGORY_PCIE

Definition at line 272 of file system_topology.h.

             {
    REC_CATEGORY_MEMORY,
    REC_CATEGORY_CPU,
    REC_CATEGORY_NETWORK,
    REC_CATEGORY_AFFINITY,
    REC_CATEGORY_PCIE
} RecommendationCategory;

RecommendationPriority

enum RecommendationPriority

Enumerator
REC_PRIORITY_LOW
REC_PRIORITY_MEDIUM
REC_PRIORITY_HIGH
REC_PRIORITY_CRITICAL

Definition at line 265 of file system_topology.h.

             {
    REC_PRIORITY_LOW,
    REC_PRIORITY_MEDIUM,
    REC_PRIORITY_HIGH,
    REC_PRIORITY_CRITICAL
} RecommendationPriority;

Function Documentation

topology_discover()

int topology_discover

(

SystemTopology *

topo

)

Definition at line 979 of file system_topology.c.

                                            {
    memset(topo, 0, sizeof(*topo));
 
    // Get hostname and kernel version
    gethostname(topo->hostname, sizeof(topo->hostname));
 
    struct utsname uts;
    if (uname(&uts) == 0) {
        snprintf(topo->kernel_version, sizeof(topo->kernel_version),
                 "%s %s", uts.sysname, uts.release);
    }
 
    // Check for root access
    topo->has_root_access = (geteuid() == 0);
 
    // Run all discovery functions
    topology_discover_cpu(&topo->cpu);
    topology_discover_cache(&topo->cache);
    topology_discover_numa(&topo->numa);
    topology_discover_memory(&topo->memory);
    topology_discover_pcie(&topo->pcie);
    topology_discover_network(&topo->network);
    topology_discover_affinity(&topo->affinity);
 
    return 0;
}

References SystemTopology::affinity, SystemTopology::cache, SystemTopology::cpu, SystemTopology::has_root_access, SystemTopology::hostname, SystemTopology::kernel_version, SystemTopology::memory, SystemTopology::network, SystemTopology::numa, SystemTopology::pcie, topology_discover_affinity(), topology_discover_cache(), topology_discover_cpu(), topology_discover_memory(), topology_discover_network(), topology_discover_numa(), and topology_discover_pcie().

Referenced by main().

topology_discover_affinity()

int topology_discover_affinity

(

AffinityInfo *

aff

)

Definition at line 936 of file system_topology.c.

                                                  {
    memset(aff, 0, sizeof(*aff));
 
    // OpenMP settings
    const char *omp_threads = getenv("OMP_NUM_THREADS");
    if (omp_threads) {
        aff->omp_num_threads = atoi(omp_threads);
    } else {
        aff->omp_num_threads = sysconf(_SC_NPROCESSORS_ONLN);
    }
 
    const char *omp_bind = getenv("OMP_PROC_BIND");
    if (omp_bind) {
        strncpy(aff->omp_proc_bind, omp_bind, sizeof(aff->omp_proc_bind) - 1);
        aff->affinity_set = true;
    } else {
        strcpy(aff->omp_proc_bind, "not set");
    }
 
    const char *omp_places = getenv("OMP_PLACES");
    if (omp_places) {
        strncpy(aff->omp_places, omp_places, sizeof(aff->omp_places) - 1);
    } else {
        strcpy(aff->omp_places, "not set");
    }
 
    // Current process affinity
    cpu_set_t mask;
    if (sched_getaffinity(0, sizeof(mask), &mask) == 0) {
        for (int i = 0; i < MAX_CPUS && aff->num_affinity_cpus < MAX_CPUS; i++) {
            if (CPU_ISSET(i, &mask)) {
                aff->affinity_cpus[aff->num_affinity_cpus++] = i;
            }
        }
    }
 
    return 0;
}

References AffinityInfo::affinity_cpus, AffinityInfo::affinity_set, mask, MAX_CPUS, AffinityInfo::num_affinity_cpus, AffinityInfo::omp_num_threads, AffinityInfo::omp_places, and AffinityInfo::omp_proc_bind.

Referenced by topology_discover().

topology_discover_cache()

int topology_discover_cache

(

CacheTopology *

cache

)

Definition at line 246 of file system_topology.c.

                                                  {
    memset(cache, 0, sizeof(*cache));
 
    const char *base = "/sys/devices/system/cpu/cpu0/cache";
    DIR *dir = opendir(base);
    if (!dir) return -1;
 
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        if (strncmp(entry->d_name, "index", 5) != 0) continue;
 
        char path[512];
        CacheInfo *ci = &cache->levels[cache->num_levels];
 
        snprintf(path, sizeof(path), "%s/%s/level", base, entry->d_name);
        ci->level = read_file_int(path);
 
        snprintf(path, sizeof(path), "%s/%s/type", base, entry->d_name);
        read_file_string(path, ci->type, sizeof(ci->type));
 
        snprintf(path, sizeof(path), "%s/%s/size", base, entry->d_name);
        char size_str[32];
        if (read_file_string(path, size_str, sizeof(size_str)) == 0) {
            ci->size_kb = atoi(size_str);  // Usually in KB with 'K' suffix
        }
 
        snprintf(path, sizeof(path), "%s/%s/coherency_line_size", base, entry->d_name);
        ci->line_size_bytes = read_file_int(path);
 
        snprintf(path, sizeof(path), "%s/%s/ways_of_associativity", base, entry->d_name);
        ci->ways_of_associativity = read_file_int(path);
 
        snprintf(path, sizeof(path), "%s/%s/shared_cpu_map", base, entry->d_name);
        char cpu_map[256];
        if (read_file_string(path, cpu_map, sizeof(cpu_map)) == 0) {
            ci->shared_by_cores = count_set_bits(cpu_map);
        }
 
        if (ci->level == 3) {
            cache->l3_total_kb = ci->size_kb;  // Will be multiplied if multiple
        }
 
        cache->num_levels++;
        if (cache->num_levels >= MAX_CACHE_LEVELS) break;
    }
    closedir(dir);
 
    // Sort by level (L1 → L2 → L3) and type (Data → Instruction → Unified)
    qsort(cache->levels, cache->num_levels, sizeof(CacheInfo), cache_compare);
 
    return 0;
}

References cache_compare(), count_set_bits(), CacheTopology::l3_total_kb, CacheInfo::level, CacheTopology::levels, CacheInfo::line_size_bytes, MAX_CACHE_LEVELS, CacheTopology::num_levels, read_file_int(), read_file_string(), CacheInfo::shared_by_cores, CacheInfo::size_kb, CacheInfo::type, and CacheInfo::ways_of_associativity.

Referenced by topology_discover().

topology_discover_cpu()

int topology_discover_cpu

(

CPUInfo *

cpu

)

Definition at line 112 of file system_topology.c.

                                        {
    memset(cpu, 0, sizeof(*cpu));
 
    FILE *f = fopen("/proc/cpuinfo", "r");
    if (!f) return -1;
 
    char line[4096];  // Flags line can be very long on modern CPUs (AVX-512 + AMX)
    int processor_count = 0;
    int physical_id_max = -1;
    int core_id_max = -1;
 
    while (fgets(line, sizeof(line), f)) {
        char *colon = strchr(line, ':');
        if (!colon) continue;
 
        char *key = line;
        char *value = colon + 1;
        *colon = '\0';
        trim_string(key);
        trim_string(value);
 
        if (strcmp(key, "processor") == 0) {
            processor_count++;
        } else if (strcmp(key, "model name") == 0 && cpu->model_name[0] == '\0') {
            strncpy(cpu->model_name, value, sizeof(cpu->model_name) - 1);
        } else if (strcmp(key, "vendor_id") == 0 && cpu->vendor[0] == '\0') {
            strncpy(cpu->vendor, value, sizeof(cpu->vendor) - 1);
        } else if (strcmp(key, "cpu family") == 0 && cpu->family == 0) {
            cpu->family = atoi(value);
        } else if (strcmp(key, "model") == 0 && cpu->model == 0) {
            cpu->model = atoi(value);
        } else if (strcmp(key, "stepping") == 0 && cpu->stepping == 0) {
            cpu->stepping = atoi(value);
        } else if (strcmp(key, "cpu MHz") == 0 && cpu->base_freq_mhz == 0) {
            cpu->base_freq_mhz = atof(value);
        } else if (strcmp(key, "physical id") == 0) {
            int id = atoi(value);
            if (id > physical_id_max) physical_id_max = id;
        } else if (strcmp(key, "core id") == 0) {
            int id = atoi(value);
            if (id > core_id_max) core_id_max = id;
        } else if (strcmp(key, "flags") == 0) {
            // Use word-boundary-aware matching for CPU flags
            cpu->has_sse4_2   = has_cpu_flag(value, "sse4_2");
            cpu->has_avx      = has_cpu_flag(value, "avx");
            cpu->has_avx2     = has_cpu_flag(value, "avx2");
            cpu->has_avx512f  = has_cpu_flag(value, "avx512f");
            cpu->has_avx512bw = has_cpu_flag(value, "avx512bw");
            cpu->has_avx512vl = has_cpu_flag(value, "avx512vl");
            cpu->has_avx512_bf16 = has_cpu_flag(value, "avx512_bf16");
            cpu->has_amx_tile = has_cpu_flag(value, "amx_tile");
            cpu->has_amx_int8 = has_cpu_flag(value, "amx_int8");
            cpu->has_amx_bf16 = has_cpu_flag(value, "amx_bf16");
            cpu->has_amx      = cpu->has_amx_tile || cpu->has_amx_int8 || cpu->has_amx_bf16;
            cpu->has_vnni     = has_cpu_flag(value, "avx512_vnni") || has_cpu_flag(value, "avx_vnni");
        }
    }
    fclose(f);
 
    cpu->logical_cores = processor_count;
    cpu->sockets = physical_id_max + 1;
    if (cpu->sockets < 1) cpu->sockets = 1;
 
    // Read from /sys for more accurate core count
    int cores_per_socket = read_file_int("/sys/devices/system/cpu/cpu0/topology/core_cpus_list");
    if (cores_per_socket < 0) {
        // Fallback: estimate from logical cores and sockets
        cpu->physical_cores = cpu->logical_cores / 2;  // Assume HT
        cpu->cores_per_socket = cpu->physical_cores / cpu->sockets;
    } else {
        // Count unique core IDs
        char path[256];
        int unique_cores = 0;
        int seen_cores[MAX_CPUS] = {0};
 
        for (int i = 0; i < cpu->logical_cores && i < MAX_CPUS; i++) {
            snprintf(path, sizeof(path),
                     "/sys/devices/system/cpu/cpu%d/topology/core_id", i);
            int core_id = read_file_int(path);
            if (core_id >= 0 && core_id < MAX_CPUS && !seen_cores[core_id]) {
                seen_cores[core_id] = 1;
                unique_cores++;
            }
        }
        cpu->physical_cores = unique_cores > 0 ? unique_cores : cpu->logical_cores / 2;
        cpu->cores_per_socket = cpu->physical_cores / cpu->sockets;
    }
 
    cpu->threads_per_core = cpu->logical_cores / cpu->physical_cores;
 
    // Try to get max frequency
    int max_freq = read_file_int("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
    if (max_freq > 0) {
        cpu->max_freq_mhz = max_freq / 1000.0f;
    }
 
    // Estimate PCIe lanes based on CPU model
    if (strstr(cpu->model_name, "Xeon") || strstr(cpu->model_name, "EPYC")) {
        cpu->pcie_lanes_total = 64;  // Server CPUs typically have more
        cpu->pcie_generation = 4;
    } else if (strstr(cpu->model_name, "i9") || strstr(cpu->model_name, "i7")) {
        cpu->pcie_lanes_total = 20;
        cpu->pcie_generation = cpu->has_avx512f ? 4 : 3;
    } else {
        cpu->pcie_lanes_total = 16;
        cpu->pcie_generation = 3;
    }
 
    return 0;
}

References CPUInfo::base_freq_mhz, CPUInfo::cores_per_socket, CPUInfo::family, CPUInfo::has_amx, CPUInfo::has_amx_bf16, CPUInfo::has_amx_int8, CPUInfo::has_amx_tile, CPUInfo::has_avx, CPUInfo::has_avx2, CPUInfo::has_avx512_bf16, CPUInfo::has_avx512bw, CPUInfo::has_avx512f, CPUInfo::has_avx512vl, has_cpu_flag(), CPUInfo::has_sse4_2, CPUInfo::has_vnni, id, CPUInfo::logical_cores, MAX_CPUS, CPUInfo::max_freq_mhz, CPUInfo::model, CPUInfo::model_name, CPUInfo::pcie_generation, CPUInfo::pcie_lanes_total, CPUInfo::physical_cores, read_file_int(), CPUInfo::sockets, CPUInfo::stepping, CPUInfo::threads_per_core, trim_string(), and CPUInfo::vendor.

Referenced by topology_discover().

topology_discover_memory()

int topology_discover_memory

(

MemoryInfo *

mem

)

Definition at line 553 of file system_topology.c.

                                              {
    memset(mem, 0, sizeof(*mem));
 
    // Basic memory info from /proc/meminfo
    FILE *f = fopen("/proc/meminfo", "r");
    if (f) {
        char line[256];
        while (fgets(line, sizeof(line), f)) {
            uint64_t val;
            if (sscanf(line, "MemTotal: %lu kB", &val) == 1) {
                mem->total_mb = val / 1024;
            } else if (sscanf(line, "MemAvailable: %lu kB", &val) == 1) {
                mem->available_mb = val / 1024;
            } else if (sscanf(line, "Cached: %lu kB", &val) == 1) {
                mem->cached_mb = val / 1024;
            }
        }
        fclose(f);
    }
 
    // Try to get DIMM info via dmidecode (requires root)
    char output[8192];
    if (run_command("dmidecode -t memory 2>/dev/null", output, sizeof(output)) == 0 &&
        strlen(output) > 100) {
 
        char *line = strtok(output, "\n");
        MemorySlot *current_slot = NULL;
 
        while (line) {
            trim_string(line);
 
            if (strstr(line, "Memory Device")) {
                if (mem->num_slots < MAX_MEMORY_SLOTS) {
                    current_slot = &mem->slots[mem->num_slots++];
                    memset(current_slot, 0, sizeof(*current_slot));
                    current_slot->slot_number = mem->num_slots;
                }
            } else if (current_slot) {
                uint64_t val;
                int ival;
                char str[64];
 
                if (sscanf(line, "Size: %lu MB", &val) == 1) {
                    current_slot->size_mb = val;
                    current_slot->populated = true;
                    mem->slots_populated++;
                } else if (sscanf(line, "Size: %lu GB", &val) == 1) {
                    current_slot->size_mb = val * 1024;
                    current_slot->populated = true;
                    mem->slots_populated++;
                } else if (strstr(line, "Size: No Module")) {
                    current_slot->populated = false;
                } else if (sscanf(line, "Speed: %d MT/s", &ival) == 1 ||
                           sscanf(line, "Speed: %d MHz", &ival) == 1) {
                    current_slot->speed_mhz = ival;
                    if (mem->memory_speed_mhz == 0) mem->memory_speed_mhz = ival;
                } else if (sscanf(line, "Type: %63s", str) == 1) {
                    strncpy(current_slot->type, str, sizeof(current_slot->type) - 1);
                    if (mem->memory_type[0] == '\0') {
                        strncpy(mem->memory_type, str, sizeof(mem->memory_type) - 1);
                    }
                } else if (sscanf(line, "Locator: %63s", str) == 1) {
                    strncpy(current_slot->locator, str, sizeof(current_slot->locator) - 1);
                } else if (sscanf(line, "Rank: %d", &ival) == 1) {
                    current_slot->rank = ival;
                } else if (sscanf(line, "Data Width: %d bits", &ival) == 1) {
                    current_slot->data_width_bits = ival;
                }
            }
 
            line = strtok(NULL, "\n");
        }
    }
 
    // Estimate channel configuration
    if (mem->slots_populated > 0) {
        if (mem->slots_populated == 1) {
            strcpy(mem->channel_config, "Single-channel");
            mem->num_channels = 1;
            mem->channels_populated = 1;
        } else if (mem->slots_populated == 2) {
            strcpy(mem->channel_config, "Dual-channel");
            mem->num_channels = 2;
            mem->channels_populated = 2;
        } else if (mem->slots_populated == 4) {
            strcpy(mem->channel_config, "Quad-channel");
            mem->num_channels = 4;
            mem->channels_populated = 4;
        } else if (mem->slots_populated >= 6) {
            strcpy(mem->channel_config, "Hexa-channel or more");
            mem->num_channels = 6;
            mem->channels_populated = mem->slots_populated;
        } else {
            snprintf(mem->channel_config, sizeof(mem->channel_config),
                     "%d DIMMs", mem->slots_populated);
            mem->num_channels = mem->slots_populated;
            mem->channels_populated = mem->slots_populated;
        }
 
        // Estimate bandwidth
        // DDR4: speed * 8 bytes * channels
        // DDR5: speed * 8 bytes * channels (but DDR5 has 2 channels per DIMM)
        float bytes_per_transfer = 8.0f;
        if (strstr(mem->memory_type, "DDR5")) {
            mem->theoretical_bandwidth_gbs =
                (mem->memory_speed_mhz * bytes_per_transfer * mem->channels_populated * 2) / 1000.0f;
        } else {
            mem->theoretical_bandwidth_gbs =
                (mem->memory_speed_mhz * bytes_per_transfer * mem->channels_populated) / 1000.0f;
        }
    }
 
    // Always measure actual bandwidth (quick ~0.5s test)
    // Use extended version to get NUMA node and thread count for transparency
    mem->measured_bandwidth_gbs = topology_measure_memory_bandwidth_ex(
        &mem->bw_test_numa_node,
        &mem->bw_test_num_threads
    );
 
    // If dmidecode didn't give us channel info, estimate from measured bandwidth
    if (mem->slots_populated == 0 && mem->measured_bandwidth_gbs > 0) {
        // Try to detect memory speed from /sys or assume DDR4-3200
        if (mem->memory_speed_mhz == 0) {
            // Common defaults: DDR4-2666, DDR4-3200, DDR5-4800
            // Assume DDR4-3200 as a reasonable default
            mem->memory_speed_mhz = 3200;
            strcpy(mem->memory_type, "DDR4");
        }
 
        // Estimate channels from measured bandwidth
        mem->estimated_channels = topology_estimate_channels_from_bandwidth(
            mem->measured_bandwidth_gbs, mem->memory_speed_mhz, mem->memory_type);
 
        // Update channel config string
        switch (mem->estimated_channels) {
            case 1:
                strcpy(mem->channel_config, "Single-channel (estimated)");
                break;
            case 2:
                strcpy(mem->channel_config, "Dual-channel (estimated)");
                break;
            case 4:
                strcpy(mem->channel_config, "Quad-channel (estimated)");
                break;
            case 6:
                strcpy(mem->channel_config, "Hexa-channel (estimated)");
                break;
            case 8:
                strcpy(mem->channel_config, "Octa-channel (estimated)");
                break;
            default:
                snprintf(mem->channel_config, sizeof(mem->channel_config),
                         "%d-channel (estimated)", mem->estimated_channels);
        }
 
        mem->channels_populated = mem->estimated_channels;
        mem->num_channels = mem->estimated_channels;
 
        // Recalculate theoretical based on estimated channels
        mem->theoretical_bandwidth_gbs =
            (mem->memory_speed_mhz * 8.0f * mem->estimated_channels) / 1000.0f;
    }
 
    return 0;
}

References MemoryInfo::available_mb, MemoryInfo::bw_test_num_threads, MemoryInfo::bw_test_numa_node, MemoryInfo::cached_mb, MemoryInfo::channel_config, MemoryInfo::channels_populated, MemorySlot::data_width_bits, MemoryInfo::estimated_channels, MemorySlot::locator, MAX_MEMORY_SLOTS, MemoryInfo::measured_bandwidth_gbs, MemoryInfo::memory_speed_mhz, MemoryInfo::memory_type, MemoryInfo::num_channels, MemoryInfo::num_slots, MemorySlot::populated, MemorySlot::rank, run_command(), MemorySlot::size_mb, MemorySlot::slot_number, MemoryInfo::slots, MemoryInfo::slots_populated, MemorySlot::speed_mhz, MemoryInfo::theoretical_bandwidth_gbs, topology_estimate_channels_from_bandwidth(), topology_measure_memory_bandwidth_ex(), MemoryInfo::total_mb, trim_string(), and MemorySlot::type.

Referenced by topology_discover().

topology_discover_network()

int topology_discover_network

(

NetworkTopology *

net

)

Definition at line 832 of file system_topology.c.

                                                    {
    memset(net, 0, sizeof(*net));
 
    const char *base = "/sys/class/net";
    DIR *dir = opendir(base);
    if (!dir) return -1;
 
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        if (entry->d_name[0] == '.') continue;
        if (strcmp(entry->d_name, "lo") == 0) continue;  // Skip loopback
 
        if (net->num_interfaces >= MAX_NICS) break;
        NetworkInterface *nic = &net->interfaces[net->num_interfaces];
        memset(nic, 0, sizeof(*nic));
 
        strncpy(nic->name, entry->d_name, sizeof(nic->name) - 1);
 
        char path[512];
 
        // Check if interface is up
        snprintf(path, sizeof(path), "%s/%s/operstate", base, entry->d_name);
        char state[32];
        if (read_file_string(path, state, sizeof(state)) == 0) {
            nic->is_up = (strcmp(state, "up") == 0);
        }
 
        // Get speed
        snprintf(path, sizeof(path), "%s/%s/speed", base, entry->d_name);
        int speed = read_file_int(path);
        if (speed > 0) {
            nic->speed_mbps = speed;
            nic->has_link = true;
        }
 
        // Get MTU
        snprintf(path, sizeof(path), "%s/%s/mtu", base, entry->d_name);
        nic->mtu = read_file_int(path);
 
        // Get MAC address
        snprintf(path, sizeof(path), "%s/%s/address", base, entry->d_name);
        read_file_string(path, nic->mac_address, sizeof(nic->mac_address));
 
        // Get driver
        snprintf(path, sizeof(path), "%s/%s/device/driver", base, entry->d_name);
        char driver_link[512];
        ssize_t len = readlink(path, driver_link, sizeof(driver_link) - 1);
        if (len > 0) {
            driver_link[len] = '\0';
            char *driver_name = strrchr(driver_link, '/');
            if (driver_name) {
                strncpy(nic->driver, driver_name + 1, sizeof(nic->driver) - 1);
            }
        }
 
        // Check for InfiniBand
        snprintf(path, sizeof(path), "/sys/class/infiniband/%s", entry->d_name);
        if (access(path, F_OK) == 0) {
            nic->is_infiniband = true;
            nic->supports_rdma = true;
        }
 
        // Check for RoCE capability
        if (strstr(nic->driver, "mlx") || strstr(nic->driver, "bnxt") ||
            strstr(nic->driver, "qed")) {
            nic->supports_roce = true;
            nic->supports_rdma = true;
        }
 
        // Get PCI address
        snprintf(path, sizeof(path), "%s/%s/device", base, entry->d_name);
        char pci_link[512];
        len = readlink(path, pci_link, sizeof(pci_link) - 1);
        if (len > 0) {
            pci_link[len] = '\0';
            char *pci = strrchr(pci_link, '/');
            if (pci) {
                strncpy(nic->pci_address, pci + 1, sizeof(nic->pci_address) - 1);
            }
        }
 
        // Calculate bandwidth
        float bandwidth = nic->speed_mbps / 8000.0f;  // Mbps to GB/s
 
        if (bandwidth > net->max_bandwidth_gbs) {
            net->max_bandwidth_gbs = bandwidth;
            net->best_interface_idx = net->num_interfaces;
        }
 
        if (nic->supports_rdma) {
            net->has_rdma = true;
        }
 
        net->num_interfaces++;
    }
    closedir(dir);
 
    return 0;
}

References NetworkTopology::best_interface_idx, NetworkInterface::driver, NetworkInterface::has_link, NetworkTopology::has_rdma, NetworkTopology::interfaces, NetworkInterface::is_infiniband, NetworkInterface::is_up, NetworkInterface::mac_address, NetworkTopology::max_bandwidth_gbs, MAX_NICS, NetworkInterface::mtu, NetworkInterface::name, NetworkTopology::num_interfaces, NetworkInterface::pci_address, read_file_int(), read_file_string(), NetworkInterface::speed_mbps, NetworkInterface::supports_rdma, and NetworkInterface::supports_roce.

Referenced by topology_discover().

topology_discover_numa()

int topology_discover_numa

(

NUMATopology *

numa

)

Definition at line 303 of file system_topology.c.

                                               {
    memset(numa, 0, sizeof(*numa));
 
    const char *base = "/sys/devices/system/node";
    DIR *dir = opendir(base);
    if (!dir) {
        // No NUMA, single node system
        numa->num_nodes = 1;
        numa->nodes[0].node_id = 0;
 
        struct sysinfo si;
        if (sysinfo(&si) == 0) {
            numa->nodes[0].memory_total_mb = si.totalram / (1024 * 1024);
            numa->nodes[0].memory_free_mb = si.freeram / (1024 * 1024);
        }
        return 0;
    }
 
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        if (strncmp(entry->d_name, "node", 4) != 0) continue;
        if (!isdigit(entry->d_name[4])) continue;
 
        int node_id = atoi(entry->d_name + 4);
        if (node_id >= MAX_NUMA_NODES) continue;
 
        NUMANode *node = &numa->nodes[numa->num_nodes];
        node->node_id = node_id;
 
        char path[512];
 
        // Memory info
        snprintf(path, sizeof(path), "%s/%s/meminfo", base, entry->d_name);
        FILE *f = fopen(path, "r");
        if (f) {
            char line[256];
            while (fgets(line, sizeof(line), f)) {
                uint64_t val;
                if (sscanf(line, "Node %*d MemTotal: %lu kB", &val) == 1) {
                    node->memory_total_mb = val / 1024;
                } else if (sscanf(line, "Node %*d MemFree: %lu kB", &val) == 1) {
                    node->memory_free_mb = val / 1024;
                }
            }
            fclose(f);
        }
 
        // CPU list
        snprintf(path, sizeof(path), "%s/%s/cpulist", base, entry->d_name);
        char cpulist[512];
        if (read_file_string(path, cpulist, sizeof(cpulist)) == 0) {
            // Parse CPU list (e.g., "0-7,16-23")
            char *saveptr;
            char *token = strtok_r(cpulist, ",", &saveptr);
            while (token && node->num_cpus < MAX_CPUS) {
                int start, end;
                if (sscanf(token, "%d-%d", &start, &end) == 2) {
                    for (int i = start; i <= end && node->num_cpus < MAX_CPUS; i++) {
                        node->cpu_list[node->num_cpus++] = i;
                    }
                } else if (sscanf(token, "%d", &start) == 1) {
                    node->cpu_list[node->num_cpus++] = start;
                }
                token = strtok_r(NULL, ",", &saveptr);
            }
        }
 
        numa->num_nodes++;
    }
    closedir(dir);
 
    // Read NUMA distances
    char path[512];
    snprintf(path, sizeof(path), "%s/node0/distance", base);
    char dist_str[256];
    if (read_file_string(path, dist_str, sizeof(dist_str)) == 0) {
        char *saveptr;
        char *token = strtok_r(dist_str, " ", &saveptr);
        int col = 0;
        while (token && col < numa->num_nodes) {
            numa->distances[0][col++] = atoi(token);
            token = strtok_r(NULL, " ", &saveptr);
        }
    }
 
    return 0;
}

References NUMANode::cpu_list, NUMATopology::distances, end, MAX_CPUS, MAX_NUMA_NODES, NUMANode::memory_free_mb, NUMANode::memory_total_mb, NUMANode::node_id, NUMATopology::nodes, NUMANode::num_cpus, NUMATopology::num_nodes, read_file_string(), start, and token.

Referenced by topology_discover().

topology_discover_pcie()

int topology_discover_pcie

(

PCIeTopology *

pcie

)

Definition at line 730 of file system_topology.c.

                                               {
    memset(pcie, 0, sizeof(*pcie));
 
    char output[32768];
    if (run_command("lspci -vvv 2>/dev/null", output, sizeof(output)) != 0) {
        return -1;
    }
 
    PCIeDevice *current = NULL;
    char *line = strtok(output, "\n");
 
    while (line) {
        // New device line: "00:1f.0 ISA bridge: Intel..."
        if (strlen(line) > 0 && isxdigit(line[0]) && line[2] == ':') {
            if (pcie->num_devices < MAX_PCIE_DEVICES) {
                current = &pcie->devices[pcie->num_devices++];
                memset(current, 0, sizeof(*current));
 
                // Parse BDF
                sscanf(line, "%x:%x.%x", &current->bus, &current->device, &current->function);
 
                // Get device name (after the type)
                char *name_start = strchr(line, ':');
                if (name_start) {
                    name_start = strchr(name_start + 1, ':');
                    if (name_start) {
                        name_start++;
                        while (*name_start == ' ') name_start++;
                        strncpy(current->device_name, name_start,
                                sizeof(current->device_name) - 1);
                    }
                }
 
                // Check device type
                current->is_gpu = (strstr(line, "VGA") != NULL ||
                                   strstr(line, "3D controller") != NULL ||
                                   strstr(line, "Display") != NULL);
                current->is_nic = (strstr(line, "Ethernet") != NULL ||
                                   strstr(line, "Network") != NULL ||
                                   strstr(line, "InfiniBand") != NULL);
                current->is_nvme = (strstr(line, "Non-Volatile memory") != NULL);
            }
        } else if (current) {
            // Parse LnkCap and LnkSta for PCIe info
            if (strstr(line, "LnkCap:")) {
                char *speed = strstr(line, "Speed ");
                char *width = strstr(line, "Width x");
                if (speed) {
                    float gts;
                    if (sscanf(speed, "Speed %fGT/s", &gts) == 1) {
                        if (gts >= 64) current->link_speed_max = 6;
                        else if (gts >= 32) current->link_speed_max = 5;
                        else if (gts >= 16) current->link_speed_max = 4;
                        else if (gts >= 8) current->link_speed_max = 3;
                        else if (gts >= 5) current->link_speed_max = 2;
                        else current->link_speed_max = 1;
                    }
                }
                if (width) {
                    sscanf(width, "Width x%d", &current->link_width_max);
                }
            } else if (strstr(line, "LnkSta:")) {
                char *speed = strstr(line, "Speed ");
                char *width = strstr(line, "Width x");
                if (speed) {
                    float gts;
                    if (sscanf(speed, "Speed %fGT/s", &gts) == 1) {
                        if (gts >= 64) current->link_speed = 6;
                        else if (gts >= 32) current->link_speed = 5;
                        else if (gts >= 16) current->link_speed = 4;
                        else if (gts >= 8) current->link_speed = 3;
                        else if (gts >= 5) current->link_speed = 2;
                        else current->link_speed = 1;
                    }
                }
                if (width) {
                    sscanf(width, "Width x%d", &current->link_width);
                }
            }
        }
 
        line = strtok(NULL, "\n");
    }
 
    // Calculate bandwidths and summary
    for (int i = 0; i < pcie->num_devices; i++) {
        PCIeDevice *d = &pcie->devices[i];
        d->bandwidth_gbs = pcie_bandwidth_gbs(d->link_speed, d->link_width);
        d->bandwidth_max_gbs = pcie_bandwidth_gbs(d->link_speed_max, d->link_width_max);
 
        if (d->link_width > 0) {
            pcie->total_lanes_used += d->link_width;
        }
    }
 
    return 0;
}

References PCIeDevice::bandwidth_gbs, PCIeDevice::bandwidth_max_gbs, PCIeDevice::bus, PCIeDevice::device, PCIeDevice::device_name, PCIeTopology::devices, PCIeDevice::function, PCIeDevice::is_gpu, PCIeDevice::is_nic, PCIeDevice::is_nvme, PCIeDevice::link_speed, PCIeDevice::link_speed_max, PCIeDevice::link_width, PCIeDevice::link_width_max, MAX_PCIE_DEVICES, PCIeTopology::num_devices, pcie_bandwidth_gbs(), run_command(), and PCIeTopology::total_lanes_used.

Referenced by topology_discover().

topology_estimate_memory_bandwidth()

float topology_estimate_memory_bandwidth

(

const MemoryInfo *

mem

)

Definition at line 1116 of file system_topology.c.

                                                                {
    return mem->theoretical_bandwidth_gbs;
}

References MemoryInfo::theoretical_bandwidth_gbs.

topology_estimate_network_training_time()

float topology_estimate_network_training_time	(	const NetworkTopology *	net,
		uint64_t	model_size_mb
	)

Definition at line 1120 of file system_topology.c.

                                                                       {
    if (net->max_bandwidth_gbs <= 0) return -1;
 
    // Time to transfer model_size_mb in seconds
    // Account for protocol overhead (~10%)
    float effective_bw = net->max_bandwidth_gbs * 0.9f * 1024;  // Convert to MB/s
    return model_size_mb / effective_bw;
}

References NetworkTopology::max_bandwidth_gbs.

Referenced by topology_print_distributed_potential().

topology_generate_recommendations()

int topology_generate_recommendations	(	const SystemTopology *	topo,
		RecommendationList *	recs
	)

Definition at line 1010 of file system_topology.c.

                                                                 {
    memset(recs, 0, sizeof(*recs));
 
    // Memory recommendations
    if (topo->memory.slots_populated > 0 &&
        topo->memory.slots_populated < topo->memory.num_slots) {
 
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_MEDIUM;
        r->category = REC_CATEGORY_MEMORY;
        strcpy(r->title, "Memory Slots Available");
        snprintf(r->description, sizeof(r->description),
                 "Only %d of %d memory slots populated. Adding more DIMMs "
                 "could increase memory bandwidth.",
                 topo->memory.slots_populated, topo->memory.num_slots);
        snprintf(r->action, sizeof(r->action),
                 "Consider adding %d more matching DIMMs for better bandwidth",
                 topo->memory.num_slots - topo->memory.slots_populated);
    }
 
    // Single-channel warning
    if (topo->memory.channels_populated == 1 && topo->memory.num_slots > 1) {
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_HIGH;
        r->category = REC_CATEGORY_MEMORY;
        strcpy(r->title, "Single-Channel Memory");
        strcpy(r->description,
               "Running in single-channel mode significantly reduces memory bandwidth. "
               "This will impact training performance.");
        strcpy(r->action,
               "Add a second DIMM in the correct slot to enable dual-channel mode");
    }
 
    // Affinity recommendations
    if (!topo->affinity.affinity_set) {
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_MEDIUM;
        r->category = REC_CATEGORY_AFFINITY;
        strcpy(r->title, "OpenMP Affinity Not Set");
        strcpy(r->description,
               "OpenMP thread affinity is not configured. Threads may migrate "
               "between cores causing cache misses and NUMA penalties.");
        strcpy(r->action,
               "export OMP_PROC_BIND=close OMP_PLACES=cores");
    }
 
    // Network recommendations
    if (topo->network.max_bandwidth_gbs < 1.0f) {  // Less than 10 GbE
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_MEDIUM;
        r->category = REC_CATEGORY_NETWORK;
        strcpy(r->title, "Slow Network for Distributed Training");
        snprintf(r->description, sizeof(r->description),
                 "Maximum network bandwidth is %.2f GB/s. This will be a "
                 "significant bottleneck for distributed training.",
                 topo->network.max_bandwidth_gbs);
        strcpy(r->action,
               "Consider upgrading to 10GbE+ or InfiniBand for distributed training");
    }
 
    // RDMA recommendation
    if (!topo->network.has_rdma && topo->network.num_interfaces > 0) {
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_LOW;
        r->category = REC_CATEGORY_NETWORK;
        strcpy(r->title, "No RDMA-Capable NICs");
        strcpy(r->description,
               "No RDMA-capable network adapters detected. RDMA enables direct "
               "memory access between nodes, reducing latency for gradient sync.");
        strcpy(r->action,
               "Consider Mellanox ConnectX or Intel E810 for RDMA support");
    }
 
    // SIMD recommendations
    if (!topo->cpu.has_avx2) {
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_LOW;
        r->category = REC_CATEGORY_CPU;
        strcpy(r->title, "Limited SIMD Support");
        strcpy(r->description,
               "CPU does not support AVX2. Kernel performance will be limited.");
        strcpy(r->action, "AVX2+ CPUs provide significantly better performance");
    }
 
    // NUMA warning for multi-socket
    if (topo->numa.num_nodes > 1) {
        Recommendation *r = &recs->recommendations[recs->num_recommendations++];
        r->priority = REC_PRIORITY_MEDIUM;
        r->category = REC_CATEGORY_CPU;
        strcpy(r->title, "Multi-NUMA System Detected");
        snprintf(r->description, sizeof(r->description),
                 "System has %d NUMA nodes. Cross-node memory access is slower. "
                 "Ensure data locality for best performance.",
                 topo->numa.num_nodes);
        strcpy(r->action,
               "Use numactl --localalloc or NUMA-aware memory allocation");
    }
 
    return 0;
}

References Recommendation::action, SystemTopology::affinity, AffinityInfo::affinity_set, Recommendation::category, MemoryInfo::channels_populated, SystemTopology::cpu, Recommendation::description, CPUInfo::has_avx2, NetworkTopology::has_rdma, NetworkTopology::max_bandwidth_gbs, SystemTopology::memory, SystemTopology::network, NetworkTopology::num_interfaces, NUMATopology::num_nodes, RecommendationList::num_recommendations, MemoryInfo::num_slots, SystemTopology::numa, Recommendation::priority, REC_CATEGORY_AFFINITY, REC_CATEGORY_CPU, REC_CATEGORY_MEMORY, REC_CATEGORY_NETWORK, REC_PRIORITY_HIGH, REC_PRIORITY_LOW, REC_PRIORITY_MEDIUM, RecommendationList::recommendations, MemoryInfo::slots_populated, and Recommendation::title.

Referenced by topology_print_summary().

topology_print_affinity()

void topology_print_affinity

(

const AffinityInfo *

aff

)

Definition at line 528 of file show_config.c.

                                                      {
    print_section("THREAD AFFINITY (OpenMP)");
 
    print_tree_item(0, 0, "OMP_NUM_THREADS: %d", aff->omp_num_threads);
    print_tree_item(0, 0, "OMP_PROC_BIND: %s%s%s",
                    aff->affinity_set ? C(GREEN) : C(YELLOW),
                    aff->omp_proc_bind, C(RESET));
    print_tree_item(0, 1, "OMP_PLACES: %s", aff->omp_places);
 
    if (!aff->affinity_set) {
        printf("\n");
        print_warning("Thread affinity not configured");
        printf("  %s💡 Recommendation:%s export OMP_PROC_BIND=close OMP_PLACES=cores\n",
               C(CYAN), C(RESET));
    }
}

References AffinityInfo::affinity_set, C, CYAN, GREEN, AffinityInfo::omp_num_threads, AffinityInfo::omp_places, AffinityInfo::omp_proc_bind, print_section(), print_tree_item(), print_warning(), RESET, and YELLOW.

Referenced by topology_print_summary().

topology_print_cache()

void topology_print_cache	(	const CacheTopology *	cache,
		int	logical_cores
	)

Definition at line 169 of file show_config.c.

                                                                         {
    print_section("CACHE HIERARCHY");
 
    // Show data source
    printf("  %sSource: /sys/devices/system/cpu/cpu0/cache/%s\n\n",
           C(DIM), C(RESET));
 
    for (int i = 0; i < cache->num_levels; i++) {
        const CacheInfo *c = &cache->levels[i];
        int is_last = (i == cache->num_levels - 1);
 
        // Calculate number of instances (how many of this cache exist)
        int instances = 1;
        if (c->shared_by_cores > 0 && logical_cores > 0) {
            instances = logical_cores / c->shared_by_cores;
            if (instances < 1) instances = 1;
        }
 
        // Calculate total size across all instances
        int total_kb = c->size_kb * instances;
 
        // Format size nicely (KB or MB)
        char size_str[32];
        if (total_kb >= 1024) {
            snprintf(size_str, sizeof(size_str), "%d MiB", total_kb / 1024);
        } else {
            snprintf(size_str, sizeof(size_str), "%d KiB", total_kb);
        }
 
        // Format instance info like lscpu
        char instance_str[32] = "";
        if (instances > 1) {
            snprintf(instance_str, sizeof(instance_str), " (%d instances)", instances);
        } else {
            snprintf(instance_str, sizeof(instance_str), " (%d instance)", instances);
        }
 
        print_tree_item(0, is_last, "L%d%c: %s%s",
                        c->level,
                        c->type[0] == 'D' ? 'd' : (c->type[0] == 'I' ? 'i' : ' '),
                        size_str, instance_str);
    }
}

References C, DIM, CacheInfo::level, CacheTopology::levels, CacheTopology::num_levels, print_section(), print_tree_item(), RESET, CacheInfo::shared_by_cores, CacheInfo::size_kb, and CacheInfo::type.

Referenced by topology_print_summary().

topology_print_cpu()

void topology_print_cpu

(

const CPUInfo *

cpu

)

Definition at line 103 of file show_config.c.

                                            {
    print_section("CPU");
 
    printf("  %s%s%s\n", C(BOLD), cpu->model_name, C(RESET));
 
    // Build SIMD string with detailed AVX-512 sub-features
    char simd_buf[256] = "";
    if (cpu->has_avx512f) {
        strcat(simd_buf, "AVX-512");
        // Add AVX-512 sub-features in parentheses
        char sub_features[64] = "";
        if (cpu->has_avx512_bf16) strcat(sub_features, "BF16, ");
        if (cpu->has_avx512bw) strcat(sub_features, "BW, ");
        if (cpu->has_avx512vl) strcat(sub_features, "VL, ");
        if (sub_features[0]) {
            // Remove trailing ", "
            sub_features[strlen(sub_features) - 2] = '\0';
            strcat(simd_buf, " (");
            strcat(simd_buf, sub_features);
            strcat(simd_buf, ")");
        }
        strcat(simd_buf, " ");
    } else if (cpu->has_avx2) {
        strcat(simd_buf, "AVX2 ");
    } else if (cpu->has_avx) {
        strcat(simd_buf, "AVX ");
    } else if (cpu->has_sse4_2) {
        strcat(simd_buf, "SSE4.2 ");
    }
 
    if (cpu->has_vnni) strcat(simd_buf, "VNNI ");
 
    // AMX details
    if (cpu->has_amx) {
        strcat(simd_buf, "AMX");
        char amx_features[32] = "";
        if (cpu->has_amx_bf16) strcat(amx_features, "BF16,");
        if (cpu->has_amx_int8) strcat(amx_features, "INT8,");
        if (amx_features[0]) {
            amx_features[strlen(amx_features) - 1] = '\0';  // Remove trailing comma
            strcat(simd_buf, "(");
            strcat(simd_buf, amx_features);
            strcat(simd_buf, ") ");
        } else {
            strcat(simd_buf, " ");
        }
    }
 
    print_tree_item(0, 0, "Sockets: %d", cpu->sockets);
    print_tree_item(0, 0, "Cores: %d physical, %d logical %s",
                    cpu->physical_cores, cpu->logical_cores,
                    cpu->threads_per_core > 1 ? "(HT/SMT enabled)" : "");
    print_tree_item(0, 0, "Frequency: %.0f MHz (max: %.0f MHz)",
                    cpu->base_freq_mhz, cpu->max_freq_mhz);
    print_tree_item(0, 0, "SIMD: %s%s%s",
                    C(cpu->has_avx512f ? GREEN : (cpu->has_avx2 ? GREEN : YELLOW)),
                    simd_buf[0] ? simd_buf : "Basic",
                    C(RESET));
    print_tree_item(0, 1, "PCIe: Gen %d, ~%d lanes from CPU",
                    cpu->pcie_generation, cpu->pcie_lanes_total);
 
    if (!cpu->has_avx2) {
        print_warning("No AVX2 support - kernel performance will be limited");
    }
}

References CPUInfo::base_freq_mhz, BOLD, C, GREEN, CPUInfo::has_amx, CPUInfo::has_amx_bf16, CPUInfo::has_amx_int8, CPUInfo::has_avx, CPUInfo::has_avx2, CPUInfo::has_avx512_bf16, CPUInfo::has_avx512bw, CPUInfo::has_avx512f, CPUInfo::has_avx512vl, CPUInfo::has_sse4_2, CPUInfo::has_vnni, CPUInfo::logical_cores, CPUInfo::max_freq_mhz, CPUInfo::model_name, CPUInfo::pcie_generation, CPUInfo::pcie_lanes_total, CPUInfo::physical_cores, print_section(), print_tree_item(), print_warning(), RESET, CPUInfo::sockets, CPUInfo::threads_per_core, and YELLOW.

Referenced by topology_print_summary().

topology_print_distributed_potential()

void topology_print_distributed_potential

(

const SystemTopology *

topo

)

Definition at line 584 of file show_config.c.

                                                                      {
    print_section("DISTRIBUTED TRAINING POTENTIAL");
 
    char mem_bw_buf[32], net_bw_buf[32];
    format_bandwidth(topo->memory.theoretical_bandwidth_gbs, mem_bw_buf, sizeof(mem_bw_buf));
    format_bandwidth(topo->network.max_bandwidth_gbs, net_bw_buf, sizeof(net_bw_buf));
 
    printf("  Single Node Capacity:\n");
    print_tree_item(0, 0, "Compute: %d cores @ %s",
                    topo->cpu.physical_cores,
                    topo->cpu.has_avx512f ? "AVX-512" :
                    (topo->cpu.has_avx2 ? "AVX2" : "AVX"));
    print_tree_item(0, 0, "Memory: %lu GB @ %s",
                    (unsigned long)(topo->memory.total_mb / 1024), mem_bw_buf);
    print_tree_item(0, 1, "Network: %s", net_bw_buf);
 
    // Estimate sync times for various model sizes
    printf("\n  Estimated Gradient Sync Time (single allreduce):\n");
 
    uint64_t model_sizes[] = {100, 500, 1000, 7000};  // MB
    const char *model_names[] = {"100 MB (BERT-base)", "500 MB (GPT-2)",
                                  "1 GB (ResNet-50 batch)", "7 GB (LLaMA-7B)"};
 
    for (int i = 0; i < 4; i++) {
        float sync_time = topology_estimate_network_training_time(
            &topo->network, model_sizes[i]);
 
        const char *time_color = "";
        if (sync_time < 0.1f) time_color = GREEN;
        else if (sync_time < 1.0f) time_color = YELLOW;
        else time_color = RED;
 
        printf("    %-25s %s%8.2f sec%s\n",
               model_names[i], C(time_color), sync_time, C(RESET));
    }
 
    // Multi-node projection
    printf("\n  Multi-Node Projection (assuming identical nodes):\n");
    int nodes[] = {2, 4, 8, 16};
    for (int i = 0; i < 4; i++) {
        int n = nodes[i];
        uint64_t total_mem = topo->memory.total_mb * n;
        int total_cores = topo->cpu.physical_cores * n;
 
        char total_mem_buf[32];
        format_size(total_mem, total_mem_buf, sizeof(total_mem_buf));
 
        printf("    %2d nodes: %4d cores, %s memory\n",
               n, total_cores, total_mem_buf);
    }
 
    // Ring-allreduce topology diagram
    printf("\n  Ring-AllReduce Topology (4 nodes):\n");
    printf("     %s┌─────────┐     ┌─────────┐%s\n", C(CYAN), C(RESET));
    printf("     %s│ Node 0  │────→│ Node 1  │%s\n", C(CYAN), C(RESET));
    printf("     %s│ Worker  │     │ Worker  │%s\n", C(CYAN), C(RESET));
    printf("     %s└────↑────┘     └────│────┘%s\n", C(CYAN), C(RESET));
    printf("     %s     │               │     %s\n", C(CYAN), C(RESET));
    printf("     %s     │               ↓     %s\n", C(CYAN), C(RESET));
    printf("     %s┌────│────┐     ┌────↓────┐%s\n", C(CYAN), C(RESET));
    printf("     %s│ Node 3  │←────│ Node 2  │%s\n", C(CYAN), C(RESET));
    printf("     %s│ Worker  │     │ Worker  │%s\n", C(CYAN), C(RESET));
    printf("     %s└─────────┘     └─────────┘%s\n", C(CYAN), C(RESET));
}

References C, SystemTopology::cpu, CYAN, format_bandwidth(), format_size(), GREEN, CPUInfo::has_avx2, CPUInfo::has_avx512f, NetworkTopology::max_bandwidth_gbs, SystemTopology::memory, SystemTopology::network, CPUInfo::physical_cores, print_section(), print_tree_item(), RED, RESET, MemoryInfo::theoretical_bandwidth_gbs, topology_estimate_network_training_time(), MemoryInfo::total_mb, and YELLOW.

Referenced by topology_print_summary().

topology_print_memory()

void topology_print_memory

(

const MemoryInfo *

mem

)

Definition at line 292 of file show_config.c.

                                                  {
    print_section("MEMORY");
 
    // Show data sources
    printf("  %sSource: /proc/meminfo, dmidecode (if root), STREAM benchmark%s\n\n",
           C(DIM), C(RESET));
 
    char total_buf[32], avail_buf[32], theo_bw_buf[32], meas_bw_buf[32];
    format_size(mem->total_mb, total_buf, sizeof(total_buf));
    format_size(mem->available_mb, avail_buf, sizeof(avail_buf));
    format_bandwidth(mem->theoretical_bandwidth_gbs, theo_bw_buf, sizeof(theo_bw_buf));
    format_bandwidth(mem->measured_bandwidth_gbs, meas_bw_buf, sizeof(meas_bw_buf));
 
    printf("  %sTotal: %s%s (%s available)\n",
           C(BOLD), total_buf, C(RESET), avail_buf);
 
    if (mem->memory_type[0]) {
        print_tree_item(0, 0, "Type: %s @ %d MT/s", mem->memory_type, mem->memory_speed_mhz);
    }
 
    print_tree_item(0, 0, "Configuration: %s", mem->channel_config);
 
    if (mem->num_slots > 0) {
        print_tree_item(0, 0, "Slots: %d/%d populated",
                        mem->slots_populated, mem->num_slots);
    }
 
    // Show bandwidth measurements with explanation
    printf("\n  %sBandwidth Analysis:%s\n", C(CYAN), C(RESET));
 
    // Theoretical bandwidth calculation
    if (mem->memory_speed_mhz > 0 && mem->channels_populated > 0) {
        printf("  %s├── Theoretical: %d MT/s × 8 bytes × %d channel(s) = %s%s\n",
               C(DIM), mem->memory_speed_mhz, mem->channels_populated,
               theo_bw_buf, C(RESET));
 
        // Show SNC relationship for multi-channel configs
        if (mem->channels_populated >= 4) {
            printf("  %s│   └── SNC potential: %d ch ÷ 2 = SNC2 (%d ch/node), ÷ 4 = SNC4 (%d ch/node)%s\n",
                   C(DIM), mem->channels_populated,
                   mem->channels_populated / 2,
                   mem->channels_populated / 4,
                   C(RESET));
        } else if (mem->channels_populated >= 2) {
            printf("  %s│   └── SNC potential: %d ch ÷ 2 = SNC2 (%d ch/node)%s\n",
                   C(DIM), mem->channels_populated,
                   mem->channels_populated / 2,
                   C(RESET));
        }
    } else {
        printf("  %s├── Theoretical: %s (estimated)%s\n",
               C(DIM), theo_bw_buf, C(RESET));
    }
 
    // Measured bandwidth with methodology
    if (mem->measured_bandwidth_gbs > 0) {
        float efficiency = (mem->theoretical_bandwidth_gbs > 0) ?
            (mem->measured_bandwidth_gbs / mem->theoretical_bandwidth_gbs * 100.0f) : 0;
 
        printf("  %s├── Measured: %s%s%s (%.0f%% efficiency)%s\n",
               C(DIM),
               C(mem->measured_bandwidth_gbs > 40 ? GREEN : YELLOW),
               meas_bw_buf, C(RESET), efficiency, C(RESET));
        printf("  %s│   Method: STREAM Triad (c[i] = a[i] + s*b[i])%s\n",
               C(DIM), C(RESET));
        printf("  %s│   Buffer: 256 MB × 3 arrays, 3 iterations%s\n",
               C(DIM), C(RESET));
        printf("  %s│   NUMA node: %d (memory allocated on this node)%s\n",
               C(DIM), mem->bw_test_numa_node, C(RESET));
        printf("  %s│   Threads: %d (OMP_NUM_THREADS)%s\n",
               C(DIM), mem->bw_test_num_threads, C(RESET));
        printf("  %s└── Formula: (256MB × 3 × 3) / time = GB/s%s\n",
               C(DIM), C(RESET));
    }
 
    // Show DIMM details if available
    if (mem->num_slots > 0 && mem->slots[0].locator[0]) {
        printf("\n  DIMM Layout:\n");
        for (int i = 0; i < mem->num_slots; i++) {
            const MemorySlot *s = &mem->slots[i];
            if (s->populated) {
                char dimm_size[32];
                format_size(s->size_mb, dimm_size, sizeof(dimm_size));
                printf("    %s[%s]%s %s: %s%s @ %d MT/s%s\n",
                       C(GREEN), s->locator, C(RESET),
                       s->type, C(BOLD), dimm_size, s->speed_mhz, C(RESET));
            } else {
                printf("    %s[%s]%s EMPTY\n",
                       C(DIM), s->locator, C(RESET));
            }
        }
    }
 
    if (mem->channels_populated == 1 && mem->num_slots > 1) {
        print_warning("Single-channel mode - bandwidth reduced by ~50%%");
    }
 
    if (mem->num_slots > 0 && mem->slots_populated < mem->num_slots) {
        printf("  %s💡 Tip:%s Add %d more DIMM(s) for better bandwidth\n",
               C(CYAN), C(RESET), mem->num_slots - mem->slots_populated);
    }
}

References MemoryInfo::available_mb, BOLD, MemoryInfo::bw_test_num_threads, MemoryInfo::bw_test_numa_node, C, MemoryInfo::channel_config, MemoryInfo::channels_populated, CYAN, DIM, format_bandwidth(), format_size(), GREEN, MemorySlot::locator, MemoryInfo::measured_bandwidth_gbs, MemoryInfo::memory_speed_mhz, MemoryInfo::memory_type, MemoryInfo::num_slots, MemorySlot::populated, print_section(), print_tree_item(), print_warning(), RESET, MemorySlot::size_mb, MemoryInfo::slots, MemoryInfo::slots_populated, MemorySlot::speed_mhz, MemoryInfo::theoretical_bandwidth_gbs, MemoryInfo::total_mb, MemorySlot::type, and YELLOW.

Referenced by topology_print_summary().

topology_print_network()

void topology_print_network

(

const NetworkTopology *

net

)

Definition at line 458 of file show_config.c.

                                                        {
    print_section("NETWORK INTERFACES");
 
    if (net->num_interfaces == 0) {
        printf("  %sNo network interfaces detected%s\n", C(DIM), C(RESET));
        return;
    }
 
    char bw_buf[32];
 
    for (int i = 0; i < net->num_interfaces; i++) {
        const NetworkInterface *n = &net->interfaces[i];
 
        const char *status_icon = n->is_up && n->has_link ? "✓" : "✗";
        const char *status_color = n->is_up && n->has_link ? GREEN : RED;
 
        float bw_gbs = n->speed_mbps / 8000.0f;
        format_bandwidth(bw_gbs, bw_buf, sizeof(bw_buf));
 
        printf("  %s%s%s %s%-10s%s ",
               C(status_color), status_icon, C(RESET),
               C(BOLD), n->name, C(RESET));
 
        if (n->has_link) {
            // Color code speed
            const char *speed_color = "";
            if (n->speed_mbps >= 100000) speed_color = GREEN;      // 100 GbE+
            else if (n->speed_mbps >= 10000) speed_color = GREEN;  // 10 GbE
            else if (n->speed_mbps >= 1000) speed_color = YELLOW;  // 1 GbE
            else speed_color = RED;                                 // < 1 GbE
 
            printf("%s%6lu Mbps%s (%s) ",
                   C(speed_color), (unsigned long)n->speed_mbps, C(RESET), bw_buf);
        } else {
            printf("%sno link    %s ", C(RED), C(RESET));
        }
 
        if (n->driver[0]) {
            printf("%s[%s]%s ", C(DIM), n->driver, C(RESET));
        }
 
        if (n->supports_rdma) {
            printf("%s[RDMA]%s ", C(GREEN), C(RESET));
        }
        if (n->is_infiniband) {
            printf("%s[IB]%s ", C(MAGENTA), C(RESET));
        }
 
        printf("\n");
    }
 
    // Network capability summary
    printf("\n  For Distributed Training:\n");
 
    if (net->max_bandwidth_gbs >= 12.5f) {
        print_ok("100 GbE+ available - excellent for distributed training");
    } else if (net->max_bandwidth_gbs >= 1.25f) {
        printf("  %s✓%s 10 GbE available - good for small clusters\n",
               C(GREEN), C(RESET));
    } else if (net->max_bandwidth_gbs >= 0.125f) {
        print_warning("Only 1 GbE - significant bottleneck for distributed training");
    } else {
        print_warning("Very slow network - distributed training not recommended");
    }
 
    if (net->has_rdma) {
        print_ok("RDMA capable NIC detected - low-latency gradient sync possible");
    }
}

References BOLD, C, DIM, NetworkInterface::driver, format_bandwidth(), GREEN, NetworkInterface::has_link, NetworkTopology::has_rdma, NetworkTopology::interfaces, NetworkInterface::is_infiniband, NetworkInterface::is_up, MAGENTA, NetworkTopology::max_bandwidth_gbs, NetworkInterface::name, NetworkTopology::num_interfaces, print_ok(), print_section(), print_warning(), RED, RESET, NetworkInterface::speed_mbps, NetworkInterface::supports_rdma, and YELLOW.

Referenced by topology_print_summary().

topology_print_numa()

void topology_print_numa	(	const NUMATopology *	numa,
		int	sockets
	)

Definition at line 213 of file show_config.c.

                                                                {
    print_section("NUMA TOPOLOGY");
 
    // Show source
    printf("  %sSource: /sys/devices/system/node/%s\n", C(DIM), C(RESET));
 
    // Single NUMA node - UMA system
    if (numa->num_nodes <= 1) {
        printf("\n  %s✓ Single NUMA node (Uniform Memory Access)%s\n", C(GREEN), C(RESET));
        printf("  %s  All memory is local - no NUMA penalties%s\n", C(DIM), C(RESET));
        printf("\n  %sNote: Sub-NUMA Clustering (SNC) / NUMA-Per-Socket (NPS) not detected.%s\n",
               C(DIM), C(RESET));
        printf("  %s  On Xeon/EPYC, check BIOS settings or run: numactl --hardware%s\n",
               C(DIM), C(RESET));
        return;
    }
 
    // Detect potential Sub-NUMA Clustering (SNC) or NUMA-Per-Socket (NPS)
    // If num_nodes > sockets, SNC/NPS is likely enabled
    // SNC divides each socket's memory channels into groups, one per sub-NUMA node
    if (sockets > 0 && numa->num_nodes > sockets) {
        int nodes_per_socket = numa->num_nodes / sockets;
        printf("\n  %s⚠ Sub-NUMA detected: %d NUMA nodes on %d socket(s) = SNC%d or NPS%d%s\n",
               C(YELLOW), numa->num_nodes, sockets, nodes_per_socket, nodes_per_socket, C(RESET));
        printf("  %s  Intel: Sub-NUMA Clustering (SNC) | AMD: NUMA-Per-Socket (NPS)%s\n",
               C(DIM), C(RESET));
        printf("  %s  Each sub-node has its own memory channels for lower latency%s\n",
               C(DIM), C(RESET));
    } else if (sockets > 1) {
        // Multi-socket without SNC
        printf("\n  %sMulti-socket system: %d sockets, %d NUMA nodes%s\n",
               C(CYAN), sockets, numa->num_nodes, C(RESET));
        printf("  %s  SNC/NPS not enabled - each socket is one NUMA node%s\n",
               C(DIM), C(RESET));
        printf("  %s  💡 Enable SNC in BIOS to partition channels for lower latency%s\n",
               C(DIM), C(RESET));
    }
 
    printf("\n");
    char size_buf[32];
 
    for (int i = 0; i < numa->num_nodes; i++) {
        const NUMANode *n = &numa->nodes[i];
        int is_last = (i == numa->num_nodes - 1);
 
        format_size(n->memory_total_mb, size_buf, sizeof(size_buf));
        print_tree_item(0, is_last, "Node %d: %s, CPUs %d-%d",
                        n->node_id, size_buf,
                        n->cpu_list[0],
                        n->cpu_list[n->num_cpus - 1]);
    }
 
    // Print distance matrix if more than 2 nodes
    if (numa->num_nodes >= 2 && numa->distances[0][1] > 0) {
        printf("\n  NUMA Distances (10=local, higher=remote):\n");
        printf("       ");
        for (int i = 0; i < numa->num_nodes; i++) {
            printf(" N%d ", i);
        }
        printf("\n");
        for (int i = 0; i < numa->num_nodes; i++) {
            printf("    N%d", i);
            for (int j = 0; j < numa->num_nodes; j++) {
                int dist = numa->distances[i][j];
                if (dist == 10) {
                    printf(" %s%2d%s ", C(GREEN), dist, C(RESET));
                } else {
                    printf(" %s%2d%s ", C(YELLOW), dist, C(RESET));
                }
            }
            printf("\n");
        }
    }
 
    // Tip for accurate per-node bandwidth
    printf("\n  %s💡 Per-node bandwidth: numactl --cpunodebind=0 --membind=0 ./build/show_config%s\n",
           C(CYAN), C(RESET));
}

References C, NUMANode::cpu_list, CYAN, DIM, NUMATopology::distances, format_size(), GREEN, NUMANode::memory_total_mb, NUMANode::node_id, NUMATopology::nodes, NUMANode::num_cpus, NUMATopology::num_nodes, print_section(), print_tree_item(), RESET, and YELLOW.

Referenced by topology_print_summary().

topology_print_pcie()

void topology_print_pcie

(

const PCIeTopology *

pcie

)

Definition at line 395 of file show_config.c.

                                                   {
    print_section("PCIe DEVICES");
 
    int gpu_count = 0, nic_count = 0, nvme_count = 0;
    char bw_buf[32];
 
    for (int i = 0; i < pcie->num_devices; i++) {
        const PCIeDevice *d = &pcie->devices[i];
 
        // Skip bridges and other infrastructure devices
        if (d->link_width == 0) continue;
        if (strstr(d->device_name, "bridge") ||
            strstr(d->device_name, "Bridge") ||
            strstr(d->device_name, "Host") ||
            strstr(d->device_name, "PCI")) continue;
 
        const char *type_icon = "   ";
        const char *type_color = "";
        if (d->is_gpu) {
            type_icon = "🎮 ";
            type_color = GREEN;
            gpu_count++;
        } else if (d->is_nic) {
            type_icon = "🌐 ";
            type_color = CYAN;
            nic_count++;
        } else if (d->is_nvme) {
            type_icon = "💾 ";
            type_color = MAGENTA;
            nvme_count++;
        }
 
        format_bandwidth(d->bandwidth_gbs, bw_buf, sizeof(bw_buf));
 
        // Truncate long device names
        char name[48];
        strncpy(name, d->device_name, sizeof(name) - 1);
        name[sizeof(name) - 1] = '\0';
        if (strlen(d->device_name) > 45) {
            strcpy(name + 42, "...");
        }
 
        printf("  %s%s%s%-45s%s x%d Gen%d %s%s%s",
               type_icon, C(type_color), C(BOLD), name, C(RESET),
               d->link_width, d->link_speed,
               C(DIM), bw_buf, C(RESET));
 
        // Show if not running at max capability
        if (d->link_width < d->link_width_max || d->link_speed < d->link_speed_max) {
            printf(" %s(capable: x%d Gen%d)%s",
                   C(YELLOW), d->link_width_max, d->link_speed_max, C(RESET));
        }
        printf("\n");
    }
 
    if (gpu_count == 0 && nic_count == 0 && nvme_count == 0) {
        printf("  %sNo significant PCIe devices detected%s\n", C(DIM), C(RESET));
    }
 
    printf("\n  Summary: %d GPU(s), %d NIC(s), %d NVMe(s)\n",
           gpu_count, nic_count, nvme_count);
}

References PCIeDevice::bandwidth_gbs, BOLD, C, CYAN, PCIeDevice::device_name, PCIeTopology::devices, DIM, format_bandwidth(), GREEN, PCIeDevice::is_gpu, PCIeDevice::is_nic, PCIeDevice::is_nvme, PCIeDevice::link_speed, PCIeDevice::link_speed_max, PCIeDevice::link_width, PCIeDevice::link_width_max, MAGENTA, PCIeTopology::num_devices, print_section(), RESET, and YELLOW.

Referenced by topology_print_summary().

topology_print_recommendations()

void topology_print_recommendations

(

const RecommendationList *

recs

)

Definition at line 545 of file show_config.c.

                                                                    {
    if (recs->num_recommendations == 0) {
        print_section("RECOMMENDATIONS");
        print_ok("No significant issues detected!");
        return;
    }
 
    print_section("RECOMMENDATIONS");
 
    for (int i = 0; i < recs->num_recommendations; i++) {
        const Recommendation *r = &recs->recommendations[i];
 
        const char *priority_icon = "";
        const char *priority_color = "";
        switch (r->priority) {
            case REC_PRIORITY_CRITICAL:
                priority_icon = "🔴";
                priority_color = RED;
                break;
            case REC_PRIORITY_HIGH:
                priority_icon = "🟠";
                priority_color = RED;
                break;
            case REC_PRIORITY_MEDIUM:
                priority_icon = "🟡";
                priority_color = YELLOW;
                break;
            case REC_PRIORITY_LOW:
                priority_icon = "🟢";
                priority_color = GREEN;
                break;
        }
 
        printf("\n  %s %s%s%s\n", priority_icon, C(priority_color), r->title, C(RESET));
        printf("     %s\n", r->description);
        printf("     %s→ %s%s\n", C(CYAN), r->action, C(RESET));
    }
}

References Recommendation::action, C, CYAN, Recommendation::description, GREEN, RecommendationList::num_recommendations, print_ok(), print_section(), Recommendation::priority, REC_PRIORITY_CRITICAL, REC_PRIORITY_HIGH, REC_PRIORITY_LOW, REC_PRIORITY_MEDIUM, RecommendationList::recommendations, RED, RESET, Recommendation::title, and YELLOW.

Referenced by topology_print_summary().

topology_print_summary()

void topology_print_summary

(

const SystemTopology *

topo

)

Definition at line 649 of file show_config.c.

                                                        {
    print_header("C-Kernel-Engine System Configuration");
 
    printf("  %sHostname:%s %s\n", C(DIM), C(RESET), topo->hostname);
    printf("  %sKernel:%s   %s\n", C(DIM), C(RESET), topo->kernel_version);
    if (!topo->has_root_access) {
        printf("  %sNote:%s Running without root - some info may be unavailable\n",
               C(YELLOW), C(RESET));
    }
 
    topology_print_cpu(&topo->cpu);
    topology_print_cache(&topo->cache, topo->cpu.logical_cores);
    topology_print_numa(&topo->numa, topo->cpu.sockets);
    topology_print_memory(&topo->memory);
    topology_print_pcie(&topo->pcie);
    topology_print_network(&topo->network);
    topology_print_affinity(&topo->affinity);
 
    RecommendationList recs;
    topology_generate_recommendations(topo, &recs);
    topology_print_recommendations(&recs);
 
    topology_print_distributed_potential(topo);
 
    printf("\n");
}

References SystemTopology::affinity, C, SystemTopology::cache, SystemTopology::cpu, DIM, SystemTopology::has_root_access, SystemTopology::hostname, SystemTopology::kernel_version, CPUInfo::logical_cores, SystemTopology::memory, SystemTopology::network, SystemTopology::numa, SystemTopology::pcie, print_header(), RESET, CPUInfo::sockets, topology_generate_recommendations(), topology_print_affinity(), topology_print_cache(), topology_print_cpu(), topology_print_distributed_potential(), topology_print_memory(), topology_print_network(), topology_print_numa(), topology_print_pcie(), topology_print_recommendations(), and YELLOW.

Referenced by main().