#include<stdio.h>
#include<time.h>
#include<string.h>
#include<cstring>
#include<Windows.h>
#include<string>
#include<iostream>
//#include "CPUID.h"

using namespace std;
/*
double CPUSpeed()
{
wchar_t Buffer[_MAX_PATH];
DWORD BufSize = _MAX_PATH;
DWORD dwMHz = _MAX_PATH;
HKEY hKey;

// open the key where the proc speed is hidden:
long lError = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
0,
KEY_READ,
&hKey);
if (lError != ERROR_SUCCESS)
{// if the key is not found, tell the user why:
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
lError,
0,
Buffer,
_MAX_PATH,
0);
wprintf(Buffer);
return 0;
}

// query the key:
RegQueryValueEx(hKey, L"~MHz", NULL, NULL, (LPBYTE)&dwMHz, &BufSize);
return (double)dwMHz;
}
*/
double PCFreq = 0.0;
__int64 CounterStart = 0;

void StartCounter()
{
	LARGE_INTEGER li;
	if (!QueryPerformanceFrequency(&li))
		cout << "QueryPerformanceFrequency failed!\n";

	PCFreq = double(li.QuadPart) / 1000.0;

	QueryPerformanceCounter(&li);
	CounterStart = li.QuadPart;
}
double GetCounter()
{
	LARGE_INTEGER li;
	QueryPerformanceCounter(&li);
	return double(li.QuadPart - CounterStart) / PCFreq;
}


