Tối ưu hóa siêu C ++ của phép nhân ma trận với Armadillo

Tôi đang sử dụng Armadillo để thực hiện các phép nhân ma trận rất chuyên sâu với độ dài cạnh , trong đó n có thể lên tới 20 hoặc thậm chí hơn. Tôi đang sử dụng Armadillo với OpenBLAS để nhân ma trận, dường như đang làm rất tốt trong các lõi song song, ngoại trừ việc tôi gặp vấn đề với phép nhân trong Armadillo để tối ưu hóa hiệu suất.$2^n$$n$

Nói rằng tôi có một vòng lặp ở dạng sau:

arma::cx_mat stateMatrix, evolutionMatrix; //armadillo complex matrix type
for(double t = t0; t < t1; t += 1/sampleRate)
{
    ...
    stateMatrix = evolutionMatrix*stateMatrix;
    ...
}

Trong C ++ cơ bản, tôi thấy vấn đề ở đây là C ++ sẽ phân bổ một đối tượng mới của cx_matcửa hàng evolutionMatrix*stateMatrix, và sau đó sao chép các đối tượng mới để stateMatrixcó operator=(). Điều này rất, rất không hiệu quả. Mọi người đều biết rằng việc trả về các lớp dữ liệu lớn phức tạp là một ý tưởng tồi, phải không?

Cách tôi thấy cách này hiệu quả hơn là với một hàm thực hiện phép nhân dưới dạng:

void multiply(const cx_mat& mat1, const cx_mat& mat2, cx_mat& output)
{
    ... //multiplication of mat1 and mat2 and then store it in output
}

Theo cách này, Người ta không phải sao chép các đối tượng lớn có giá trị trả về và đầu ra không phải được phân bổ lại với mỗi phép nhân.

Câu hỏi : Làm thế nào tôi có thể tìm thấy một sự thỏa hiệp, trong đó tôi có thể sử dụng Armadillo để nhân với giao diện BLAS đẹp mắt của mình và thực hiện điều này một cách hiệu quả mà không phải tạo lại các đối tượng ma trận và sao chép chúng với mỗi thao tác?

Đây không phải là một vấn đề triển khai trong Armadillo sao?

Trong C ++ cơ bản, tôi thấy vấn đề ở đây là C ++ sẽ phân bổ một đối tượng mới của cx_mat để lưu trữ EvolutionMatrix * stateMatrix, sau đó sao chép đối tượng mới sang stateMatrix với toán tử = ().

Tôi nghĩ rằng bạn đúng khi nó tạo ra những thứ tạm thời, quá chậm, nhưng tôi nghĩ lý do tại sao nó làm điều đó là sai.

Armadillo, giống như bất kỳ thư viện đại số tuyến tính C ++ tốt nào, sử dụng các mẫu biểu thức để thực hiện đánh giá biểu thức bị trì hoãn. Khi bạn viết ra một sản phẩm ma trận như A*B, không có temporaries được tạo ra, thay vì Armadillo làm cho một đối tượng tạm thời ( x) mà giữ tham chiếu đến Avà B, và sau đó, đưa ra một biểu hiện như C = x, tính tích ma trận lưu trữ kết quả trực tiếp trong C, mà không tạo ra bất kỳ tạm thời.

Nó cũng sử dụng tối ưu hóa này để xử lý các biểu thức như A*B*C*D, trong đó, tùy thuộc vào kích thước ma trận, các lệnh nhân nhất định sẽ hiệu quả hơn các biểu thức khác.

Đây không phải là một vấn đề triển khai trong Armadillo sao?

Nếu Armadillo không thực hiện tối ưu hóa này, đó sẽ là một lỗi trong Armadillo cần được báo cáo cho các nhà phát triển.

Tuy nhiên, trong trường hợp của bạn, có một vấn đề khác quan trọng hơn. Trong một biểu thức như A=B*Clưu trữ Akhông chứa bất kỳ dữ liệu đầu vào nào nếu Akhông bí danh Bhoặc C. Trong trường hợp của bạn A = A*B, việc viết bất cứ điều gì vào ma trận đầu ra cũng sẽ sửa đổi một trong các ma trận đầu vào.

Thậm chí cho chức năng được đề xuất của bạn

multiply(const cx_mat&, const cx_mat&, cx_mat&)

