show_config.c File Reference

#include "system_topology.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>

Go to the source code of this file.

Macros
#define	_GNU_SOURCE
#define	BG_GREEN   "\033[42m"
#define	BG_RED   "\033[41m"
#define	BG_YELLOW   "\033[43m"
#define	BLUE   "\033[34m"
#define	BOLD   "\033[1m"
#define	C(color)   (use_colors ? color : "")
#define	CYAN   "\033[36m"
#define	DIM   "\033[2m"
#define	GREEN   "\033[32m"
#define	MAGENTA   "\033[35m"
#define	RED   "\033[31m"
#define	RESET   "\033[0m"
#define	WHITE   "\033[37m"
#define	YELLOW   "\033[33m"

Functions
static const char *	format_bandwidth (float bw_gbs, char *buf, size_t buf_size)
static const char *	format_size (uint64_t size_mb, char *buf, size_t buf_size)
int	main (int argc, char *argv[])
static void	print_header (const char *title)
static void	print_ok (const char *msg)
static void	print_section (const char *title)
static void	print_tree_item (int level, int is_last, const char *fmt,...)
static void	print_warning (const char *msg)
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)

Variables
static int	use_colors = 1

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 8 of file show_config.c.

BG_GREEN

#define BG_GREEN   "\033[42m"

Definition at line 33 of file show_config.c.

BG_RED

#define BG_RED   "\033[41m"

Definition at line 32 of file show_config.c.

BG_YELLOW

#define BG_YELLOW   "\033[43m"

Definition at line 34 of file show_config.c.

BLUE

#define BLUE   "\033[34m"

Definition at line 27 of file show_config.c.

BOLD

#define BOLD   "\033[1m"

Definition at line 21 of file show_config.c.

C

#define C

(

color

)

(use_colors ? color : "")

Definition at line 39 of file show_config.c.

CYAN

#define CYAN   "\033[36m"

Definition at line 29 of file show_config.c.

DIM

#define DIM   "\033[2m"

Definition at line 22 of file show_config.c.

GREEN

#define GREEN   "\033[32m"

Definition at line 25 of file show_config.c.

MAGENTA

#define MAGENTA   "\033[35m"

Definition at line 28 of file show_config.c.

RED

#define RED   "\033[31m"

Definition at line 24 of file show_config.c.

RESET

#define RESET   "\033[0m"

Definition at line 20 of file show_config.c.

WHITE

#define WHITE   "\033[37m"

Definition at line 30 of file show_config.c.

YELLOW

#define YELLOW   "\033[33m"

Definition at line 26 of file show_config.c.

Function Documentation

format_bandwidth()

static const char* format_bandwidth ( float  bw_gbs, char *  buf, size_t  buf_size  )

static

Definition at line 56 of file show_config.c.

                                                                              {
    if (bw_gbs >= 1.0f) {
        snprintf(buf, buf_size, "%.1f GB/s", bw_gbs);
    } else {
        snprintf(buf, buf_size, "%.0f MB/s", bw_gbs * 1024);
    }
    return buf;
}

Referenced by topology_print_distributed_potential(), topology_print_memory(), topology_print_network(), and topology_print_pcie().

format_size()

static const char* format_size ( uint64_t  size_mb, char *  buf, size_t  buf_size  )

static

Definition at line 45 of file show_config.c.

                                                                             {
    if (size_mb >= 1024 * 1024) {
        snprintf(buf, buf_size, "%.1f TB", size_mb / (1024.0 * 1024.0));
    } else if (size_mb >= 1024) {
        snprintf(buf, buf_size, "%.1f GB", size_mb / 1024.0);
    } else {
        snprintf(buf, buf_size, "%lu MB", (unsigned long)size_mb);
    }
    return buf;
}

Referenced by topology_print_distributed_potential(), topology_print_memory(), and topology_print_numa().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 680 of file show_config.c.

                                 {
    // Check for --no-color flag
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--no-color") == 0) {
            use_colors = 0;
        }
        if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
            printf("Usage: %s [OPTIONS]\n", argv[0]);
            printf("\nDisplay system hardware configuration for C-Kernel-Engine\n");
            printf("\nOptions:\n");
            printf("  --no-color    Disable colored output\n");
            printf("  --help, -h    Show this help message\n");
            return 0;
        }
    }
 
    // Check if stdout is a terminal
    if (!isatty(1)) {
        use_colors = 0;
    }
 
    SystemTopology topo;
    if (topology_discover(&topo) < 0) {
        fprintf(stderr, "Error: Failed to discover system topology\n");
        return 1;
    }
 
    topology_print_summary(&topo);
 
    return 0;
}

References topology_discover(), topology_print_summary(), and use_colors.

print_header()

static void print_header ( const char *  title )

static

Definition at line 65 of file show_config.c.

                                            {
    printf("\n%s", C(BOLD));
    printf("═══════════════════════════════════════════════════════════════════════════════\n");
    printf("  %s\n", title);
    printf("═══════════════════════════════════════════════════════════════════════════════%s\n",
           C(RESET));
}

References BOLD, C, and RESET.

Referenced by topology_print_summary().

print_ok()

static void print_ok ( const char *  msg )

static

Definition at line 95 of file show_config.c.

                                      {
    printf("  %s✓  %s%s\n", C(GREEN), msg, C(RESET));
}

References C, GREEN, and RESET.

Referenced by topology_print_network(), and topology_print_recommendations().

print_section()

static void print_section ( const char *  title )

static

Definition at line 73 of file show_config.c.

                                             {
    printf("\n%s  %s%s\n", C(CYAN), title, C(RESET));
    printf("  ────────────────────────────────────────────────────────────────────────────\n");
}

References C, CYAN, and RESET.

Referenced by 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(), and topology_print_recommendations().

print_tree_item()

static void print_tree_item ( int  level, int  is_last, const char *  fmt,   ...  )

static

Definition at line 78 of file show_config.c.

                                                                          {
    for (int i = 0; i < level; i++) {
        printf("  │   ");
    }
    printf("  %s── ", is_last ? "└" : "├");
 
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
    printf("\n");
}

Referenced by topology_print_affinity(), topology_print_cache(), topology_print_cpu(), topology_print_distributed_potential(), topology_print_memory(), and topology_print_numa().

print_warning()

static void print_warning ( const char *  msg )

static

Definition at line 91 of file show_config.c.

                                           {
    printf("  %s⚠️  %s%s\n", C(YELLOW), msg, C(RESET));
}

References C, RESET, and YELLOW.

Referenced by topology_print_affinity(), topology_print_cpu(), topology_print_memory(), and topology_print_network().

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().

Variable Documentation

use_colors

int use_colors = 1

static

Definition at line 37 of file show_config.c.

Referenced by main().