Несоответствие производительности между графическим процессором и процессором при умножении матриц: Eigen против ViennaCL

Я столкнулся с проблемой производительности при выполнении операций умножения матриц с использованием библиотек Eigen и ViennaCL на C++. Я сравниваю производительность выполнения этих операций на встроенном графическом процессоре моей системы и на центральном процессоре.

Моя система оснащена встроенным графическим процессором Intel, и я запускаю код на процессоре Intel Core i5 восьмого поколения. К моему удивлению, я обнаружил, что умножение матриц занимает около 200 секунд при выполнении на графическом процессоре с использованием ViennaCL, тогда как при выполнении на процессоре с использованием Eigen оно занимает всего около 20 секунд.

Я озадачен этим несоответствием производительности и хотел бы лучше понять причину этого. Может ли встроенный графический процессор действительно иметь такую ​​низкую производительность по сравнению с процессором при операциях умножения матриц?

я использую премейк

workspace "Project"
    configurations { "Debug", "Release" }
    location "build"

project "Project"
    kind "ConsoleApp"
    language "C++"
    targetdir "build/bin/%{cfg.buildcfg}"
    objdir "build/obj/%{cfg.buildcfg}"

    files { "src/*.cpp", "include/*.hpp" }
    includedirs { "include", "vendor/*" }

    filter "configurations:Debug"
        symbols "On"
        optimize "On"

    filter "configurations:Release"
        symbols "Off"
        optimize "On"

    filter {}

@:~/repos/cpp-projct$ tree -L 1
.
├── build
├── cr.sh
├── include
├── premake.lua
├── src
└── vendor (eigen and viennaCL here, just $ wget and $ tar)

Редактировать:

Код отредактирован с учетом предложений, выводится в файл.txt; Я не проверял предложение использовать целые числа или другой тип, потому что не мог просто поменять тип.

#include <Eigen/Dense>
#include <chrono>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <viennacl/matrix.hpp>

int main() {
  const int size = 1500;  // Size of the matrices
  std::string fileName1 = "./list1.txt";
  std::string fileName2 = "./list2.txt";

  // Creating two large matrices using ViennaCL
  viennacl::matrix<float> matrix1_viennacl(size, size);
  viennacl::matrix<float> matrix2_viennacl(size, size);

  // Creating two large matrices using Eigen
  Eigen::MatrixXf matrix1_eigen(size, size);
  Eigen::MatrixXf matrix2_eigen(size, size);

  // Initializing the matrices with random values
  for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
      matrix1_viennacl(i, j) = rand() / static_cast<float>(RAND_MAX);
      matrix2_viennacl(i, j) = rand() / static_cast<float>(RAND_MAX);
    }
  }

  // Initializing the matrices with the same random values
  for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
      matrix1_eigen(i, j) = matrix1_viennacl(i, j);
      matrix2_eigen(i, j) = matrix2_viennacl(i, j);
    }
  }

  //==============================================================

  // Performing computation with the matrices using ViennaCL and
  // measuring the execution time
  auto start_viennacl = std::chrono::steady_clock::now();
  viennacl::matrix<float> result_viennacl =
      viennacl::linalg::prod(matrix1_viennacl, matrix2_viennacl);
  auto end_viennacl = std::chrono::steady_clock::now();
  std::chrono::duration<double> time_viennacl = end_viennacl - start_viennacl;

  std::ofstream file1(fileName1);
  if (!file1.is_open()) {
    std::cout << "Err file 1" << std::endl;
    return 1;
  }
  for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
      file1 << result_viennacl(i, j) << std::endl;
    }
  }

  // Printing the execution time with ViennaCL
  std::cout << "Execution time with ViennaCL: " << time_viennacl.count()
            << " seconds" << std::endl;

  //=================================================================

  // Performing computation with the matrices using Eigen and
  // measuring the execution time
  auto start_eigen = std::chrono::steady_clock::now();
  Eigen::MatrixXf result_eigen = matrix1_eigen * matrix2_eigen;
  auto end_eigen = std::chrono::steady_clock::now();
  std::chrono::duration<double> time_eigen = end_eigen - start_eigen;

  std::ofstream file2(fileName2);
  if (!file2.is_open()) {
    std::cout << "Err file 2" << std::endl;
    return 1;
  }
  for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
      file2 << result_eigen(i, j) << std::endl;
    }
  }

  // Printing the execution time with Eigen
  std::cout << "Execution time with Eigen: " << time_eigen.count() << " seconds"
            << std::endl;

  return 0;
}

@:~/repos/cpp-template$ bash cr.sh
Execution time with ViennaCL: 9.81101 seconds
Execution time with Eigen: 0.68594 seconds
@:~/repos/cpp-template$