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