int main()
{
	unsigned long long start = 0, FamilyCode = 0, ExtendedFamily = 0, stop = 0, brand_table = 0, brand_table_count = 0, regA,ModelNr=0,Type=0,ExtendedModel=0;
	string vendor;
	//char vendor[12];
	__asm
	{
		rdtsc; EDX, EAX
			MOV DWORD PTR start + 4, EDX
			OR DWORD PTR start, EAX
	}
	Sleep(1000);
	__asm
	{
		rdtsc; EDX, EAX
			MOV DWORD PTR stop + 4, EDX
			OR DWORD PTR stop, EAX
	}
	__asm
	{
		mov eax, 1
			cpuid
			mov dword ptr regA, EAX
			//	MOV DWORD PTR vendor, EBX
			//MOV DWORD PTR vendor + 4, EDX
			//MOV DWORD PTR vendor + 8, ECX
			MOV DWORD PTR vendor, EAX

			/*

			//print Brand ID
			CMP		_cpu_type,6
			JB		print_486_type
			JA		print_pentiumiiimodel18_type
			MOV		EAX,DWORD PTR _cpu_signature
			SHR		 EAX,4
			AND		AL,0Fh
			CMP		AL, 8
			JNE		print_pentiumiiimodel18_type

			print_pentiumii18_type:
			CMP EAX,8
			JB print_unknown_type
			MOV EAX, DWORD PTR _features_ebx
			OR AL,AL
			JZ print_unknown_type
			MOV DI, offset brand_table
			MOV XC, brand_table_count
			*/
	}
	/*

	//CPUID cpuID(0); // Get CPU vendor


	//vendor += string((const char *)&cpuID.EBX(), 4);
	//vendor += string((const char *)&cpuID.EDX(), 4);
	//vendor += string((const char *)&cpuID.ECX(), 4);

	//cout << "CPU vendor = " << vendor << endl;

	//CPUID cpuID2(1);
	//FamilyCode = (regA >> 20) & 0xFF + (regA >> 8) & 0x0F
	*/
	ModelNr = (regA >> 4) & 0x0F;
	FamilyCode = (regA >> 8) & 0x0F;
	Type = (regA >>12)& 0x03;
	ExtendedModel = (regA >> 16) & 0x0F;
	ExtendedFamily = (regA >> 20) & 0xFF;

	//printf(" ModelNr=%d\n FamilyCode=%d\n Type=%d\n ExtendedModel=%d\n ExtendedFamily=%d", ModelNr, FamilyCode, Type, ExtendedModel, ExtendedFamily);
	printf(" ModelNr=%d\n", ModelNr);
	printf("FamilyCode =%d\n", FamilyCode);
	printf("Type =%d\n", Type);
	printf("ExtendedModel =%d\n", ExtendedModel);
	printf("ExtendedFamily =%d\n", ExtendedFamily);

	//F = CPUID(1).EAX[27:20] + CPUID(1).EAX[11:8];
	//printf("\n Vendor : %s \n", vendor);

	//rdtsc();
	//wait(1000);
	//rdtsc(stop)
	double freq = (stop - start) / 1000000.0;
	cout << "\nFreq : " << freq << "MHz\n";
	/* ex1
	cout << "\nCerinta 1\n\n";
	cout << "CPU speed : " << CPUSpeed() << "MHz";
	*/
	cout << "\nCerinta 2\n\n";
	// ex2
	//current_thread=GetCurrentProcess();
	int core = 2;
	cout << SetThreadAffinityMask(GetCurrentThread(), (1 << core) - 1);

	//ex3
	cout << "\n Cerinta 3\n\n";

	/*

	//high priority
	SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp process high priority : " << GetCounter();
	cout << "\n";

	//normal priority
	SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp process normal priority : " << GetCounter();
	cout << "\n";

	//idle priority
	SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp process normal idle : " << GetCounter();
	cout << "\n";



	//ex4
	cout << "\nCerinta 4\n\n";


	//highest priority

	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp thread highest : " << GetCounter();
	cout << "\n";


	//above_normal priority
	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp thread above normal : " << GetCounter();
	cout << "\n";


	//below normal priority
	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
	StartCounter();
	for (int i = 0; i < 10000; i++)
	for (int j = 0; j < 10000; j++)
	for (int k = 0; k < 5; k++)
	{

	}

	cout << "Timp thread below normal : " << GetCounter();
	cout << "\n";
	//system("PAUSE");

	*/

	// lab 6 ( lab 5 )

// add 2 vect 4 elem normal

	cout << "add 2 vect 4 elem normal \n\n";
	float v1[] = { 0, 1, 2, 3 }, v2[] = {5,6,7,8}, v3[4];
	int i = 0;
	printf("Vector suma :");
	StartCounter();
	for (i = 0; i < 4; i++)
	{
		v3[i] = v1[i] + v2[i];
		printf("%f ", v3[i]);
	}
	cout<<"\n A durat : "<< GetCounter()<<"\n";

// add 2 vect 4 elem SSE

	cout << "\n\nadd 2 vect 4 elem SSE \n\n";
	float adr1,adr2;
	__m128 _mm_load_ps(float const* adr1);
	__m128 _mm_load_ps(float const* adr2);
	StartCounter();
	__m128 _mm_add_ps(__m128 adr1, __m128 adr2);
	cout << "\n A durat : " << GetCounter() << "\n";

//Inmultirea unui vector cu un scalar folosind instructiuni instructiuni obisnuite

	cout << "\nInmultirea unui vector cu un scalar folosind instructiuni instructiuni obisnuite\n\n";
	float v4[] = { 0, 1, 2, 3 }, v6[4];
	printf("Vector inmult :");
	StartCounter();
	for (i = 0; i < 4; i++)
	{
		v6[i] = 2 * v4[i];
		printf("%f ", v6[i]);
	}
	cout << "\n A durat : " << GetCounter() << "\n";


//Inmultirea unui vector cu un scalar folosind instructiuni SSE;

	cout << "\n Inmultirea unui vector cu un scalar folosind instructiuni SSE\n\n";
	__m128 _mm_set1_ps(float f);
	__m128 _mm_load_ps(float const* adr2);
	StartCounter();
	__m128 _mm_mul_ps(__m128 f, __m128 adr2);
	cout << "\n A durat : " << GetCounter() << "\n";


//Inmultirea unei matrici de dimensiune 4x4 cu un vector de 4 elemente folosind instructiuni obisnuite

	cout << "\n Inmultirea unei matrici de dimensiune 4x4 cu un vector de 4 elemente folosind instructiuni obisnuite\n\n";
	float m1[4][4] = { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 }, { 12, 13, 14, 15 } }, vec[] = { 1, 2, 3, 4 }, r1[4] = {0,0,0,0};
	int j = 0;
	cout << "Rez : ";
	StartCounter();
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			r1[i] = m1[i][j] * vec[i] + r1[i];
		}
		cout <<r1[i]<<", ";StartCounter();
	}
	cout << "\n A durat : " << GetCounter() << "\n";


// Inmultirea unei matrici de dimensiune 4x4 cu un vector de 4 elemente folosind instructiuni SSE

	cout << "\n Inmultirea unei matrici de dimensiune 4x4 cu un vector de 4 elemente folosind instructiuni SSE\n\n";
	__m128 _mm_set1_ps(float f);
	__m128 _mm_load_ps(float const* adr2);
	StartCounter();
	__m128 _mm_mul_ps(__m128 f, __m128 adr2);
	cout << "\n A durat : " << GetCounter() << "\n";





	return 0;
}