# memberdef

refid: a499cea27634568dc36bd8ec9992f9cda
name: neighbor_allocation
definition: Algebra neighbor_allocation
type: Algebra
argsstring: (const Algebra &solution, float tasks, float cores)
scope: pelib::crown
detaileddescription:
Compute a new allocation within the distance in number of task and number of cores allocated
    @param task Proportion, between 0 and 1, of the number of tasks whose allocation can change. At least one task is selected for change.
    @param 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.


refid: ae85fb9cfeaaff95ce0d05f9f6d38ff65
name: neighbor_allocation_full
definition: Algebra neighbor_allocation_full
type: Algebra
argsstring: (const Algebra &solution, float distance)
scope: pelib::crown
detaileddescription:
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.  


refid: a6986c7b16aff8e752de220f52908b8f0
name: neighbor_allocation_tasks
definition: Algebra neighbor_allocation_tasks
type: Algebra
argsstring: (const Algebra &solution, float distance)
scope: pelib::crown
detaileddescription:
Compute a neighbor solution where distance only influence the number of tasks transformed. Their allocation can only change by one core.  


refid: a6e4cfc023003708a0df1f2c8a020234f
name: neighbor_allocation_cores
definition: Algebra neighbor_allocation_cores
type: Algebra
argsstring: (const Algebra &solution, float distance)
scope: pelib::crown
detaileddescription:
Compute a neighbor solution where distance only influcen the number of core a task can be added or removed. Only one task is transformed.  


refid: a1ec00d43e494fe2fd1c581a7ff864b5d
name: quality_generic
definition: float quality_generic
type: float
argsstring: (const Algebra &schedule)
scope: pelib::crown
detaileddescription:
Compute the energy consumption of a input schedule using a generic energy model parametrized with scalars alpha, alpha-static, zeta and epsilon  


refid: a6ece66c7b7fc62b8357b46c6555229d1
name: quality_idle
definition: float quality_idle
type: float
argsstring: (const Algebra &schedule)
scope: pelib::crown
detaileddescription:
Compute energy consumption of input schedule using an energy model taking the energy consumed by idle cores into account  


refid: abb1a2f822cec3ce08aa8937f88c528ff
name: quality_off
definition: float quality_off
type: float
argsstring: (const Algebra &schedule)
scope: pelib::crown
detaileddescription:
Compute energy consumption of input schedule using an energy model considering idle cores at shut down  


refid: abc38c50a6dad4bbaeca9f05b26519305
name: annealing
definition: Algebra annealing
type: Algebra
scope: pelib::crown
argsstring:
(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)

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


