Loading...
Searching...
No Matches
_starpu_job Struct Reference

`#include <jobs.h>`

## Data Fields

unsigned long | job_id
struct starpu_task * | task
struct _starpu_job * | quick_next
starpu_pthread_mutex_t | sync_mutex
starpu_pthread_cond_t | sync_cond
struct _starpu_data_descr | ordered_buffers [STARPU_NMAXBUFS]
struct _starpu_task_wrapper_dlist | dep_slots [STARPU_NMAXBUFS]
struct _starpu_data_descr * | dyn_ordered_buffers
struct _starpu_task_wrapper_dlist * | dyn_dep_slots
struct _starpu_tag * | tag
struct _starpu_cg_list | job_successors
struct starpu_task * | end_rdep
starpu_data_handle_t | implicit_dep_handle
struct _starpu_task_wrapper_dlist | implicit_dep_slot
unsigned | submitted:2
unsigned | terminated:2
unsigned | continuation
unsigned | continuation_resubmit
void(* | continuation_callback_on_sleep )(void *arg)
void * | continuation_callback_on_sleep_arg
void(* | omp_cleanup_callback )(void *arg)
void * | omp_cleanup_callback_arg
unsigned | discontinuous
struct timespec | cumulated_ts
double | cumulated_energy_consumed
uint32_t | footprint
unsigned | footprint_is_computed:1
unsigned | exclude_from_dag:1
unsigned | internal:1
unsigned | sequential_consistency:1
unsigned | reduction_task:1
unsigned | nimpl
int | task_size
int | workerid
int | combined_workerid
int | active_task_alias_count
struct bound_task * | bound_task
starpu_pthread_barrier_t | before_work_barrier
starpu_pthread_barrier_t | after_work_barrier
unsigned | after_work_busy_barrier
struct _starpu_graph_node * | graph_node
int | already_turned_into_bubble
unsigned | is_bubble:1

## Detailed Description

A job is the internal representation of a task.

## Field Documentation

## job_id

unsigned long _starpu_job::job_id

Each job is attributed a unique id. This however only defined when recording traces or using jobid-based task breakpoints

## task

struct starpu_task* _starpu_job::task

The task associated to that job

## quick_next

struct _starpu_job* _starpu_job::quick_next

A task that this will unlock quickly, e.g. we are the pre_sync part of a data acquisition, and the caller promised that data release will happen immediately, so that the post_sync task will be started immediately after.

## sync_mutex

starpu_pthread_mutex_t _starpu_job::sync_mutex

These synchronization structures are used to wait for the job to be available or terminated for instance.

## ordered_buffers

struct _starpu_data_descr _starpu_job::ordered_buffers[STARPU_NMAXBUFS]

To avoid deadlocks, we reorder the different buffers accessed to by the task so that we always grab the rw-lock associated to the handles in the same order.

## tag

struct _starpu_tag* _starpu_job::tag

If a tag is associated to the job, this points to the internal data structure that describes the tag status.

## job_successors

struct _starpu_cg_list _starpu_job::job_successors

Maintain a list of all the completion groups that depend on the job.

## end_rdep

struct starpu_task* _starpu_job::end_rdep

Task whose termination depends on this task

## implicit_dep_handle

starpu_data_handle_t _starpu_job::implicit_dep_handle

For tasks with cl==NULL but submitted with explicit data dependency, the handle for this dependency, so as to remove the task from the last_writer/readers

## submitted

unsigned _starpu_job::submitted

Indicates whether the task associated to that job has already been submitted to StarPU (1) or not (0) (using starpu_task_submit). Becomes and stays 2 when the task is submitted several times.

Protected by j->sync_mutex.

## terminated

unsigned _starpu_job::terminated

Indicates whether the task associated to this job is terminated or not.

Protected by j->sync_mutex.

## continuation

unsigned _starpu_job::continuation

Job is a continuation or a regular task.

## continuation_resubmit

unsigned _starpu_job::continuation_resubmit

If 0, the prepared continuation is not resubmitted automatically when going to sleep, if 1, the prepared continuation is immediately resubmitted when going to sleep.

## continuation_callback_on_sleep

void(* _starpu_job::continuation_callback_on_sleep) (void *arg)

Callback function called when:

- The continuation starpu task is ready to be submitted again if continuation_resubmit = 0;
- The continuation starpu task has just been re-submitted if continuation_resubmit = 1.

## discontinuous

unsigned _starpu_job::discontinuous

Job has been stopped at least once.

## cumulated_ts

struct timespec _starpu_job::cumulated_ts

Cumulated execution time for discontinuous jobs

## cumulated_energy_consumed

double _starpu_job::cumulated_energy_consumed

Cumulated energy consumption for discontinuous jobs

## footprint

uint32_t _starpu_job::footprint

The value of the footprint that identifies the job may be stored in this structure.

## exclude_from_dag

unsigned _starpu_job::exclude_from_dag

Should that task appear in the debug tools ? (eg. the DAG generated with dot)

## internal

unsigned _starpu_job::internal

Is that task internal to StarPU?

## sequential_consistency

unsigned _starpu_job::sequential_consistency

Did that task use sequential consistency for its data?

## reduction_task

unsigned _starpu_job::reduction_task

During the reduction of a handle, StarPU may have to submit tasks to perform the reduction itself: those task should not be stalled while other tasks are blocked until the handle has been properly reduced, so we need a flag to differentiate them from "normal" tasks.

## nimpl

unsigned _starpu_job::nimpl

The implementation associated to the job

## task_size

int _starpu_job::task_size

Number of workers executing that task (>1 if the task is parallel)

## workerid

int _starpu_job::workerid

The worker the task is running on (or -1 when not running yet)

## combined_workerid

int _starpu_job::combined_workerid

In case we have assigned this job to a combined workerid

## active_task_alias_count

int _starpu_job::active_task_alias_count

How many workers are currently running an alias of that job (for parallel tasks only).

## before_work_barrier

starpu_pthread_barrier_t _starpu_job::before_work_barrier

Parallel workers may have to synchronize before/after the execution of a parallel task.

The documentation for this struct was generated from the following file:

- jobs.h