pelib::crown Namespace Reference

Classes
class	CrownUtil
Functions
float	quality_simple (const Algebra &schedule)
float	quality_idle (const Algebra &schedule)
float	quality_off (const Algebra &schedule)
float	quality_generic (const Algebra &schedule)
Algebra	neighbor_allocation (const Algebra &solution, float tasks, float cores)
Algebra	neighbor_allocation_full (const Algebra &solution, float distance)
Algebra	neighbor_allocation_tasks (const Algebra &solution, float distance)
Algebra	neighbor_allocation_cores (const Algebra &solution, float distance)
Algebra	neighbor_efficiency (const Algebra &solution, float distance)
Algebra	annealing (const Algebra &initial, const Algebra &initial_best, float(*quality)(const Algebra &solution), Algebra(*neighbor)(const Algebra &solution, float distance), float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
float	annealing_complexity (float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_annealing_allocation_simple (const Algebra &initial, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_annealing_allocation_idle (const Algebra &initial, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_annealing_allocation_off (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_simple (const Algebra &schedule, unsigned int precision)
Algebra	crown_binary_idle (const Algebra &schedule, unsigned int precision)
Algebra	crown_binary_off (const Algebra &schedule, unsigned int precision)
Algebra	crown_binary (const Algebra &schedule, unsigned int precision)
Algebra	crown_binary_annealing_allocation_simple (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_annealing_allocation_idle (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_annealing_allocation_off (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_annealing_efficiency_simple (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_annealing_efficiency_idle (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
Algebra	crown_binary_annealing_efficiency_off (const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)
float	crown_binary_complexity (const Algebra &schedule, unsigned int precision=0)

---

Function Documentation

Algebra pelib::crown::annealing	(	const Algebra &	initial,
		const Algebra &	initial_best,
		float(*)(const Algebra &solution)	quality,
		Algebra(*)(const Algebra &solution, float distance)	neighbor,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run simulating annealing and produce a copy of the initial solution and add the allocation vector wi

float pelib::crown::annealing_complexity	(	float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Returns time in the number of instruction as counter by a time complexity analysis, to run simulated annealing with the input problem and parameters

Algebra pelib::crown::crown_annealing_allocation_idle	(	const Algebra &	initial,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model including energy consumed by processors at idle time.

Algebra pelib::crown::crown_annealing_allocation_off	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model excluding the energy consumed by processors at idle time.

Algebra pelib::crown::crown_annealing_allocation_simple	(	const Algebra &	initial,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and the "simple" energy model.

Algebra pelib::crown::crown_binary	(	const Algebra &	schedule,
		unsigned int	precision
	)

Run binary search to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and a generic energy model depending on scalars alpha, alpha-static, zeta and epsilon.

Algebra pelib::crown::crown_binary_annealing_allocation_idle	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model including energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_annealing_allocation_off	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model excluding the energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_annealing_allocation_simple	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and the "simple" energy model.

Algebra pelib::crown::crown_binary_annealing_efficiency_idle	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing on task minimal efficiency, to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model including energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_annealing_efficiency_off	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing on task minimal efficiency, to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model excluding the energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_annealing_efficiency_simple	(	const Algebra &	schedule,
		float	temperature,
		float	cooling,
		float	final,
		int	max_transform,
		int	max_new_state,
		float	distance
	)

Run binary search and simulated annealing on task minimal efficiency, to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and the "simple" energy model.

float pelib::crown::crown_binary_complexity	(	const Algebra &	schedule,
		unsigned int	precision = 0
	)

Return the complexity in number of (virtual) instructions of binary search to compute an allocation for an input problem

Algebra pelib::crown::crown_binary_idle	(	const Algebra &	schedule,
		unsigned int	precision
	)

Run binary search to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model including energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_off	(	const Algebra &	schedule,
		unsigned int	precision
	)

Run binary search to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and an energy model excluding the energy consumed by processors at idle time.

Algebra pelib::crown::crown_binary_simple	(	const Algebra &	schedule,
		unsigned int	precision
	)

Run binary search to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and the "simple" energy model.

Algebra pelib::crown::neighbor_allocation	(	const Algebra &	solution,
		float	tasks,
		float	cores
	)

Compute a new allocation within the distance in number of task and number of cores allocated

Parameters:

task	Proportion, between 0 and 1, of the number of tasks whose allocation can change. At least one task is selected for change.
core	Proportion, between 0 and 1, of the maximal number of core that can be added or removed to tasks transformed. Each task transformed is added or removed at least one core.

Algebra pelib::crown::neighbor_allocation_cores	(	const Algebra &	solution,
		float	distance
	)

Compute a neighbor solution where distance only influcen the number of core a task can be added or removed. Only one task is transformed.

Algebra pelib::crown::neighbor_allocation_full	(	const Algebra &	solution,
		float	distance
	)

Compute a neighbor solution where distance influence both the number of tasks transformed and the number of cores a task can be added or removed.

Algebra pelib::crown::neighbor_allocation_tasks	(	const Algebra &	solution,
		float	distance
	)

Compute a neighbor solution where distance only influence the number of tasks transformed. Their allocation can only change by one core.

Algebra pelib::crown::neighbor_efficiency	(	const Algebra &	solution,
		float	distance
	)

Compute a neighbor allocation by influencing the minimal efficiency of tasks begin transformed.

float pelib::crown::quality_generic

(

const Algebra &

schedule

)

Compute the energy consumption of a input schedule using a generic energy model parametrized with scalars alpha, alpha-static, zeta and epsilon

float pelib::crown::quality_idle

(

const Algebra &

schedule

)

Compute energy consumption of input schedule using an energy model taking the energy consumed by idle cores into account

float pelib::crown::quality_off

(

const Algebra &

schedule

)

Compute energy consumption of input schedule using an energy model considering idle cores at shut down

float pelib::crown::quality_simple

(

const Algebra &

schedule

)

Compute energy consumption of input schedule using a simple energy model