Function compute_precision_cast_node

cactus/graph/graph_ops_math.cpp:311–348

}

void compute_precision_cast_node(GraphNode& node, const std::vector<std::unique_ptr<GraphNode>>& nodes, const std::unordered_map<size_t, size_t>& node_index_map) {
    const auto& input_buf = get_input(node, 0, nodes, node_index_map);

    if (input_buf.precision == node.output_buffer.precision) {
        std::memcpy(node.output_buffer.get_data(), input_buf.get_data(), input_buf.byte_size);
        return;
    }

    size_t count = input_buf.total_size;

    if (input_buf.precision == Precision::INT8 && node.output_buffer.precision == Precision::FP32) {
        if (input_buf.is_grouped_int8()) {
            dequant_grouped_int8<float>(input_buf.data_as<int8_t>(), node.output_buffer.data_as<float>(),
                                        input_buf.scales_as_fp16(), input_buf.shape, input_buf.group_size);
        } else {
            Quantization::int8_to_fp32(input_buf.data_as<int8_t>(), node.output_buffer.data_as<float>(), count, 1.0f);
        }
    } else if (input_buf.precision == Precision::FP32 && node.output_buffer.precision == Precision::INT8) {
        Quantization::fp32_to_int8(input_buf.data_as<float>(), node.output_buffer.data_as<int8_t>(), count, 1.0f);
    } else if (input_buf.precision == Precision::FP16 && node.output_buffer.precision == Precision::FP32) {
        Quantization::fp16_to_fp32(input_buf.data_as<__fp16>(), node.output_buffer.data_as<float>(), count);
    } else if (input_buf.precision == Precision::FP32 && node.output_buffer.precision == Precision::FP16) {
        Quantization::fp32_to_fp16(input_buf.data_as<float>(), node.output_buffer.data_as<__fp16>(), count);
    } else if (input_buf.precision == Precision::INT8 && node.output_buffer.precision == Precision::FP16) {
        if (input_buf.is_grouped_int8()) {
            dequant_grouped_int8<__fp16>(input_buf.data_as<int8_t>(), node.output_buffer.data_as<__fp16>(),
                                         input_buf.scales_as_fp16(), input_buf.shape, input_buf.group_size);
        } else {
            Quantization::int8_to_fp16(input_buf.data_as<int8_t>(), node.output_buffer.data_as<__fp16>(), count, 1.0f);
        }
    } else if (input_buf.precision == Precision::FP16 && node.output_buffer.precision == Precision::INT8) {
        Quantization::fp16_to_int8(input_buf.data_as<__fp16>(), node.output_buffer.data_as<int8_t>(), count, 1.0f);
    } else {
        throw std::runtime_error("Unsupported precision conversion from " +
                                std::to_string(static_cast<int>(input_buf.precision)) +
                                " to " + std::to_string(static_cast<int>(node.output_buffer.precision)));
    }
}