File size: 2,646 Bytes
67c4f10
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include "parvulus_engine.h"
#include "vision_encoder.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <chrono>
#include <iomanip>

int main() {
    std::cout << "=========================================================\n";
    std::cout << "  VISION ENCODER STANDALONE SELF-TEST & BENCHMARK\n";
    std::cout << "=========================================================\n";

    ParvulusEngine engine(0);
    if (!engine.load_weights("parvulus_model_weights.bin")) {
        std::cerr << "Failed to load parvulus_model_weights.bin\n";
        return 1;
    }

    std::vector<float> h_obs(6 * 256 * 256, 0.5f);
    std::vector<float> h_text(256, 0.1f);

    float *d_obs, *d_text, *d_z_vis;
    cudaMalloc(&d_obs, 6 * 256 * 256 * sizeof(float));
    cudaMalloc(&d_text, 256 * sizeof(float));
    cudaMalloc(&d_z_vis, 16 * 256 * sizeof(float));

    cudaMemcpy(d_obs, h_obs.data(), h_obs.size() * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_text, h_text.data(), h_text.size() * sizeof(float), cudaMemcpyHostToDevice);

    std::cout << "[Test] Warming up Vision Backbone (20 iterations)...\n";
    for (int i = 0; i < 20; ++i) {
        engine.forward_encoder(d_obs, d_text, d_z_vis);
    }
    cudaDeviceSynchronize();

    std::cout << "[Test] Benchmarking 100 Vision Encoder iterations...\n";
    auto t0 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 100; ++i) {
        engine.forward_encoder(d_obs, d_text, d_z_vis);
    }
    cudaDeviceSynchronize();
    auto t1 = std::chrono::high_resolution_clock::now();

    double avg_ms = std::chrono::duration<double, std::milli>(t1 - t0).count() / 100.0;
    std::cout << "  -> Average Vision Encoder Latency: " << std::fixed << std::setprecision(3) << avg_ms << " ms\n";

    std::vector<float> h_z_vis(16 * 256);
    cudaMemcpy(h_z_vis.data(), d_z_vis, 16 * 256 * sizeof(float), cudaMemcpyDeviceToHost);

    // Verify finite values and non-trivial output
    bool valid = true;
    for (float v : h_z_vis) {
        if (std::isnan(v) || std::isinf(v)) {
            valid = false;
            break;
        }
    }

    cudaFree(d_obs);
    cudaFree(d_text);
    cudaFree(d_z_vis);

    if (valid) {
        std::cout << "  -> Vision output verified (finite, stable).\n";
        std::cout << "=========================================================\n";
        std::cout << "  VISION ENCODER TEST PASSED!\n";
        std::cout << "=========================================================\n";
        return 0;
    } else {
        std::cerr << "  -> Error: Output contains NaN or Inf!\n";
        return 1;
    }
}