// Copyright 2015 The Gemmlowp Authors. All Rights Reserved.
//
// 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 <unistd.h>
#ifdef __APPLE__
#include <sys/time.h>
#endif
#include <cstdint>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <map>
#include <vector>
#include "../meta/legacy_multi_thread_gemm.h"
#include "../public/gemmlowp.h"
#include "test.h"
// lets include these so we make sure they always compile
#include "../meta/multi_thread_gemm.h"
#include "../meta/multi_thread_transform.h"
#include "../meta/legacy_multi_thread_common.h"
#if defined(__arm__) && !defined(GEMMLOWP_NEON)
#warning "Building without NEON support on ARM, check your compiler setup!"
#endif
double time() {
#ifdef __APPLE__
timeval t;
gettimeofday(&t, nullptr);
return t.tv_sec + 1e-6 * t.tv_usec;
#else
timespec t;
clock_gettime(CLOCK_REALTIME, &t);
return t.tv_sec + 1e-9 * t.tv_nsec;
#endif
}
void prepare_test_data(std::uint8_t* data, std::int32_t rows, std::int32_t cols,
std::int32_t seed, std::int32_t seed_2) {
std::int32_t value = seed;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
data[i * cols + j] = static_cast<std::uint8_t>(value);
value = ((value * seed_2) + seed) % 256;
}
}
}
void check_result(std::uint8_t* left, std::uint8_t* right, std::uint8_t* result,
std::int32_t rows, std::int32_t cols, std::int32_t depth,
std::int32_t lhs_offset, std::int32_t rhs_offset,
std::int32_t sum_offset, std::int32_t mul_offset,
std::int32_t shift) {
std::int32_t rounding = (1 << (shift - 1));
std::int32_t wrong = 0;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
std::int32_t expected = 0;
for (int k = 0; k < depth; ++k) {
expected +=
(static_cast<std::int32_t>(left[depth * i + k]) + lhs_offset) *
(static_cast<std::int32_t>(right[depth * j + k]) + rhs_offset);
}
expected += sum_offset;
expected *= mul_offset;
expected += rounding;
expected = (expected >> shift);
if (expected < 0) {
expected = 0;
} else if (expected > 255) {
expected = 255;
}
expected = static_cast<std::int32_t>(static_cast<std::uint8_t>(expected));
std::int32_t actual = static_cast<std::int32_t>(result[i * cols + j]);
if (actual != expected) {
std::cout << "(" << i << ", " << j << "): " << expected << "!="
<< actual << std::endl;
wrong++;
}
}
}
if (wrong > 0) {
std::cout << "Wrong: " << rows << "x" << cols << "x" << depth << " : "
<< wrong << "/" << (rows * cols) << std::endl
<< std::flush;
std::exit(1);
} else {
std::cout << "." << std::flush;
}
}
void check_result_f(std::uint8_t* left, std::uint8_t* right, float* result,
std::int32_t rows, std::int32_t cols, std::int32_t depth,
std::int32_t lhs_offset, std::int32_t rhs_offset,
float result_offset) {
std::int32_t wrong = 0;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
std::int32_t expected = 0;
for (int k = 0; k < depth; ++k) {
expected +=
(static_cast<std::int32_t>(left[depth * i + k]) + lhs_offset) *
(static_cast<std::int32_t>(right[depth * j + k]) + rhs_offset);
}
float expected_float = static_cast<float>(expected) * result_offset;
float actual_float = result[i * cols + j];
if (actual_float != expected_float) {
std::cout << "(" << i << ", " << j << "): " << expected_float << "!="
<< actual_float << std::endl;
wrong++;
}
}
}
if (wrong > 0) {
std::cout << "Wrong: " << rows << "x" << cols << "x" << depth << " : "
<< wrong << "/" << (rows * cols) << std::endl
<< std::flush;
std::exit(1);
} else {
std::cout << "." << std::flush;
}
}
void check_result_i32(std::uint8_t* left, std::uint8_t* right,
std::int32_t* result, std::int32_t rows,
std::int32_t cols, std::int32_t depth,
std::int32_t lhs_offset, std::int32_t rhs_offset) {
std::int32_t wrong = 0;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
std::int32_t expected = 0;
for (int k = 0; k < depth; ++k) {
expected +=
(static_cast<std::int32_t>(left[depth * i + k]) + lhs_offset) *
(static_cast<std::int32_t>(right[depth * j + k]) + rhs_offset);
}
std::int32_t actual = result[i * cols + j];
if (actual != expected) {
std::cout << "(" << i << ", " << j << "): " << expected << "!="
<< actual << std::endl;
wrong++;
}
}
}
if (wrong > 0) {
std::cout << "Wrong: " << rows << "x" << cols << "x" << depth << " : "
<< wrong << "/" << (rows * cols) << std::endl
<< std::flush;
std::exit(1);
} else {
std::cout << "." << std::flush;
}
}
template <typename T>
void clear(T* result, std::int32_t rows, std::int32_t cols) {
for (int i = 0; i < rows * cols; ++i) {
result[i] = static_cast<T>(0);
}
}
void test(std::uint8_t* scratch, std::uint8_t* lhs, std::uint8_t* rhs,
std::int32_t m, std::int32_t n, std::int32_t k, std::uint8_t* result,
gemmlowp::WorkersPool* pool, std::int32_t pool_size) {
prepare_test_data(lhs, m, k, 11, 13);
prepare_test_data(rhs, n, k, 177, 19);
clear(result, m, n);
gemmlowp::meta::multi_thread_gemm_q8(pool, pool_size, scratch, lhs, rhs, m, n,
k, -127, -127, 127 * k, 1, 7, result);
check_result(lhs, rhs, result, m, n, k, -127, -127, 127 * k, 1, 7);
}
void test_f(std::uint8_t* scratch, std::uint8_t* lhs, std::uint8_t* rhs,
std::int32_t m, std::int32_t n, std::int32_t k, float* result,
gemmlowp::WorkersPool* pool, std::int32_t pool_size) {
prepare_test_data(lhs, m, k, 11, 13);
prepare_test_data(rhs, n, k, 177, 19);
clear(result, m, n);
float scale = 1.0f / 1234567.8f;
gemmlowp::meta::multi_thread_gemm_f(pool, pool_size, scratch, lhs, rhs, m, n,
k, -127, -127, scale, result);
check_result_f(lhs, rhs, result, m, n, k, -127, -127, scale);
}
void test_i32(std::uint8_t* scratch, std::uint8_t* lhs, std::uint8_t* rhs,
std::int32_t m, std::int32_t n, std::int32_t k,
std::int32_t* result, gemmlowp::WorkersPool* pool,
std::int32_t pool_size) {
prepare_test_data(lhs, m, k, 11, 13);
prepare_test_data(rhs, n, k, 177, 19);
clear(result, m, n);
gemmlowp::meta::multi_thread_gemm_i32(pool, pool_size, scratch, lhs, rhs, m,
n, k, -127, -127, result);
check_result_i32(lhs, rhs, result, m, n, k, -127, -127);
}
void q_suite(int mi, int ni, int ki, int mx, int nx, int kx, int md, int nd,
int kd, std::uint8_t* scratch, std::uint8_t* left,
std::uint8_t* right, std::uint8_t* result,
gemmlowp::WorkersPool* pool, int t) {
for (int m = mi; m < mx; m += md) {
for (int n = ni; n < nx; n += nd) {
for (int k = ki; k < kx; k += kd) {
test(scratch, left, right, m, n, k, result, pool, t);
}
}
}
std::cout << std::endl;
}
void f_suite(int mi, int ni, int ki, int mx, int nx, int kx, int md, int nd,
int kd, std::uint8_t* scratch, std::uint8_t* left,
std::uint8_t* right, float* result, gemmlowp::WorkersPool* pool,
int t) {
for (int m = mi; m < mx; m += md) {
for (int n = ni; n < nx; n += nd) {
for (int k = ki; k < kx; k += kd) {
test_f(scratch, left, right, m, n, k, result, pool, t);
}
}
}
std::cout << std::endl;
}
void i32_suite(int mi, int ni, int ki, int mx, int nx, int kx, int md, int nd,
int kd, std::uint8_t* scratch, std::uint8_t* left,
std::uint8_t* right, std::int32_t* result,
gemmlowp::WorkersPool* pool, int t) {
for (int m = mi; m < mx; m += md) {
for (int n = ni; n < nx; n += nd) {
for (int k = ki; k < kx; k += kd) {
test_i32(scratch, left, right, m, n, k, result, pool, t);
}
}
}
std::cout << std::endl;
}
int main(int argc, char* argv[]) {
bool run_long_test = false;
if (argc > 1 && strcmp(argv[1], "long")) {
run_long_test = true;
}
const std::int32_t min_n = 1;
const std::int32_t min_m = 1;
const std::int32_t min_k = 8;
const std::int32_t max_n = 1024;
const std::int32_t max_m = 1024;
const std::int32_t max_k = 2048;
std::uint8_t* left = new std::uint8_t[max_m * max_k];
std::uint8_t* right = new std::uint8_t[max_n * max_k];
std::uint8_t* result = new std::uint8_t[max_m * max_n];
float* result_float = new float[max_m * max_n];
std::int32_t* result_i32 = new std::int32_t[max_m * max_n];
std::uint8_t* scratch = new std::uint8_t[1024 * 1024 * 64];
gemmlowp::WorkersPool pool;
int max_repetitions = run_long_test ? 10 : 1;
for (int repetitions = 0; repetitions < max_repetitions; ++repetitions) {
int t = std::min(repetitions + 1, 4);
std::cout << "Threads: " << t << std::endl << std::flush;
std::cout << "Quantized 8 bit." << std::endl << std::flush;
std::cout << "Small." << std::endl << std::flush;
q_suite(1, 1, 1, 16, 16, 32, 1, 1, 1, scratch, left, right, result, &pool,
t);
if (run_long_test) {
std::cout << "Big." << std::endl << std::flush;
q_suite(1, 1, 1, 512, 512, 2048, 111, 111, 111, scratch, left, right,
result, &pool, t);
}
std::cout << "Gemv." << std::endl << std::flush;
q_suite(1, 1, 1, 2, 512, 2048, 1, 111, 111, scratch, left, right, result,
&pool, t);
q_suite(1, 1, 1, 512, 2, 2048, 111, 1, 111, scratch, left, right, result,
&pool, t);
std::cout << std::endl << "Floats." << std::endl << std::flush;
std::cout << "Small." << std::endl << std::flush;
f_suite(1, 1, 1, 16, 16, 32, 1, 1, 1, scratch, left, right, result_float,
&pool, t);
if (run_long_test) {
std::cout << "Big." << std::endl << std::flush;
f_suite(1, 1, 1, 512, 512, 2048, 111, 111, 111, scratch, left, right,
result_float, &pool, t);
}
std::cout << "Gemv." << std::endl << std::flush;
f_suite(1, 1, 1, 2, 512, 2048, 1, 111, 111, scratch, left, right,
result_float, &pool, t);
f_suite(1, 1, 1, 512, 2, 2048, 111, 1, 111, scratch, left, right,
result_float, &pool, t);
std::cout << std::endl << "Int32." << std::endl << std::flush;
std::cout << "Small." << std::endl << std::flush;
i32_suite(1, 1, 1, 16, 16, 32, 1, 1, 1, scratch, left, right, result_i32,
&pool, t);
if (run_long_test) {
std::cout << "Big." << std::endl << std::flush;
i32_suite(1, 1, 1, 512, 512, 2048, 111, 111, 111, scratch, left, right,
result_i32, &pool, t);
}
std::cout << "Gemv." << std::endl << std::flush;
i32_suite(1, 1, 1, 2, 512, 2048, 1, 111, 111, scratch, left, right,
result_i32, &pool, t);
i32_suite(1, 1, 1, 512, 2, 2048, 111, 1, 111, scratch, left, right,
result_i32, &pool, t);
std::cout << std::endl << std::flush;
}
std::cout << "Done." << std::endl << std::flush;
}