int main (const int argc, char const * const argv[]) {
#ifndef DENORMALS
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
_MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
#endif
auto pairhmm = Pairhmm<
//PairhmmScalarImpl<float>,
//PairhmmScalarImpl<double>
//PairhmmSSEFloatImpl,
//PairhmmAVXFloatImpl,
//PairhmmAVXDoubleImpl
PairhmmAVXFloat2DiagsImpl,
PairhmmAVXDouble2DiagsImpl
>{};
InputReader<TestcaseIterator> reader {};
if (argc == 2)
reader.from_file(argv[1]);
double computation_time = 0.f;
Chronos time;
for (auto& testcase : reader) {
time.reset();
auto results = pairhmm.calculate(testcase);
computation_time += time.elapsed();
for (auto x : results)
cout << x << endl;
}
std::cerr << "done in " << computation_time << "ms\n";
return 0;
}
void useMonteCarlo(void)
{
int n = 8192;
float a = -1.0;
float b = 1.0;
float m = 8.5;
Chronos chronoCudaMonteCarlo;
chronoCudaMonteCarlo.start();
MonteCarlo *monteCarlo = new MonteCarlo(a, b, m, n);
monteCarlo->run();
double secondesCudaMonteCarlo = chronoCudaMonteCarlo.stop();
Chronos chronoMonteCarloSequentiel;
float resultatSequentiel = monteCarloSequentielleCuda(n * 10000);
double secondesMonteCarloSequentiel = chronoMonteCarloSequentiel.stop();
cout << "Resultat monte carlo cuda= " << monteCarlo->getResultat() << " temps d'excecution = " << secondesCudaMonteCarlo << endl;
cout << "Resultat monte carlo sequentielle= " << resultatSequentiel << " temps d'excecution = " << secondesMonteCarloSequentiel << endl;
delete monteCarlo;
}
static void useHistogramme(void)
{
Chronos chronoHistogramme;
chronoHistogramme.start();
Histogramme *histogramme = new Histogramme();
histogramme->run();
double secondesHistogramme = chronoHistogramme.stop();
histogramme->printTabFrequence();
cout << "Temps d'execution= " << secondesHistogramme << endl;
delete histogramme;
}
/*--------------------------------------*\
|* Public *|
\*-------------------------------------*/
void algo_histogramme(Algo_Pi algo, int n, string titre)
{
cout << "Title: " << titre << endl;
cout << "n= " << n << endl;
Chronos chrono;
unsigned int* tabFrequence = algo(n);
for (int i = 0; i < 256; i++)
{
cout << "tabFrequence[" << i << "]=" << tabFrequence[i] << endl;
}
chrono.stop();
chrono.print("time= ");
cout << "-----------------------------------" << endl;
}
int mainCore(void)
{
bool isOk = true;
Chronos chrono;
chrono.start();
//isOk &= useHello();
//isOk &= useRippling ();
//isOk &= useMandelbrot();
//isOk &= useJulia ();
//isOk &= useHeater();
//isOk &= useRayTracing();
isOk &= demoAll();
cout << "\n-------------------------------------------------" << endl;
cout << "End Main : isOk = " << isOk << endl;
return isOk ? EXIT_SUCCESS : EXIT_FAILURE;
}
bool isAlgo_OK(AlgoMonteCarlo algoPI, int n, string title)
{
cout << endl << "[" << title << " running ...]" << endl;
cout << "n=" << n << endl;
Chronos chrono;
double piHat = algoPI(n);
chrono.stop();
cout.precision(8);
cout << "Pi hat = " << piHat << endl;
cout << "Pi true = " << PI << endl;
bool isOk = MathTools::isEquals(piHat, PI, 1e-6);
cout << "isOk = " << isOk << endl;
cout.precision(3);
chrono.print("time : ");
return isOk;
}
bool useRayTracing(void)
{
int nbMeasure = 5;
int maxDimension = 5000;
Chronos init;
Chronos core;
for (int d = 2000; d < maxDimension; d += 500)
{
for (int nbSphere = 100; nbSphere < 1000; nbSphere += 200)
{
for (int numThreads = 1; numThreads < 6; numThreads++)
{
for (int i = 0; i < nbMeasure; i++)
{
cout << d << ",";
cout << nbSphere << ",";
cout << numThreads << ",";
init.start();
RayTracingImageCudaMOO rayTracing(d, d, 0, 0.005, nbSphere, numThreads);
cout << init.stop() << ",";
core.start();
rayTracing.fillImageGL();
cout << core.stop() << endl;
}
}
}
}
return true;
}
void useProduitScalaire(void)
{
int n = 8192;
Chronos chronoCuda;
chronoCuda.start();
ProduitScalaire *produitScalaire = new ProduitScalaire(n);
produitScalaire->launchProduitScalaire();
double secondesCuda = chronoCuda.stop();
Chronos chronoCPU;
chronoCPU.start();
float resultatSequentiel = produitScalaireSequentielleCuda(n);
double secondesCPU = chronoCPU.stop();
cout << "Resultat produit scalaire cuda= " << produitScalaire->getResultat() << " temps d'execution= " << secondesCuda << endl;
cout << "Resultat produit scalaire sequentiel= " << resultatSequentiel << " temps d'execution= " << secondesCPU << endl;
delete produitScalaire;
}
