系统编程完全精通：从 C 语言到 Rust，写给 AI 工程师的底层编程指南

#include <stdio.h>

void demonstrate_stack() {
    int x = 10;           // 在栈上分配 4 字节
    double y = 3.14;      // 在栈上分配 8 字节
    char arr[100];        // 在栈上分配 100 字节

    printf("x 地址: %p\n", (void*)&x);
    printf("y 地址: %p\n", (void*)&y);
    printf("arr 地址: %p\n", (void*)arr);
    // 函数结束时,上述变量会自动释放
}

int main() {
    demonstrate_stack();
    // 到这里,x、y、arr 已经被释放
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    float* weights;
    int size;
} Layer;

Layer* create_layer(int size) {
    Layer* layer = (Layer*)malloc(sizeof(Layer));
    if (layer == NULL) {
        fprintf(stderr, "内存分配失败\n");
        return NULL;
    }

    layer->weights = (float*)calloc(size, sizeof(float));
    if (layer->weights == NULL) {
        free(layer);
        return NULL;
    }

    layer->size = size;

    // 权重初始化
    for (int i = 0; i < size; i++) {
        layer->weights[i] = (float)rand() / RAND_MAX * 0.1f;
    }

    return layer;
}

void destroy_layer(Layer* layer) {
    if (layer != NULL) {
        free(layer->weights);  // 先释放内部指针
        free(layer);           // 再释放结构体
    }
}

int main() {
    Layer* fc = create_layer(512);
    printf("层大小: %d, 第一个权重: %.6f\n", fc->size, fc->weights[0]);
    destroy_layer(fc);
    fc = NULL;  // 防止悬垂指针
    return 0;
}

#include <stdio.h>
#include <string.h>

// 危险函数 —— 可能引发缓冲区溢出
void vulnerable_copy(char* dst, const char* src) {
    strcpy(dst, src);  // 没有长度检查!
}

// 安全函数
void safe_copy(char* dst, size_t dst_size, const char* src) {
    strncpy(dst, src, dst_size - 1);
    dst[dst_size - 1] = '\0';  // 始终保证以空字符结尾
}

int main() {
    char buffer[16];

    // 安全的复制
    safe_copy(buffer, sizeof(buffer), "Hello, World!");
    printf("复制结果: %s\n", buffer);

    // 危险的输入 —— 实际使用中绝对不要这样做
    // vulnerable_copy(buffer, "这个字符串比 16 字节长得多!!!");

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void pointer_arithmetic_demo() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* ptr = arr;

    printf("数组遍历(指针运算):\n");
    for (int i = 0; i < 5; i++) {
        printf("  arr[%d] = %d (地址: %p)\n", i, *(ptr + i), (void*)(ptr + i));
    }

    // 把 2D 数组当作 1D 访问
    float matrix[3][4];
    float* flat = (float*)matrix;

    for (int i = 0; i < 12; i++) {
        flat[i] = (float)i * 0.5f;
    }

    printf("\n矩阵 [1][2] = %.1f\n", matrix[1][2]);  // flat[6]
}

#include <stdio.h>
#include <math.h>

// 定义激活函数类型
typedef float (*ActivationFn)(float);

float relu(float x) { return x > 0.0f ? x : 0.0f; }
float sigmoid(float x) { return 1.0f / (1.0f + expf(-x)); }
float tanh_act(float x) { return tanhf(x); }

// 对层应用激活函数
void apply_activation(float* data, int n, ActivationFn fn) {
    for (int i = 0; i < n; i++) {
        data[i] = fn(data[i]);
    }
}

// 激活函数工厂
ActivationFn get_activation(const char* name) {
    if (strcmp(name, "relu") == 0)    return relu;
    if (strcmp(name, "sigmoid") == 0) return sigmoid;
    if (strcmp(name, "tanh") == 0)    return tanh_act;
    return NULL;
}

int main() {
    float data[5] = {-2.0f, -1.0f, 0.0f, 1.0f, 2.0f};

    ActivationFn fn = get_activation("relu");
    apply_activation(data, 5, fn);

    printf("ReLU 结果: ");
    for (int i = 0; i < 5; i++) printf("%.1f ", data[i]);
    printf("\n");

    return 0;
}

