Nhân vectơ ma trận 4x4 hiệu quả với SSE: sản phẩm thêm và chấm ngang - điểm là gì?

Question

Tôi đang cố gắng để thực hiện hiệu quả nhất của phép nhân 4x4 ma trận (M) với một vec-tơ (u) sử dụng SSE. Ý tôi là Mu = v

Theo như tôi hiểu có hai cách chính để đi về điều này:.

method 1) v1 = dot(row1, u), v2 = dot(row2, u), v3 = dot(row3, u), v4 = dot(row4, u) 
    method 2) v = u1 col1 + u2 col2 + u3 col3 + u4 col4. 

Cách 2 là dễ thực hiện trong SSE2. Phương pháp 1 có thể được thực hiện với hướng dẫn thêm ngang trong SSE3 hoặc hướng dẫn sản phẩm chấm trong SSE4. Tuy nhiên, trong tất cả các phương pháp thử nghiệm 2 của tôi luôn luôn hoạt động tốt hơn phương pháp 1.

Một nơi mà mặc dù phương pháp 1 sẽ có lợi thế là ma trận 3x4, ví dụ như biến đổi affine. Trong trường hợp này, sản phẩm dấu chấm cuối cùng là không cần thiết. Nhưng ngay cả trong trường hợp này phương pháp 2 trên ma trận 4x4 nhanh hơn phương pháp 1 trên ma trận 3x4. Phương pháp duy nhất tôi tìm thấy nhanh hơn phương pháp 2 trên ma trận 4x4 là phương pháp 2 trên ma trận 4x3.

Vậy điểm thêm của hướng ngang và hướng dẫn sản phẩm chấm là gì? Trong thực tế, hướng dẫn sản xuất chấm cho hiệu suất tồi tệ nhất trong trường hợp này. Có lẽ nó có liên quan đến định dạng dữ liệu? Nếu người ta không thể xác định làm thế nào ma trận được đặt hàng sau đó một transpose là cần thiết và trong trường hợp đó có lẽ phương pháp 1 sẽ tốt hơn?

Xem bên dưới để biết một số mã.

__m128 m4x4v_colSSE(const __m128 cols[4], const __m128 v) { 
    __m128 u1 = _mm_shuffle_ps(v,v, _MM_SHUFFLE(0,0,0,0)); 
    __m128 u2 = _mm_shuffle_ps(v,v, _MM_SHUFFLE(1,1,1,1)); 
    __m128 u3 = _mm_shuffle_ps(v,v, _MM_SHUFFLE(2,2,2,2)); 
    __m128 u4 = _mm_shuffle_ps(v,v, _MM_SHUFFLE(3,3,3,3)); 

    __m128 prod1 = _mm_mul_ps(u1, cols[0]); 
    __m128 prod2 = _mm_mul_ps(u2, cols[1]); 
    __m128 prod3 = _mm_mul_ps(u3, cols[2]); 
    __m128 prod4 = _mm_mul_ps(u4, cols[3]); 

    return _mm_add_ps(_mm_add_ps(prod1, prod2), _mm_add_ps(prod3, prod4)); 
} 

__m128 m4x4v_rowSSE3(const __m128 rows[4], const __m128 v) { 
    __m128 prod1 = _mm_mul_ps(rows[0], v); 
    __m128 prod2 = _mm_mul_ps(rows[1], v); 
    __m128 prod3 = _mm_mul_ps(rows[2], v); 
    __m128 prod4 = _mm_mul_ps(rows[3], v); 

    return _mm_hadd_ps(_mm_hadd_ps(prod1, prod2), _mm_hadd_ps(prod3, prod4)); 
} 

__m128 m4x4v_rowSSE4(const __m128 rows[4], const __m128 v) { 
    __m128 prod1 = _mm_dp_ps (rows[0], v, 0xFF); 
    __m128 prod2 = _mm_dp_ps (rows[1], v, 0xFF); 
    __m128 prod3 = _mm_dp_ps (rows[2], v, 0xFF); 
    __m128 prod4 = _mm_dp_ps (rows[3], v, 0xFF); 

    return _mm_shuffle_ps(_mm_movelh_ps(prod1, prod2), _mm_movelh_ps(prod3, prod4), _MM_SHUFFLE(2, 0, 2, 0)); 
} 

Answer 1

Hướng dẫn sản phẩm thêm và chấm phức tạp được phân tách thành nhiều vi xử lý đơn giản hơn được thực hiện bởi bộ xử lý giống như hướng dẫn đơn giản. Việc phân tách chính xác các hướng dẫn sản phẩm thêm và chấm ngang thành vi xử lý là đặc thù cho bộ vi xử lý, nhưng đối với bộ vi xử lý gần đây của Intel, phần thêm ngang được phân tách thành 2 bộ vi xử lý SHUFFLE + 1 ADD và sản phẩm chấm được phân tách thành 1 MUL + 1 SHUFFLE + 2 ADD microoperations. Bên cạnh số lượng vi xử lý lớn hơn, hướng dẫn này cũng nhấn mạnh bộ giải mã lệnh trong đường ống xử lý: Bộ xử lý Intel chỉ có thể giải mã một lệnh phức tạp trên mỗi chu kỳ (so với 4 hướng dẫn đơn giản). Trên máy ủi AMD, chi phí tương đối của các lệnh phức tạp này thậm chí còn cao hơn.