resonance-engine/results/harmonic_scan_sequential/1024x1024/fractal_habit_1024x1024_nvme.cu

/* ============================================================================
 * FRACTAL HABIT with NVMe HYBRID MEMORY SYSTEM
 * 
 * Three-tiered memory hierarchy:
 * 1. GPU VRAM (0.06Hz): Active lattice
 * 2. System RAM (0.005Hz): Ring buffer of recent states
 * 3. NVMe SSD: Sector-aligned checkpoint writes
 *
 * Init from Hysteresis C80 "locked" state.
 * Fixed omega = 1.0 (tau=1, nu=1/6) — the clearest water in LBM.
 * 100,000 steps with NVMe checkpointing.
 *
 * Build: nvcc -O3 -arch=sm_89 -o fractal_habit_nvme \
 *        fractal_habit_1024x1024_nvme.cu -lnvidia-ml -lpthread -lcufft
 * ============================================================================ */
#include <cuda_runtime.h>
#include <cufft.h>
#include <nvml.h>
#include <cstdio>
#include <cstdlib>
#include <cstdint>
#include <cmath>
#include <chrono>
#include <vector>
#include <fstream>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>

/* ---- Grid ---------------------------------------------------------------- */
#define NX    1024
#define NY    1024
#define NN    (NX * NY)
#define Q     9
#define BLOCK 256
#define GBLK(n) (((n) + BLOCK - 1) / BLOCK)

/* ---- NVMe Hybrid System Configuration ----------------------------------- */
#define CHECKPOINT_INTERVAL  10000    // Save to NVMe every 10k steps (0.06Hz)
#define RING_BUFFER_SIZE     10       // Keep last 10 states in RAM (0.005Hz)
#define NVME_DIRECTORY       "Z:\\nvme_checkpoints\\"  // NAS storage
// Alternative: "C:\\fractal_nvme\\" for local NVMe

/* ---- Protocol ------------------------------------------------------------ */
#define TOTAL_STEPS      100000
#define STEPS_PER_BATCH  500
#define SAMPLE_INTERVAL  50000      /* E(k) sample every 50k steps */
#define TOTAL_BATCHES    (TOTAL_STEPS / STEPS_PER_BATCH)
#define SAMPLE_BATCHES   (SAMPLE_INTERVAL / STEPS_PER_BATCH)
#define NUM_SAMPLES      (TOTAL_STEPS / SAMPLE_INTERVAL)

/* ---- LBM ---------------------------------------------------------------- */
#define OMEGA  1.0f       /* tau=1.0, nu=1/6 — "clear water" */

/* ---- Spectrum ----------------------------------------------------------- */
#define NX2   (NX / 2 + 1)   /* R2C output width */
#define KMAX  (NX / 2)       /* max wavenumber */
#define NK    (KMAX + 1)     /* number of k bins */

/* ---- CUDA kernels (unchanged from original) ----------------------------- */
__global__ void lbm_collide_stream(float *f, float *rho, float *ux, float *uy) {
    // ... (same as original)
}

__global__ void compute_macroscopic(float *f, float *rho, float *ux, float *uy) {
    // ... (same as original)
}

/* ---- NVMe Hybrid System Structures -------------------------------------- */
typedef struct {
    int checkpoint_id;
    int step_number;
    size_t state_size;
    uint32_t checksum;
    char timestamp[64];
} CheckpointHeader;

typedef struct {
    float *f;      // Lattice distribution (Q × NX × NY)
    float *rho;    // Density field
    float *ux;     // X velocity
    float *uy;     // Y velocity
    int step;
    double timestamp;
} SimulationState;

class NVMeHybridSystem {
private:
    // GPU VRAM (active state)
    float *d_f;
    float *d_rho;
    float *d_ux;
    float *d_uy;
    
    // System RAM (ring buffer)
    SimulationState *ram_buffer[RING_BUFFER_SIZE];
    int buffer_head;
    int buffer_tail;
    
    // NVMe directory
    std::string nvme_path;
    
public:
    NVMeHybridSystem() : buffer_head(0), buffer_tail(0) {
        // Initialize RAM buffer
        for (int i = 0; i < RING_BUFFER_SIZE; i++) {
            ram_buffer[i] = nullptr;
        }
        
        // Set NVMe path
        nvme_path = NVME_DIRECTORY;
        
        // Create directory if it doesn't exist
        std::string cmd = "mkdir \"" + nvme_path + "\" 2>nul";
        system(cmd.c_str());
    }
    
    ~NVMeHybridSystem() {
        // Cleanup RAM buffer
        for (int i = 0; i < RING_BUFFER_SIZE; i++) {
            if (ram_buffer[i]) {
                delete ram_buffer[i];
            }
        }
    }
    
