FT Namespace Reference

Namespace for everything linked to Fault tolerance aspects. More...

Classes
class	Cheater
	This class modelize a generic cheater and is used as a base class for specialized cheaters. A cheat interviene at different granularity of tasks. More...
class	BernouilliCheater
class	ExponentialCheater
Enumerations
enum	eprng_t {   PRNG_RAND,   PRNG_RAND48,   PRNG_MT19937 }
	Pseudo random generator to be used -- see http://www.boost.org/libs/random/random-generators.html. More...
enum	edistribution_t {   UNIFORM,   EXPONENTIAL,   REVERSE_EXPONENTIAL,   NORMAL,   LOGNORMAL,   UNDEFINED }
	Distribution to be used -- see http://www.boost.org/libs/random/random-distributions.html. More...
enum	task_level_t {   NO_TASK_LEVEL = 0x0u,   TASK_LEVEL_0 = 0x1u,   TASK_LEVEL_1 = 0x2u,   ANY_TASK_LEVEL = 0xFFu }
enum	task_type_t {   TASK_GENERATE = 0x1u,   TASK_ASSIGN_INPUT_VALUE_TO_TERMINALS = 0x2u,   TASK_EVALUATE = 0x4u,   TASK_FITNESS = 0x8u,   TASK_ELITISM = 0x10u,   TASK_RUN_SINGLE_GENERATION = 0x20u,   TASK_TOURNAMENT_SELECTION = 0x40u,   TASK_INDIVIDUAL_OPERATOR = 0x80u,   ALL_TASKS = 0xFFu }
enum	cheat_mode_t {   CHEAT_UNIFORM,   CHEAT_OVER_GENERATIONS,   CHEAT_OVER_SEQUENTIAL_ORDER }
Functions
std::ostream &	operator<< (std::ostream &os, const eprng_t prng)
std::ostream &	operator<< (std::ostream &os, const edistribution_t d)
std::ostream &	operator<< (std::ostream &os, const task_level_t c)
std::ostream &	operator<< (std::ostream &os, const task_type_t t)
std::ostream &	operator<< (std::ostream &os, const cheat_mode_t t)
template<class T >
std::ostream &	operator<< (std::ostream &os, const Cheater< T > &c)
template<class T >
std::ostream &	operator<< (std::ostream &os, const BernouilliCheater< T > &c)
template<class T >
std::ostream &	operator<< (std::ostream &os, const ExponentialCheater< T > &c)
Variables
const size_t	LEVEL_0_WIDTH = 6

---

Detailed Description

Namespace for everything linked to Fault tolerance aspects.

---

Enumeration Type Documentation

enum FT::cheat_mode_t

Enumerator:

CHEAT_UNIFORM	uniform cheat: don't care about the direction of the cheat
CHEAT_OVER_GENERATIONS	use distribution to decide about cheating using the current generation
CHEAT_OVER_SEQUENTIAL_ORDER	use distribution to decide about cheating using the current task position in the sequential order

enum FT::edistribution_t

Distribution to be used -- see http://www.boost.org/libs/random/random-distributions.html.

Enumerator:

UNIFORM	uniform distribution -- corresponds to boost::uniform_real
EXPONENTIAL	exponential distribution -- boost::exponential_distribution
REVERSE_EXPONENTIAL	reverse exponention (i.e 1 - exp())
NORMAL	normal (gaussian) distribution -- corresponds to boost::normal_distribution
LOGNORMAL	lognormal distribution -- corresponds to boost::lognormal_distribution
UNDEFINED

enum FT::eprng_t

Pseudo random generator to be used -- see http://www.boost.org/libs/random/random-generators.html.

            Macro                   prng affected to the prng_t type
       +--------------+----------------------+
       | PRNG_RAND    |   boost::minstd_rand | Linear congruential algorithm
       | PRNG_RAND48  |   boost::rand48      | Linear congruential algorithm
       | PRNG_MT19937 |   boost::mt19937     | Mersenne Twister
       +--------------+----------------------+
       

