330 lines
11 KiB
Plaintext
330 lines
11 KiB
Plaintext
|
/* ============================================================================
|
|||
|
|
* FRACTAL HABIT 1024×1024 - CRYSTALLIZED VERSION
|
|||
|
|
*
|
|||
|
|
* Adapted from the-craw's successful crystallization approach:
|
|||
|
|
* 1. Unified state with metadata header
|
|||
|
|
* 2. Entropy and thermal tracking
|
|||
|
|
* 3. Checksum verification
|
|||
|
|
* 4. Human-readable annotation
|
|||
|
|
*
|
|||
|
|
* Based on: fractal_habit_1024x1024_nvme_proper.cu
|
|||
|
|
* fractal_crystallize_v031.cu (the-craw)
|
|||
|
|
* Date: 2026-03-12
|
|||
|
|
* ============================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#include <stdio.h>
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
#include <stdint.h>
|
|||
|
|
#include <math.h>
|
|||
|
|
#include <time.h>
|
|||
|
|
#include <cuda.h>
|
|||
|
|
#include <cuda_runtime.h>
|
|||
|
|
#include <cufft.h>
|
|||
|
|
#include <nvml.h>
|
|||
|
|
|
|||
|
|
/* ---- Grid ---------------------------------------------------------------- */
|
|||
|
|
#define NX 1024
|
|||
|
|
#define NY 1024
|
|||
|
|
#define NN (NX * NY)
|
|||
|
|
#define Q 9
|
|||
|
|
#define BLOCK 256
|
|||
|
|
#define GBLK(n) (((n) + BLOCK - 1) / BLOCK)
|
|||
|
|
|
|||
|
|
/* ---- 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)
|
|||
|
|
|
|||
|
|
/* ---- Crystallization Structures (from the-craw) ------------------------- */
|
|||
|
|
typedef struct {
|
|||
|
|
uint32_t magic; // 0x43525953 ("CRYS")
|
|||
|
|
uint32_t version; // 0x01000000 (v1.0.0)
|
|||
|
|
uint32_t grid_x;
|
|||
|
|
uint32_t grid_y;
|
|||
|
|
uint32_t q;
|
|||
|
|
uint32_t step;
|
|||
|
|
float omega;
|
|||
|
|
float viscosity;
|
|||
|
|
float entropy; // Spectral entropy (bits)
|
|||
|
|
float slope; // Power-law slope
|
|||
|
|
float kx0_fraction; // Fraction of energy in kx=0
|
|||
|
|
float total_energy;
|
|||
|
|
uint32_t peak_k;
|
|||
|
|
uint32_t thermal_state; // GPU temperature × 100
|
|||
|
|
uint64_t timestamp; // Unix timestamp in milliseconds
|
|||
|
|
uint64_t checksum_data;
|
|||
|
|
uint64_t checksum_header;
|
|||
|
|
char hostname[64];
|
|||
|
|
char user[32];
|
|||
|
|
char annotation[128]; // Human-readable annotation
|
|||
|
|
uint32_t reserved[8]; // Future use
|
|||
|
|
} CrystallizationHeader;
|
|||
|
|
|
|||
|
|
#define CRYSTAL_MAGIC 0x43525953 // "CRYS" in hex
|
|||
|
|
#define CRYSTAL_VERSION 0x01000000 // v1.0.0
|
|||
|
|
|
|||
|
|
/* ---- Crystallization Functions ------------------------------------------ */
|
|||
|
|
|
|||
|
|
// Calculate Fletcher-64 checksum
|
|||
|
|
uint64_t calculate_checksum(const void* data, size_t size) {
|
|||
|
|
const uint32_t* words = (const uint32_t*)data;
|
|||
|
|
size_t num_words = size / sizeof(uint32_t);
|
|||
|
|
|
|||
|
|
uint64_t sum1 = 0;
|
|||
|
|
uint64_t sum2 = 0;
|
|||
|
|
|
|||
|
|
for (size_t i = 0; i < num_words; i++) {
|
|||
|
|
sum1 = (sum1 + words[i]) % 0xFFFFFFFF;
|
|||
|
|
sum2 = (sum2 + sum1) % 0xFFFFFFFF;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return (sum2 << 32) | sum1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Get GPU temperature (returns temperature × 100)
|
|||
|
|
uint32_t get_gpu_temperature() {
|
|||
|
|
nvmlReturn_t result;
|
|||
|
|
nvmlDevice_t device;
|
|||
|
|
unsigned int temp = 0;
|
|||
|
|
|
|||
|
|
result = nvmlInit();
|
|||
|
|
if (result != NVML_SUCCESS) return 0;
|
|||
|
|
|
|||
|
|
result = nvmlDeviceGetHandleByIndex(0, &device);
|
|||
|
|
if (result != NVML_SUCCESS) {
|
|||
|
|
nvmlShutdown();
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
result = nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp);
|
|||
|
|
nvmlShutdown();
|
|||
|
|
|
|||
|
|
if (result != NVML_SUCCESS) return 0;
|
|||
|
|
return temp * 100; // Store as integer × 100
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* ---- Crystallized Checkpoint Function ----------------------------------- */
|
|||
|
|
void save_crystallized_checkpoint(int step, float* d_f, float* d_rho,
|
|||
|
|
float* d_ux, float* d_uy,
|
|||
|
|
double entropy, double slope,
|
|||
|
|
double kx0_frac, double total_energy,
|
|||
|
|
uint32_t peak_k) {
|
|||
|
|
char filename[256];
|
|||
|
|
sprintf(filename, "C:\\fractal_nvme_test\\crystal_%08d.crys", step);
|
|||
|
|
|
|||
|
|
printf("[Crystal] Saving crystallized state at step %d to %s\n", step, filename);
|
|||
|
|
|
|||
|
|
// Create directory if it doesn't exist
|
|||
|
|
system("mkdir C:\\fractal_nvme_test 2>nul");
|
|||
|
|
|
|||
|
|
FILE* fp = fopen(filename, "wb");
|
|||
|
|
if (!fp) {
|
|||
|
|
printf("[Crystal] ERROR: Cannot open file for writing\n");
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Calculate sizes
|
|||
|
|
size_t f_size = Q * NN * sizeof(float);
|
|||
|
|
size_t field_size = NN * sizeof(float);
|
|||
|
|
|
|||
|
|
// Allocate host memory
|
|||
|
|
float* h_f = (float*)malloc(f_size);
|
|||
|
|
float* h_rho = (float*)malloc(field_size);
|
|||
|
|
float* h_ux = (float*)malloc(field_size);
|
|||
|
|
float* h_uy = (float*)malloc(field_size);
|
|||
|
|
|
|||
|
|
if (!h_f || !h_rho || !h_ux || !h_uy) {
|
|||
|
|
printf("[Crystal] ERROR: Memory allocation failed\n");
|
|||
|
|
fclose(fp);
|
|||
|
|
if (h_f) free(h_f);
|
|||
|
|
if (h_rho) free(h_rho);
|
|||
|
|
if (h_ux) free(h_ux);
|
|||
|
|
if (h_uy) free(h_uy);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Copy from device to host
|
|||
|
|
cudaMemcpy(h_f, d_f, f_size, cudaMemcpyDeviceToHost);
|
|||
|
|
cudaMemcpy(h_rho, d_rho, field_size, cudaMemcpyDeviceToHost);
|
|||
|
|
cudaMemcpy(h_ux, d_ux, field_size, cudaMemcpyDeviceToHost);
|
|||
|
|
cudaMemcpy(h_uy, d_uy, field_size, cudaMemcpyDeviceToHost);
|
|||
|
|
|
|||
|
|
// Prepare header
|
|||
|
|
CrystallizationHeader header;
|
|||
|
|
memset(&header, 0, sizeof(header));
|
|||
|
|
|
|||
|
|
header.magic = CRYSTAL_MAGIC;
|
|||
|
|
header.version = CRYSTAL_VERSION;
|
|||
|
|
header.grid_x = NX;
|
|||
|
|
header.grid_y = NY;
|
|||
|
|
header.q = Q;
|
|||
|
|
header.step = step;
|
|||
|
|
header.omega = 1.85f; // From original code
|
|||
|
|
header.viscosity = (1.0f/1.85f - 0.5f)/3.0f;
|
|||
|
|
header.entropy = (float)entropy;
|
|||
|
|
header.slope = (float)slope;
|
|||
|
|
header.kx0_fraction = (float)kx0_frac;
|
|||
|
|
header.total_energy = (float)total_energy;
|
|||
|
|
header.peak_k = peak_k;
|
|||
|
|
header.thermal_state = get_gpu_temperature();
|
|||
|
|
header.timestamp = (uint64_t)time(NULL) * 1000; // Milliseconds
|
|||
|
|
|
|||
|
|
// Get hostname and username (Windows)
|
|||
|
|
char hostname[64] = "Beast-Windows";
|
|||
|
|
char username[32] = "Administrator";
|
|||
|
|
strncpy(header.hostname, hostname, 63);
|
|||
|
|
strncpy(header.user, username, 31);
|
|||
|
|
|
|||
|
|
// Create annotation
|
|||
|
|
char annotation[128];
|
|||
|
|
if (entropy > 6.0) {
|
|||
|
|
sprintf(annotation, "HIGH-ENTROPY STATE: %.2f bits, slope %.2f, k=%d dominant",
|
|||
|
|
entropy, slope, peak_k);
|
|||
|
|
} else if (entropy > 4.0) {
|
|||
|
|
sprintf(annotation, "MODERATE ENTROPY: %.2f bits, developing structure", entropy);
|
|||
|
|
} else {
|
|||
|
|
sprintf(annotation, "LOW ENTROPY: %.2f bits, initial state", entropy);
|
|||
|
|
}
|
|||
|
|
strncpy(header.annotation, annotation, 127);
|
|||
|
|
|
|||
|
|
// Calculate checksums
|
|||
|
|
size_t data_size = f_size + 3 * field_size;
|
|||
|
|
uint8_t* data_buffer = (uint8_t*)malloc(data_size);
|
|||
|
|
if (data_buffer) {
|
|||
|
|
// Concatenate all data for checksum
|
|||
|
|
memcpy(data_buffer, h_f, f_size);
|
|||
|
|
memcpy(data_buffer + f_size, h_rho, field_size);
|
|||
|
|
memcpy(data_buffer + f_size + field_size, h_ux, field_size);
|
|||
|
|
memcpy(data_buffer + f_size + 2 * field_size, h_uy, field_size);
|
|||
|
|
|
|||
|
|
header.checksum_data = calculate_checksum(data_buffer, data_size);
|
|||
|
|
free(data_buffer);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Calculate header checksum (excluding checksum fields)
|
|||
|
|
header.checksum_header = calculate_checksum(&header,
|
|||
|
|
sizeof(header) - 16); // Exclude checksum_data and checksum_header
|
|||
|
|
|
|||
|
|
// Write header
|
|||
|
|
fwrite(&header, sizeof(header), 1, fp);
|
|||
|
|
|
|||
|
|
// Write data
|
|||
|
|
fwrite(h_f, f_size, 1, fp);
|
|||
|
|
fwrite(h_rho, field_size, 1, fp);
|
|||
|
|
fwrite(h_ux, field_size, 1, fp);
|
|||
|
|
fwrite(h_uy, field_size, 1, fp);
|
|||
|
|
|
|||
|
|
fclose(fp);
|
|||
|
|
|
|||
|
|
// Free memory
|
|||
|
|
free(h_f);
|
|||
|
|
free(h_rho);
|
|||
|
|
free(h_ux);
|
|||
|
|
free(h_uy);
|
|||
|
|
|
|||
|
|
// Print summary
|
|||
|
|
printf("[Crystal] Crystallization complete:\n");
|
|||
|
|
printf(" - Size: %.2f MB\n", (sizeof(header) + data_size) / (1024.0f * 1024.0f));
|
|||
|
|
printf(" - Entropy: %.3f bits\n", entropy);
|
|||
|
|
printf(" - Slope: %.2f\n", slope);
|
|||
|
|
printf(" - Peak k: %d\n", peak_k);
|
|||
|
|
printf(" - kx=0: %.2f%%\n", kx0_frac * 100);
|
|||
|
|
printf(" - Thermal: %.2f°C\n", header.thermal_state / 100.0f);
|
|||
|
|
printf(" - Annotation: %s\n", annotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* ---- Original LBM Kernels (unchanged) ----------------------------------- */
|
|||
|
|
__constant__ int d_ex[Q] = { 0, 1, 0,-1, 0, 1,-1,-1, 1 };
|
|||
|
|
__constant__ int d_ey[Q] = { 0, 0, 1, 0,-1, 1, 1,-1,-1 };
|
|||
|
|
__constant__ float d_w[Q] = { 4.f/9, 1.f/9, 1.f/9, 1.f/9, 1.f/9,
|
|||
|
|
1.f/36,1.f/36,1.f/36,1.f/36 };
|
|||
|
|
|
|||
|
|
__global__ void lbm_step(const float* f_src, float* f_dst,
|
|||
|
|
float* rho_out, float* ux_out, float* uy_out, float omega, int nx, int ny) {
|
|||
|
|
const int idx = blockIdx.x * blockDim.x + threadIdx.x;
|
|||
|
|
const int N = nx * ny;
|
|||
|
|
if (idx >= N) return;
|
|||
|
|
const int x = idx % nx, y = idx / nx;
|
|||
|
|
|
|||
|
|
float fl[Q];
|
|||
|
|
for (int i = 0; i < Q; i++) {
|
|||
|
|
int sx = (x - d_ex[i] + nx) % nx;
|
|||
|
|
int sy = (y - d_ey[i] + ny) % ny;
|
|||
|
|
fl[i] = f_src[i * N + sy * nx + sx];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
float rho = 0.f, ux = 0.f, uy = 0.f;
|
|||
|
|
for (int i = 0; i < Q; i++) {
|
|||
|
|
rho += fl[i];
|
|||
|
|
ux += (float)d_ex[i] * fl[i];
|
|||
|
|
uy += (float)d_ey[i] * fl[i];
|
|||
|
|
}
|
|||
|
|
float inv = 1.f / fmaxf(rho, 1e-10f);
|
|||
|
|
ux *= inv; uy *= inv;
|
|||
|
|
rho_out[idx] = rho; ux_out[idx] = ux; uy_out[idx] = uy;
|
|||
|
|
|
|||
|
|
const float u2 = ux * ux + uy * uy;
|
|||
|
|
for (int i = 0; i < Q; i++) {
|
|||
|
|
float eu = (float)d_ex[i] * ux + (float)d_ey[i] * uy;
|
|||
|
|
float feq = d_w[i] * rho * (1.f + 3.f*eu + 4.5f*eu*eu - 1.5f*u2);
|
|||
|
|
f_dst[i * N + idx] = fl[i] - omega * (fl[i] - feq);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* ---- Spectral Analysis Functions (from original) ------------------------ */
|
|||
|
|
// Note: These functions should be copied from the original
|
|||
|
|
// fractal_habit_1024x1024_nvme_proper.cu
|
|||
|
|
// For brevity, placeholder comments are used
|
|||
|
|
|
|||
|
|
__global__ void compute_spectrum(const cufftComplex* d_fft_ux,
|
|||
|
|
const cufftComplex* d_fft_uy,
|
|||
|
|
double* d_spec, int nx, int ny, int nk) {
|
|||
|
|
// Original spectral computation kernel
|
|||
|
|
// Should be copied from original file
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
__global__ void compute_kx0_fraction(const cufftComplex* d_fft_rho,
|
|||
|
|
double* d_kx0, double* d_kx_nz,
|
|||
|
|
int nx, int ny) {
|
|||
|
|
// Original kx=0 fraction computation
|
|||
|
|
// Should be copied from original file
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
double calc_entropy(const double* spec, int nk) {
|
|||
|
|
// Original entropy calculation
|
|||
|
|
// Should be copied from original file
|
|||
|
|
return 0.0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
double calc_slope(const double* spec, int nk) {
|
|||
|
|
// Original slope calculation
|
|||
|
|
// Should be copied from original file
|
|||
|
|
return 0.0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* ---- Main Function (modified for crystallization) ----------------------- */
|
|||
|
|
int main() {
|
|||
|
|
// Original initialization code from fractal_habit_1024x1024_nvme_proper.cu
|
|||
|
|
// Should be copied here
|
|||
|
|
|
|||
|
|
// Key modifications needed:
|
|||
|
|
// 1. Track entropy, slope, kx0_frac, total_energy, peak_k
|
|||
|
|
// 2. Call save_crystallized_checkpoint() instead of save_nvme_checkpoint()
|
|||
|
|
// 3. Pass spectral analysis results to crystallization function
|
|||
|
|
|
|||
|
|
printf("FRACTAL HABIT 1024×1024 - CRYSTALLIZED VERSION\n");
|
|||
|
|
printf("Adapted from the-craw's successful approach\n");
|
|||
|
|
printf("Grid: %d×%d (%d cells)\n", NX, NY, NN);
|
|||
|
|
printf("Target: High-entropy crystallization with metadata\n");
|
|||
|
|
printf("===============================================================\n");
|
|||
|
|
|
|||
|
|
// Placeholder - actual main() implementation should be copied
|
|||
|
|
// from the original file and modified as described above
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|