fn ownership_basics() {
    // String 分配在堆上
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的所有权移动(move)给了 s2

    // println!("{}", s1);  // 编译错误!s1 已经被移动
    println!("{}", s2);  // OK

    // 用 clone 做深拷贝
    let s3 = s2.clone();
    println!("s2={}, s3={}", s2, s3);  // 两者都有效

    // i32 实现了 Copy trait —— 发生的是复制而非移动
    let x: i32 = 5;
    let y = x;  // 被复制
    println!("x={}, y={}", x, y);  // 两者都有效
}

fn calculate_stats(data: &[f32]) -> (f32, f32) {
    let sum: f32 = data.iter().sum();
    let mean = sum / data.len() as f32;

    let variance: f32 = data.iter()
        .map(|x| (x - mean).powi(2))
        .sum::<f32>() / data.len() as f32;

    (mean, variance.sqrt())
}

fn normalize(data: &mut Vec<f32>) {
    let mean: f32 = data.iter().sum::<f32>() / data.len() as f32;
    let std = {
        let var: f32 = data.iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f32>() / data.len() as f32;
        var.sqrt()
    };

    for x in data.iter_mut() {
        *x = (*x - mean) / (std + 1e-8);
    }
}

fn main() {
    let mut weights: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0, 5.0];

    // 不可变引用 —— 没有所有权移动
    let (mean, std) = calculate_stats(&weights);
    println!("平均值: {:.3}, 标准差: {:.3}", mean, std);

    // 可变引用 —— 同一时刻只允许一个
    normalize(&mut weights);
    println!("归一化后: {:?}", weights);
}

// 生命周期标注:返回值的生命周期取两个输入中较短的那一个
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

struct ModelCache<'a> {
    model_name: &'a str,
    embeddings: Vec<f32>,
}

impl<'a> ModelCache<'a> {
    fn new(name: &'a str, dim: usize) -> Self {
        ModelCache {
            model_name: name,
            embeddings: vec![0.0f32; dim],
        }
    }

    fn get_name(&self) -> &str {
        self.model_name
    }
}

fn lifetime_example() {
    let name = String::from("bert-base");
    let cache = ModelCache::new(&name, 768);
    println!("缓存的模型: {}", cache.get_name());
    // cache 和 name 在同一个作用域内均有效
}

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::sync::Arc;

// 推理结果类型
#[derive(Debug)]
struct InferenceResult {
    label: String,
    confidence: f32,
    latency_ms: u64,
}

// 模型服务器(用 Arc 在线程间共享)
struct ModelServer {
    model_name: String,
    // 实际实现中会包含 candle 或 ort 模型
}

impl ModelServer {
    fn new(name: &str) -> Self {
        ModelServer { model_name: name.to_string() }
    }

