int main(int argc, char *argv[])
{
Chronometer total;
total.start();
try {
Util::check(argv[1] == NULL, "You must specify an output directory.");
ChronoPlotter plotter(argv[1], new RangeLoop(Population::NUM_SELECTION, 50, 301, 50), "Tiempo (ms)");
plotter.parameters.putNumber(Population::NUM_CROSSOVER, 0);
plotter.parameters.putNumber(Dummy::WEIGHS_RANGE, 5);
JoinEnumLoop linesLoop(ET_SELECTION_ALGORITHM);
linesLoop.addInnerLoop(new RangeLoop(Population::SIZE, 400, 501, 100));
linesLoop.addEnumLoop(SA_ROULETTE_WHEEL, NULL);
linesLoop.addEnumLoop(SA_RANKING, NULL);
linesLoop.addEnumLoop(SA_TOURNAMENT, new RangeLoop(Population::TOURNAMENT_SIZE, 5, 30, 10));
linesLoop.addEnumLoop(SA_TRUNCATION, NULL);
plotter.plotChrono(chronoSelection, "chronoGen_Selection", &linesLoop, 50);
printf("Exit success.\n");
} catch (std::string& error) {
cout << "Error: " << error << endl;
}
MemoryManagement::printTotalAllocated();
MemoryManagement::printTotalPointers();
MemoryManagement::printListOfPointers();
total.stop();
printf("Total time spent: %f \n", total.getSeconds());
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
Chronometer total;
total.start();
try {
Util::check(argv[1] == NULL, "You must specify an output directory.");
ChronoPlotter plotter(argv[1], new RangeLoop(Dummy::SIZE, 50, 301, 50), "Tiempo (ms)");
plotter.parameters.putNumber(PROBABILITY, 0);
plotter.parameters.putNumber(NUM_TIMES, 0);
plotter.parameters.putNumber(Dummy::WEIGHS_RANGE, 20);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_IMPLEMENTATION), IT_C);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_FUNCTION), FT_IDENTITY);
plotter.parameters.putNumber(Dummy::NUM_INPUTS, 2);
EnumLoop averageLoop(ET_BUFFER, 2, BT_FLOAT, BT_BIT);
averageLoop.addInnerLoop(new RangeLoop(Dummy::NUM_LAYERS, 1, 2, 1));
EnumLoop crossLoop(ET_CROSS_LEVEL);
JoinEnumLoop* crossAlgLoop = new JoinEnumLoop(ET_CROSS_ALG);
crossLoop.addInnerLoop(crossAlgLoop);
crossAlgLoop->addEnumLoop(CA_UNIFORM, new RangeLoop(PROBABILITY, 0.2, 0.5, 0.2));
crossAlgLoop->addEnumLoop(CA_MULTIPOINT, new RangeLoop(NUM_TIMES, 1, 10, 5));
crossAlgLoop->addEnumLoop(CA_PROPORTIONAL, NULL);
plotter.plotChronoAveraged(chronoCrossover, "chronoGen_crossover", &crossLoop, &averageLoop, 50);
EnumLoop mutatAlgLoop(ET_MUTATION_ALG, 2, MA_PER_INDIVIDUAL, MA_PROBABILISTIC);
mutatAlgLoop.addInnerLoop(new RangeLoop(PROBABILITY, 0.0025, 0.011, 0.0025));
plotter.plotChronoAveraged(chronoMutations, "chronoGen_mutate", &mutatAlgLoop, &averageLoop, 100);
EnumLoop resetAlgLoop(ET_RESET_ALG, 2, RA_PER_INDIVIDUAL, RA_PROBABILISTIC);
resetAlgLoop.addInnerLoop(new RangeLoop(PROBABILITY, 0.0025, 0.011, 0.0025));
plotter.plotChronoAveraged(chronoReset, "chronoGen_reset", &resetAlgLoop, &averageLoop, 100);
// // separated files
//
// EnumLoop filesLoop(ET_BUFFER, 3, BT_FLOAT, BT_BIT, BT_SIGN);
//
// plotter.plotChronoFiles(chronoCrossover, "Individual_crossover", &crossLoop, &filesLoop, 5);
// plotter.plotChronoAveraged(chronoMutations, "Individual_mutate", &mutatAlgLoop, &filesLoop, 10);
// plotter.plotChronoAveraged(chronoReset, "Individual_reset", &resetAlgLoop, &filesLoop, 10);
printf("Exit success.\n");
} catch (std::string& error) {
cout << "Error: " << error << endl;
}
MemoryManagement::printTotalAllocated();
MemoryManagement::printTotalPointers();
MemoryManagement::printListOfPointers();
total.stop();
printf("Total time spent: %f \n", total.getSeconds());
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
Chronometer total;
total.start();
try {
Util::check(argv[1] == NULL, "You must specify an output directory.");
ChronoPlotter plotter(argv[1], new RangeLoop(Dummy::SIZE, 512, 8193, 512), "Tiempo (ms)");
unsigned repetitions = 500;
plotter.parameters.putNumber(Dummy::WEIGHS_RANGE, 20);
plotter.parameters.putNumber(Dummy::NUM_INPUTS, 2);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_FUNCTION), FT_IDENTITY);
EnumLoop linesLoop(ET_IMPLEMENTATION);
linesLoop.addInnerLoop(new EnumLoop(ET_BUFFER, 3, BT_FLOAT, BT_BIT, BT_SIGN));
RangeLoop averageLoop(Dummy::OUTPUT_SIZE, 512, 1025, 512);
plotter.plotChronoAveraged(chronoCalculateAndAddTo, "impl_calculate_inputSize", &linesLoop,
&averageLoop, repetitions);
repetitions = 1000;
plotter.resetRangeX(Dummy::OUTPUT_SIZE, 128, 2049, 128);
averageLoop.setKey(Dummy::SIZE);
plotter.plotChronoAveraged(chronoCalculateAndAddTo, "impl_calculate_outputSize", &linesLoop,
&averageLoop, repetitions);
EnumLoop filesLoop(ET_BUFFER, 3, BT_FLOAT, BT_BIT, BT_SIGN);
EnumLoop cudaLinesLoop(ET_IMPLEMENTATION, 4, IT_CUDA_REDUC0, IT_CUDA_REDUC, IT_CUDA_OUT, IT_CUDA_INV);
cudaLinesLoop.addInnerLoop(new ExpLoop(CUDA_BLOCK_SIZE, 16, 513, 2));
plotter.plotChronoFilesAveraged(chronoCalculateAndAddTo, "impl_calculate_outputSize_blockSize", &cudaLinesLoop,
&filesLoop, &averageLoop, repetitions);
repetitions = 500;
plotter.resetRangeX(Dummy::SIZE, 512, 8193, 512);
averageLoop.setKey(Dummy::OUTPUT_SIZE);
plotter.plotChronoFilesAveraged(chronoCalculateAndAddTo, "impl_calculate_inputSize_blockSize", &cudaLinesLoop,
&filesLoop, &averageLoop, repetitions);
printf("Exit success.\n");
} catch (std::string error) {
cout << "Error: " << error << endl;
}
MemoryManagement::printTotalAllocated();
MemoryManagement::printTotalPointers();
//MemoryManagement::mem_printListOfPointers();
total.stop();
printf("Total time spent: %f \n", total.getSeconds());
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
Chronometer total;
total.start();
try {
Test test;
test.parameters.putNumber(Dummy::WEIGHS_RANGE, 20);
test.parameters.putNumber(Enumerations::enumTypeToString(ET_FUNCTION), FT_IDENTITY);
RangeLoop* sizeLoop = new RangeLoop(Dummy::SIZE, 100, 101, 100);
Loop* loop = sizeLoop;
RangeLoop* outputSizeLoop = new RangeLoop(Dummy::OUTPUT_SIZE, 1, 4, 2);
loop->addInnerLoop(outputSizeLoop);
EnumLoop* bufferTypeLoop = new EnumLoop(Enumerations::enumTypeToString(ET_BUFFER), ET_BUFFER);
loop->addInnerLoop(bufferTypeLoop);
// loop->addInnerLoop(new EnumLoop(ET_IMPLEMENTATION, 2, IT_C, IT_SSE2));
sizeLoop->addInnerLoop(new EnumLoop(ET_IMPLEMENTATION));
loop->print();
// test.testMemoryLosses(testLoops, ¶metersMap, "test loops", &loop);
test.testMemoryLosses(testBuffer, "Buffer", loop);
// exclude BYTE
bufferTypeLoop->exclude(ET_BUFFER, 1, BT_BYTE);
test.testMemoryLosses(testConnection, "Connection", loop);
RangeLoop* numInputsLoop = new RangeLoop(Dummy::NUM_INPUTS, 1, 3, 1);
loop->addInnerLoop(numInputsLoop);
test.testMemoryLosses(testLayer, "Layer", loop);
RangeLoop* numLayersLoop = new RangeLoop(Dummy::NUM_LAYERS, 1, 3, 1);
loop->addInnerLoop(numLayersLoop);
test.testMemoryLosses(testNeuralNet, "NeuralNet", loop);
test.testMemoryLosses(testIndividual, "Individual", loop);
sizeLoop->resetRange(1, 3, 1);
outputSizeLoop->resetRange(1, 1, 1);
numInputsLoop->resetRange(1, 1, 1);
numLayersLoop->resetRange(1, 1, 1);
test.testMemoryLosses(testPopulation, "Population", loop);
delete(loop);
MemoryManagement::printListOfPointers();
printf("Exit success.\n");
} catch (string& error) {
cout << "Error: " << error << endl;
} catch (...) {
printf("An error was thrown.\n");
}
MemoryManagement::printTotalAllocated();
MemoryManagement::printTotalPointers();
total.stop();
printf("Total time spent: %f \n", total.getSeconds());
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
Chronometer total;
total.start();
try {
Util::check(argv[1] == NULL, "You must specify an output directory.");
TaskPlotter plotter(argv[1], new RangeLoop("Generation", 0, 50, 5));
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_IMPLEMENTATION), IT_SSE2);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_FUNCTION), FT_IDENTITY);
plotter.parameters.putNumber(Dummy::WEIGHS_RANGE, 5);
plotter.parameters.putNumber(Population::MUTATION_RANGE, 2);
unsigned populationSize = 8;
plotter.parameters.putNumber(Population::SIZE, populationSize);
plotter.parameters.putNumber(Population::NUM_SELECTION, populationSize / 2);
plotter.parameters.putNumber(Population::NUM_CROSSOVER, populationSize / 2);
// plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_BUFFER), BT_BIT);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_RESET_ALG), RA_DISABLED);
JoinEnumLoop linesLoop(ET_CROSS_ALG);
linesLoop.addEnumLoop(CA_UNIFORM, new RangeLoop(Population::UNIFORM_CROSS_PROB, 0.2, 0.5, 0.2));
linesLoop.addEnumLoop(CA_MULTIPOINT, new RangeLoop(Population::MULTIPOINT_NUM, 1, 7, 5));
linesLoop.addEnumLoop(CA_PROPORTIONAL, NULL);
EnumLoop averageLoop(ET_BUFFER, 3, BT_FLOAT, BT_BIT, BT_SIGN);
averageLoop.addInnerLoop(new EnumLoop(ET_CROSS_LEVEL));
JoinEnumLoop* selectionLoop = new JoinEnumLoop(ET_SELECTION_ALGORITHM);
selectionLoop->addEnumLoop(SA_ROULETTE_WHEEL, NULL);
selectionLoop->addEnumLoop(SA_RANKING, NULL);
selectionLoop->addEnumLoop(SA_TOURNAMENT, new RangeLoop(Population::TOURNAMENT_SIZE, 3, 5, 3));
selectionLoop->addEnumLoop(SA_TRUNCATION, NULL);
averageLoop.addInnerLoop(selectionLoop);
JoinEnumLoop* mutationLoop = new JoinEnumLoop(ET_MUTATION_ALG);
// mutationLoop->addEnumLoop(MA_DISABLED, NULL);
mutationLoop->addEnumLoop(MA_PER_INDIVIDUAL, new RangeLoop(Population::MUTATION_NUM, 2, 3, 2));
mutationLoop->addEnumLoop(MA_PROBABILISTIC, new RangeLoop(Population::MUTATION_PROB, 0.05, 0.30, 0.35));
averageLoop.addInnerLoop(mutationLoop);
plotter.parameters.putNumber(Dummy::SIZE, 2);
plotter.parameters.putNumber(Dummy::NUM_TESTS, 0);
EnumLoop filesLoop(ET_TEST_TASKS, 3, TT_BIN_OR, TT_BIN_AND, TT_BIN_XOR);
plotter.plotTaskFilesAveraged("CrossoverAlg", &linesLoop, &filesLoop, &averageLoop);
plotter.parameters.putNumber(Dummy::SIZE, 6);
plotter.parameters.putNumber(Dummy::NUM_TESTS, 2);
plotter.parameters.putNumber(Enumerations::enumTypeToString(ET_TEST_TASKS), TT_REVERSI);
//
plotter.plotTaskAveraged("CrossoverAlg_REVERSI", &linesLoop, &averageLoop);
printf("Exit success.\n");
} catch (std::string error) {
cout << "Error: " << error << endl;
// } catch (...) {
// printf("An error was thrown.\n", 1);
}
MemoryManagement::printTotalAllocated();
MemoryManagement::printTotalPointers();
MemoryManagement::printListOfPointers();
total.stop();
printf("Total time spent: %f \n", total.getSeconds());
return EXIT_SUCCESS;
}
