Question about the C API (not C++) about getting the return output of running a session

[sweetbbak]

Here is an example of what I'm trying to translate to C:

    auto outputTensors = session.onnx.Run(
        Ort::RunOptions {nullptr},
        inputNames.data(),
        inputTensors.data(),
        inputTensors.size(),
        outputNames.data(),
        outputNames.size()
    );

everything has this API of running a session and the return value is the output tensors, but in C, it returns an OrtStatusPtr
but I am lost as to how to achieve this in C so that I can write a wrapper around it for Zig... How can I retrieve the outputs of running a session in C? Thank you.

here are other examples of similar languages that all have a similar API:

        audio = self.sess.run(
            None,
            dict(
                tokens=tokens, style=voice, speed=np.ones(1, dtype=np.float32) * speed
            ),
        )[0]

        let outputs: Vec<Value> = {
            let mut inputs = vec![
                Value::from_array(session.allocator(), &phoneme_inputs).unwrap(),
                Value::from_array(session.allocator(), &input_lengths).unwrap(),
                Value::from_array(session.allocator(), &scales).unwrap(),
            ];
            if let Some(ref sid_tensor) = speaker_id {
                inputs.push(Value::from_array(session.allocator(), sid_tensor).unwrap());
            }
            match session.run(inputs) {
                Ok(out) => out,
                Err(e) => {
                    return Err(PiperError::OperationError(format!(
                        "Failed to run model inference. Error: {}",
                        e
                    )))
                }
            }
        };

my code in Zig:

    pub fn run(self: *Self) !void {
        // this is just directly calling the C api here
        const status = self.ort_api.Run.?(
            self.session,
            self.run_opts,
            self.input_names.ptr,
            self.ort_inputs.?.ptr,
            self.ort_inputs.?.len,
            self.output_names.ptr,
            self.output_names.len,
            self.ort_outputs.?.ptr,
        );

        try checkError(self.ort_api, status);
    }

I would guess that 'output' would be something that I pass into this function and that would be filled with the output, but I have no idea what that is supposed to look like and I'm having trouble finding any information or real world examples of this. If this is the case, I have no idea how I would know the length of the output tensor, either.

[Craigacp]

You can look at how the Java binding calls the C API, it shows how the inputs and outputs are passed in - https://github.com/microsoft/onnxruntime/blob/main/java/src/main/native/ai_onnxruntime_OrtSession.c#L349.

[sweetbbak]

Thanks, that definitely helps.

I'll just leave what I ended up writing in case anyone comes across this later

    var shape_info: ?*c_api.OrtTensorTypeAndShapeInfo = mem.zeroes(?*c_api.OrtTensorTypeAndShapeInfo);
    try Error(
        ort_api,
        ort_api.GetTensorTypeAndShape.?(tensor, &shape_info),
    );

    var num_dims: usize = 0;
    try Error(
        ort_api,
        ort_api.GetDimensionsCount.?(shape_info, &num_dims),
    );

    std.debug.print("num dims: {any}\n", .{num_dims});

    var output_dims: []i64 = try allocator.alloc(i64, num_dims);
    _ = &output_dims;
    // var output_dims_c: *i64 = @ptrCast(&output_dims);
    defer allocator.free(output_dims);

    try Error(
        ort_api,
        ort_api.GetDimensions.?(shape_info, @ptrCast(output_dims.ptr), num_dims),
    );
    const thing = output_dims[output_dims.len - 1];
    std.debug.print("output dims: {d}\n", .{thing});

    var buf: []f32 = try allocator.alloc(f32, elem_count);

    try onnx.Error(
        onnx_instance.ort_api,
        onnx_instance.ort_api.GetTensorMutableData.?(output_tensor, @ptrCast(&buf)),
    );

then you have the output data and the length and can do everything that you need.