| StarPU Handbook
    | 
| Data Structures | |
| struct | sc_hypervisor_policy | 
| struct | sc_hypervisor_policy_config | 
| struct | sc_hypervisor_wrapper | 
| struct | sc_hypervisor_resize_ack | 
| struct | sc_hypervisor_policy_task_pool | 
| Functions | |
| void | sc_hypervisor_post_resize_request (unsigned sched_ctx, int task_tag) | 
| unsigned | sc_hypervisor_get_size_req (unsigned **sched_ctxs, int *nsched_ctxs, int **workers, int *nworkers) | 
| void | sc_hypervisor_save_size_req (unsigned *sched_ctxs, int nsched_ctxs, int *workers, int nworkers) | 
| void | sc_hypervisor_free_size_req (void) | 
| unsigned | sc_hypervisor_can_resize (unsigned sched_ctx) | 
| struct sc_hypervisor_policy_config * | sc_hypervisor_get_config (unsigned sched_ctx) | 
| void | sc_hypervisor_set_config (unsigned sched_ctx, void *config) | 
| unsigned * | sc_hypervisor_get_sched_ctxs () | 
| int | sc_hypervisor_get_nsched_ctxs () | 
| struct sc_hypervisor_wrapper * | sc_hypervisor_get_wrapper (unsigned sched_ctx) | 
| double | sc_hypervisor_get_elapsed_flops_per_sched_ctx (struct sc_hypervisor_wrapper *sc_w) | 
| struct sc_hypervisor_policy | 
This structure contains all the methods that implement a hypervisor resizing policy.
| Data Fields | |
| const char * | name | 
| unsigned | custom | 
| void(* | size_ctxs )(unsigned *sched_ctxs, int nsched_ctxs, int *workers, int nworkers) | 
| void(* | resize_ctxs )(unsigned *sched_ctxs, int nsched_ctxs, int *workers, int nworkers) | 
| void(* | handle_idle_cycle )(unsigned sched_ctx, int worker) | 
| void(* | handle_pushed_task )(unsigned sched_ctx, int worker) | 
| void(* | handle_poped_task )(unsigned sched_ctx, int worker, struct starpu_task *task, uint32_t footprint) | 
| void(* | handle_idle_end )(unsigned sched_ctx, int worker) | 
| void(* | handle_post_exec_hook )(unsigned sched_ctx, int task_tag) | 
| void(* | handle_submitted_job )(struct starpu_codelet *cl, unsigned sched_ctx, uint32_t footprint, size_t data_size) | 
| void(* | end_ctx )(unsigned sched_ctx) | 
| sc_hypervisor_policy::name | 
Indicates the name of the policy, if there is not a custom policy, the policy corresponding to this name will be used by the hypervisor
| sc_hypervisor_policy::custom | 
Indicates whether the policy is custom or not
| sc_hypervisor_policy::size_ctxs | 
Distribute workers to contexts even at the beginning of the program
| sc_hypervisor_policy::resize_ctxs | 
Require explicit resizing
| sc_hypervisor_policy::handle_idle_cycle | 
It is called whenever the indicated worker executes another idle cycle in sched_ctx
| sc_hypervisor_policy::handle_pushed_task | 
It is called whenever a task is pushed on the worker’s queue corresponding to the context sched_ctx
| sc_hypervisor_policy::handle_poped_task | 
It is called whenever a task is poped from the worker’s queue corresponding to the context sched_ctx
The hypervisor takes a decision when another task was poped from this worker in this ctx
| sc_hypervisor_policy::handle_idle_end | 
It is called whenever a task is executed on the indicated worker and context after a long period of idle time
| sc_hypervisor_policy::handle_post_exec_hook | 
It is called whenever a tag task has just been executed. The table of resize requests is provided as well as the tag
| sc_hypervisor_policy::handle_submitted_job | 
The hypervisor takes a decision when a job was submitted in this ctx
| sc_hypervisor_policy::end_ctx | 
The hypervisor takes a decision when a certain ctx was deleted
| struct sc_hypervisor_policy_config | 
This structure contains all configuration information of a context. It contains configuration information for each context, which can be used to construct new resize strategies.
| struct sc_hypervisor_wrapper | 
This structure is a wrapper of the contexts available in StarPU and contains all information about a context obtained by incrementing the performance counters.
| Data Fields | ||
|---|---|---|
| unsigned | sched_ctx | The context wrapped | 
| struct sc_hypervisor_policy_config * | config | The corresponding resize configuration | 
| double | start_time_w | |
| double | current_idle_time | The idle time counter of each worker of the context | 
| double | idle_time | The time the workers were idle from the last resize | 
| double | idle_start_time | The moment when the workers started being idle | 
| double | exec_time | |
| double | exec_start_time | |
| int | worker_to_be_removed | The list of workers that will leave this contexts (lazy resizing process) | 
| int | pushed_tasks | The number of pushed tasks of each worker of the context | 
| int | poped_tasks | The number of poped tasks of each worker of the context | 
| double | total_flops | The total number of flops to execute by the context | 
| double | total_elapsed_flops | The number of flops executed by each workers of the context | 
| double | elapsed_flops | The number of flops executed by each worker of the context from last resize | 
| size_t | elapsed_data | The quantity of data (in bytes) used to execute tasks on each worker in this ctx | 
| int | elapsed_tasks | The nr of tasks executed on each worker in this ctx | 
| double | ref_speed | The average speed of the workers (type of workers) when they belonged to this context 0 - cuda 1 - cpu | 
| double | submitted_flops | The number of flops submitted to this ctx | 
| double | remaining_flops | The number of flops that still have to be executed by the workers in the context | 
| double | start_time | The time when he started executed | 
| double | real_start_time | The first time a task was pushed to this context | 
| double | hyp_react_start_time | |
| struct sc_hypervisor_resize_ack | resize_ack | The structure confirming the last resize finished and a new one can be done | 
| starpu_pthread_mutex_t | mutex | The mutex needed to synchronize the acknowledgment of the workers into the receiver context | 
| unsigned | total_flops_available | A boolean indicating if the hypervisor can use the flops corresponding to the entire execution of the context | 
| unsigned | to_be_sized | |
| unsigned | compute_idle | |
| struct sc_hypervisor_resize_ack | 
This structures checks if the workers moved to another context are actually taken into account in that context.
| struct sc_hypervisor_policy_task_pool | 
task wrapper linked list
| Data Fields | ||
|---|---|---|
| struct starpu_codelet * | cl | Which codelet has been executed | 
| uint32_t | footprint | Task footprint key | 
| unsigned | sched_ctx_id | Context the task belongs to | 
| unsigned long | n | Number of tasks of this kind | 
| size_t | data_size | The quantity of data(in bytes) needed by the task to execute | 
| struct sc_hypervisor_policy_task_pool * | next | Other task kinds | 
| void sc_hypervisor_post_resize_request | ( | unsigned | sched_ctx, | 
| int | task_tag | ||
| ) | 
Requires resizing the context sched_ctx whenever a task tagged with the id task_tag finished executing 
| unsigned sc_hypervisor_get_size_req | ( | unsigned ** | sched_ctxs, | 
| int * | nsched_ctxs, | ||
| int ** | workers, | ||
| int * | nworkers | ||
| ) | 
Check if there are pending demands of resizing
| void sc_hypervisor_save_size_req | ( | unsigned * | sched_ctxs, | 
| int | nsched_ctxs, | ||
| int * | workers, | ||
| int | nworkers | ||
| ) | 
Save a demand of resizing
| void sc_hypervisor_free_size_req | ( | void | ) | 
Clear the list of pending demands of resizing
| unsigned sc_hypervisor_can_resize | ( | unsigned | sched_ctx | ) | 
Check out if a context can be resized
| 
 | read | 
Returns the configuration structure of a context
| void sc_hypervisor_set_config | ( | unsigned | sched_ctx, | 
| void * | config | ||
| ) | 
Set a certain configuration to a contexts
| unsigned * sc_hypervisor_get_sched_ctxs | ( | ) | 
Gets the contexts managed by the hypervisor
| int sc_hypervisor_get_nsched_ctxs | ( | ) | 
Gets the number of contexts managed by the hypervisor
| 
 | read | 
Returns the wrapper corresponding the context sched_ctx 
| double sc_hypervisor_get_elapsed_flops_per_sched_ctx | ( | struct sc_hypervisor_wrapper * | sc_w | ) | 
Returns the flops of a context elapsed from the last resize
 1.8.1.2
 1.8.1.2