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

Merge pull request #8325 from imapp-pl/yul-phaser-population-tweaks

Browse Source 
[yul-phaser] Miscellaneous Population tweaks and improvements
This commit is contained in:
chriseth 2020-02-19 12:35:10 +01:00 committed by GitHub
commit 357c936243
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 367 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
test/yulPhaser/Chromosome.cpp
View File

@ -21,8 +21,18 @@
#include <tools/yulPhaser/SimulationRNG.h>
#include <libyul/optimiser/BlockFlattener.h>
#include <libyul/optimiser/StructuralSimplifier.h>
#include <libyul/optimiser/ConditionalSimplifier.h>
#include <libyul/optimiser/ExpressionInliner.h>
#include <libyul/optimiser/ExpressionSimplifier.h>
#include <libyul/optimiser/ForLoopConditionOutOfBody.h>
#include <libyul/optimiser/ForLoopConditionOutOfBody.h>
#include <libyul/optimiser/ForLoopInitRewriter.h>
#include <libyul/optimiser/FunctionHoister.h>
#include <libyul/optimiser/LoopInvariantCodeMotion.h>
#include <libyul/optimiser/RedundantAssignEliminator.h>
#include <libyul/optimiser/Rematerialiser.h>
#include <libyul/optimiser/Suite.h>
#include <libyul/optimiser/StructuralSimplifier.h>
#include <libyul/optimiser/UnusedPruner.h>
#include <libsolutil/CommonIO.h>
@ -39,25 +49,49 @@ namespace solidity::phaser::test
BOOST_AUTO_TEST_SUITE(Phaser)
BOOST_AUTO_TEST_SUITE(ChromosomeTest)
BOOST_AUTO_TEST_CASE(makeRandom_should_create_chromosome_with_random_optimisation_steps)
BOOST_AUTO_TEST_CASE(constructor_should_convert_from_string_to_optimisation_steps)
{
constexpr uint32_t numSteps = 1000;
vector<string> expectedSteps{
ConditionalSimplifier::name,
FunctionHoister::name,
RedundantAssignEliminator::name,
ForLoopConditionOutOfBody::name,
Rematerialiser::name,
ForLoopConditionOutOfBody::name,
ExpressionSimplifier::name,
ForLoopInitRewriter::name,
LoopInvariantCodeMotion::name,
ExpressionInliner::name
};
auto chromosome1 = Chromosome::makeRandom(numSteps);
auto chromosome2 = Chromosome::makeRandom(numSteps);
BOOST_CHECK_EQUAL(chromosome1.length(), numSteps);
BOOST_CHECK_EQUAL(chromosome2.length(), numSteps);
BOOST_TEST(Chromosome("ChrOmOsoMe").optimisationSteps() == expectedSteps);
}
multiset<string> steps1;
multiset<string> steps2;
for (auto const& step: chromosome1.optimisationSteps())
steps1.insert(step);
for (auto const& step: chromosome2.optimisationSteps())
steps2.insert(step);
BOOST_AUTO_TEST_CASE(makeRandom_should_return_different_chromosome_each_time)
{
SimulationRNG::reset(1);
for (size_t i = 0; i < 10; ++i)
BOOST_TEST(Chromosome::makeRandom(100) != Chromosome::makeRandom(100));
}
// Check if steps are different and also if they're not just a permutation of the same set.
// Technically they could be the same and still random but the probability is infinitesimally low.
BOOST_TEST(steps1 != steps2);
BOOST_AUTO_TEST_CASE(makeRandom_should_use_every_possible_step_with_the_same_probability)
{
SimulationRNG::reset(1);
constexpr int samplesPerStep = 100;
constexpr double relativeTolerance = 0.01;
map<string, size_t> stepIndices = enumerateOptmisationSteps();
auto chromosome = Chromosome::makeRandom(stepIndices.size() * samplesPerStep);
vector<size_t> samples;
for (auto& step: chromosome.optimisationSteps())
samples.push_back(stepIndices.at(step));
const double expectedValue = (stepIndices.size() - 1) / 2.0;
const double variance = (stepIndices.size() * stepIndices.size() - 1) / 12.0;
BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
}
BOOST_AUTO_TEST_CASE(constructor_should_store_optimisation_steps)