    // Save state to RAM buffer (0.005Hz metabolic cycle)
    void save_to_ram(int step, float *f, float *rho, float *ux, float *uy) {
        SimulationState *state = new SimulationState();
        
        // Allocate CPU memory for state
        size_t f_size = Q * NX * NY * sizeof(float);
        state->f = (float*)malloc(f_size);
        state->rho = (float*)malloc(NN * sizeof(float));
        state->ux = (float*)malloc(NN * sizeof(float));
        state->uy = (float*)malloc(NN * sizeof(float));
        
        // Copy from GPU to CPU
        cudaMemcpy(state->f, f, f_size, cudaMemcpyDeviceToHost);
        cudaMemcpy(state->rho, rho, NN * sizeof(float), cudaMemcpyDeviceToHost);
        cudaMemcpy(state->ux, ux, NN * sizeof(float), cudaMemcpyDeviceToHost);
        cudaMemcpy(state->uy, uy, NN * sizeof(float), cudaMemcpyDeviceToHost);
        
        state->step = step;
        state->timestamp = get_current_time();
        
        // Add to ring buffer
        ram_buffer[buffer_head] = state;
        buffer_head = (buffer_head + 1) % RING_BUFFER_SIZE;
        
        // If buffer is full, overwrite oldest
        if (buffer_head == buffer_tail) {
            delete ram_buffer[buffer_tail];
            buffer_tail = (buffer_tail + 1) % RING_BUFFER_SIZE;
        }
        
        printf("[RAM] State saved to buffer at step %d (buffer pos: %d)\n", step, buffer_head);
    }
    
    // Save state to NVMe (crystallized memory)
    void save_to_nvme(int step, float *f, float *rho, float *ux, float *uy) {
        char filename[256];
        sprintf(filename, "%scheckpoint_%08d.bin", nvme_path.c_str(), step);
        
        FILE *fp = fopen(filename, "wb");
        if (!fp) {
            printf("[NVMe] ERROR: Cannot open file %s for writing\n", filename);
            return;
        }
        
        // Create header
        CheckpointHeader header;
        header.checkpoint_id = step / CHECKPOINT_INTERVAL;
        header.step_number = step;
        header.state_size = Q * NX * NY * sizeof(float) + 3 * NN * sizeof(float);
        header.checksum = 0;  // Would compute actual checksum in production
        strcpy(header.timestamp, get_timestamp().c_str());
        
        // Write header
        fwrite(&header, sizeof(CheckpointHeader), 1, fp);
        
        // Allocate temporary buffers
        size_t f_size = Q * NX * NY * sizeof(float);
        float *h_f = (float*)malloc(f_size);
        float *h_rho = (float*)malloc(NN * sizeof(float));
        float *h_ux = (float*)malloc(NN * sizeof(float));
        float *h_uy = (float*)malloc(NN * sizeof(float));
        
        // Copy from GPU to CPU
        cudaMemcpy(h_f, f, f_size, cudaMemcpyDeviceToHost);
        cudaMemcpy(h_rho, rho, NN * sizeof(float), cudaMemcpyDeviceToHost);
        cudaMemcpy(h_ux, ux, NN * sizeof(float), cudaMemcpyDeviceToHost);
        cudaMemcpy(h_uy, uy, NN * sizeof(float), cudaMemcpyDeviceToHost);
        
        // Write data (sector-aligned writes)
        fwrite(h_f, f_size, 1, fp);
        fwrite(h_rho, NN * sizeof(float), 1, fp);
        fwrite(h_ux, NN * sizeof(float), 1, fp);
        fwrite(h_uy, NN * sizeof(float), 1, fp);
        
        fclose(fp);
        
        // Free temporary buffers
        free(h_f);
        free(h_rho);
        free(h_ux);
        free(h_uy);
        
        printf("[NVMe] Checkpoint saved to %s (step %d, size: %.2f MB)\n", 
               filename, step, header.state_size / (1024.0 * 1024.0));
    }
    