Enumerator:

PRNG_RAND	corresponds to boost::minstd_rand -- Linear congruential algorithm
PRNG_RAND48	corresponds to boost::rand48 -- Linear congruential algorithm
PRNG_MT19937	corresponds to boost::mt19937 -- Mersenne Twister

enum FT::task_level_t

Granularity of the tasks considered (TASK_LEVEL_0 corresponds to the tasks right under main typically). Two levels are considered here:

• TASK_LEVEL_0 : This includes the tasks that are run under the main function typically (in the KAAPI vision). The affected fonctions respect the following algorithm:

     Population pop();
     pop.generate();          // CHEAT possible
     pop.evaluate();          // CHEAT possible
     pop.calculateFitness();  // CHEAT possible
     while (1) {
         pop.runGeneration();    // CHEAT possible
         pop.evaluate();         // CHEAT possible
         pop.calculateFitness(); // CHEAT possible
         do something for if pop.getBest().getFitness() == maxFitness // CHEAT possible?
     }

• TASK_LEVEL_1 : This goes one step further in the decomposition of the tasks. Here are the details:

       //Population pop();
       // pop.generate();         
       for_each ind in population: generate(ind->chromosome())
       //pop.evaluate();       
       for all data_sample in learning set (input/output values)
           set_terminals(data_sample.input) // use input values
           for_each ind in population: 
           ind.evaluate(data_sample.output)
       //pop.calculateFitness();  
       for_each ind in population: ind.calculateFitness()
       while (1) {
           //pop.runGeneration(); 
     pick the elite (i.e copy the best)
     temp_pop = tournamentSelection(pop) (2 players until temp_pop is fed)
     apply OneIndividual operator to temp_pop
     apply TwoIndividual operator to temp_pop
     replace first ind of temp_pop (NOT sorted) with elite
     pop = temp_pop
           //pop.evaluate();      
           cf previous description
     // pop.calculateFitness();
           cf previous description
     do something for if pop.getBest().getFitness() == maxFitness // CHEAT possible?
       }
  

Enumerator:

NO_TASK_LEVEL	cheat at no level
TASK_LEVEL_0	level 0 (just under main)
TASK_LEVEL_1	level 1
ANY_TASK_LEVEL	any level (less efficient for the attacker point of view)

enum FT::task_type_t

type (i.e name) of the task considered for cheating.

Enumerator:

TASK_GENERATE
TASK_ASSIGN_INPUT_VALUE_TO_TERMINALS
TASK_EVALUATE
TASK_FITNESS
TASK_ELITISM
TASK_RUN_SINGLE_GENERATION
TASK_TOURNAMENT_SELECTION
TASK_INDIVIDUAL_OPERATOR
ALL_TASKS

---

Function Documentation

template<class T >

std::ostream& FT::operator<<	(	std::ostream &	os,
		const ExponentialCheater< T > &	c
	)			[inline]

template<class T >

std::ostream& FT::operator<<	(	std::ostream &	os,
		const BernouilliCheater< T > &	c
	)			[inline]

template<class T >

std::ostream& FT::operator<<	(	std::ostream &	os,
		const Cheater< T > &	c
	)			[inline]

std::ostream & FT::operator<<	(	std::ostream &	os,
		const cheat_mode_t	t
	)

std::ostream & FT::operator<<	(	std::ostream &	os,
		const task_type_t	t
	)

std::ostream & FT::operator<<	(	std::ostream &	os,
		const task_level_t	c
	)

std::ostream & FT::operator<<	(	std::ostream &	os,
		const edistribution_t	d
	)

std::ostream & FT::operator<<	(	std::ostream &	os,
		const eprng_t	prng
	)

---

Variable Documentation

const size_t FT::LEVEL_0_WIDTH = 6

number of tasks in a critical path for level 0 of tasks (right under