refid: af2e00a0bdc38c2bec2f8faa8e4dc8968
name: annealing_complexity
definition: float annealing_complexity
type: float
scope: pelib::crown
argsstring:
(float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

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


refid: aef5bdf9ad94966cc31997a03c7c102ef
name: crown_binary_simple
definition: Algebra crown_binary_simple
type: Algebra
argsstring: (const Algebra &taskgraph, unsigned int precision)
scope: pelib::crown
detaileddescription:
Run binary search to compute allocation, using LTLG and Height heuristics for mapping and frequency scaling, respectively, and the "simple" energy model.  


refid: a02027ceaecace25165f601137a7eddeb
name: crown_binary_idle
definition: Algebra crown_binary_idle
type: Algebra
argsstring: (const Algebra &taskgraph, unsigned int precision)
scope: pelib::crown
detaileddescription:
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.  


refid: a38fbc46193e672fd62395c3947b73086
name: crown_binary_off
definition: Algebra crown_binary_off
type: Algebra
argsstring: (const Algebra &taskgraph, unsigned int precision)
scope: pelib::crown
detaileddescription:
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.  


refid: a0d6980f5e20e4f9997a8a06a8e63586b
name: crown_binary
definition: Algebra crown_binary
type: Algebra
argsstring: (const Algebra &taskgraph, unsigned int precision)
scope: pelib::crown
detaileddescription:
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.  


refid: adf49eb33a8035de7df0e31113438b64c
name: crown_annealing_allocation_idle
definition: Algebra crown_annealing_allocation_idle
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &initial, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

detaileddescription:
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.  


refid: a84e1a2911fd1af34e28dfdf7904b6de1
name: crown_annealing_allocation_off
definition: Algebra crown_annealing_allocation_off
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &initial, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

detaileddescription:
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.  


refid: a75143813b3e5fc9e9c99b7c1b88dcc93
name: crown_annealing_allocation_simple
definition: Algebra crown_annealing_allocation_simple
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &initial, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

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


refid: a89b961aa0db9fb81fdd910e79be2e72d
name: crown_binary_annealing_allocation_idle
definition: Algebra crown_binary_annealing_allocation_idle
type: Algebra
scope: pelib::crown
detaileddescription:
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.  


refid: ab65e5fb5564e89b2da5ab18e8bb2b2e8
name: crown_binary_annealing_allocation_off
definition: Algebra crown_binary_annealing_allocation_off
type: Algebra
scope: pelib::crown
detaileddescription:
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.  


refid: a2574da58a498ea80eb21f057112f1c4a
name: crown_binary_annealing_allocation_simple
definition: Algebra crown_binary_annealing_allocation_simple
type: Algebra
scope: pelib::crown
detaileddescription:
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.  


refid: a40a96982413597f336cdc3a0761a9378
name: crown_binary_annealing_efficiency_simple
definition: Algebra crown_binary_annealing_efficiency_simple
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

detaileddescription:
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.  


refid: a5a0170868b61d612739dbb5ae19a2919
name: crown_binary_annealing_efficiency_idle
definition: Algebra crown_binary_annealing_efficiency_idle
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

detaileddescription:
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.  


refid: a9076a6fcda558ee76e2881db0259224b
name: crown_binary_annealing_efficiency_off
definition: Algebra crown_binary_annealing_efficiency_off
type: Algebra
scope: pelib::crown
argsstring:
(const Algebra &schedule, float temperature, float cooling, float final, int max_transform, int max_new_state, float distance)

detaileddescription:
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.  


refid: aceb22894874c35b405ac4e758f382ecd
name: crown_binary_complexity
definition: float crown_binary_complexity
type: float
argsstring: (const Algebra &schedule, unsigned int precision)
scope: pelib::crown
detaileddescription:
Return the complexity in number of (virtual) instructions of binary search to compute an allocation for an input problem  


refid: a2c62eaf216867545e3ea228338dd25fb
name: allocation_temin
definition: pelib::Algebra allocation_temin
type: pelib::Algebra
argsstring: (const pelib::Algebra &schedule)
detaileddescription:
Compute an allocation that maximizes speedup of each tasks individually, given a minimum efficiency constraint per task in vector temin, or scalar gemin if temin doesn't exists, or 0.5 if neither temin or gemin is in input Algebra collection.  


refid: a8c1b6cca521f025c1ffd18c035700d0d
name: allocation_fastest_complexity
definition: float allocation_fastest_complexity
type: float
argsstring: (const pelib::Algebra &schedule)
detaileddescription:
Return the time in number of instructions as given by a time complexity analysis to run the fastest allocation algorithm with the given input problem.  


refid: a5bde5c7dc177867f7dc3d5d6f4a0449e
name: frequency_height_complexity
definition: float frequency_height_complexity
type: float
argsstring: (const pelib::Algebra &input)
detaileddescription:
Run the number of instructions as computed by a time complexity analysis of the Height frequency scaling heuristic with the given input problem  


refid: afa99ea83770cba915dd5debb7350c133
name: mapping_ltlg
definition: pelib::Algebra mapping_ltlg
type: pelib::Algebra
argsstring: (const pelib::Algebra &input)
detaileddescription:
Add mapping vector "group" to Algebra collection using Longest Task, Lowest Group-first parallel task mapping heuristic  


refid: aab63f393aad4cc575fcde36fa0cc7da0
name: mapping_ltlg_complexity
definition: float mapping_ltlg_complexity
type: float
argsstring: (const pelib::Algebra &input)
detaileddescription:
Return the number of instruction as computed by a time complexity analysis of the LTLG heuristic for the given input  


refid: a2693001e81434d4de9b7b78e75a8a3b9
name: mapping_quality
definition: float mapping_quality
type: float
argsstring: (const pelib::Algebra &input)
detaileddescription:
Return time in the number of instructions between the beginning of a schedule stage and the time the last task terminates  


refid: ad6f96b38d04bcf77977115df5bdfcd68
name: assert_scanf
initializer:
{ int num = expr; if (num == 0 || num == EOF) { fprintf(stderr, "[%s:%s:%d] Error while reading input. Aborting.\n", __FILE__, __FUNCTION__, __LINE__); abort(); }}


refid: a4d1d826dd2035361f29d397988b4e12d
name: readfiles
definition: void readfiles
type: void
argsstring:
(int *L, int *b, int *n, int tau[MAXTASKS], int *corecount, float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], float *M)


refid: a49520bb040fa6bcaad3087df32b73fe4
name: fillTasklist
definition: Task * fillTasklist
type: Task *
argsstring:
(Task *tasklist, int tau[MAXTASKS], float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], int n, int groupOrder[MAXCORES *2])


