|
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.
| Data Fields | ||
|---|---|---|
| int | min_nworkers |
Indicates the minimum number of workers needed by the context |
| int | max_nworkers |
Indicates the maximum number of workers needed by the context |
| int | granularity |
Indicates the workers granularity of the context |
| int | priority[STARPU_NMAXWORKERS] |
Indicates the priority of each worker in the context |
| double | max_idle[STARPU_NMAXWORKERS] |
Indicates the maximum idle time accepted before a resize is triggered |
| double | min_working[STARPU_NMAXWORKERS] |
Indicates that underneath this limit the priority of the worker is reduced |
| int | fixed_workers[STARPU_NMAXWORKERS] |
Indicates which workers can be moved and which ones are fixed |
| double | new_workers_max_idle |
Indicates the maximum idle time accepted before a resize is triggered for the workers that just arrived in the new context |
| double | ispeed_w_sample[STARPU_NMAXWORKERS] |
Indicates the sample used to compute the instant speed per worker |
| double | ispeed_ctx_sample |
Indicates the sample used to compute the instant speed per ctxs |
| double | time_sample |
todo |
| 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[STARPU_NMAXWORKERS] | |
| double | current_idle_time[STARPU_NMAXWORKERS] |
The idle time counter of each worker of the context |
| double | idle_time[STARPU_NMAXWORKERS] |
The time the workers were idle from the last resize |
| double | idle_start_time[STARPU_NMAXWORKERS] |
The moment when the workers started being idle |
| double | exec_time[STARPU_NMAXWORKERS] | |
| double | exec_start_time[STARPU_NMAXWORKERS] | |
| int | worker_to_be_removed[STARPU_NMAXWORKERS] |
The list of workers that will leave this contexts (lazy resizing process) |
| int | pushed_tasks[STARPU_NMAXWORKERS] |
The number of pushed tasks of each worker of the context |
| int | poped_tasks[STARPU_NMAXWORKERS] |
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[STARPU_NMAXWORKERS] |
The number of flops executed by each workers of the context |
| double | elapsed_flops[STARPU_NMAXWORKERS] |
The number of flops executed by each worker of the context from last resize |
| size_t | elapsed_data[STARPU_NMAXWORKERS] |
The quantity of data (in bytes) used to execute tasks on each worker in this ctx |
| int | elapsed_tasks[STARPU_NMAXWORKERS] |
The nr of tasks executed on each worker in this ctx |
| double | ref_speed[2] |
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[STARPU_NMAXWORKERS] | |
| 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
| struct sc_hypervisor_policy_config * sc_hypervisor_get_config | ( | unsigned | sched_ctx | ) |
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
| struct sc_hypervisor_wrapper * sc_hypervisor_get_wrapper | ( | unsigned | sched_ctx | ) |
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.7