// Copyright (c) 2023-2024, ARM Limited. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "generate_utils.h" #include #include namespace tosa { NLOHMANN_JSON_SERIALIZE_ENUM(DType, { { DType::DType_UNKNOWN, "UNKNOWN" }, { DType::DType_BOOL, "BOOL" }, { DType::DType_INT4, "INT4" }, { DType::DType_INT8, "INT8" }, { DType::DType_INT16, "INT16" }, { DType::DType_INT32, "INT32" }, { DType::DType_INT48, "INT48" }, { DType::DType_FP16, "FP16" }, { DType::DType_BF16, "BF16" }, { DType::DType_FP32, "FP32" }, { DType::DType_SHAPE, "SHAPE" }, }) NLOHMANN_JSON_SERIALIZE_ENUM(Op, { { Op::Op_UNKNOWN, "UNKNOWN" }, { Op::Op_ABS, "ABS" }, { Op::Op_ADD, "ADD" }, { Op::Op_ARGMAX, "ARGMAX" }, { Op::Op_AVG_POOL2D, "AVG_POOL2D" }, { Op::Op_CAST, "CAST" }, { Op::Op_CEIL, "CEIL" }, { Op::Op_CLAMP, "CLAMP" }, { Op::Op_CONCAT, "CONCAT" }, { Op::Op_CONST, "CONST" }, { Op::Op_CONV2D, "CONV2D" }, { Op::Op_DEPTHWISE_CONV2D, "DEPTHWISE_CONV2D" }, { Op::Op_CONV3D, "CONV3D" }, { Op::Op_EQUAL, "EQUAL" }, { Op::Op_ERF, "ERF" }, { Op::Op_EXP, "EXP" }, { Op::Op_FLOOR, "FLOOR" }, { Op::Op_FFT2D, "FFT2D" }, { Op::Op_FULLY_CONNECTED, "FULLY_CONNECTED" }, { Op::Op_GATHER, "GATHER" }, { Op::Op_GREATER, "GREATER" }, { Op::Op_GREATER_EQUAL, "GREATER_EQUAL" }, { Op::Op_IDENTITY, "IDENTITY" }, { Op::Op_LOG, "LOG" }, { Op::Op_MATMUL, "MATMUL" }, { Op::Op_MAXIMUM, "MAXIMUM" }, { Op::Op_MAX_POOL2D, "MAX_POOL2D" }, { Op::Op_MINIMUM, "MINIMUM" }, { Op::Op_MUL, "MUL" }, { Op::Op_NEGATE, "NEGATE" }, { Op::Op_PAD, "PAD" }, { Op::Op_POW, "POW" }, { Op::Op_RECIPROCAL, "RECIPROCAL" }, { Op::Op_REDUCE_MAX, "REDUCE_MAX" }, { Op::Op_REDUCE_MIN, "REDUCE_MIN" }, { Op::Op_REDUCE_PRODUCT, "REDUCE_PRODUCT" }, { Op::Op_REDUCE_SUM, "REDUCE_SUM" }, { Op::Op_RESHAPE, "RESHAPE" }, { Op::Op_RESIZE, "RESIZE" }, { Op::Op_REVERSE, "REVERSE" }, { Op::Op_RFFT2D, "RFFT2D" }, { Op::Op_RSQRT, "RSQRT" }, { Op::Op_SCATTER, "SCATTER" }, { Op::Op_SELECT, "SELECT" }, { Op::Op_SIGMOID, "SIGMOID" }, { Op::Op_SLICE, "SLICE" }, { Op::Op_SUB, "SUB" }, { Op::Op_TANH, "TANH" }, { Op::Op_TILE, "TILE" }, { Op::Op_TRANSPOSE, "TRANSPOSE" }, { Op::Op_TRANSPOSE_CONV2D, "TRANSPOSE_CONV2D" }, }) } // namespace tosa namespace TosaReference { NLOHMANN_JSON_SERIALIZE_ENUM(GeneratorType, { { GeneratorType::Unknown, "UNKNOWN" }, { GeneratorType::PseudoRandom, "PSEUDO_RANDOM" }, { GeneratorType::DotProduct, "DOT_PRODUCT" }, { GeneratorType::OpFullRange, "OP_FULL_RANGE" }, { GeneratorType::OpBoundary, "OP_BOUNDARY" }, { GeneratorType::OpSpecial, "OP_SPECIAL" }, { GeneratorType::FixedData, "FIXED_DATA" }, }) // NOTE: This assumes it's VARIABLE if the InputType is not recognized NLOHMANN_JSON_SERIALIZE_ENUM(InputType, { { InputType::Variable, "VARIABLE" }, { InputType::Constant, "CONSTANT" }, }) void from_json(const nlohmann::json& j, DotProductInfo& dotProductInfo) { j.at("s").get_to(dotProductInfo.s); j.at("ks").get_to(dotProductInfo.ks); j.at("acc_type").get_to(dotProductInfo.accType); if (j.contains("kernel")) { j.at("kernel").get_to(dotProductInfo.kernel); } if (j.contains("axis")) { j.at("axis").get_to(dotProductInfo.axis); } } void from_json(const nlohmann::json& j, PseudoRandomInfo& pseudoRandomInfo) { j.at("rng_seed").get_to(pseudoRandomInfo.rngSeed); if (j.contains("range")) { j.at("range").get_to(pseudoRandomInfo.range); } if (j.contains("round")) { j.at("round").get_to(pseudoRandomInfo.round); } } void from_json(const nlohmann::json& j, FixedDataInfo& fixedDataInfo) { j.at("data").get_to(fixedDataInfo.data); } void from_json(const nlohmann::json& j, GenerateConfig& cfg) { j.at("data_type").get_to(cfg.dataType); j.at("input_type").get_to(cfg.inputType); j.at("shape").get_to(cfg.shape); j.at("input_pos").get_to(cfg.inputPos); j.at("op").get_to(cfg.opType); j.at("generator").get_to(cfg.generatorType); // Set up defaults for dotProductInfo cfg.dotProductInfo.s = -1; cfg.dotProductInfo.ks = -1; cfg.dotProductInfo.accType = DType_UNKNOWN; cfg.dotProductInfo.kernel = std::vector(); cfg.dotProductInfo.axis = -1; if (j.contains("dot_product_info")) { j.at("dot_product_info").get_to(cfg.dotProductInfo); } // Set up defaults for pseudoRandomInfo cfg.pseudoRandomInfo.rngSeed = -1; cfg.pseudoRandomInfo.range = std::vector(); cfg.pseudoRandomInfo.round = false; if (j.contains("pseudo_random_info")) { j.at("pseudo_random_info").get_to(cfg.pseudoRandomInfo); } // Set up defaults for fixedDataInfo cfg.fixedDataInfo.data = std::vector(); if (j.contains("fixed_data_info")) { j.at("fixed_data_info").get_to(cfg.fixedDataInfo); } } std::optional parseGenerateConfig(const char* json, const char* tensorName) { if (!tensorName) return std::nullopt; auto jsonCfg = nlohmann::json::parse(json, nullptr, /* allow exceptions */ false); if (jsonCfg.is_discarded()) { WARNING("[Generator] Invalid json config."); return std::nullopt; } if (!jsonCfg.contains("tensors")) { WARNING("[Generator] Missing tensors in json config."); return std::nullopt; } const auto& tensors = jsonCfg["tensors"]; if (!tensors.contains(tensorName)) { WARNING("[Generator] Missing tensor %s in json config.", tensorName); return std::nullopt; } const auto& namedTensor = tensors[tensorName]; return namedTensor.get(); } int64_t numElementsFromShape(const std::vector& shape) { // Rank 0 shapes have no entries and so this will return 1 // Other ranked shapes will return the product of their dimensions return std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies()); } size_t elementSizeFromType(DType type) { switch (type) { case DType::DType_BOOL: case DType::DType_UINT8: case DType::DType_INT8: return 1; case DType::DType_UINT16: case DType::DType_INT16: case DType::DType_FP16: case DType::DType_BF16: return 2; case DType::DType_INT32: case DType::DType_FP32: case DType::DType_SHAPE: return 4; default: return 0; } return 0; } } // namespace TosaReference