/*
	SelectionSort.cpp

*/

#include "stdafx.h"
#include "SelectionSort.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 SelectionSortAR(SortRecStruct* pArray, size_t pTop, size_t pBtm, bool* pAbort)
{	// forward scan
	size_t	sztMaxPtr, sztScan;

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

DWORD __stdcall SelectionSortA(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortAR( pArray, 0, pRecCount - 1, pAbort );
}

static DWORD __stdcall SelectionSortBR(SortRecStruct* pArray, size_t pTop, size_t pBtm, bool* pAbort)
{	// reverse sccan
	size_t	sztMinPtr, sztScan;

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

DWORD __stdcall SelectionSortB(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortBR( pArray, 0, pRecCount - 1, pAbort );
}

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

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

DWORD __stdcall SelectionSortC(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortCR( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

static DWORD __stdcall SelectionSortDR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// reverse sccan
	SortRecStruct	*RecMinPtr, *RecScan;

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

DWORD __stdcall SelectionSortD(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortDR( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

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

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

DWORD __stdcall SelectionSortE(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortER( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

extern "C" DWORD __stdcall SelectionSortERAsm(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort);
DWORD __stdcall SelectionSortEAsm(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortERAsm( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

static DWORD __stdcall SelectionSortFR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// reverse sccan
	SortRecStruct	*RecMinPtr, *RecScan;
	DWORD	MinKeyValue;

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

DWORD __stdcall SelectionSortF(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortFR( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

extern "C" DWORD __stdcall SelectionSortFRAsm(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort);
DWORD __stdcall SelectionSortFAsm(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortFRAsm( pArray, &pArray[ pRecCount - 1 ], pAbort );
}
static DWORD __stdcall SelectionSortGR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// forward scan
	SortRecStruct	*RecMaxPtr, *RecScan;
	size_t	sztOutCtr, sztInCtr;
	DWORD	MaxKeyValue;

	sztOutCtr = pBtm - pTop;
	while( sztOutCtr )
	{
		RecMaxPtr = pBtm; MaxKeyValue = RecMaxPtr->Key; RecScan = pTop; sztInCtr = sztOutCtr;
		do
		{
			if( RecScan->Key > MaxKeyValue )
			{
				RecMaxPtr = RecScan; MaxKeyValue = RecMaxPtr->Key;
			}
			RecScan++; sztInCtr--;
		}
		while( sztInCtr );
		SwapUU( RecMaxPtr, pBtm-- );
		if( *pAbort ) return 1223;
		sztOutCtr--;
	}
	return 0;
}

DWORD __stdcall SelectionSortG(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortGR( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

extern "C" DWORD __stdcall SelectionSortGRAsm(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort);
DWORD __stdcall SelectionSortGAsm(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortGRAsm( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

static DWORD __stdcall SelectionSortHR(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort)
{	// reverse sccan
	SortRecStruct	*RecMinPtr, *RecScan;
	size_t	sztOutCtr, sztInCtr;
	DWORD	MinKeyValue;

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

DWORD __stdcall SelectionSortH(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortHR( pArray, &pArray[ pRecCount - 1 ], pAbort );
}

extern "C" DWORD __stdcall SelectionSortHRAsm(SortRecStruct* pTop, SortRecStruct* pBtm, bool* pAbort);
DWORD __stdcall SelectionSortHAsm(SortRecStruct* pArray, size_t pRecCount, bool* pAbort)
{
	return SelectionSortHRAsm( pArray, &pArray[ pRecCount - 1 ], pAbort );
}