tse.h

Go to the documentation of this file.

/*
 * (C) Copyright 2015-2024 Intel Corporation.
 * (C) Copyright 2026 Hewlett Packard Enterprise Development LP
 *
 * SPDX-License-Identifier: BSD-2-Clause-Patent
 */
 
#ifndef __TSE_SCHEDULE_H__
#define __TSE_SCHEDULE_H__
 
#include <gurt/list.h>
 
#include <pthread.h>
#include <inttypes.h>
#include <stdbool.h>

#define TSE_TASK_ARG_LEN    (840 + sizeof(pthread_mutex_t))
#define TSE_PRIV_SIZE       (TSE_TASK_ARG_LEN + 136)
#define TSE_TASK_SIZE       (TSE_PRIV_SIZE + 8)

typedef struct tse_task {
    int         dt_result;
    int         dt_pad32;
    struct {
        char        dt_space[TSE_PRIV_SIZE];
    }           dt_private;
} tse_task_t;

typedef struct {
    int     ds_result;

    void        *ds_udata;

    struct {
        uint64_t    ds_space[48];
    }           ds_private;
} tse_sched_t;

typedef int (*tse_sched_comp_cb_t)(void *args, int rc);
typedef int (*tse_task_func_t)(tse_task_t *);

typedef int (*tse_task_cb_t)(tse_task_t *, void *arg);

void *
tse_task2arg(tse_task_t *task);

tse_sched_t *
tse_task2sched(tse_task_t *task);

int
tse_sched_init(tse_sched_t *sched, tse_sched_comp_cb_t comp_cb,
        void *udata);

void
tse_sched_fini(tse_sched_t *sched);

void
tse_sched_addref(tse_sched_t *sched);

void
tse_sched_decref(tse_sched_t *sched);

void
tse_sched_complete(tse_sched_t *sched, int ret, bool cancel);

int
tse_sched_register_comp_cb(tse_sched_t *sched, tse_sched_comp_cb_t comp_cb, void *arg);

void
tse_sched_progress(tse_sched_t *sched);

bool
tse_sched_check_complete(tse_sched_t *sched);

int
tse_task_create(tse_task_func_t task_func, tse_sched_t *sched, void *priv,
        tse_task_t **taskp);

int
tse_task_schedule(tse_task_t *task, bool instant);

int
tse_task_schedule_with_delay(tse_task_t *task, bool instant, uint64_t delay);

int
tse_task_register_comp_cb(tse_task_t *task, tse_task_cb_t comp_cb,
              void *arg, size_t arg_size);

int
tse_task_register_comp_cb_and_reinit(tse_task_t *task, tse_task_cb_t comp_cb, void *arg,
                     size_t arg_size, uint64_t delay);

void
tse_task_complete(tse_task_t *task, int ret);

void *
tse_task_buf_embedded(tse_task_t *task, int size);

void *
tse_task_get_priv(tse_task_t *task);

void *
tse_task_set_priv(tse_task_t *task, void *priv);

int
tse_task_register_deps(tse_task_t *task, int num_deps,
               tse_task_t *dep_tasks[]);

int
tse_task_register_cbs(tse_task_t *task, tse_task_cb_t prep_cb,
              void *prep_data, size_t prep_data_size,
              tse_task_cb_t comp_cb, void *comp_data,
              size_t comp_data_size);

int
tse_task_reinit(tse_task_t *task);

int
tse_task_reinit_with_delay(tse_task_t *task, uint64_t delay);

int
tse_task_reset(tse_task_t *task, tse_task_func_t task_func, void *priv);

void
tse_task_addref(tse_task_t *task);

void
tse_task_decref(tse_task_t *task);

int
tse_task_list_add(tse_task_t *task, d_list_t *head);

void
tse_task_list_del(tse_task_t *task);

tse_task_t *
tse_task_list_first(d_list_t *head);

void
tse_task_list_sched(d_list_t *head, bool instant);

void
tse_task_list_abort(d_list_t *head, int rc);

int
tse_task_list_depend(d_list_t *head, tse_task_t *task);

int
tse_task_depend_list(tse_task_t *task, d_list_t *head);

int
tse_task_list_traverse(d_list_t *head, tse_task_cb_t cb, void *arg);

int
tse_task_list_traverse_adv(d_list_t *head, tse_task_cb_t cb, void *arg);

void
tse_disable_propagate(tse_task_t *task);
 
#endif /* __TSE_SCHEDULE_H__ */