#include <windows.h>
#include <iostream.h>
#include <stdio.h>

#include <xmmintrin.h>

// Prototpes
void InterpolateSSE(int* iStrip1, int* iStrip2, int* iDest, float fPercent1, int iSize);
void Interpolate(int* iStrip1, int* iStrip2, int* iDest, float fPercent1, int iSize);

int main()
{
	// Allocate memory for buffers
	int* test1 = (int*) _aligned_malloc(256 * sizeof(int), 16);
	int* test2 = (int*) _aligned_malloc(256 * sizeof(int), 16);
	int* test3 = (int*) _aligned_malloc(256 * sizeof(int), 16);
	for(int i=0; i < 256; i++)
	{
		// Fill arrays with arbitrary values
		test1 = (i+5) * 3;
		test2 = (i+2) *5 ;
		test3 = 0;
	}	

	// Setup performance counter
	LARGE_INTEGER perf_frequency;
	LARGE_INTEGER start;
	LARGE_INTEGER stop;
	QueryPerformanceFrequency(&perf_frequency);
	float event_time ;

	// Test without SSE
	QueryPerformanceCounter(&start);
	for(i=0; i < 100000; i++)
		Interpolate(test1, test2, test3, 0.32f, 256);
	QueryPerformanceCounter(&stop);
	event_time = ( (float)stop.QuadPart - (float)start.QuadPart ) / perf_frequency.QuadPart;
	printf ("\n\n\n\n\t\t100,000 loops took: %4.6f seconds without SSE\n", event_time);
	printf ("\n\n\n\t\tPleas wait while 2nd test completes…");


	// Test with SSE
	QueryPerformanceCounter(&start);
	for(i=0; i < 100000; i++)
		InterpolateSSE(test1, test2, test3, 0.32f, 256);
	QueryPerformanceCounter(&stop);
	event_time = ( (float)stop.QuadPart - (float)start.QuadPart ) / perf_frequency.QuadPart;
	printf ("\n\n\n\n\t\t100,000 loops took: %4.6f seconds with SSE\n\n\n\n\n", event_time);
	cin >> i;

	// Deallocate memory
	_aligned_free(test1);
	_aligned_free(test2);
	_aligned_free(test3);

	

	return 0;
}


// Interpolate between int arrays using SSE ''Optimizations''
void InterpolateSSE(int* iStrip1, int* iStrip2, int* iDest, float fPercent1, int iSize)
{
	// This function assumes sizeof(iStrip1) = sizeof(iStrip2) = sizeof(iDest)
	__m128 a = _mm_set_ps1(fPercent1); 
	__m128 b = _mm_set_ps1((1.0f - fPercent1));
	

	__m128 low, high;
	__m128* pSrc1 = (__m128*) iStrip1;
    __m128* pSrc2 = (__m128*) iStrip2;
    __m128* pDest = (__m128*) iDest;

	
	int nLoop = iSize >> 2;

	for(int i=0; i < nLoop; i++)
	{
		low =  _mm_mul_ps(*pSrc1 , b);
		high = _mm_mul_ps(*pSrc2 , a);
		*pDest = _mm_add_ps(low, high);          
		//*pDest = _mm_add_ps(_mm_mul_ps(*pSrc1 , a), _mm_mul_ps(*pSrc2 , b));          
		//int total = (int)((m_iDereferenceBuffer1[j] * m_fP1) + (m_iDereferenceBuffer2[j] * m_fP2) - m_iCloudCover);

		pSrc1++;
		pSrc2++;
		pDest++;
	}
}

// Interpolate between int arrays using traditional methods
void Interpolate(int* iStrip1, int* iStrip2, int* iDest, float fPercent1, int iSize)
{
	for (int i=0; i < iSize; i++)
		iDest = (int)(iStrip1*(1.0f - fPercent1) + iStrip2*(fPercent1));
}

 </pre>   </i>  

quote:Original post by Anonymous Poster
The time measurement is way wrong you don''t go from 4 to 0.018 seconds.

quote:Original post by Narcist
Actually AP is right, the time for non SSE was wrong (errant breakpoint or my breakpoint at the end of main being hit mid non-sse timing)

The packed arithmetic intrinsics supporting the 128-bit integerMMX technology enhancements provided by the Streaming SIMDExtensions 2 (SSE2) instructions process are listed in theInteger Arithmetic Operations table. _mm_add_epi8 PADDB Addition _mm_add_epi16 PADDW Addition _mm_add_epi32 PADDD Addition _mm_add_si64 PADDQ Addition _mm_add_epi64 PADDQ Addition _mm_adds_epi8 PADDSB Addition _mm_adds_epi16 PADDSW Addition _mm_adds_epu8 PADDUSB Addition _mm_adds_epu16 PADDUSW Addition _mm_avg_epu8 PAVGB Computes average _mm_avg_epu16 PAVGW Computes average _mm_madd_epi16 PMADDWD Multiplication/addition _mm_max_epi16 PMAXSW Computes maxima _mm_max_epu8 PMAXUB Computes maxima _mm_min_epi16 PMINSW Computes minima _mm_min_epu8 PMINUB Computes minima _mm_mulhi_epi16 PMULHW Multiplication _mm_mulhi_epu16 PMULHUW Multiplication _mm_mullo_epi16 PMULLW Multiplication _mm_mul_su32 PMULUDQ Multiplication _mm_mul_epu32 PMULUDQ Multiplication _mm_sad_epu8 PSADBW Computes difference/adds _mm_sub_epi8 PSUBB Subtraction _mm_sub_epi16 PSUBW Subtraction _mm_sub_epi32 PSUBD Subtraction _mm_sub_si64 PSUBQ Subtraction _mm_sub_epi64 PSUBQ Subtraction _mm_subs_epi8 PSUBSB Subtraction _mm_subs_epi16 PSUBSW Subtraction _mm_subs_epu8 PSUBUSB Subtraction _mm_subs_epu16 PSUBUSW Subtraction   

The SSE2 extensions use the same single instruction multipledata (SIMD) execution model that is used with the MMX technology and the SSE extensions. It extends this model with support for packed double-precision floating point values and for 128-bit packed integers.The SSE2 extensions add the following features to the IA-32 architecture, while maintaining backward compatibility with all existing IA-32 processors, applications and operating systems.Six data types:- 128-bit packed double precision floating point (two IEEE  standard 754 double-precision floating-point values packed into  a double quadword)- 128-bit packed byte integers.- 128-bit packed word integers.- 128-bit packed doubleword integers.- 128-bit packed quadword integers. 

PEXTRW - Extracts one of four wordsPINSRW - Inserts a word  PMAXSW - Computes the maximum  PMAXUB - Computes the maximum, unsigned  PMINSW - Computes the minimum  PMINUB - Computes the minimum, unsigned  PMOVMSKB - Creates an 8-bit mask  PMULHUW - Multiplies, returning high bits  PSHUFW - Returns a combination of four words  MASKMOVQ - Computes conditional store  PAVGB - Computes rounded average  PAVGW - Computes rounded average  PSADBW - Computes sum of absolute differences