17
test/yulPhaser/Common.cpp
View File

@ -19,10 +19,21 @@
#include <libyul/optimiser/Suite.h>
#include <regex>
using namespace std;
using namespace solidity;
using namespace solidity::yul;
vector<size_t> phaser::test::chromosomeLengths(Population const& _population)
{
vector<size_t> lengths;
for (auto const& individual: _population.individuals())
lengths.push_back(individual.chromosome.length());
return lengths;
}
map<string, size_t> phaser::test::enumerateOptmisationSteps()
{
map<string, size_t> stepIndices;
@ -32,3 +43,9 @@ map<string, size_t> phaser::test::enumerateOptmisationSteps()
return stepIndices;
}
string phaser::test::stripWhitespace(string const& input)
{
regex whitespaceRegex("\\s+");
return regex_replace(input, whitespaceRegex, "");
}

11
test/yulPhaser/Common.h
View File

@ -28,6 +28,8 @@
#pragma once
#include <tools/yulPhaser/Population.h>
#include <cassert>
#include <map>
#include <string>
@ -37,11 +39,20 @@ namespace solidity::phaser::test
{
// CHROMOSOME AND POPULATION HELPERS
/// Returns a vector containing lengths of all chromosomes in the population (in the same order).
std::vector<size_t> chromosomeLengths(Population const& _population);
/// Assigns indices from 0 to N to all optimisation steps available in the OptimiserSuite.
/// This is a convenience helper to make it easier to test their distribution with tools made for
/// integers.
std::map<std::string, size_t> enumerateOptmisationSteps();
// STRING UTILITIES
/// Returns the input string with all the whitespace characters (spaces, line endings, etc.) removed.
std::string stripWhitespace(std::string const& input);
// STATISTICAL UTILITIES
/// Calculates the mean value of a series of samples given in a vector.

29
test/yulPhaser/CommonTest.cpp
View File

@ -19,11 +19,14 @@
#include <libyul/optimiser/Suite.h>
#include <liblangutil/CharStream.h>
#include <boost/test/unit_test.hpp>
#include <set>
using namespace std;
using namespace solidity::langutil;
using namespace solidity::yul;
using namespace boost::test_tools;
@ -33,6 +36,18 @@ namespace solidity::phaser::test
BOOST_AUTO_TEST_SUITE(Phaser)
BOOST_AUTO_TEST_SUITE(CommonTest)
BOOST_AUTO_TEST_CASE(chromosomeLengths_should_return_lengths_of_all_chromosomes_in_a_population)
{
CharStream sourceStream("{}", "");
auto program = Program::load(sourceStream);
Population population1(program, {Chromosome(), Chromosome("a"), Chromosome("aa"), Chromosome("aaa")});
BOOST_TEST((chromosomeLengths(population1) == vector<size_t>{0, 1, 2, 3}));
Population population2(program);
BOOST_TEST((chromosomeLengths(population2) == vector<size_t>{}));
}
BOOST_AUTO_TEST_CASE(enumerateOptimisationSteps_should_assing_indices_to_all_available_optimisation_steps)
{
map<string, char> stepsAndAbbreviations = OptimiserSuite::stepNameToAbbreviationMap();
@ -51,6 +66,20 @@ BOOST_AUTO_TEST_CASE(enumerateOptimisationSteps_should_assing_indices_to_all_ava
}
}
BOOST_AUTO_TEST_CASE(stripWhitespace_should_remove_all_whitespace_characters_from_a_string)
{
BOOST_TEST(stripWhitespace("") == "");
BOOST_TEST(stripWhitespace(" ") == "");
BOOST_TEST(stripWhitespace(" \n\t\v ") == "");
BOOST_TEST(stripWhitespace("abc") == "abc");
BOOST_TEST(stripWhitespace(" abc") == "abc");
BOOST_TEST(stripWhitespace("abc ") == "abc");
BOOST_TEST(stripWhitespace(" a b c ") == "abc");
BOOST_TEST(stripWhitespace(" a b\tc\n") == "abc");
BOOST_TEST(stripWhitespace(" a b \n\n c \n\t\v") == "abc");
}
BOOST_AUTO_TEST_CASE(mean_should_calculate_statistical_mean)
{
BOOST_TEST(mean<int>({0}) == 0.0);

215
test/yulPhaser/Population.cpp
View File

@ -15,6 +15,8 @@
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
#include <test/yulPhaser/Common.h>
#include <tools/yulPhaser/Chromosome.h>
#include <tools/yulPhaser/Population.h>
#include <tools/yulPhaser/Program.h>
@ -53,40 +55,80 @@ namespace
}
}
class PopulationFixture
{
protected:
PopulationFixture():
m_sourceStream(SampleSourceCode, ""),
m_program(Program::load(m_sourceStream)) {}
static constexpr char SampleSourceCode[] =
"{\n"
" let factor := 13\n"
" {\n"
" if factor\n"
" {\n"
" let variable := add(1, 2)\n"
" }\n"
" let result := factor\n"
" }\n"
" let something := 6\n"
" {\n"
" {\n"
" {\n"
" let value := 15\n"
" }\n"
" }\n"
" }\n"
" let something_else := mul(mul(something, 1), add(factor, 0))\n"
" if 1 { let x := 1 }\n"
" if 0 { let y := 2 }\n"
"}\n";
CharStream m_sourceStream;
Program m_program;
};
BOOST_AUTO_TEST_SUITE(Phaser)
BOOST_AUTO_TEST_SUITE(PopulationTest)
string const& sampleSourceCode =
"{\n"
" let factor := 13\n"
" {\n"
" if factor\n"
" {\n"
" let variable := add(1, 2)\n"
" }\n"
" let result := factor\n"
" }\n"
" let something := 6\n"
" {\n"
" {\n"
" {\n"
" let value := 15\n"
" }\n"
" }\n"
" }\n"
" let something_else := mul(mul(something, 1), add(factor, 0))\n"
" if 1 { let x := 1 }\n"
" if 0 { let y := 2 }\n"
"}\n";
BOOST_AUTO_TEST_CASE(constructor_should_copy_chromosomes_and_not_compute_fitness)
BOOST_AUTO_TEST_CASE(isFitter_should_use_fitness_as_the_main_criterion)
{
BOOST_TEST(isFitter(Individual{Chromosome("a"), 5}, Individual{Chromosome("a"), 10}));
BOOST_TEST(!isFitter(Individual{Chromosome("a"), 10}, Individual{Chromosome("a"), 5}));
BOOST_TEST(isFitter(Individual{Chromosome("aaa"), 5}, Individual{Chromosome("aaaaa"), 10}));
BOOST_TEST(!isFitter(Individual{Chromosome("aaaaa"), 10}, Individual{Chromosome("aaa"), 5}));
BOOST_TEST(isFitter(Individual{Chromosome("aaaaa"), 5}, Individual{Chromosome("aaa"), 10}));
BOOST_TEST(!isFitter(Individual{Chromosome("aaa"), 10}, Individual{Chromosome("aaaaa"), 5}));
}
BOOST_AUTO_TEST_CASE(isFitter_should_use_alphabetical_order_when_fitness_is_the_same)
{
BOOST_TEST(isFitter(Individual{Chromosome("a"), 3}, Individual{Chromosome("c"), 3}));
BOOST_TEST(!isFitter(Individual{Chromosome("c"), 3}, Individual{Chromosome("a"), 3}));
BOOST_TEST(isFitter(Individual{Chromosome("a"), 3}, Individual{Chromosome("aa"), 3}));
BOOST_TEST(!isFitter(Individual{Chromosome("aa"), 3}, Individual{Chromosome("a"), 3}));
BOOST_TEST(isFitter(Individual{Chromosome("T"), 3}, Individual{Chromosome("a"), 3}));
BOOST_TEST(!isFitter(Individual{Chromosome("a"), 3}, Individual{Chromosome("T"), 3}));
}
BOOST_AUTO_TEST_CASE(isFitter_should_return_false_for_identical_individuals)
{
BOOST_TEST(!isFitter(Individual{Chromosome("a"), 3}, Individual{Chromosome("a"), 3}));
BOOST_TEST(!isFitter(Individual{Chromosome("acT"), 0}, Individual{Chromosome("acT"), 0}));
}
BOOST_FIXTURE_TEST_CASE(constructor_should_copy_chromosomes_and_not_compute_fitness, PopulationFixture)
{
CharStream sourceStream(sampleSourceCode, current_test_case().p_name);
vector<Chromosome> chromosomes = {
Chromosome::makeRandom(5),
Chromosome::makeRandom(10),
};
Population population(Program::load(sourceStream), chromosomes);
Population population(m_program, chromosomes);
BOOST_TEST(population.individuals().size() == 2);
BOOST_TEST(population.individuals()[0].chromosome == chromosomes[0]);
@ -96,40 +138,88 @@ BOOST_AUTO_TEST_CASE(constructor_should_copy_chromosomes_and_not_compute_fitness
BOOST_TEST(all_of(population.individuals().begin(), population.individuals().end(), fitnessNotSet));
}
BOOST_AUTO_TEST_CASE(makeRandom_should_return_population_with_random_chromosomes)
BOOST_FIXTURE_TEST_CASE(makeRandom_should_get_chromosome_lengths_from_specified_generator, PopulationFixture)
{
CharStream sourceStream(sampleSourceCode, current_test_case().p_name);
auto program = Program::load(sourceStream);
auto population1 = Population::makeRandom(program, 100);
auto population2 = Population::makeRandom(program, 100);
size_t chromosomeCount = 30;
size_t maxLength = 5;
assert(chromosomeCount % maxLength == 0);
BOOST_TEST(population1.individuals().size() == 100);
BOOST_TEST(population2.individuals().size() == 100);
auto nextLength = [counter = 0, maxLength]() mutable { return counter++ % maxLength; };
auto population = Population::makeRandom(m_program, chromosomeCount, nextLength);
int numMatchingPositions = 0;
for (size_t i = 0; i < 100; ++i)
if (population1.individuals()[i].chromosome == population2.individuals()[i].chromosome)
++numMatchingPositions;
// Assume that the results are random if there are no more than 10 identical chromosomes on the
// same positions. One duplicate is very unlikely but still possible after billions of runs
// (especially for short chromosomes). For ten the probability is so small that we can ignore it.
BOOST_TEST(numMatchingPositions < 10);
// We can't rely on the order since the population sorts its chromosomes immediately but
// we can check the number of occurrences of each length.
for (size_t length = 0; length < maxLength; ++length)
BOOST_TEST(
count_if(
population.individuals().begin(),
population.individuals().end(),
[&length](auto const& individual) { return individual.chromosome.length() == length; }
) == chromosomeCount / maxLength
);
}
BOOST_AUTO_TEST_CASE(makeRandom_should_not_compute_fitness)
BOOST_FIXTURE_TEST_CASE(makeRandom_should_get_chromosome_lengths_from_specified_range, PopulationFixture)
{
CharStream sourceStream(sampleSourceCode, current_test_case().p_name);
auto population = Population::makeRandom(Program::load(sourceStream), 5);
auto population = Population::makeRandom(m_program, 100, 5, 10);
BOOST_TEST(all_of(
population.individuals().begin(),
population.individuals().end(),
[](auto const& individual){ return 5 <= individual.chromosome.length() && individual.chromosome.length() <= 10; }
));
}
BOOST_FIXTURE_TEST_CASE(makeRandom_should_use_random_chromosome_length, PopulationFixture)
{
SimulationRNG::reset(1);
constexpr int populationSize = 200;
constexpr int minLength = 5;
constexpr int maxLength = 10;
constexpr double relativeTolerance = 0.05;
auto population = Population::makeRandom(m_program, populationSize, minLength, maxLength);
vector<size_t> samples = chromosomeLengths(population);
const double expectedValue = (maxLength + minLength) / 2.0;
const double variance = ((maxLength - minLength + 1) * (maxLength - minLength + 1) - 1) / 12.0;
BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
}
BOOST_FIXTURE_TEST_CASE(makeRandom_should_return_population_with_random_chromosomes, PopulationFixture)
{
SimulationRNG::reset(1);
constexpr int populationSize = 100;
constexpr int chromosomeLength = 30;
constexpr double relativeTolerance = 0.01;
map<string, size_t> stepIndices = enumerateOptmisationSteps();
auto population = Population::makeRandom(m_program, populationSize, chromosomeLength, chromosomeLength);
vector<size_t> samples;
for (auto& individual: population.individuals())
for (auto& step: individual.chromosome.optimisationSteps())
samples.push_back(stepIndices.at(step));
const double expectedValue = (stepIndices.size() - 1) / 2.0;
const double variance = (stepIndices.size() * stepIndices.size() - 1) / 12.0;
BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
}
BOOST_FIXTURE_TEST_CASE(makeRandom_should_not_compute_fitness, PopulationFixture)
{
auto population = Population::makeRandom(m_program, 3, 5, 10);
BOOST_TEST(all_of(population.individuals().begin(), population.individuals().end(), fitnessNotSet));
}
BOOST_AUTO_TEST_CASE(run_should_evaluate_fitness)
BOOST_FIXTURE_TEST_CASE(run_should_evaluate_fitness, PopulationFixture)
{
stringstream output;
CharStream sourceStream(sampleSourceCode, current_test_case().p_name);
auto population = Population::makeRandom(Program::load(sourceStream), 5);
auto population = Population::makeRandom(m_program, 5, 5, 10);
assert(all_of(population.individuals().begin(), population.individuals().end(), fitnessNotSet));
population.run(1, output);
@ -137,23 +227,21 @@ BOOST_AUTO_TEST_CASE(run_should_evaluate_fitness)
BOOST_TEST(all_of(population.individuals().begin(), population.individuals().end(), fitnessSet));
}
BOOST_AUTO_TEST_CASE(run_should_not_make_fitness_of_top_chromosomes_worse)
BOOST_FIXTURE_TEST_CASE(run_should_not_make_fitness_of_top_chromosomes_worse, PopulationFixture)
{
stringstream output;
CharStream sourceStream(sampleSourceCode, current_test_case().p_name);
vector<Chromosome> chromosomes = {
Chromosome({StructuralSimplifier::name}),
Chromosome({BlockFlattener::name}),
Chromosome({SSAReverser::name}),
Chromosome({UnusedPruner::name}),
Chromosome({StructuralSimplifier::name, BlockFlattener::name}),
Chromosome(vector<string>{StructuralSimplifier::name}),
Chromosome(vector<string>{BlockFlattener::name}),
Chromosome(vector<string>{SSAReverser::name}),
Chromosome(vector<string>{UnusedPruner::name}),
Chromosome(vector<string>{StructuralSimplifier::name, BlockFlattener::name}),
};
auto program = Program::load(sourceStream);
Population population(program, chromosomes);
Population population(m_program, chromosomes);
size_t initialTopFitness[2] = {
Population::measureFitness(chromosomes[0], program),
Population::measureFitness(chromosomes[1], program),
Population::measureFitness(chromosomes[0], m_program),
Population::measureFitness(chromosomes[1], m_program),
};
for (int i = 0; i < 6; ++i)
@ -173,6 +261,15 @@ BOOST_AUTO_TEST_CASE(run_should_not_make_fitness_of_top_chromosomes_worse)
}
}
BOOST_FIXTURE_TEST_CASE(plus_operator_should_add_two_populations, PopulationFixture)
{
BOOST_CHECK_EQUAL(
Population(m_program, {Chromosome("ac"), Chromosome("cx")}) +
Population(m_program, {Chromosome("g"), Chromosome("h"), Chromosome("iI")}),
Population(m_program, {Chromosome("ac"), Chromosome("cx"), Chromosome("g"), Chromosome("h"), Chromosome("iI")})
);
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE_END()

9
test/yulPhaser/Program.cpp
View File

@ -15,6 +15,8 @@
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
#include <test/yulPhaser/Common.h>
#include <tools/yulPhaser/Exceptions.h>
#include <tools/yulPhaser/Program.h>
@ -30,7 +32,6 @@
#include <boost/test/unit_test.hpp>
#include <cassert>
#include <regex>
#include <string>
using namespace std;
@ -51,12 +52,6 @@ namespace
else
return _block;
}
string stripWhitespace(string const& input)
{
regex whitespaceRegex("\\s+");
return regex_replace(input, whitespaceRegex, "");
}
}
namespace solidity::phaser::test

