#include "parvulus_c_api.h" #include #include #include #include #include #include #include #include #include #include #include void print_help(const char* prog) { std::cout << "====================================================================\n"; std::cout << " PARVULUS STANDALONE PURE CUDA RUNTIME CLI (Vector-First)\n"; std::cout << " Zero PyTorch, Zero LibTorch, Zero Python, Pure CUDA/cuBLAS Engine\n"; std::cout << "====================================================================\n\n"; std::cout << "Usage: " << prog << " [options]\n\n"; std::cout << "Options:\n"; std::cout << " --device CUDA GPU device ID (default: 0)\n"; std::cout << " --weights Path to parvulus_model_weights.bin\n"; std::cout << " --embeddings Path to task_embeddings.bin (optional lookup table)\n"; std::cout << " --scale Path to action_scale.bin (default: action_scale.bin)\n"; std::cout << " --nfe Number of Euler ODE flow steps (default: 10)\n"; std::cout << "\nTask Conditioning (Vector-First):\n"; std::cout << " --task_vector_file Load 256-dim task vector from file (.bin, .npy, .txt)\n"; std::cout << " --task_vector \"\" Pass 256-dim float vector directly as string\n"; std::cout << " --task Task instruction text (looks up in embeddings table)\n"; std::cout << "\nInputs & Outputs:\n"; std::cout << " --agent_img Path to 256x256x3 uint8 raw RGB agentview image\n"; std::cout << " --wrist_img Path to 256x256x3 uint8 raw RGB wrist image\n"; std::cout << " --output File path to write predicted 8x7 action trajectory\n"; std::cout << " --benchmark Run N chunk benchmark iterations and report latency\n"; std::cout << " -h, --help Show this help message and exit\n\n"; std::cout << "Examples:\n"; std::cout << " # 1. Run inference using a direct 256-dim task vector:\n"; std::cout << " " << prog << " --task_vector_file embedding.bin\n\n"; std::cout << " # 2. Run inference with a perturbed instruction vector or numpy array:\n"; std::cout << " " << prog << " --task_vector_file perturbed_emb.npy --output actions.txt\n\n"; std::cout << " # 3. High-throughput 100-chunk benchmark:\n"; std::cout << " " << prog << " --benchmark 100\n"; std::cout << "====================================================================\n"; } bool file_exists(const std::string& path) { std::ifstream f(path.c_str()); return f.good(); } std::string find_file(const std::string& filename) { if (file_exists(filename)) return filename; if (file_exists("c_engine/" + filename)) return "c_engine/" + filename; if (file_exists("../c_engine/" + filename)) return "../c_engine/" + filename; return filename; } bool load_vector_from_file(const std::string& path, std::vector& out_vec) { out_vec.resize(256, 0.0f); std::ifstream fb(path, std::ios::binary); if (!fb.is_open()) return false; fb.seekg(0, std::ios::end); size_t sz = fb.tellg(); fb.seekg(0, std::ios::beg); // 1. Raw float binary (256 * 4 = 1024 bytes) if (sz == 256 * sizeof(float)) { fb.read(reinterpret_cast(out_vec.data()), 256 * sizeof(float)); return true; } // 2. NumPy .npy format if (sz >= 1024 && path.size() >= 4 && path.substr(path.size() - 4) == ".npy") { fb.seekg(sz - 256 * sizeof(float), std::ios::beg); fb.read(reinterpret_cast(out_vec.data()), 256 * sizeof(float)); return true; } // 3. ASCII whitespace or comma delimited text fb.close(); std::ifstream ft(path); std::string token; int count = 0; while (ft >> token && count < 256) { if (!token.empty() && token.back() == ',') token.pop_back(); if (token.empty()) continue; try { out_vec[count++] = std::stof(token); } catch (...) {} } return count == 256; } bool parse_vector_from_string(const std::string& str, std::vector& out_vec) { out_vec.clear(); std::stringstream ss(str); std::string token; while (std::getline(ss, token, ',')) { std::stringstream ss_tok(token); float val; while (ss_tok >> val) { out_vec.push_back(val); } } return out_vec.size() >= 256; } int main(int argc, char** argv) { int device_id = 0; int num_euler_steps = 10; int benchmark_n = 0; std::string weights_path = find_file("parvulus_model_weights.bin"); std::string embeddings_path = find_file("task_embeddings.bin"); std::string scale_path = find_file("action_scale.bin"); std::string task_desc = "pick up the black bowl between the plate and the ramekin and place it on the plate"; std::string task_vector_file = ""; std::string task_vector_str = ""; std::string agent_img_path = ""; std::string wrist_img_path = ""; std::string output_path = ""; for (int i = 1; i < argc; ++i) { std::string arg = argv[i]; if (arg == "-h" || arg == "--help") { print_help(argv[0]); return 0; } else if (arg == "--device" && i + 1 < argc) { device_id = std::atoi(argv[++i]); } else if (arg == "--weights" && i + 1 < argc) { weights_path = argv[++i]; } else if (arg == "--embeddings" && i + 1 < argc) { embeddings_path = argv[++i]; } else if (arg == "--scale" && i + 1 < argc) { scale_path = argv[++i]; } else if (arg == "--nfe" && i + 1 < argc) { num_euler_steps = std::atoi(argv[++i]); } else if (arg == "--task" && i + 1 < argc) { task_desc = argv[++i]; } else if ((arg == "--task_vector_file" || arg == "--task_emb_raw") && i + 1 < argc) { task_vector_file = argv[++i]; } else if (arg == "--task_vector" && i + 1 < argc) { task_vector_str = argv[++i]; } else if (arg == "--agent_img" && i + 1 < argc) { agent_img_path = argv[++i]; } else if (arg == "--wrist_img" && i + 1 < argc) { wrist_img_path = argv[++i]; } else if (arg == "--output" && i + 1 < argc) { output_path = argv[++i]; } else if (arg == "--benchmark") { benchmark_n = 100; if (i + 1 < argc && argv[i + 1][0] != '-') { benchmark_n = std::atoi(argv[++i]); } } else { std::cerr << "Unknown option: " << arg << " (use --help for options)\n"; return 1; } } std::cout << "====================================================================\n"; std::cout << " PARVULUS STANDALONE PURE CUDA RUNTIME (Vector-First)\n"; std::cout << " Zero PyTorch, Zero LibTorch, Standalone C/CUDA Engine\n"; std::cout << " CUDA Device: " << device_id << " | Euler ODE Steps: " << num_euler_steps << "\n"; std::cout << "====================================================================\n"; // 1. Instantiate pure CUDA engine ParvulusHandle engine = parvulus_create(device_id); if (!engine) { std::cerr << "[Error] Failed to initialize CUDA engine on device " << device_id << "\n"; return 1; } // 2. Load model weights std::cout << "[Init] Loading weights: " << weights_path << "...\n"; const char* emb_path_c = embeddings_path.empty() ? nullptr : embeddings_path.c_str(); const char* scl_path_c = scale_path.empty() ? nullptr : scale_path.c_str(); auto t_load_0 = std::chrono::high_resolution_clock::now(); bool ok = parvulus_load(engine, weights_path.c_str(), emb_path_c, scl_path_c); auto t_load_1 = std::chrono::high_resolution_clock::now(); double load_ms = std::chrono::duration(t_load_1 - t_load_0).count(); if (!ok) { std::cerr << "[Error] Failed to load binary model assets!\n"; parvulus_destroy(engine); return 1; } std::cout << "[Init] Engine initialized in " << std::fixed << std::setprecision(2) << load_ms << " ms.\n"; // 3. Set Task Conditioning Vector (First-Class Vector Pipeline) std::vector task_vector(256, 0.0f); bool vector_loaded = false; if (!task_vector_file.empty()) { if (load_vector_from_file(task_vector_file, task_vector)) { vector_loaded = true; std::cout << "[Task] Loaded 256-dim task conditioning vector from file: " << task_vector_file << "\n"; parvulus_set_task_vector(engine, task_vector.data()); } else { std::cerr << "[Error] Failed to load 256 floats from: " << task_vector_file << "\n"; parvulus_destroy(engine); return 1; } } else if (!task_vector_str.empty()) { if (parse_vector_from_string(task_vector_str, task_vector)) { vector_loaded = true; std::cout << "[Task] Parsed 256-dim task conditioning vector from command-line string.\n"; parvulus_set_task_vector(engine, task_vector.data()); } else { std::cerr << "[Error] Failed to parse 256 floats from --task_vector string!\n"; parvulus_destroy(engine); return 1; } } else { // Fall back to lookup string if provided std::cout << "[Task] Instruction: \"" << task_desc << "\" (using lookup table)\n"; if (!parvulus_set_task_string(engine, task_desc.c_str())) { std::cerr << "[Error] Task prompt not found in lookup cache: " << task_desc << "\n"; parvulus_destroy(engine); return 1; } } // 4. Prepare Image Buffers const size_t img_size = 256 * 256 * 3; std::vector agent_img(img_size, 128); std::vector wrist_img(img_size, 128); if (!agent_img_path.empty()) { std::ifstream f(agent_img_path, std::ios::binary); if (!f.is_open() || !f.read(reinterpret_cast(agent_img.data()), img_size)) { std::cerr << "[Warning] Could not read agent image from: " << agent_img_path << ", using test pattern.\n"; } else { std::cout << "[Input] Loaded agent image: " << agent_img_path << "\n"; } } if (!wrist_img_path.empty()) { std::ifstream f(wrist_img_path, std::ios::binary); if (!f.is_open() || !f.read(reinterpret_cast(wrist_img.data()), img_size)) { std::cerr << "[Warning] Could not read wrist image from: " << wrist_img_path << ", using test pattern.\n"; } else { std::cout << "[Input] Loaded wrist image: " << wrist_img_path << "\n"; } } std::vector actions(8 * 7, 0.0f); // 5. Benchmark or Single Prediction if (benchmark_n > 0) { std::cout << "\n[Benchmark] Warming up (10 iterations)...\n"; for (int i = 0; i < 10; ++i) { parvulus_predict_chunk(engine, agent_img.data(), wrist_img.data(), nullptr, actions.data(), num_euler_steps, nullptr); } std::cout << "[Benchmark] Running " << benchmark_n << " consecutive chunk predictions...\n"; std::vector latencies_ms; latencies_ms.reserve(benchmark_n); for (int i = 0; i < benchmark_n; ++i) { auto t0 = std::chrono::high_resolution_clock::now(); parvulus_predict_chunk(engine, agent_img.data(), wrist_img.data(), nullptr, actions.data(), num_euler_steps, nullptr); auto t1 = std::chrono::high_resolution_clock::now(); latencies_ms.push_back(std::chrono::duration(t1 - t0).count()); } std::sort(latencies_ms.begin(), latencies_ms.end()); double min_ms = latencies_ms.front(); double max_ms = latencies_ms.back(); double mean_ms = std::accumulate(latencies_ms.begin(), latencies_ms.end(), 0.0) / benchmark_n; double p50_ms = latencies_ms[benchmark_n / 2]; double p95_ms = latencies_ms[static_cast(benchmark_n * 0.95)]; double p99_ms = latencies_ms[static_cast(benchmark_n * 0.99)]; double action_rate = 8.0 / (mean_ms / 1000.0); std::cout << "\n====================================================================\n"; std::cout << " LATENCY BENCHMARK RESULTS (N=" << benchmark_n << " chunks):\n"; std::cout << "====================================================================\n"; std::cout << " - Min Latency: " << std::fixed << std::setprecision(3) << min_ms << " ms\n"; std::cout << " - p50 Latency: " << std::fixed << std::setprecision(3) << p50_ms << " ms\n"; std::cout << " - Mean Chunk Latency: " << std::fixed << std::setprecision(3) << mean_ms << " ms\n"; std::cout << " - p95 Latency: " << std::fixed << std::setprecision(3) << p95_ms << " ms\n"; std::cout << " - p99 Latency: " << std::fixed << std::setprecision(3) << p99_ms << " ms\n"; std::cout << " - Max Latency: " << std::fixed << std::setprecision(3) << max_ms << " ms\n"; std::cout << " - Effective Action Rate: " << std::fixed << std::setprecision(1) << action_rate << " Hz\n"; std::cout << "====================================================================\n"; } else { auto t0 = std::chrono::high_resolution_clock::now(); bool pred_ok = parvulus_predict_chunk(engine, agent_img.data(), wrist_img.data(), nullptr, actions.data(), num_euler_steps, nullptr); auto t1 = std::chrono::high_resolution_clock::now(); double pred_ms = std::chrono::duration(t1 - t0).count(); if (!pred_ok) { std::cerr << "[Error] Action chunk prediction failed!\n"; parvulus_destroy(engine); return 1; } std::cout << "\n[Inference] Predicted 8x7 action chunk in " << std::fixed << std::setprecision(2) << pred_ms << " ms.\n"; } // 6. Print Action Trajectory std::cout << "\nPredicted Action Chunk [8 Steps x 7 Dimensions (dx, dy, dz, droll, dpitch, dyaw, gripper)]:\n"; std::cout << "--------------------------------------------------------------------------------------\n"; for (int step = 0; step < 8; ++step) { std::cout << " Step " << step << ": ["; for (int d = 0; d < 7; ++d) { std::cout << std::setw(8) << std::fixed << std::setprecision(4) << actions[step * 7 + d] << (d < 6 ? ", " : ""); } std::cout << "]\n"; } std::cout << "--------------------------------------------------------------------------------------\n"; // 7. Write to output file if requested if (!output_path.empty()) { std::ofstream out_f(output_path); if (out_f.is_open()) { for (int step = 0; step < 8; ++step) { for (int d = 0; d < 7; ++d) { out_f << std::fixed << std::setprecision(6) << actions[step * 7 + d] << (d < 6 ? " " : "\n"); } } std::cout << "[Output] Saved action chunk to: " << output_path << "\n"; } else { std::cerr << "[Warning] Failed to write output to: " << output_path << "\n"; } } // 8. Cleanup parvulus_destroy(engine); std::cout << "\n[Pure CUDA] Engine released cleanly.\n"; return 0; }