Dobiasd
commented
6 years ago Just tried out OpenBLAS as an alternative to Eigen, but it is not faster.
#include <chrono>
#include <iostream>
#include <eigen3/Eigen/Dense>
extern "C" {
void sgemm_(char*, char*, int*, int*,int*, float*, float*, int*, float*, int*, float*, float*, int*);
}
using RowMajorMat = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
#define mat_size_1 512
#define mat_size_2 4609
#define mat_size_3 784
float multiply_unaligned()
{
RowMajorMat a(mat_size_1, mat_size_2);
RowMajorMat b(mat_size_2, mat_size_3);
const std::size_t num_bytes = a.rows() * b.cols() * sizeof(float);
float* ptr = (float*)std::malloc(num_bytes);
Eigen::Map<RowMajorMat, Eigen::Unaligned> c(
ptr,
static_cast<Eigen::Index>(a.rows()),
static_cast<Eigen::Index>(b.cols()));
c.noalias() = a * b;
float check_value = ptr[0];
std::free(ptr);
return check_value;
}
float multiply_openblas()
{
int m = mat_size_1;
int n = mat_size_3;
int k = mat_size_2;
int sizeofa = m * k;
int sizeofb = k * n;
int sizeofc = m * n;
char ta = 'N';
char tb = 'N';
float alpha = 1;
float beta = 1;
struct timeval start,finish;
float duration;
float* A = (float*)malloc(sizeof(float) * sizeofa);
float* B = (float*)malloc(sizeof(float) * sizeofb);
float* C = (float*)malloc(sizeof(float) * sizeofc);
sgemm_(&ta, &tb, &m, &n, &k, &alpha, A, &m, B, &k, &beta, C, &m);
float check = C[0];
free(A);
free(B);
free(C);
return check;
}
template <typename Func>
void measure(const std::string& name, const Func f)
{
using namespace std::chrono;
float checksum = 0.0f; // to prevent compiler from optimizing everything away
const auto start_time_ns = high_resolution_clock::now().time_since_epoch().count();
const std::size_t runs = 10;
for (size_t i = 0; i < runs; ++i)
{
checksum += f();
}
const auto end_time_ns = high_resolution_clock::now().time_since_epoch().count();
const auto elapsed_ms = (end_time_ns - start_time_ns) / (runs * 1000000);
std::cout << name << " (checksum: " << checksum << ") elapsed_ms: " << elapsed_ms << std::endl;
}
int main()
{
for (std::size_t i = 0; i < 5; ++i)
{
measure("unaligned", multiply_unaligned);
measure("openblas ", multiply_openblas);
std::cout << "--------" << std::endl;
}
}g++ --std=c++14 -O3 -mfma gemm_benchmark.cpp -lopenblas -lgfortran -o gemm_benchmark && taskset --cpu-list 1 ./gemm_benchmarkunaligned (checksum: 0) elapsed_ms: 41
openblas (checksum: 0) elapsed_ms: 43
--------
unaligned (checksum: 0) elapsed_ms: 39
openblas (checksum: 0) elapsed_ms: 43
--------
unaligned (checksum: 0) elapsed_ms: 39
openblas (checksum: 0) elapsed_ms: 41
--------
unaligned (checksum: 0) elapsed_ms: 39
openblas (checksum: 0) elapsed_ms: 42
--------
unaligned (checksum: 0) elapsed_ms: 38
openblas (checksum: 0) elapsed_ms: 42I'm using -mfma instead of -mavx here, to make things fair, because OpenBLAS prebuilt library uses it anyway.
patrikhuber
GValiente
headupinclouds
Improve runtime on VGG-like models
Compiled using GCC with
-O3-mavxand running on a single-CPU, frugally-deep is faster on most typical model architectures than Keras+TensorFlow. However onVGG16andVGG19we are about 20% behind. I think it would be awesome if we were able to change this! :DProfiling forward passes on
VGG16in and endless loop shows that the matrix multiplication in our im2col convolution takes up about 80% of the CPU time.We currently use GEMM (general matrix multiplication) of the Eigen library for this.
So to isolate the problem, I wrote the following benchmark. To decide on matrix sizes for this test, I measured the runtime of the single layers of
VGG16and used the dimensions typically occuring in the most costly ones.It compares the performance of different ways to do GEMM with Eigen, i.e. aligned/unaligned memory and row-majow/column-major memory order. But these make no difference.
Output on my machine:
Any ideas on how to improve are very welcome. :)