Method encode_layers

src/framework/modules/wavlm_encoder.cpp:623–675

    }

    WavlmEncoderLayerOutput encode_layers(
        const std::vector<float> & input_values,
        int64_t batch,
        int64_t samples,
        std::vector<int64_t> output_layers) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (batch != 1) {
            throw std::runtime_error("WavLM encoder currently requires batch size 1");
        }
        if (samples <= 0 || static_cast<int64_t>(input_values.size()) != batch * samples) {
            throw std::runtime_error("WavLM encoder input size mismatch");
        }
        if (output_layers.empty()) {
            throw std::runtime_error("WavLM encoder requires output layers");
        }
        std::sort(output_layers.begin(), output_layers.end());
        output_layers.erase(std::unique(output_layers.begin(), output_layers.end()), output_layers.end());
        if (!reuse_graph_) {
            release_graph();
        }
        ensure_graph(batch, samples, output_layers);
        const int64_t actual_tokens = wavlm_output_frames(samples);
        if (actual_tokens > token_capacity_) {
            throw std::runtime_error("WavLM request token count exceeds graph capacity");
        }
        auto timing_start = Clock::now();
        std::vector<float> padded_input(static_cast<size_t>(sample_capacity_), 0.0F);
        std::copy(input_values.begin(), input_values.end(), padded_input.begin());
        core::write_tensor_f32(input_, padded_input);
        engine::debug::timing_log_scalar("framework.wavlm.input_upload_ms", engine::debug::elapsed_ms(timing_start));
        timing_start = Clock::now();
        upload_runtime_masks(samples, actual_tokens);
        engine::debug::timing_log_scalar("framework.wavlm.mask_upload_ms", engine::debug::elapsed_ms(timing_start));
        timing_start = Clock::now();
        if (engine::core::compute_backend_graph(weights_->execution_context->backend(), graph_) != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("ggml_backend_graph_compute failed for WavLM encoder");
        }
        engine::debug::timing_log_scalar("framework.wavlm.graph.compute_ms", engine::debug::elapsed_ms(timing_start));
        WavlmEncoderLayerOutput out;
        out.layer_indices = output_layers_;
        out.hidden_states.reserve(outputs_.size());
        timing_start = Clock::now();
        for (const auto & output : outputs_) {
            auto values = core::read_tensor_f32(output.tensor);
            values.resize(static_cast<size_t>(actual_tokens * output.shape.dims[2]));
            out.hidden_states.push_back(std::move(values));
        }
        engine::debug::timing_log_scalar("framework.wavlm.output_read_ms", engine::debug::elapsed_ms(timing_start));
        out.batch = batch;
        out.tokens = actual_tokens;
        out.hidden_size = outputs_.front().shape.dims[2];
        return out;
    }

    void release_runtime_graph() {
        std::lock_guard<std::mutex> lock(mutex_);