#include "channel_quant.hpp" #include #include #include #include #include #include namespace { using U64 = std::uint64_t; using I64 = std::int64_t; using channel_quant::Tensor; using channel_quant::QuantParam; class Arguments { public: explicit Arguments(const std::vector &words) : words_(words) {} template bool next(Number &value) { if (position_ == words_.size()) return false; const std::string &token = words_[position_++]; const auto result = std::from_chars(token.data(), token.data() + token.size(), value); return result.ec == std::errc{} && result.ptr == token.data() + token.size(); } bool done() const { return position_ == words_.size(); } private: const std::vector &words_; std::size_t position_ = 1; }; std::vector words(const std::string &line) { std::istringstream stream(line); std::vector result; std::string token; while (stream >> token) result.push_back(token); return result; } template void csv(const std::vector &values) { if (values.empty()) std::cout << '-'; for (std::size_t index = 0; index < values.size(); ++index) { if (index != 0) std::cout << ','; std::cout << values[index]; } } void parameters(const std::vector ¶ms) { if (params.empty()) std::cout << '-'; for (std::size_t index = 0; index < params.size(); ++index) { if (index != 0) std::cout << ';'; const QuantParam &p = params[index]; std::cout << p.numerator << ',' << p.denominator << ',' << p.zero << ',' << p.qmin << ',' << p.qmax; } } void hash_word(U64 &hash, U64 word) { for (unsigned byte = 0; byte < 8; ++byte) { hash ^= (word >> (byte * 8)) & 255; hash *= 1099511628211ULL; } } template void hash_vector(U64 &hash, const std::vector &values) { hash_word(hash, static_cast(values.size())); for (Number value : values) hash_word(hash, static_cast(value)); } U64 tensor_hash(const Tensor &tensor) { U64 hash = 14695981039346656037ULL; hash_vector(hash, tensor.shape); hash_vector(hash, tensor.strides); hash_word(hash, static_cast(tensor.origin)); hash_vector(hash, tensor.storage); return hash; } U64 params_hash(const std::vector ¶ms) { U64 hash = 14695981039346656037ULL; hash_word(hash, params.size()); for (const QuantParam &p : params) { hash_word(hash, p.numerator); hash_word(hash, p.denominator); hash_word(hash, static_cast(p.zero)); hash_word(hash, static_cast(p.qmin)); hash_word(hash, static_cast(p.qmax)); } return hash; } bool view(Arguments &args, Tensor &tensor, int &axis) { unsigned rank = 0; unsigned strides = 0; std::size_t count = 0; Tensor replacement; int next_axis = 0; if (!args.next(rank) || !args.next(strides) || !args.next(next_axis) || !args.next(replacement.origin) || !args.next(count) || rank > 5 || strides > 5 || count > 10000) return false; replacement.shape.resize(rank); replacement.strides.resize(strides); replacement.storage.resize(count); for (std::size_t &value : replacement.shape) if (!args.next(value)) return false; for (std::size_t &value : replacement.strides) if (!args.next(value)) return false; for (I64 &value : replacement.storage) if (!args.next(value)) return false; if (!args.done()) return false; tensor = std::move(replacement); axis = next_axis; return true; } bool load_params(Arguments &args, std::vector (¶ms)[2]) { unsigned target = 0; unsigned count = 0; if (!args.next(target) || !args.next(count) || target > 1 || count > 16) return false; std::vector replacement(count); for (QuantParam &p : replacement) { if (!args.next(p.numerator) || !args.next(p.denominator) || !args.next(p.zero) || !args.next(p.qmin) || !args.next(p.qmax)) return false; } if (!args.done()) return false; params[target].swap(replacement); return true; } } int main() { channel_quant::Calibrator banks[2]; unsigned selected = 0; Tensor tensor{{1}, {1}, 0, {0}}; int axis = 0; std::vector params[2]; std::string line; while (std::getline(std::cin, line)) { const std::vector fields = words(line); if (fields.empty() || fields[0][0] == '#') continue; const std::string &op = fields[0]; Arguments args(fields); channel_quant::Calibrator &bank = banks[selected]; int number = 0; std::size_t index = 0; if (op == "V") { if (!view(args, tensor, axis)) return 2; std::cout << "V 0\n"; } else if (op == "F") { if (!load_params(args, params)) return 2; std::cout << "F 0\n"; } else if (op == "U" || op == "M") { unsigned other = 0; if (!args.next(other) || !args.done() || other > 1) return 2; if (op == "U") { selected = other; std::cout << "U " << selected << '\n'; } else { std::cout << "R " << bank.merge(banks[other]) << '\n'; } } else if (op == "C") { if (!args.next(index) || !args.next(number) || !args.done()) return 2; std::cout << "R " << bank.configure(index, number) << '\n'; } else if (op == "Z" && args.done()) { bank.reset(); std::cout << "R 0\n"; } else if (op == "A" && args.done()) { std::cout << "R " << bank.update(tensor, axis) << '\n'; } else if (op == "B" && args.done()) { std::cout << "R " << bank.checkpoint() << '\n'; } else if (op == "R" && args.done()) { std::cout << "R " << bank.restore() << '\n'; } else if (op == "X" && args.done()) { std::cout << "R " << bank.clear() << '\n'; } else if (op == "D" && args.done()) { std::cout << "R " << bank.discard_checkpoint() << '\n'; } else if (op == "S" && args.done()) { std::cout << "S " << bank.channels() << ' ' << bank.mode() << ' ' << bank.total() << '\n'; } else if (op == "I" && args.done()) { std::cout << "I " << tensor_hash(tensor) << ' ' << params_hash(params[0]) << ' ' << params_hash(params[1]) << '\n'; } else if (op == "L" || op == "G" || op == "P") { if (!args.next(number) || !args.done() || number < 0) return 2; const std::size_t size = static_cast(number); if (op == "L") { channel_quant::Layout out{{size}, {size}, size, number, size, size}; const int result = channel_quant::inspect_layout(tensor, axis, out); std::cout << "L " << result << ' ' << out.axis << ' ' << out.origin << ' ' << out.elements << ' ' << out.channels << ' '; csv(out.shape); std::cout << ' '; csv(out.strides); std::cout << '\n'; } else if (op == "G") { std::vector values{number}; std::vector channels{size}; const int result = channel_quant::gather(tensor, axis, values, channels); std::cout << "G " << result << ' '; csv(values); std::cout << ' '; csv(channels); std::cout << '\n'; } else { std::vector values{{size, size, number, number, number}}; const int result = bank.parameters(values); std::cout << "P " << result << ' '; parameters(values); std::cout << '\n'; } } else if (op == "E" || op == "Q") { if (!args.next(index) || !args.next(number) || !args.done() || number < 0) return 2; if (op == "E") { I64 value = number; std::size_t channel = static_cast(number); const int result = channel_quant::element(tensor, axis, index, value, channel); std::cout << "E " << result << ' ' << value << ' ' << channel << '\n'; } else { channel_quant::Range range{static_cast(number), number, number}; const int result = bank.query(index, range); std::cout << "Q " << result << ' ' << range.count << ' ' << range.minimum << ' ' << range.maximum << '\n'; } } else if (op == "T" || op == "H") { if (!args.next(number) || !args.done()) return 2; std::vector out{number}; const int result = op == "T" ? channel_quant::quantize(tensor, axis, params[0], out) : channel_quant::requantize(tensor, axis, params[0], params[1], out); std::cout << op << ' ' << result << ' '; csv(out); std::cout << '\n'; } else if (op == "O") { I64 nonce = 0; if (!args.next(nonce) || !args.done()) return 2; std::vector out{nonce}; const int result = channel_quant::dequantize(tensor, axis, params[0], out); std::cout << "O " << result << ' '; csv(out); std::cout << '\n'; } else { return 2; } } return std::cin.bad() ? 2 : 0; }