#include <MsmMap.h>

Public Member Functions
	C1Matrix (Float r=0)

void	set (Float r)

Public Attributes
Float	melem [C1_MATRIX_SIZE]

Friends
C1Vector	operator* (const C1Matrix &m, const C1Vector &u)

Detailed Description

Definition at line 110 of file MsmMap.h.

Constructor & Destructor Documentation

◆ C1Matrix()

C1Matrix::C1Matrix ( Float r = 0 )

inline

Definition at line 112 of file MsmMap.h.

112 { set(r); }

Member Function Documentation

◆ set()

void C1Matrix::set ( Float r )

inline

Definition at line 113 of file MsmMap.h.

References C1_MATRIX_SIZE, and melem.

Referenced by ComputeMsmMgr::initialize().

                       {
       for (int n=0;  n < C1_MATRIX_SIZE;  n++)  melem[n] = 0;
     }

Friends And Related Function Documentation

◆ operator*

C1Vector operator*	(	const C1Matrix &	m,
		const C1Vector &	u
	)

friend

Definition at line 116 of file MsmMap.h.

                                                                     {
       C1Vector v;
 
       // XXX not tested yet
 #if 1 && (defined(__SSE2__) && ! defined(NAMD_DISABLE_SSE))
       // Hand-coded SSE2 vectorization
       // This loop requires that the single-precision input arrays be 
       // aligned on 16-byte boundaries, such that array[index % 4 == 0] 
       // can be safely accessed with aligned load/store operations
       for (int k=0, j=0;  j < C1_VECTOR_SIZE;  j++) {
         __m128 melem4 = _mm_load_ps(&m.melem[k]);
         __m128 uelem4 = _mm_load_ps(&u.velem[0]);
         __m128 tmp4 = _mm_mul_ps(melem4, uelem4); 
         melem4 = _mm_load_ps(&m.melem[k+4]);
         uelem4 = _mm_load_ps(&u.velem[4]);
         tmp4 = _mm_add_ps(tmp4, _mm_mul_ps(melem4, uelem4)); 
 
         // do a 4-element reduction and accumulate result
         __m128 sum4 = tmp4;
         sum4 = _mm_shuffle_ps(sum4, sum4, _MM_SHUFFLE(2, 3, 0, 1));
         sum4 = _mm_add_ps(sum4, tmp4);
         tmp4 = sum4;
         sum4 = _mm_shuffle_ps(sum4, sum4, _MM_SHUFFLE(1, 0, 3, 2));
         sum4 = _mm_add_ps(sum4, tmp4);
 
         // all 4 elements are now set to the sum
         float sum;
         _mm_store_ss(&sum, sum4); // store lowest element
         v.velem[j] += sum;
         k+=8;
       }
 #elif 0 && (defined(__AVX__) && ! defined(NAMD_DISABLE_SSE))
       // Hand-coded AVX vectorization
       // This loop requires that the single-precision input arrays be 
       // aligned on 32-byte boundaries, such that array[index % 8 == 0] 
       // can be safely accessed with aligned load/store operations
       for (int k=0, j=0;  j < C1_VECTOR_SIZE;  j++) {
         __m256 melem8 = _mm256_load_ps(&m.melem[k]);
         __m256 uelem8 = _mm256_load_ps(&u.velem[0]);
         __m256 tmp8 = _mm256_mul_ps(melem8, uelem8); 
 
         // XXX this still needs to be rewritten a bit for AVX
         // do an 8-element reduction and accumulate result
         __m256 sum8 = tmp8;
         sum8 = _mm256_hadd_ps(sum8, sum8);
         sum8 = _mm256_hadd_ps(sum8, sum8);
         tmp8 = sum8;
         tmp8 = _mm256_permute2f128_ps(tmp8, tmp8, 1);
         sum8 = _mm256_hadd_ps(tmp8, sum8);
 
         // all 8 elements are now set to the sum
         float sum;
         _mm_store_ss(&sum, sum8); // store lowest element
         v.velem[j] += sum;
         k+=8;
       }
 #else
 #if defined(__INTEL_COMPILER)
 #pragma vector always
 #endif
       for (int k=0, j=0;  j < C1_VECTOR_SIZE;  j++) {
         for (int i = 0;  i < C1_VECTOR_SIZE;  i++, k++) {
           v.velem[j] += m.melem[k] * u.velem[i];
         }
       }
 #endif
       return v;
     }