Podivné optimalizace c++ 11 – C / C++ – Fórum – Programujte.com

Zdravim,

cely den si lamu hlavu nadtim, proc tento kod:

#include "stdafx.h"
#include <math.h>
#include <iostream>
#include <ctime>
#include <thread>

 void fce(float* a, float* b, float* c, int from, int to){
	for (int i = from; i < to; i++)
	{
		c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int p = 0;
	int repeat = 3;
	while (repeat-- > 0)
	{
		int n = 20 * 1000 * 1000;
		auto a = new float[n];
		auto b = new float[n];
		auto c = new float[n];
		auto d = new float[n];

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}

		clock_t begin_time = clock();

		for (int i = 0; i < n; i++)
		{
			
			c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
		}

		
		std::cout << "\nres:   " << c[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);


		begin_time = clock();
		std::thread t5(fce, a, b, d, 0, n );
		t5.join();
		std::cout << "\nres T: " << c[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);


		delete[] a;
		delete[] b;
		delete[] c;
		delete[] d;
	}
	std::cout << "\nALL DONE";
	std::cin >> p;


	return 0;
}

ma v release (se zapnutyma sse2, jinak default; visual studio 2013) ma na mem notasu (ivy bridge i7; w8.1) tento vystup:

res:   20.5757 ela:728
res T: 20.5757 ela:329
res:   20.5757 ela:708
res T: 20.5757 ela:329
res:   20.5757 ela:704
res T: 20.5757 ela:332
ALL DONE

abych to popsal tak nechapu jak je mozne za ta stejna funkce kterou volam v cyklu trva prumerne 700ms, zatimco kdyz tuto uplne stejnou funkci spustim v thredu (pouze spustim to same v thredu nic nijak neparalelizuju) tak jak je mozne ze bezi cca 2x tak rychleji?

ono to totiz nemusi byt uplne ekvivalentni... treba pri alokaci jen system bere na vedomi, ze chces tolik a tolik ramky, ale doopravdy ji zabere az kdyz se zacne pouzivat... takze doporucuju udelat poradnej test a mit pred threadem taktez uvolneni, alokaci, inicializaci ... a po nem uvolneni

upraveno vysledky porad stejny. nejaky jiny napad?   

#include "stdafx.h"
#include <math.h>
#include <iostream>
#include <ctime>
#include <thread>

 void fce(float* a, float* b, float* c, int from, int to){
	for (int i = from; i < to; i++)
	{
		c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int p = 0;
	int repeat = 3;
	while (repeat-- > 0)
	{
		int n = 20 * 1000 * 1000;
		auto a = new float[n];
		auto b = new float[n];
		auto c = new float[n];
		

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}

		clock_t begin_time = clock();

		for (int i = 0; i < n; i++)
		{
			
			c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
		}

		
		std::cout << "\nres:   " << c[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);

		delete[] a;
		delete[] b;
	
		a = new float[n];
		b = new float[n];
		auto d = new float[n];

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}



		begin_time = clock();
		std::thread t5(fce, a, b, d, 0, n );
		t5.join();
		std::cout << "\nres T: " << d[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);


		delete[] a;
		delete[] b;
		delete[] c;
		delete[] d;
	}
	std::cout << "\nALL DONE";
	std::cin >> p;


	return 0;
}

no jeste by se dala spoustet ta sama funkce... v obou pripadech

kazdopadne ti nic nebrani porovnat vygenerovany kod v assembleru

Možná se na samostatné funkci víc vyřádí. Zkus ji použít v obou případech. A taky bych pro jistotu to zjišťování konečného času dal před ten výpis, ale to nebude velký rozdíl.

Nejlepší by bylo to dekompilovat a podívat se, jestli je něco jinak.

pak bych zkusil jedno pole akorat 3x vetsi, kdy  3n bude to a  3n+1 b a 3n+2 vysledek ... cache prediction by taky mohla udelat nejake drobne zpomaleni (pokud to nezvladne predikci pro vsechny tri naraz)

predelal jsem to a volam tam i tu funkci

#include "stdafx.h"
#include <math.h>
#include <iostream>
#include <ctime>
#include <thread>

void fce(float* a, float* b, float* c, int from, int to){
	for (int i = from; i < to; i++)
	{
		c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int p = 0;
	int repeat = 3;
	while (repeat-- > 0)
	{
		int n = 20 * 1000 * 1000;
		auto a = new float[n];
		auto b = new float[n];
		auto c = new float[n];
		

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}

		clock_t begin_time = clock();

		for (int i = 0; i < n; i++)
		{
			
			c[i] = (float)(log(a[i]) / sqrt(b[i]) + exp((a[i] + 1) / (b[i] - 1)));
		}

		
		std::cout << "\nres:   " << c[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);

		delete[] a;
		delete[] b;
		delete[] c;

		a = new float[n];
		b = new float[n];
		c = new float[n];

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}

		begin_time = clock();
		fce(a, b, c, 0, n);
		std::cout << "\nres:F  " << c[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);

		delete[] a;
		delete[] b;

		// VLAKNO
		a = new float[n];
		b = new float[n];
		
		auto d = new float[n];

		for (int i = 0; i < n; i++)
		{
			a[i] = i;
			b[i] = i;
		}

		begin_time = clock();
		std::thread t5(fce, a, b, d, 0, n );
		t5.join();
		std::cout << "\nres T: " << d[2] << " ela:" << float((clock() - begin_time)) / (CLOCKS_PER_SEC / 1000.0);
		
		
		delete[] a;
		delete[] b;
		delete[] c;
		delete[] d;
		
	}
	std::cout << "\nALL DONE";
	std::cin >> p;


	return 0;
}

vystup je tento

res:   20.5757 ela:680
res:F  20.5757 ela:346
res T: 20.5757 ela:367
res:   20.5757 ela:668
res:F  20.5757 ela:343
res T: 20.5757 ela:340
res:   20.5757 ela:653
res:F  20.5757 ela:336
res T: 20.5757 ela:333
ALL DONE

pokud ovsem zapoznamkuju kod od poznamky //VLAKNO tak jsou casi res a resF stejne okolo tech 340ms.

jako me jde spis o to, ze jak ma teda pak clovek vytvorit nejaky algoritmus, kdyz na takovehle "kravine" se mu jednou vykona program za 700ms a kdyz to napise ve forme funkce (coz by melo byt logicky o nejakou nanosekundu pomalejsi) tak mu to bezi 2x rychleji (jako kdyby to bylo par % ale 2x tolik). jako jak ma clovek pak neco udelat v tom c++