taskqueue.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include "time.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct MPTask MPTask;
typedef struct MPTaskInfo MPTaskInfo;
typedef struct MPTaskQueue MPTaskQueue;
typedef struct MPTaskQueueInfo MPTaskQueueInfo;

typedef uint32_t (*MPTaskFunc)(uint32_t, uint32_t);

typedef enum MPTaskState
{
   MP_TASK_STATE_INITIALISED           = 1 << 0,
   MP_TASK_STATE_READY                 = 1 << 1,
   MP_TASK_STATE_RUNNING               = 1 << 2,
   MP_TASK_STATE_FINISHED              = 1 << 3,
} MPTaskState;

typedef enum MPTaskQueueState
{
   MP_TASK_QUEUE_STATE_INITIALISED     = 1 << 0,
   MP_TASK_QUEUE_STATE_READY           = 1 << 1,
   MP_TASK_QUEUE_STATE_STOPPING        = 1 << 2,
   MP_TASK_QUEUE_STATE_STOPPED         = 1 << 3,
   MP_TASK_QUEUE_STATE_FINISHED        = 1 << 4,
} MPTaskQueueState;

#pragma pack(push, 1)
struct MPTaskInfo
{
   MPTaskState state;
   uint32_t result;
   uint32_t coreID;
   OSTime duration;
};
#pragma pack(pop)
WUT_CHECK_OFFSET(MPTaskInfo, 0x00, state);
WUT_CHECK_OFFSET(MPTaskInfo, 0x04, result);
WUT_CHECK_OFFSET(MPTaskInfo, 0x08, coreID);
WUT_CHECK_OFFSET(MPTaskInfo, 0x0C, duration);
WUT_CHECK_SIZE(MPTaskInfo, 0x14);

#pragma pack(push, 1)
struct MPTask
{
   MPTask *self;
   MPTaskQueue *queue;
   MPTaskState state;
   MPTaskFunc func;
   uint32_t userArg1;
   uint32_t userArg2;
   uint32_t result;
   uint32_t coreID;
   OSTime duration;
   void *userData;
};
#pragma pack(pop)
WUT_CHECK_OFFSET(MPTask, 0x00, self);
WUT_CHECK_OFFSET(MPTask, 0x04, queue);
WUT_CHECK_OFFSET(MPTask, 0x08, state);
WUT_CHECK_OFFSET(MPTask, 0x0C, func);
WUT_CHECK_OFFSET(MPTask, 0x10, userArg1);
WUT_CHECK_OFFSET(MPTask, 0x14, userArg2);
WUT_CHECK_OFFSET(MPTask, 0x18, result);
WUT_CHECK_OFFSET(MPTask, 0x1C, coreID);
WUT_CHECK_OFFSET(MPTask, 0x20, duration);
WUT_CHECK_OFFSET(MPTask, 0x28, userData);
WUT_CHECK_SIZE(MPTask, 0x2C);

struct MPTaskQueueInfo
{
   MPTaskQueueState state;
   uint32_t tasks;
   uint32_t tasksReady;
   uint32_t tasksRunning;
   uint32_t tasksFinished;
};
WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x00, state);
WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks);
WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady);
WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning);
WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished);
WUT_CHECK_SIZE(MPTaskQueueInfo, 0x14);

struct MPTaskQueue
{
   MPTaskQueue *self;
   MPTaskQueueState state;
   uint32_t tasks;
   uint32_t tasksReady;
   uint32_t tasksRunning;
   WUT_UNKNOWN_BYTES(4);
   uint32_t tasksFinished;
   WUT_UNKNOWN_BYTES(8);
   uint32_t queueIndex;
   WUT_UNKNOWN_BYTES(8);
   uint32_t queueSize;
   WUT_UNKNOWN_BYTES(4);
   MPTask **queue;
   uint32_t queueMaxSize;
   OSSpinLock lock;
};
WUT_CHECK_OFFSET(MPTaskQueue, 0x00, self);
WUT_CHECK_OFFSET(MPTaskQueue, 0x04, state);
WUT_CHECK_OFFSET(MPTaskQueue, 0x08, tasks);
WUT_CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady);
WUT_CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning);
WUT_CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished);
WUT_CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex);
WUT_CHECK_OFFSET(MPTaskQueue, 0x30, queueSize);
WUT_CHECK_OFFSET(MPTaskQueue, 0x38, queue);
WUT_CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize);
WUT_CHECK_OFFSET(MPTaskQueue, 0x40, lock);
WUT_CHECK_SIZE(MPTaskQueue, 0x50);

void
MPInitTaskQ(MPTaskQueue *queue,
            MPTask **queueBuffer,
            uint32_t queueBufferLen);

BOOL
MPTermTaskQ(MPTaskQueue *queue);

BOOL
MPGetTaskQInfo(MPTaskQueue *queue,
               MPTaskQueueInfo *info);

BOOL
MPStartTaskQ(MPTaskQueue *queue);

BOOL
MPStopTaskQ(MPTaskQueue *queue);

BOOL
MPResetTaskQ(MPTaskQueue *queue);

BOOL
MPEnqueTask(MPTaskQueue *queue,
            MPTask *task);

MPTask *
MPDequeTask(MPTaskQueue *queue);

uint32_t
MPDequeTasks(MPTaskQueue *queue,
             MPTask **queueBuffer,
             uint32_t queueBufferLen);

BOOL
MPWaitTaskQ(MPTaskQueue *queue,
            MPTaskQueueState mask);

BOOL
MPWaitTaskQWithTimeout(MPTaskQueue *queue,
                       MPTaskQueueState wmask,
                       OSTime timeout);

BOOL
MPPrintTaskQStats(MPTaskQueue *queue,
                  uint32_t unk);

void
MPInitTask(MPTask *task,
           MPTaskFunc func,
           uint32_t userArg1,
           uint32_t userArg2);

BOOL
MPTermTask(MPTask* task);

BOOL
MPGetTaskInfo(MPTask *task,
              MPTaskInfo *info);

void *
MPGetTaskUserData(MPTask *task);

void
MPSetTaskUserData(MPTask *task,
                  void *userData);

BOOL
MPRunTasksFromTaskQ(MPTaskQueue *queue,
                    uint32_t count);

BOOL
MPRunTask(MPTask *task);

#ifdef __cplusplus
}
#endif