6
tools/yulPhaser/Chromosome.cpp
View File

@ -36,6 +36,12 @@ ostream& operator<<(ostream& _stream, Chromosome const& _chromosome);
}
Chromosome::Chromosome(string const& _optimisationSteps)
{
for (char abbreviation: _optimisationSteps)
m_optimisationSteps.push_back(OptimiserSuite::stepAbbreviationToNameMap().at(abbreviation));
}
Chromosome Chromosome::makeRandom(size_t _length)
{
vector<string> steps;

1
tools/yulPhaser/Chromosome.h
View File

@ -42,6 +42,7 @@ public:
Chromosome() = default;
explicit Chromosome(std::vector<std::string> _optimisationSteps):
m_optimisationSteps(std::move(_optimisationSteps)) {}
explicit Chromosome(std::string const& _optimisationSteps);
static Chromosome makeRandom(size_t _length);
size_t length() const { return m_optimisationSteps.size(); }

61
tools/yulPhaser/Population.cpp
View File

@ -19,14 +19,17 @@
#include <tools/yulPhaser/Program.h>
#include <libsolutil/CommonData.h>
#include <libsolutil/CommonIO.h>
#include <algorithm>
#include <cassert>
#include <iostream>
#include <numeric>
using namespace std;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::util;
using namespace solidity::phaser;
namespace solidity::phaser
@ -49,6 +52,17 @@ ostream& phaser::operator<<(ostream& _stream, Individual const& _individual)
return _stream;
}
bool phaser::isFitter(Individual const& a, Individual const& b)
{
assert(a.fitness.has_value() && b.fitness.has_value());
return (
(a.fitness.value() < b.fitness.value()) ||
(a.fitness.value() == b.fitness.value() && a.chromosome.length() < b.chromosome.length()) ||
(a.fitness.value() == b.fitness.value() && a.chromosome.length() == b.chromosome.length() && toString(a.chromosome) < toString(b.chromosome))
);
}
Population::Population(Program _program, vector<Chromosome> const& _chromosomes):
m_program{move(_program)}
{
@ -56,15 +70,33 @@ Population::Population(Program _program, vector<Chromosome> const& _chromosomes)
m_individuals.push_back({chromosome});
}
Population Population::makeRandom(Program _program, size_t _size)
Population Population::makeRandom(
Program _program,
size_t _size,
function<size_t()> _chromosomeLengthGenerator
)
{
vector<Individual> individuals;
for (size_t i = 0; i < _size; ++i)
individuals.push_back({Chromosome::makeRandom(randomChromosomeLength())});
individuals.push_back({Chromosome::makeRandom(_chromosomeLengthGenerator())});
return Population(move(_program), individuals);
}
Population Population::makeRandom(
Program _program,
size_t _size,
size_t _minChromosomeLength,
size_t _maxChromosomeLength
)
{
return makeRandom(
move(_program),
_size,
std::bind(uniformChromosomeLength, _minChromosomeLength, _maxChromosomeLength)
);
}
size_t Population::measureFitness(Chromosome const& _chromosome, Program const& _program)
{
Program programCopy = _program;
@ -86,6 +118,20 @@ void Population::run(optional<size_t> _numRounds, ostream& _outputStream)
}
}
Population operator+(Population _a, Population _b)
{
assert(toString(_a.m_program) == toString(_b.m_program));
return Population(_a.m_program, move(_a.m_individuals) + move(_b.m_individuals));
}
bool Population::operator==(Population const& _other) const
{
// TODO: Comparing programs is pretty heavy but it's just a stopgap. It will soon be replaced
// by a comparison of fitness metric associated with the population (once metrics are introduced).
return m_individuals == _other.m_individuals && toString(m_program) == toString(_other.m_program);
}
ostream& phaser::operator<<(ostream& _stream, Population const& _population)
{
auto individual = _population.m_individuals.begin();
@ -111,12 +157,7 @@ void Population::doSelection()
{
assert(all_of(m_individuals.begin(), m_individuals.end(), [](auto& i){ return i.fitness.has_value(); }));
sort(
m_individuals.begin(),
m_individuals.end(),
[](auto const& a, auto const& b){ return a.fitness.value() < b.fitness.value(); }
);
sort(m_individuals.begin(), m_individuals.end(), isFitter);
randomizeWorstChromosomes(m_individuals, m_individuals.size() / 2);
}
@ -131,6 +172,6 @@ void Population::randomizeWorstChromosomes(
auto individual = _individuals.begin() + (_individuals.size() - _count);
for (; individual != _individuals.end(); ++individual)
{
*individual = {Chromosome::makeRandom(randomChromosomeLength())};
*individual = {Chromosome::makeRandom(binomialChromosomeLength(MaxChromosomeLength))};
}
}

41
tools/yulPhaser/Population.h
View File

@ -28,6 +28,17 @@
namespace solidity::phaser
{
class Population;
}
// This operator+ must be declared in the global namespace. Otherwise it would shadow global
// operator+ overloads from CommonData.h (e.g. the one for vector) in the namespace it was declared in.
solidity::phaser::Population operator+(solidity::phaser::Population _a, solidity::phaser::Population _b);
namespace solidity::phaser
{
/**
* Information describing the state of an individual member of the population during the course
* of the genetic algorithm.
@ -37,9 +48,17 @@ struct Individual
Chromosome chromosome;
std::optional<size_t> fitness = std::nullopt;
bool operator==(Individual const& _other) const { return fitness == _other.fitness && chromosome == _other.chromosome; }
bool operator!=(Individual const& _other) const { return !(*this == _other); }
friend std::ostream& operator<<(std::ostream& _stream, Individual const& _individual);
};
/// Determines which individual is better by comparing fitness values. If fitness is the same
/// takes into account all the other properties of the individual to make the comparison
/// deterministic as long as the individuals are not equal.
bool isFitter(Individual const& a, Individual const& b);
/**
* Represents a changing set of individuals undergoing a genetic algorithm.
* Each round of the algorithm involves mutating existing individuals, evaluating their fitness
@ -55,19 +74,35 @@ public:
static constexpr size_t MaxChromosomeLength = 30;
explicit Population(Program _program, std::vector<Chromosome> const& _chromosomes = {});
static Population makeRandom(Program _program, size_t _size);
static Population makeRandom(
Program _program,
size_t _size,
std::function<size_t()> _chromosomeLengthGenerator
);
static Population makeRandom(
Program _program,
size_t _size,
size_t _minChromosomeLength,
size_t _maxChromosomeLength
);
void run(std::optional<size_t> _numRounds, std::ostream& _outputStream);
friend Population (::operator+)(Population _a, Population _b);
std::vector<Individual> const& individuals() const { return m_individuals; }
static size_t randomChromosomeLength() { return SimulationRNG::binomialInt(MaxChromosomeLength, 0.5); }
static size_t uniformChromosomeLength(size_t _min, size_t _max) { return SimulationRNG::uniformInt(_min, _max); }
static size_t binomialChromosomeLength(size_t _max) { return SimulationRNG::binomialInt(_max, 0.5); }
static size_t measureFitness(Chromosome const& _chromosome, Program const& _program);
bool operator==(Population const& _other) const;
bool operator!=(Population const& _other) const { return !(*this == _other); }
friend std::ostream& operator<<(std::ostream& _stream, Population const& _population);
private:
explicit Population(Program _program, std::vector<Individual> _individuals = {}):
explicit Population(Program _program, std::vector<Individual> _individuals):
m_program{std::move(_program)},
m_individuals{std::move(_individuals)} {}

7
tools/yulPhaser/main.cpp
View File

@ -28,6 +28,7 @@
#include <boost/program_options.hpp>
#include <iostream>
#include <functional>
#include <string>
using namespace std;
@ -70,7 +71,11 @@ CharStream loadSource(string const& _sourcePath)
void runAlgorithm(string const& _sourcePath)
{
CharStream sourceCode = loadSource(_sourcePath);
auto population = Population::makeRandom(Program::load(sourceCode), 10);
auto population = Population::makeRandom(
Program::load(sourceCode),
10,
bind(Population::binomialChromosomeLength, Population::MaxChromosomeLength)
);
population.run(nullopt, cout);
}