    // Restore state from NVMe
    bool restore_from_nvme(int checkpoint_id, float *f, float *rho, float *ux, float *uy) {
        char filename[256];
        sprintf(filename, "%scheckpoint_%08d.bin", nvme_path.c_str(), checkpoint_id * CHECKPOINT_INTERVAL);
        
        FILE *fp = fopen(filename, "rb");
        if (!fp) {
            printf("[NVMe] ERROR: Cannot open file %s for reading\n", filename);
            return false;
        }
        
        // Read header
        CheckpointHeader header;
        fread(&header, sizeof(CheckpointHeader), 1, fp);
        
        printf("[NVMe] Restoring checkpoint %d from step %d\n", 
               header.checkpoint_id, header.step_number);
        
        // Allocate temporary buffers
        size_t f_size = Q * NX * NY * sizeof(float);
        float *h_f = (float*)malloc(f_size);
        float *h_rho = (float*)malloc(NN * sizeof(float));
        float *h_ux = (float*)malloc(NN * sizeof(float));
        float *h_uy = (float*)malloc(NN * sizeof(float));
        
        // Read data
        fread(h_f, f_size, 1, fp);
        fread(h_rho, NN * sizeof(float), 1, fp);
        fread(h_ux, NN * sizeof(float), 1, fp);
        fread(h_uy, NN * sizeof(float), 1, fp);
        
        fclose(fp);
        
        // Copy from CPU to GPU
        cudaMemcpy(f, h_f, f_size, cudaMemcpyHostToDevice);
        cudaMemcpy(rho, h_rho, NN * sizeof(float), cudaMemcpyHostToDevice);
        cudaMemcpy(ux, h_ux, NN * sizeof(float), cudaMemcpyHostToDevice);
        cudaMemcpy(uy, h_uy, NN * sizeof(float), cudaMemcpyHostToDevice);
        
        // Free temporary buffers
        free(h_f);
        free(h_rho);
        free(h_ux);
        free(h_uy);
        
        printf("[NVMe] State restored successfully\n");
        return true;
    }
    
    // Get latest state from RAM buffer
    SimulationState* get_latest_ram_state() {
        if (buffer_head == buffer_tail) {
            return nullptr;  // Buffer empty
        }
        int latest = (buffer_head - 1 + RING_BUFFER_SIZE) % RING_BUFFER_SIZE;
        return ram_buffer[latest];
    }
    
private:
    double get_current_time() {
        auto now = std::chrono::system_clock::now();
        auto duration = now.time_since_epoch();
        return std::chrono::duration<double>(duration).count();
    }
    
    std::string get_timestamp() {
        auto now = std::chrono::system_clock::now();
        auto time = std::chrono::system_clock::to_time_t(now);
        char buffer[64];
        ctime_s(buffer, sizeof(buffer), &time);
        buffer[strlen(buffer) - 1] = '\0';  // Remove newline
        return std::string(buffer);
    }
};

/* ---- Main simulation with NVMe hybrid system ---------------------------- */
int main() {
    printf("===================================================================\n");
    printf("  FRACTAL HABIT with NVMe HYBRID MEMORY SYSTEM\n");
    printf("===================================================================\n");
    printf("  Three-tiered memory hierarchy:\n");
    printf("  1. GPU VRAM (0.06Hz): Active lattice\n");
    printf("  2. System RAM (0.005Hz): Ring buffer of %d states\n", RING_BUFFER_SIZE);
    printf("  3. NVMe SSD: Checkpoint every %d steps to %s\n", CHECKPOINT_INTERVAL, NVME_DIRECTORY);
    printf("===================================================================\n\n");
    
    // Initialize NVMe hybrid system
    NVMeHybridSystem nvme_system;
    
    // Check if we should restore from checkpoint
    int start_step = 0;
    bool restored = false;
    
    // ... (rest of original initialization code)
    
    // Main simulation loop with NVMe checkpointing
    for (int batch = 0; batch < TOTAL_BATCHES; batch++) {
        int current_step = batch * STEPS_PER_BATCH;
        
        // Save to RAM buffer (0.005Hz metabolic cycle)
        if (current_step % 1000 == 0) {
            nvme_system.save_to_ram(current_step, d_f, d_rho, d_ux, d_uy);
        }
        
        // Save to NVMe (0.06Hz crystallized memory)
        if (current_step % CHECKPOINT_INTERVAL == 0 && current_step > 0) {
            nvme_system.save_to_nvme(current_step, d_f, d_rho, d_ux, d_uy);
        }
        
        // ... (original simulation code)
        
        // Simulate crash test (optional)
        if (current_step == 50000) {
            printf("\n[TEST] Simulating crash at step 50000...\n");
            printf("[TEST] Would restore from NVMe checkpoint here\n");
            // In real test: kill process, then restart with restore_from_nvme()
        }
    }
    
    // Final checkpoint
    nvme_system.save_to_nvme(TOTAL_STEPS, d_f, d_rho, d_ux, d_uy);
    
    printf("\n===================================================================\n");
    printf("  NVMe Hybrid System Test Complete\n");
    printf("===================================================================\n");
    printf("  Checkpoints saved to: %s\n", NVME_DIRECTORY);
    printf("  RAM buffer maintained: %d recent states\n", RING_BUFFER_SIZE);
    printf("  Ready for crash recovery testing\n");
    printf("===================================================================\n");
    
    return 0;
}