    async fn infer(&self, input: &[f32]) -> InferenceResult {
        // 模拟真实推理
        tokio::time::sleep(tokio::time::Duration::from_millis(5)).await;

        InferenceResult {
            label: "cat".to_string(),
            confidence: 0.95,
            latency_ms: 5,
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = Arc::new(ModelServer::new("resnet50"));
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    println!("ML 推理服务器启动: 127.0.0.1:8080");

    loop {
        let (mut socket, addr) = listener.accept().await?;
        let server_clone = Arc::clone(&server);

        tokio::spawn(async move {
            let mut buf = vec![0u8; 1024];
            let n = socket.read(&mut buf).await.unwrap_or(0);

            if n > 0 {
                // 用占位输入做推理
                let input = vec![0.0f32; 224 * 224 * 3];
                let result = server_clone.infer(&input).await;

                let response = format!(
                    "label={}, confidence={:.3}, latency={}ms\n",
                    result.label, result.confidence, result.latency_ms
                );

                let _ = socket.write_all(response.as_bytes()).await;
                println!("客户端 {} 处理完成", addr);
            }
        });
    }
}

use tokio::sync::mpsc;
use std::time::Instant;

#[derive(Debug)]
struct InferRequest {
    id: u64,
    data: Vec<f32>,
    response_tx: tokio::sync::oneshot::Sender<String>,
}

async fn batch_inference_worker(
    mut rx: mpsc::Receiver<InferRequest>,
    batch_size: usize,
    batch_timeout_ms: u64,
) {
    let mut pending: Vec<InferRequest> = Vec::new();
    let timeout = tokio::time::Duration::from_millis(batch_timeout_ms);

    loop {
        let deadline = tokio::time::Instant::now() + timeout;

        while pending.len() < batch_size {
            match tokio::time::timeout_at(deadline, rx.recv()).await {
                Ok(Some(req)) => pending.push(req),
                Ok(None) => return,  // channel 已关闭
                Err(_) => break,     // 超时
            }
        }

        if pending.is_empty() { continue; }

        println!("批处理: {} 个请求", pending.len());

        // 执行批量推理(实际中是模型的 forward pass)
        for req in pending.drain(..) {
            let result = format!("request_{}: label=cat, conf=0.95", req.id);
            let _ = req.response_tx.send(result);
        }
    }
}

use std::slice;

// 声明 C 库函数
extern "C" {
    fn cblas_sgemm(
        order: i32, transa: i32, transb: i32,
        m: i32, n: i32, k: i32,
        alpha: f32,
        a: *const f32, lda: i32,
        b: *const f32, ldb: i32,
        beta: f32,
        c: *mut f32, ldc: i32,
    );
}

// 安全的包装函数
pub fn matrix_multiply(
    a: &[f32], b: &[f32], c: &mut [f32],
    m: usize, n: usize, k: usize,
) {
    assert_eq!(a.len(), m * k);
    assert_eq!(b.len(), k * n);
    assert_eq!(c.len(), m * n);

    unsafe {
        cblas_sgemm(
            101,  // CblasRowMajor
            111,  // CblasNoTrans
            111,  // CblasNoTrans
            m as i32, n as i32, k as i32,
            1.0,
            a.as_ptr(), k as i32,
            b.as_ptr(), n as i32,
            0.0,
            c.as_mut_ptr(), n as i32,
        );
    }
}

// 用原始指针构造切片(在 FFI 边界上使用)
pub unsafe fn tensor_from_raw(ptr: *const f32, len: usize) -> &'static [f32] {
    slice::from_raw_parts(ptr, len)
}

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

// 以二进制文件保存/加载模型权重
typedef struct {
    uint32_t magic;     // 文件格式标识符
    uint32_t version;
    uint32_t num_layers;
    uint32_t total_params;
} ModelHeader;

int save_weights(const char* path, float* weights, int count) {
    FILE* f = fopen(path, "wb");
    if (!f) return -1;

    ModelHeader header = {
        .magic = 0x4D4C4D44,  // "MLMD"
        .version = 1,
        .num_layers = 1,
        .total_params = (uint32_t)count
    };

    fwrite(&header, sizeof(header), 1, f);
    fwrite(weights, sizeof(float), count, f);
    fclose(f);
    return 0;
}

float* load_weights(const char* path, int* count) {
    FILE* f = fopen(path, "rb");
    if (!f) return NULL;

    ModelHeader header;
    if (fread(&header, sizeof(header), 1, f) != 1) {
        fclose(f);
        return NULL;
    }

    if (header.magic != 0x4D4C4D44) {
        fprintf(stderr, "文件格式错误\n");
        fclose(f);
        return NULL;
    }

    *count = (int)header.total_params;
    float* weights = (float*)malloc(*count * sizeof(float));
    fread(weights, sizeof(float), *count, f);
    fclose(f);
    return weights;
}

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    float* data;
    int start;
    int end;
    float result;
} SumArgs;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
float global_sum = 0.0f;

void* parallel_sum(void* arg) {
    SumArgs* args = (SumArgs*)arg;
    float local_sum = 0.0f;

    for (int i = args->start; i < args->end; i++) {
        local_sum += args->data[i];
    }

    pthread_mutex_lock(&mutex);
    global_sum += local_sum;
    pthread_mutex_unlock(&mutex);

    args->result = local_sum;
    return NULL;
}

float parallel_reduce(float* data, int n, int num_threads) {
    pthread_t* threads = malloc(num_threads * sizeof(pthread_t));
    SumArgs* args = malloc(num_threads * sizeof(SumArgs));
    int chunk = n / num_threads;

    global_sum = 0.0f;

    for (int t = 0; t < num_threads; t++) {
        args[t].data = data;
        args[t].start = t * chunk;
        args[t].end = (t == num_threads - 1) ? n : (t + 1) * chunk;
        pthread_create(&threads[t], NULL, parallel_sum, &args[t]);
    }

    for (int t = 0; t < num_threads; t++) {
        pthread_join(threads[t], NULL);
    }

    free(threads);
    free(args);
    return global_sum;
}

