Function main

tests/vevo2/vevo2_warm_bench.cpp:243–333

}  // namespace

int main(int argc, char ** argv) {
    try {
        const std::filesystem::path model_path = arg_value(argc, argv, "--model", "models/Vevo2");
        const std::string backend_name = arg_value(argc, argv, "--backend", "cuda");
        const int device = int_arg(argc, argv, "--device", 0);
        const int threads = int_arg(argc, argv, "--threads", 8);
        const int warmup = int_arg(argc, argv, "--warmup", 0);
        const int iterations = int_arg(argc, argv, "--iterations", 1);
        const std::string request_sequence_json = arg_value(argc, argv, "--request-sequence-json", "");
        const std::string noise_file = arg_value(argc, argv, "--noise-file", "");
        const std::filesystem::path output_dir = arg_value(argc, argv, "--output-dir", "");
        const std::filesystem::path timing_path =
            arg_value(argc, argv, "--timing-file", "/tmp/vevo2_warm_bench_timing.log");
        if (request_sequence_json.empty()) {
            throw std::runtime_error("Vevo2 warmbench requires --request-sequence-json");
        }

        set_env_required("ENGINE_TIMING_ENABLED", "1");
        set_env_required("ENGINE_TIMING_FILE", timing_path.string());

        const auto session_option_overrides = parse_session_options(argc, argv);
        engine::runtime::ModelLoadRequest load_request;
        load_request.model_path = model_path;
        load_request.family_hint = "vevo2";
        for (const auto & [key, value] : session_option_overrides) {
            load_request.options.insert_or_assign(key, value);
        }
        auto registry = engine::runtime::make_default_registry();
        auto model = registry.load(load_request);

        engine::runtime::SessionOptions options;
        options.backend.type = parse_backend(backend_name);
        options.backend.device = device;
        options.backend.threads = threads;
        for (const auto & [key, value] : session_option_overrides) {
            options.options.insert_or_assign(key, value);
        }
        engine::runtime::TaskSpec task{engine::runtime::VoiceTaskKind::Svc, engine::runtime::RunMode::Offline};
        auto session_base = model->create_task_session(task, options);
        auto * session = dynamic_cast<engine::runtime::IOfflineVoiceTaskSession *>(session_base.get());
        if (session == nullptr) {
            throw std::runtime_error("loaded Vevo2 session is not an offline SVC session");
        }
        session->prepare({});

        const auto requests = parse_requests(request_sequence_json, noise_file);
        if (requests.empty()) {
            throw std::runtime_error("Vevo2 warmbench request sequence is empty");
        }
        for (int i = 0; i < warmup; ++i) {
            (void) session->run(requests.front());
        }

        if (!output_dir.empty()) {
            std::filesystem::create_directories(output_dir);
        }

        engine::io::json::Value::Array steps;