Làm thế nào chính xác chức năng đó sẽ giúp trong biểu thức multiply(A, B, A)? Đối với hầu hết các triển khai thông thường của chức năng đó, điều đó sẽ dẫn đến một lỗi. Nó sẽ cần phải sử dụng một số lưu trữ tạm thời, để đảm bảo dữ liệu đầu vào của nó không bị hỏng. Gợi ý của bạn là khá nhiều cách Armadillo thực hiện phép nhân ma trận, nhưng tôi nghĩ có lẽ nên cẩn thận để tránh các tình huống như multiply(A, B, A)bằng cách phân bổ tạm thời.

Giải thích khả dĩ nhất về lý do tại sao Armadillo không thực hiện tối ưu hóa này là nó sẽ không chính xác khi làm điều đó.

Cuối cùng, có một cách đơn giản hơn nhiều để làm những gì bạn muốn, như thế này:

cx_mat *A, *Atemp, B;
for (;;) {
  *Atemp = (*A)*B;
  swap(A, Atemp);
}

Điều này giống hệt với

cx_mat A, B;
for (;;) {
  A = A*B;
}

nhưng nó phân bổ một ma trận tạm thời, thay vì một ma trận tạm thời trên mỗi lần lặp.

@BillGreene chỉ ra "tối ưu hóa giá trị trả về" như một cách giải quyết vấn đề cơ bản, nhưng điều này thực sự chỉ giúp cho một nửa của nó. Giả sử bạn có mã của mẫu này:

struct ExpensiveObject { ExpensiveObject(); ~ExpensiveObject(); };

ExpensiveObject operator+ (ExpensiveObject &obj1,
                           ExpensiveObject &obj2)
{
   ExpensiveObject tmp;
   ...compute tmp based on obj1 and obj2...
   return tmp;
}

void f() {
  ExpensiveObject o1, o2, o3;
  ...initialize o1, o2...;
  o3 = o1 + o2;
}

Một trình biên dịch ngây thơ sẽ

1. tạo một vị trí để lưu trữ kết quả của phép toán cộng (một tạm thời),
2. gọi tổng đài +,
3. tạo đối tượng 'tmp' bên trong toán tử + (tạm thời thứ hai),
4. tính toán tmp,
5. sao chép tmp vào khe kết quả,
6. phá hủy tmp,
7. sao chép đối tượng kết quả vào o3
8. phá hủy đối tượng kết quả

Tối ưu hóa giá trị trả về chỉ có thể thống nhất đối tượng 'tmp' và vị trí 'kết quả', nhưng không thể loại bỏ sự cần thiết phải sao chép. Vì vậy, bạn vẫn còn lại với việc tạo ra một hoạt động tạm thời, sao chép và phá hủy tạm thời.

Cách duy nhất xung quanh điều này là toán tử + không trả về một đối tượng, mà là một đối tượng của một lớp trung gian nào đó, khi được gán cho một ExpensiveObject, thực hiện thao tác thêm và sao chép tại chỗ. Đây là cách tiếp cận điển hình được sử dụng trong các thư viện mẫu biểu thức .