// fast_ops.cpp - PyTorch C++ 扩展模块
#include <torch/extension.h>
#include <vector>

// ReLU 自定义实现
torch::Tensor fast_relu(torch::Tensor input) {
    TORCH_CHECK(input.dtype() == torch::kFloat32,
                "fast_relu: 仅支持 float32 张量,收到的类型: ",
                input.dtype());
    TORCH_CHECK(input.is_contiguous(),
                "fast_relu: 需要 contiguous 张量");

    auto output = torch::empty_like(input);
    auto* in_ptr = input.data_ptr<float>();
    auto* out_ptr = output.data_ptr<float>();
    int64_t n = input.numel();

    for (int64_t i = 0; i < n; i++) {
        out_ptr[i] = in_ptr[i] > 0.0f ? in_ptr[i] : 0.0f;
    }

    return output;
}

// 矩阵乘法 + 加偏置(fused operation)
torch::Tensor linear_forward(
    torch::Tensor input,
    torch::Tensor weight,
    torch::Tensor bias
) {
    TORCH_CHECK(input.dim() == 2, "输入必须是 2D 张量");
    TORCH_CHECK(weight.dim() == 2, "权重必须是 2D 张量");
    TORCH_CHECK(input.size(1) == weight.size(1),
                "输入和权重的维度不匹配");

    // torch::mm + 加偏置
    auto output = torch::mm(input, weight.t());
    if (bias.defined()) {
        output += bias.unsqueeze(0);
    }
    return output;
}

// 注册要绑定到 Python 的函数
PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def("fast_relu", &fast_relu, "快速 ReLU 实现");
    m.def("linear_forward", &linear_forward, "线性层前向传播");
}

// cuda_kernels.cu - CUDA C 内核
#include <cuda_runtime.h>
#include <stdio.h>

// 在 GPU 上并行执行 ReLU
__global__ void relu_kernel(
    const float* __restrict__ input,
    float* __restrict__ output,
    int n
) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;

    if (idx < n) {
        output[idx] = input[idx] > 0.0f ? input[idx] : 0.0f;
    }
}

// Softmax(包含数值稳定性处理)
__global__ void softmax_kernel(
    const float* __restrict__ input,
    float* __restrict__ output,
    int batch_size,
    int num_classes
) {
    int batch_idx = blockIdx.x;
    if (batch_idx >= batch_size) return;

    const float* in = input + batch_idx * num_classes;
    float* out = output + batch_idx * num_classes;

    // 找最大值(数值稳定性)
    float max_val = in[0];
    for (int i = 1; i < num_classes; i++) {
        max_val = fmaxf(max_val, in[i]);
    }

    // exp 求和
    float sum = 0.0f;
    for (int i = 0; i < num_classes; i++) {
        out[i] = expf(in[i] - max_val);
        sum += out[i];
    }

    // 归一化
    for (int i = 0; i < num_classes; i++) {
        out[i] /= sum;
    }
}

// 主机端函数(从 C 中调用)
void launch_relu(const float* d_in, float* d_out, int n) {
    int threads = 256;
    int blocks = (n + threads - 1) / threads;
    relu_kernel<<<blocks, threads>>>(d_in, d_out, n);
    cudaDeviceSynchronize();
}

// candle_inference.rs - 用 Rust 做 LLM 推理
use candle_core::{Device, Tensor, DType};
use candle_nn::{Linear, Module, VarBuilder};
use std::path::Path;

struct SimpleTransformerBlock {
    attention: Linear,
    feed_forward: Linear,
    norm: Vec<f32>,
}

impl SimpleTransformerBlock {
    fn new(vb: VarBuilder, hidden_dim: usize) -> candle_core::Result<Self> {
        let attention = candle_nn::linear(hidden_dim, hidden_dim, vb.pp("attention"))?;
        let feed_forward = candle_nn::linear(hidden_dim, hidden_dim * 4, vb.pp("ffn"))?;
        let norm = vec![1.0f32; hidden_dim];
        Ok(Self { attention, feed_forward, norm })
    }

    fn forward(&self, x: &Tensor) -> candle_core::Result<Tensor> {
        // Self-attention(简化版)
        let attn_out = self.attention.forward(x)?;
        let x = (x + attn_out)?;

        // FFN
        let ffn_out = self.feed_forward.forward(&x)?;
        let ffn_out = ffn_out.relu()?;

        Ok(ffn_out)
    }
}

