/*
	BubbleSort.cpp

*/

#include "stdafx.h"
#include "BubbleSort.h"
#include <emmintrin.h>

#pragma optimize( "t", on )

static void __stdcall SwapUU(void* p1, void* p2)
{
	char	*c1 = ( char* ) p1, *c2 = ( char* ) p2, cdata;
	size_t	sztRecLength = sizeof( SortRecStruct );
	__m128i	XmmTemp;
	DWORD	dwTemp;

	while( sztRecLength >= 16 )
	{
		XmmTemp = _mm_loadu_si128( ( __m128i* ) c1 );
		_mm_storeu_si128( ( __m128i* ) c1, _mm_loadu_si128( ( __m128i* ) c2 ) );
		_mm_storeu_si128( ( __m128i* ) c2, XmmTemp );
		c1 += 16; c2 += 16; sztRecLength -= 16;
	}
	if( sztRecLength >= 8 )
	{
		XmmTemp = _mm_loadl_epi64( ( __m128i* ) c1 );
		_mm_storel_epi64( ( __m128i* ) c1, _mm_loadl_epi64( ( __m128i* ) c2 ) );
		_mm_storel_epi64( ( __m128i* ) c2, XmmTemp );
		c1 += 8; c2 += 8; sztRecLength -= 8;
	}
	if( sztRecLength >= 4 )
	{
		dwTemp = *( ( DWORD* ) c1 );
		*( ( int* ) c1 ) = *( ( DWORD* ) c2 );
		*( ( DWORD* ) c2 ) = dwTemp;
		c1 += 4; c2 += 4; sztRecLength -=4;
	}
	while( sztRecLength-- )
	{
		cdata = *c1; *c1++ = *c2; *c2++ = cdata;
	}
}

static DWORD __stdcall BubbleSortAR(SortRecStruct* pArray, size_t pTop, size_t pBtm, bool* pAbort)
{	// reverse scan
	size_t	sztScanPtr;

	while( pTop < pBtm )
	{
		sztScanPtr = pBtm;
		do
		{
			if( pArray[ sztScanPtr - 1 ].Key > pArray[ sztScanPtr ].Key )
			{
				SwapUU( &pArray[ sztScanPtr - 1 ], &pArray[ sztScanPtr ] );
			}
			sztScanPtr--;
		}
		while( sztScanPtr > pTop );
		pTop++;
		if( *pAbort ) return 1223;
	}
	return 0;
}

DWORD __stdcall BubbleSortA(SortRecStruct* pArray, size_t pRecordCount, bool* pAbort)
{
	return BubbleSortAR( pArray, 0, pRecordCount - 1, pAbort );
}

static DWORD __stdcall BubbleSortBR(SortRecStruct* pArray, size_t pTop, size_t pBtm, bool* pAbort)
{	// forward scan
	size_t	sztScanPtr;

	while( pTop < pBtm )
	{
		sztScanPtr = pTop;
		do
		{
			if( pArray[ sztScanPtr + 1 ].Key < pArray[ sztScanPtr ].Key )
			{
				SwapUU( &pArray[ sztScanPtr + 1 ], &pArray[ sztScanPtr ] );
			}
			sztScanPtr++;
		}
		while( sztScanPtr < pBtm );
		pBtm--;
		if( *pAbort ) return 1223;
	}
	return 0;
}

DWORD __stdcall BubbleSortB(SortRecStruct* pArray, size_t pRecordCount, bool* pAbort)
{
	return BubbleSortBR( pArray, 0, pRecordCount - 1, pAbort );
}

static DWORD __stdcall BubbleSortCR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// reverse scan
	SortRecStruct	*RecScan;

	while( pTop < pBtm )
	{
		RecScan = pBtm;
		do
		{
			if( ( RecScan - 1 )->Key > RecScan->Key )
			{
				SwapUU( RecScan - 1, RecScan );
			}
			RecScan--;
		}
		while( RecScan > pTop );
		pTop++;
		if( *pAbort ) return 1223;
	}
	return 0;
}

DWORD __stdcall BubbleSortC(SortRecStruct* pArray, size_t pRecordCount, bool* pAbort)
{
	return BubbleSortCR( pArray, &pArray[ pRecordCount - 1 ], pAbort );
}

static DWORD __stdcall BubbleSortDR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// forward scan
	SortRecStruct	*RecScan;

	while( pTop < pBtm )
	{
		RecScan = pTop;
		do
		{
			if( ( RecScan + 1 )->Key < RecScan->Key )
			{
				SwapUU( RecScan + 1, RecScan );
			}
			RecScan++;
		}
		while( RecScan < pBtm );
		pBtm--;
		if( *pAbort ) return 1223;
	}
	return 0;
}

DWORD __stdcall BubbleSortD(SortRecStruct* pArray, size_t pRecordCount, bool* pAbort)
{
	return BubbleSortDR( pArray, &pArray[ pRecordCount - 1 ], pAbort );
}