cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
fc2e9ec2ff
solidity/test/yulPhaser/AlgorithmRunner.cpp

527 lines
18 KiB
C++
Raw Normal View History

[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
[yul-phaser] Rename Common to Helpers in tests (update references)
2020-03-02 08:40:58 +00:00
#include <test/yulPhaser/TestHelpers.h>
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
#include <tools/yulPhaser/AlgorithmRunner.h>
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
#include <tools/yulPhaser/Common.h>
[yul-phaser] Add --show-cache-stats option
2020-02-29 01:14:51 +00:00
#include <tools/yulPhaser/FitnessMetrics.h>
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
#include <liblangutil/CharStream.h>
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
#include <libsolutil/CommonIO.h>
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
#include <boost/filesystem.hpp>
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
#include <boost/test/unit_test.hpp>
#include <boost/test/tools/output_test_stream.hpp>
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
#include <regex>
#include <sstream>
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
using namespace std;
using namespace boost::unit_test::framework;
using namespace boost::test_tools;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
using namespace solidity::langutil;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
using namespace solidity::util;
[yul-phaser] Require specifying weights for Program::codeSize()
2020-02-29 20:55:32 +00:00
using namespace solidity::yul;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
namespace fs = boost::filesystem;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
namespace solidity::phaser::test
{
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
class CountingAlgorithm: public GeneticAlgorithm
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
{
public:
using GeneticAlgorithm::GeneticAlgorithm;
Population runNextRound(Population _population) override
{
++m_currentRound;
return _population;
}
size_t m_currentRound = 0;
};
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
class RandomisingAlgorithm: public GeneticAlgorithm
{
public:
using GeneticAlgorithm::GeneticAlgorithm;
Population runNextRound(Population _population) override
{
return Population::makeRandom(_population.fitnessMetric(), _population.individuals().size(), 10, 20);
}
};
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
class AlgorithmRunnerFixture
{
protected:
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
// NOTE: Regexes here should not contain spaces because we strip them before matching
[yul-phaser] AlgorithmRunner: Print elapsed time after each round
2020-02-27 01:08:40 +00:00
regex RoundSummaryRegex{R"(-+ROUND\d+\[round:[0-9.]+s,total:[0-9.]+s\]-+)"};
[yul-phaser] Add --show-initial-population option
2020-02-27 01:04:09 +00:00
regex InitialPopulationHeaderRegex{"-+INITIALPOPULATION-+"};
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
string individualPattern(Individual const& individual) const
{
ostringstream output;
[yul-phaser] Population: Print individuals in a more compact way
2020-03-09 18:24:37 +00:00
output << individual.fitness << individual.chromosome;
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
return output.str();
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
}
string topChromosomePattern(size_t roundNumber, Individual const& individual) const
{
ostringstream output;
[yul-phaser] AlgorithmRunner: Print total time when showing only the top chromosome
2020-03-09 18:23:25 +00:00
output << roundNumber << R"(\|[0-9.]+\|)" << individualPattern(individual);
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
return output.str();
}
bool nextLineMatches(stringstream& stream, regex const& pattern) const
{
string line;
if (getline(stream, line).fail())
return false;
return regex_match(stripWhitespace(line), pattern);
}
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
shared_ptr<FitnessMetric> m_fitnessMetric = make_shared<ChromosomeLengthMetric>();
[yul-phaser] AlgorithmRunner: Make all tests use population from AlgorithmRunnerFixture
2020-03-08 15:59:14 +00:00
Population const m_population = Population::makeRandom(m_fitnessMetric, 5, 0, 20);
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
stringstream m_output;
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
AlgorithmRunner::Options m_options;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
};
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
class AlgorithmRunnerAutosaveFixture: public AlgorithmRunnerFixture
{
public:
static vector<string> chromosomeStrings(Population const& _population)
{
vector<string> lines;
for (auto const& individual: _population.individuals())
lines.push_back(toString(individual.chromosome));
return lines;
}
protected:
TemporaryDirectory m_tempDir;
string const m_autosavePath = m_tempDir.memberPath("population-autosave.txt");
RandomisingAlgorithm m_algorithm;
};
Do not run tests that do not need options multiple times.
2020-07-08 15:56:14 +00:00
BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
BOOST_AUTO_TEST_SUITE(AlgorithmRunnerTest)
BOOST_FIXTURE_TEST_CASE(run_should_call_runNextRound_once_per_round, AlgorithmRunnerFixture)
{
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
m_options.maxRounds = 5;
[yul-phaser] AlgorithmRunner: Make all tests use population from AlgorithmRunnerFixture
2020-03-08 15:59:14 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
CountingAlgorithm algorithm;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
BOOST_TEST(algorithm.m_currentRound == 0);
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
runner.run(algorithm);
BOOST_TEST(algorithm.m_currentRound == 5);
runner.run(algorithm);
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
BOOST_TEST(algorithm.m_currentRound == 10);
}
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_print_round_summary_after_each_round, AlgorithmRunnerFixture)
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
{
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
m_options.maxRounds = 1;
[yul-phaser] Add --show-initial-population option
2020-02-27 01:04:09 +00:00
m_options.showInitialPopulation = false;
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
m_options.showOnlyTopChromosome = false;
m_options.showRoundInfo = true;
[yul-phaser] AlgorithmRunner: Make all tests use population from AlgorithmRunnerFixture
2020-03-08 15:59:14 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
RandomisingAlgorithm algorithm;
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
runner.run(algorithm);
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
for (auto const& individual: runner.population().individuals())
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
[yul-phaser] AlgorithmRunner: Create a structure to store runner's options
2020-02-21 18:46:18 +00:00
runner.run(algorithm);
[yul-phaser] AlgorithmRunner: A stronger test for run() output
2020-03-08 15:55:24 +00:00
BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
for (auto const& individual: runner.population().individuals())
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
BOOST_TEST(m_output.peek() == EOF);
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
}
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_not_print_round_summary_if_not_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showOnlyTopChromosome = false;
m_options.showRoundInfo = false;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
RandomisingAlgorithm algorithm;
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, regex("")));
for (auto const& individual: runner.population().individuals())
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_not_print_population_if_its_empty, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showOnlyTopChromosome = false;
m_options.showRoundInfo = true;
AlgorithmRunner runner(Population(m_fitnessMetric), {}, m_options, m_output);
RandomisingAlgorithm algorithm;
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_print_only_top_chromosome_if_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showOnlyTopChromosome = true;
m_options.showRoundInfo = true;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
RandomisingAlgorithm algorithm;
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, regex(topChromosomePattern(1, runner.population().individuals()[0]))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_not_print_round_number_for_top_chromosome_if_round_info_not_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showOnlyTopChromosome = true;
m_options.showRoundInfo = false;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
RandomisingAlgorithm algorithm;
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(runner.population().individuals()[0]))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_not_print_population_if_its_empty_and_only_top_chromosome_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 3;
m_options.showRoundInfo = true;
m_options.showInitialPopulation = false;
m_options.showOnlyTopChromosome = true;
AlgorithmRunner runner(Population(m_fitnessMetric), {}, m_options, m_output);
RandomisingAlgorithm algorithm;
runner.run(algorithm);
BOOST_TEST(m_output.peek() == EOF);
}
[yul-phaser] Add --show-initial-population option
2020-02-27 01:04:09 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_print_initial_population_if_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 0;
m_options.showInitialPopulation = true;
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = false;
[yul-phaser] Add --show-initial-population option
2020-02-27 01:04:09 +00:00
RandomisingAlgorithm algorithm;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, InitialPopulationHeaderRegex));
for (auto const& individual: m_population.individuals())
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_not_print_initial_population_if_not_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 0;
m_options.showInitialPopulation = false;
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = false;
[yul-phaser] Add --show-initial-population option
2020-02-27 01:04:09 +00:00
RandomisingAlgorithm algorithm;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
runner.run(algorithm);
BOOST_TEST(m_output.peek() == EOF);
}
[yul-phaser] Add --show-only-top-chromosome and --hide-round options
2020-02-27 01:07:48 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_print_whole_initial_population_even_if_only_top_chromosome_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 0;
m_options.showInitialPopulation = true;
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = true;
RandomisingAlgorithm algorithm;
AlgorithmRunner runner(m_population, {}, m_options, m_output);
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, InitialPopulationHeaderRegex));
for (auto const& individual: m_population.individuals())
BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
BOOST_TEST(m_output.peek() == EOF);
}
[yul-phaser] Add --show-cache-stats option
2020-02-29 01:14:51 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_print_cache_stats_if_requested, AlgorithmRunnerFixture)
{
m_options.maxRounds = 4;
m_options.showInitialPopulation = false;
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = true;
m_options.showCacheStats = true;
RandomisingAlgorithm algorithm;
vector<CharStream> sourceStreams = {
CharStream("{mstore(10, 20)}", ""),
CharStream("{mstore(10, 20)\nsstore(10, 20)}", ""),
};
vector<Program> programs = {
get<Program>(Program::load(sourceStreams[0])),
get<Program>(Program::load(sourceStreams[1])),
};
vector<shared_ptr<ProgramCache>> caches = {
make_shared<ProgramCache>(programs[0]),
make_shared<ProgramCache>(programs[1]),
};
shared_ptr<FitnessMetric> fitnessMetric = make_shared<FitnessMetricAverage>(vector<shared_ptr<FitnessMetric>>{
[yul-phaser] Require specifying weights for Program::codeSize()
2020-02-29 20:55:32 +00:00
make_shared<ProgramSize>(nullopt, caches[0], CodeWeights{}),
make_shared<ProgramSize>(nullopt, caches[1], CodeWeights{}),
[yul-phaser] Add --show-cache-stats option
2020-02-29 01:14:51 +00:00
});
Population population = Population::makeRandom(fitnessMetric, 2, 0, 5);
AlgorithmRunner runner(population, caches, m_options, m_output);
runner.run(algorithm);
BOOST_TEST(caches[0]->currentRound() == m_options.maxRounds.value());
BOOST_TEST(caches[1]->currentRound() == m_options.maxRounds.value());
CacheStats stats = caches[0]->gatherStats() + caches[1]->gatherStats();
for (size_t i = 0; i < m_options.maxRounds.value() - 1; ++i)
{
BOOST_TEST(nextLineMatches(m_output, regex(".*")));
BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
if (i > 0)
BOOST_TEST(nextLineMatches(m_output, regex(R"(Round\d+:\d+entries)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Round\d+:\d+entries)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalhits:\d+)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalmisses:\d+)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Sizeofcachedcode:\d+)")));
}
BOOST_REQUIRE(stats.roundEntryCounts.size() == 2);
BOOST_REQUIRE(stats.roundEntryCounts.count(m_options.maxRounds.value() - 1) == 1);
BOOST_REQUIRE(stats.roundEntryCounts.count(m_options.maxRounds.value()) == 1);
size_t round = m_options.maxRounds.value();
BOOST_TEST(nextLineMatches(m_output, regex(".*")));
BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
BOOST_TEST(nextLineMatches(m_output, regex("Round" + toString(round - 1) + ":" + toString(stats.roundEntryCounts[round - 1]) + "entries")));
BOOST_TEST(nextLineMatches(m_output, regex("Round" + toString(round) + ":" + toString(stats.roundEntryCounts[round]) + "entries")));
BOOST_TEST(nextLineMatches(m_output, regex("Totalhits:" + toString(stats.hits))));
BOOST_TEST(nextLineMatches(m_output, regex("Totalmisses:" + toString(stats.misses))));
BOOST_TEST(nextLineMatches(m_output, regex("Sizeofcachedcode:" + toString(stats.totalCodeSize))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_print_message_if_cache_stats_requested_but_cache_disabled, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = true;
m_options.showCacheStats = true;
RandomisingAlgorithm algorithm;
AlgorithmRunner runner(m_population, {nullptr}, m_options, m_output);
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, regex(".*")));
BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
BOOST_TEST(nextLineMatches(m_output, regex(stripWhitespace("Program cache disabled"))));
BOOST_TEST(m_output.peek() == EOF);
}
BOOST_FIXTURE_TEST_CASE(run_should_print_partial_stats_and_message_if_some_caches_disabled, AlgorithmRunnerFixture)
{
m_options.maxRounds = 1;
m_options.showInitialPopulation = false;
m_options.showRoundInfo = false;
m_options.showOnlyTopChromosome = true;
m_options.showCacheStats = true;
RandomisingAlgorithm algorithm;
CharStream sourceStream = CharStream("{}", "");
shared_ptr<ProgramCache> cache = make_shared<ProgramCache>(get<Program>(Program::load(sourceStream)));
AlgorithmRunner runner(m_population, {cache, nullptr}, m_options, m_output);
BOOST_REQUIRE(cache->gatherStats().roundEntryCounts.size() == 0);
runner.run(algorithm);
BOOST_TEST(nextLineMatches(m_output, regex(".*")));
BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalhits:\d+)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalmisses:\d+)")));
BOOST_TEST(nextLineMatches(m_output, regex(R"(Sizeofcachedcode:\d+)")));
BOOST_TEST(nextLineMatches(m_output, regex(stripWhitespace("Program cache disabled for 1 out of 2 programs"))));
BOOST_TEST(m_output.peek() == EOF);
}
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_save_initial_population_to_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
{
m_options.maxRounds = 0;
m_options.populationAutosaveFile = m_autosavePath;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
assert(!fs::exists(m_autosavePath));
runner.run(m_algorithm);
assert(runner.population() == m_population);
BOOST_TEST(fs::is_regular_file(m_autosavePath));
BOOST_TEST(readLinesFromFile(m_autosavePath) == chromosomeStrings(runner.population()));
}
BOOST_FIXTURE_TEST_CASE(run_should_save_population_to_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
{
m_options.maxRounds = 1;
m_options.populationAutosaveFile = m_autosavePath;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
assert(!fs::exists(m_autosavePath));
runner.run(m_algorithm);
assert(runner.population() != m_population);
BOOST_TEST(fs::is_regular_file(m_autosavePath));
BOOST_TEST(readLinesFromFile(m_autosavePath) == chromosomeStrings(runner.population()));
}
BOOST_FIXTURE_TEST_CASE(run_should_overwrite_existing_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
{
m_options.maxRounds = 5;
m_options.populationAutosaveFile = m_autosavePath;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
assert(!fs::exists(m_autosavePath));
vector<string> originalContent = {"Original content"};
{
ofstream tmpFile(m_autosavePath);
tmpFile << originalContent[0] << endl;
}
assert(fs::exists(m_autosavePath));
assert(readLinesFromFile(m_autosavePath) == originalContent);
runner.run(m_algorithm);
BOOST_TEST(fs::is_regular_file(m_autosavePath));
BOOST_TEST(readLinesFromFile(m_autosavePath) != originalContent);
}
BOOST_FIXTURE_TEST_CASE(run_should_not_save_population_to_file_if_autosave_file_not_specified, AlgorithmRunnerAutosaveFixture)
{
m_options.maxRounds = 5;
m_options.populationAutosaveFile = nullopt;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(m_population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Population autosave
2020-02-22 00:39:33 +00:00
assert(!fs::exists(m_autosavePath));
runner.run(m_algorithm);
BOOST_TEST(!fs::exists(m_autosavePath));
}
[yul-phaser] AlgorithmRunner: Duplicate chromosome randomisation
2020-02-26 23:40:57 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_randomise_duplicate_chromosomes_if_requested, AlgorithmRunnerFixture)
{
Chromosome duplicate("afc");
Population population(m_fitnessMetric, {duplicate, duplicate, duplicate});
CountingAlgorithm algorithm;
m_options.maxRounds = 1;
m_options.randomiseDuplicates = true;
m_options.minChromosomeLength = 50;
m_options.maxChromosomeLength = 50;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Duplicate chromosome randomisation
2020-02-26 23:40:57 +00:00
runner.run(algorithm);
auto const& newIndividuals = runner.population().individuals();
BOOST_TEST(newIndividuals.size() == 3);
BOOST_TEST((
newIndividuals[0].chromosome == duplicate ||
newIndividuals[1].chromosome == duplicate ||
newIndividuals[2].chromosome == duplicate
));
BOOST_TEST(newIndividuals[0] != newIndividuals[1]);
BOOST_TEST(newIndividuals[0] != newIndividuals[2]);
BOOST_TEST(newIndividuals[1] != newIndividuals[2]);
BOOST_TEST((newIndividuals[0].chromosome.length() == 50 || newIndividuals[0].chromosome == duplicate));
BOOST_TEST((newIndividuals[1].chromosome.length() == 50 || newIndividuals[1].chromosome == duplicate));
BOOST_TEST((newIndividuals[2].chromosome.length() == 50 || newIndividuals[2].chromosome == duplicate));
}
BOOST_FIXTURE_TEST_CASE(run_should_not_randomise_duplicate_chromosomes_if_not_requested, AlgorithmRunnerFixture)
{
Chromosome duplicate("afc");
Population population(m_fitnessMetric, {duplicate, duplicate, duplicate});
CountingAlgorithm algorithm;
m_options.maxRounds = 1;
m_options.randomiseDuplicates = false;
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
AlgorithmRunner runner(population, {}, m_options, m_output);
[yul-phaser] AlgorithmRunner: Duplicate chromosome randomisation
2020-02-26 23:40:57 +00:00
runner.run(algorithm);
BOOST_TEST(runner.population().individuals().size() == 3);
BOOST_TEST(runner.population().individuals()[0].chromosome == duplicate);
BOOST_TEST(runner.population().individuals()[1].chromosome == duplicate);
BOOST_TEST(runner.population().individuals()[2].chromosome == duplicate);
}
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
BOOST_FIXTURE_TEST_CASE(run_should_clear_cache_at_the_beginning_and_update_it_before_each_round, AlgorithmRunnerFixture)
{
CharStream sourceStream = CharStream("{}", current_test_case().p_name);
vector<shared_ptr<ProgramCache>> caches = {
make_shared<ProgramCache>(get<Program>(Program::load(sourceStream))),
make_shared<ProgramCache>(get<Program>(Program::load(sourceStream))),
};
m_options.maxRounds = 10;
[yul-phaser] AlgorithmRunner: Make all tests use population from AlgorithmRunnerFixture
2020-03-08 15:59:14 +00:00
AlgorithmRunner runner(m_population, caches, m_options, m_output);
[yul-phaser] AlgorithmRunner: Add support for ProgramCache
2020-02-26 23:55:24 +00:00
CountingAlgorithm algorithm;
BOOST_TEST(algorithm.m_currentRound == 0);
BOOST_TEST(caches[0]->currentRound() == 0);
BOOST_TEST(caches[1]->currentRound() == 0);
runner.run(algorithm);
BOOST_TEST(algorithm.m_currentRound == 10);
BOOST_TEST(caches[0]->currentRound() == 10);
BOOST_TEST(caches[1]->currentRound() == 10);
runner.run(algorithm);
BOOST_TEST(algorithm.m_currentRound == 20);
BOOST_TEST(caches[0]->currentRound() == 10);
BOOST_TEST(caches[1]->currentRound() == 10);
}
[yul-phaser] Extract the code that controls execution of algorithm rounds from GeneticAlgorithm into AlgorithmRunner
2020-02-21 15:10:07 +00:00
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE_END()
}
Reference in New Issue Copy Permalink