Stackoverflow ( https://stackoverflow.com/ ) có lẽ là một diễn đàn thảo luận tốt hơn cho câu hỏi này. Tuy nhiên, đây là một câu trả lời ngắn.

Tôi nghi ngờ rằng trình biên dịch C ++ đang tạo mã cho biểu thức này giống như bạn mô tả ở trên. Tất cả các trình biên dịch C ++ hiện đại đều thực hiện tối ưu hóa gọi là "tối ưu hóa giá trị trả về" ( http://en.wikipedia.org/wiki/Return_value_optimization ). Với tối ưu hóa giá trị trả về, kết quả evolutionMatrix*stateMatrixđược lưu trữ trực tiếp trong stateMatrix; không có bản sao được thực hiện.

Rõ ràng có sự nhầm lẫn đáng kể về chủ đề này và đó là một trong những lý do tôi đề xuất Stackoverflow có thể là một diễn đàn tốt hơn. Có rất nhiều "luật sư ngôn ngữ" C ++ ở đó trong khi hầu hết chúng ta ở đây muốn dành thời gian cho CSE. ;-)

Tôi đã tạo ra ví dụ đơn giản sau dựa trên bài của Giáo sư Bangerth:

#ifndef NDEBUG
#include <iostream>

using namespace std;
#endif

class ExpensiveObject  {
public:
  ExpensiveObject () {
#ifndef NDEBUG
    cout << "ExpensiveObject  constructor called." << endl;
#endif
    v = 0;
  }
  ExpensiveObject (int i) { 
#ifndef NDEBUG
    cout << "ExpensiveObject  constructor(int) called." << endl;
#endif
    v = i; 
  }
  ExpensiveObject (const ExpensiveObject  &a) {
    v = a.v;
#ifndef NDEBUG
    cout << "ExpensiveObject  copy constructor called." << endl;
#endif
  }
  ~ExpensiveObject() {
#ifndef NDEBUG
    cout << "ExpensiveObject  destructor called." << endl;
#endif
  }
  ExpensiveObject  operator=(const ExpensiveObject  &a) {
#ifndef NDEBUG
    cout << "ExpensiveObject  assignment operator called." << endl;
#endif
    if (this != &a) {
      return ExpensiveObject (a);
    }
  }
  void print() const {
#ifndef NDEBUG
    cout << "v=" << v << endl;
#endif
  }
  int getV() const {
    return v;
  }
private:
  int v;
};

ExpensiveObject  operator+(const ExpensiveObject  &a1, const ExpensiveObject  &a2) {
#ifndef NDEBUG
  cout << "ExpensiveObject  operator+ called." << endl;
#endif
  return ExpensiveObject (a1.getV() + a2.getV());
}

int main()
{
  ExpensiveObject  a(2), b(3);
  ExpensiveObject  c = a + b;
#ifndef NDEBUG
  c.print();
#endif
}

Có vẻ phức tạp hơn thực tế là vì tôi muốn xóa hoàn toàn tất cả mã để in đầu ra khi biên dịch ở chế độ tối ưu hóa. Khi tôi chạy phiên bản được biên dịch với tùy chọn gỡ lỗi, tôi nhận được kết quả đầu ra sau:

ExpensiveObject  constructor(int) called.
ExpensiveObject  constructor(int) called.
ExpensiveObject  operator+ called.
ExpensiveObject  constructor(int) called.
v=5
ExpensiveObject  destructor called.
ExpensiveObject  destructor called.
ExpensiveObject  destructor called.

Điều đầu tiên cần lưu ý là không có thời gian được xây dựng - chỉ có a, b và c. Hàm tạo mặc định và toán tử gán không bao giờ được gọi vì chúng không cần trong ví dụ này.

Giáo sư Bangerth đã đề cập các mẫu biểu thức. Thật vậy, kỹ thuật tối ưu hóa này rất quan trọng trong việc đạt được hiệu suất tốt trong thư viện lớp ma trận. Nhưng điều quan trọng chỉ khi các biểu thức đối tượng phức tạp hơn đơn giản là a + b. Nếu, ví dụ, thử nghiệm của tôi là:

  ExpensiveObject  a(2), b(3), c(9);
  ExpensiveObject  d = a + b + c;

Tôi sẽ nhận được đầu ra sau đây:

ExpensiveObject  constructor(int) called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  operator+ called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  operator+ called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  destructor called.
 v=14
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.

Trường hợp này cho thấy việc xây dựng tạm thời không mong muốn (5 cuộc gọi đến nhà xây dựng và hai cuộc gọi của nhà điều hành +). Việc sử dụng đúng các mẫu biểu thức (một chủ đề nằm ngoài phạm vi của diễn đàn này) sẽ ngăn chặn điều này tạm thời. (Đối với những người có động lực cao, có thể tìm thấy một cuộc thảo luận đặc biệt dễ đọc về các mẫu biểu thức trong chương 18 của http://www.amazon.com/C-Temsheet-The-Complete-Guide/dp/0201734842 ).

Cuối cùng, "bằng chứng" thực sự về những gì trình biên dịch đang thực sự xuất phát từ việc kiểm tra đầu ra mã lắp ráp của trình biên dịch. Đối với ví dụ đầu tiên, khi được biên dịch trong chế độ tối ưu hóa, mã này đơn giản đến mức đáng kinh ngạc. Tất cả các lệnh gọi hàm đã được tối ưu hóa và mã lắp ráp về cơ bản tải 2 vào một thanh ghi, 3 thành một giây và thêm chúng vào.

$\mathcal{O}(n^{2.8})$$\mathcal{O}(n^2)$$n$

Đó là, trừ khi bạn phải chịu một hằng số khổng lồ vào việc sao chép - mà thực sự là không quá xa vời, vì phiên bản với việc sao chép là đắt hơn nhiều về vấn đề khác: nó cần nhớ cách hơn. Vì vậy, nếu bạn cuối cùng phải trao đổi sang và từ đĩa cứng, việc sao chép thực sự có thể trở thành nút cổ chai. Tuy nhiên, ngay cả khi bạn không tự sao chép bất cứ điều gì, một thuật toán song song mạnh mẽ cũng có thể thực hiện một số bản sao của chính nó. Thực sự, cách duy nhất để đảm bảo không có quá nhiều bộ nhớ sẽ được sử dụng trong mỗi bước là phân chia phép nhân trong các cột củastateMatrix , do đó chỉ có các phép nhân nhỏ được thực hiện tại một thời điểm. Chẳng hạn, bạn có thể định nghĩa

class HChunkMatrix // optimised for destructive left-multiplication updates
{
  std::vector<arma::cx_mat> colChunks; // e.g. for an m×n matrix,
                                      //  use √n chunks, each an m×√n matrix
 public:
  ...

  HChunkMatrix& operator *= (const arma::cx_mat& lhMult) {
    for (&colChunk: colChunks) {
      colChunk = lhMult * colChunk;
    }
    return *this;
  }
}

Bạn cũng nên xem xét liệu bạn thậm chí có cần phải tiến hóa stateMatrixnhư là một trong những nơi đầu tiên. Nếu về cơ bản bạn chỉ muốn tiến hóa thời gian độc lập của các nkets nhà nước, thì bạn cũng có thể tiến hóa từng cái một, điều này ít tốn kém hơn về bộ nhớ. Đặc biệt nếu evolutionMatrixlà thưa thớt , mà bạn chắc chắn nên kiểm tra! Đối với điều này về cơ bản chỉ là một Hamilton, phải không? Người Hamilton thường thưa thớt hoặc gần như thưa thớt.

_{$\mathcal{O}(n^{2.38})$}

C ++ hiện đại có một giải pháp cho vấn đề bằng cách sử dụng "hàm tạo di chuyển" và "tham chiếu giá trị".

Một "constructor di chuyển" là một hàm tạo cho một lớp, ví dụ như một lớp ma trận, lấy một thể hiện khác của cùng một lớp và chuyển dữ liệu từ thể hiện khác sang thể hiện mới, để trống thể hiện ban đầu. Thông thường, một đối tượng ma trận sẽ có hai số cho kích thước và một con trỏ tới dữ liệu. Khi một hàm tạo bình thường sẽ nhân đôi dữ liệu, một hàm tạo di chuyển sẽ chỉ sao chép hai số và con trỏ, vì vậy điều này thực sự nhanh.

Một "tham chiếu giá trị", được viết ví dụ là "ma trận &&" thay vì "ma trận &" thông thường được sử dụng cho các biến tạm thời. Bạn sẽ khai báo phép nhân ma trận khi trả về ma trận &&. Bằng cách đó, trình biên dịch sẽ đảm bảo rằng một hàm tạo di chuyển rất rẻ sẽ được sử dụng để lấy kết quả ra khỏi hàm gọi nó. Vì vậy, một biểu thức như result = (a + b) * (c + d) trong đó a, b, c, d là các đối tượng ma trận khổng lồ, sẽ xảy ra mà không cần sao chép.

Googling cho "tham chiếu giá trị và các nhà xây dựng di chuyển" sẽ tìm thấy các ví dụ và hướng dẫn.

$v'*M*M*M*M*M$$M*M*M*M*M*v$

Sau đó, một lần nữa, tôi tập hợp OpenBLAS có một bộ sưu tập tối ưu hóa kiến ​​trúc cụ thể lớn hơn, vì vậy Eigen có thể hoặc không thể là một chiến thắng cho bạn. Thật không may, không có thư viện đại số tuyến tính tuyệt vời đến mức bạn thậm chí không phải xem xét những người khác khi chiến đấu cho "10% cuối cùng" của hiệu suất. Wrappers không phải là một giải pháp 100%; hầu hết (tất cả?) trong số họ không thể tận dụng khả năng của người bản địa để hợp nhất các tính toán theo cách này.