236 lines
9.2 KiB
C++

#include "channel_quant.hpp"
#include <charconv>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
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<std::string> &words) : words_(words) {}
template<class Number>
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<std::string> &words_;
std::size_t position_ = 1;
};
std::vector<std::string> words(const std::string &line)
{
std::istringstream stream(line);
std::vector<std::string> result;
std::string token;
while (stream >> token) result.push_back(token);
return result;
}
template<class Number>
void csv(const std::vector<Number> &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<QuantParam> &params)
{
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<class Number>
void hash_vector(U64 &hash, const std::vector<Number> &values)
{
hash_word(hash, static_cast<U64>(values.size()));
for (Number value : values) hash_word(hash, static_cast<U64>(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<U64>(tensor.origin));
hash_vector(hash, tensor.storage);
return hash;
}
U64 params_hash(const std::vector<QuantParam> &params)
{
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<U64>(p.zero));
hash_word(hash, static_cast<U64>(p.qmin));
hash_word(hash, static_cast<U64>(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<QuantParam> (&params)[2])
{
unsigned target = 0;
unsigned count = 0;
if (!args.next(target) || !args.next(count) || target > 1 || count > 16) return false;
std::vector<QuantParam> 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<QuantParam> params[2];
std::string line;
while (std::getline(std::cin, line)) {
const std::vector<std::string> 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<std::size_t>(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<I64> values{number};
std::vector<std::size_t> 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<QuantParam> 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<std::size_t>(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<U64>(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<int> 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<I64> 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;
}