async fn run_inference(model_path: &Path, input_ids: &[u32])
    -> candle_core::Result<Vec<f32>>
{
    let device = Device::cuda_if_available(0)?;
    println!("设备: {:?}", device);

    // 构造输入张量
    let input = Tensor::new(input_ids, &device)?;
    let input = input.unsqueeze(0)?;  // 加上 batch 维度

    // 嵌入表(示例)
    let vocab_size = 32000usize;
    let hidden_dim = 768usize;
    let embedding = Tensor::randn(0f32, 1.0, (vocab_size, hidden_dim), &device)?;

    // 嵌入查表
    let hidden = embedding.index_select(&input.flatten_all()?, 0)?;

    // 提取最后一层 logits
    let logits = hidden.mean(1)?;  // 序列维度求平均
    let logits_vec: Vec<f32> = logits.flatten_all()?.to_vec1()?;

    Ok(logits_vec)
}

#include <immintrin.h>  // AVX2
#include <stdio.h>

// 普通实现
float dot_product_scalar(const float* a, const float* b, int n) {
    float sum = 0.0f;
    for (int i = 0; i < n; i++) {
        sum += a[i] * b[i];
    }
    return sum;
}

// AVX2 SIMD 实现(同时处理 8 个 float)
float dot_product_avx2(const float* a, const float* b, int n) {
    __m256 sum_vec = _mm256_setzero_ps();
    int i = 0;

    // 每次处理 8 个
    for (; i <= n - 8; i += 8) {
        __m256 va = _mm256_loadu_ps(a + i);
        __m256 vb = _mm256_loadu_ps(b + i);
        sum_vec = _mm256_fmadd_ps(va, vb, sum_vec);  // FMA: a*b+c
    }

    // 8 个数值求和
    __m128 lo = _mm256_extractf128_ps(sum_vec, 0);
    __m128 hi = _mm256_extractf128_ps(sum_vec, 1);
    __m128 sum128 = _mm_add_ps(lo, hi);
    sum128 = _mm_hadd_ps(sum128, sum128);
    sum128 = _mm_hadd_ps(sum128, sum128);

    float result = _mm_cvtss_f32(sum128);

    // 处理剩余部分
    for (; i < n; i++) {
        result += a[i] * b[i];
    }

    return result;
}

// 缓存不友好:按列访问
void matrix_multiply_naive(float* C, const float* A, const float* B,
                            int M, int N, int K) {
    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++)
            for (int k = 0; k < K; k++)
                C[i*N+j] += A[i*K+k] * B[k*N+j];  // 访问 B 时缓存未命中很多
}

// 缓存友好:分块矩阵乘法
void matrix_multiply_blocked(float* C, const float* A, const float* B,
                              int M, int N, int K, int block_size) {
    for (int ii = 0; ii < M; ii += block_size)
        for (int jj = 0; jj < N; jj += block_size)
            for (int kk = 0; kk < K; kk += block_size)
                for (int i = ii; i < ii+block_size && i < M; i++)
                    for (int j = jj; j < jj+block_size && j < N; j++)
                        for (int k = kk; k < kk+block_size && k < K; k++)
                            C[i*N+j] += A[i*K+k] * B[k*N+j];
}

use std::time::Instant;

// 用 #[inline(always)] 强制内联
#[inline(always)]
fn relu_fast(x: f32) -> f32 {
    x.max(0.0)
}

// 迭代器链会被 LLVM 自动向量化
fn batch_relu(data: &mut [f32]) {
    data.iter_mut().for_each(|x| *x = relu_fast(*x));
}

// 用 unsafe 省略边界检查(仅在已验证安全的情况下使用)
fn dot_product_unchecked(a: &[f32], b: &[f32]) -> f32 {
    assert_eq!(a.len(), b.len());
    let n = a.len();
    let mut sum = 0.0f32;

    unsafe {
        for i in 0..n {
            sum += a.get_unchecked(i) * b.get_unchecked(i);
        }
    }
    sum
}

fn benchmark_relu() {
    let mut data: Vec<f32> = (0..1_000_000)
        .map(|i| (i as f32 - 500_000.0) / 1000.0)
        .collect();

    let start = Instant::now();
    batch_relu(&mut data);
    println!("ReLU 100万元素: {:?}", start.elapsed());
}