システムプログラミング完全攻略: 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>

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);

    return 0;
}

#include <stdio.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("\nmatrix[1][2] = %.1f\n", matrix[1][2]);  // flat[6]と同じ
}

#include <stdio.h>
#include <math.h>
#include <string.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はHeapに確保される
    let s1 = String::from("hello");
    let s2 = s1;  // s1の所有権がs2にムーブ

    // println!("{}", s1);  // コンパイルエラー! s1はムーブ済み
    println!("{}", s2);  // OK

    // cloneで深いコピー
    let s3 = s2.clone();
    println!("s2={}, s3={}", s2, s3);  // 両方有効

    // i32はCopyトレイトを実装 - ムーブではなくコピー
    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,
}

struct ModelServer {
    model_name: String,
}

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;

#[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,  // チャンネルクローズ
                Err(_) => break,     // タイムアウト
            }
        }

        if pending.is_empty() { continue; }

        println!("バッチ処理: {}件のリクエスト", pending.len());

        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;
}

// 行列積 + バイアス加算 (融合演算)
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),
                "入力と重みの次元が一致しません");

    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;
    }
}

// ホスト関数
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,
}

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"))?;
        Ok(Self { attention, feed_forward })
    }

    fn forward(&self, x: &Tensor) -> candle_core::Result<Tensor> {
        // セルフアテンション (簡略化)
        let attn_out = self.attention.forward(x)?;
        let x = (x + attn_out)?;

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

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)?;  // バッチ次元を追加

    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)?;
    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)]
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());
}