Task Pool API Reference
Task pool library
iot_taskpool.c File Reference

Implements the task pool functions in iot_taskpool.h. More...

#include "FreeRTOS.h"
#include "semphr.h"
#include "iot_config.h"
#include <stdbool.h>
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include "private/iot_taskpool_internal.h"

Macros

#define TASKPOOL_MAX_SEM_VALUE   0xFFFF
 Maximum semaphore value for wait operations.
 
#define TASKPOOL_JOB_RESCHEDULE_DELAY_MS   ( 10ULL )
 Reschedule delay in milliseconds for deferred jobs.
 

Functions

static void _initJobsCache (_taskPoolCache_t *const pCache)
 Initializes one instance of a Task pool cache. More...
 
static void _initializeJob (_taskPoolJob_t *const pJob, IotTaskPoolRoutine_t userCallback, void *pUserContext, bool isStatic)
 Initialize a job. More...
 
static _taskPoolJob_t_fetchOrAllocateJob (_taskPoolCache_t *const pCache)
 Extracts and initializes one instance of a job from the cache or, if there is none available, it allocates and initialized a new one. More...
 
static void _recycleJob (_taskPoolCache_t *const pCache, _taskPoolJob_t *const pJob)
 
static void _destroyJob (_taskPoolJob_t *const pJob)
 
static void _taskPoolWorker (void *pUserContext)
 
static int32_t _timerEventCompare (const IotLink_t *const pTimerEventLink1, const IotLink_t *const pTimerEventLink2)
 
static void _rescheduleDeferredJobsTimer (TimerHandle_t const timer, _taskPoolTimerEvent_t *const pFirstTimerEvent)
 
static void _timerCallback (TimerHandle_t xTimer)
 
static IotTaskPoolError_t _performTaskPoolParameterValidation (const IotTaskPoolInfo_t *const pInfo)
 
static void _initTaskPoolControlStructures (_taskPool_t *const pTaskPool)
 
static IotTaskPoolError_t _createTaskPool (const IotTaskPoolInfo_t *const pInfo, _taskPool_t *const pTaskPool)
 
static void _destroyTaskPool (_taskPool_t *const pTaskPool)
 
static IotTaskPoolError_t _scheduleInternal (_taskPool_t *const pTaskPool, _taskPoolJob_t *const pJob)
 
static bool _matchJobByPointer (const IotLink_t *const pLink, void *pMatch)
 
static IotTaskPoolError_t _tryCancelInternal (_taskPool_t *const pTaskPool, _taskPoolJob_t *const pJob, IotTaskPoolJobStatus_t *const pStatus)
 
IotTaskPoolError_t IotTaskPool_CreateSystemTaskPool (const IotTaskPoolInfo_t *const pInfo)
 Creates the one single instance of the system task pool. More...
 
IotTaskPoolError_t IotTaskPool_CreateJob (IotTaskPoolRoutine_t userCallback, void *pUserContext, IotTaskPoolJobStorage_t *const pJobStorage, IotTaskPoolJob_t *const ppJob)
 Creates a job for the task pool around a user-provided storage. More...
 
IotTaskPoolError_t IotTaskPool_CreateRecyclableJob (IotTaskPool_t taskPoolHandle, IotTaskPoolRoutine_t userCallback, void *pUserContext, IotTaskPoolJob_t *const ppJob)
 Creates a job for the task pool by allocating the job dynamically. More...
 
IotTaskPoolError_t IotTaskPool_DestroyRecyclableJob (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t pJobHandle)
 This function un-initializes a job. More...
 
IotTaskPoolError_t IotTaskPool_RecycleJob (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t pJob)
 Recycles a job into the task pool job cache. More...
 
IotTaskPoolError_t IotTaskPool_Schedule (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t pJob, uint32_t flags)
 This function schedules a job created with IotTaskPool_CreateJob or IotTaskPool_CreateRecyclableJob against the task pool pointed to by taskPool. More...
 
IotTaskPoolError_t IotTaskPool_ScheduleDeferred (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t job, uint32_t timeMs)
 This function schedules a job created with IotTaskPool_CreateJob against the task pool pointed to by taskPool to be executed after a user-defined time interval. More...
 
IotTaskPoolError_t IotTaskPool_GetStatus (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t job, IotTaskPoolJobStatus_t *const pStatus)
 This function retrieves the current status of a job. More...
 
IotTaskPoolError_t IotTaskPool_TryCancel (IotTaskPool_t taskPoolHandle, IotTaskPoolJob_t job, IotTaskPoolJobStatus_t *const pStatus)
 This function tries to cancel a job that was previously scheduled with IotTaskPool_Schedule. More...
 
IotTaskPoolJobStorage_tIotTaskPool_GetJobStorageFromHandle (IotTaskPoolJob_t pJob)
 Returns a pointer to the job storage from an instance of a job handle of type IotTaskPoolJob_t. This function is guaranteed to succeed for a valid job handle. More...
 
const char * IotTaskPool_strerror (IotTaskPoolError_t status)
 Returns a string that describes an IotTaskPoolError_t. More...
 

Variables

static _taskPool_t _IotSystemTaskPool = { .dispatchQueue = IOT_DEQUEUE_INITIALIZER }
 The system task pool handle for all libraries to use. User application can use the system task pool as well knowing that the usage will be shared with the system libraries as well. The system task pool needs to be initialized before any library is used or before any code that posts jobs to the task pool runs. More...
 

Detailed Description

Implements the task pool functions in iot_taskpool.h.

Function Documentation

◆ _initJobsCache()

static void _initJobsCache ( _taskPoolCache_t *const  pCache)
static

Initializes one instance of a Task pool cache.

Parameters
[in]pCacheThe pre-allocated instance of the cache to initialize.

◆ _initializeJob()

static void _initializeJob ( _taskPoolJob_t *const  pJob,
IotTaskPoolRoutine_t  userCallback,
void *  pUserContext,
bool  isStatic 
)
static

Initialize a job.

Parameters
[in]pJobThe job to initialize.
[in]userCallbackThe user callback for the job.
[in]pUserContextThe context tp be passed to the callback.
[in]isStaticA flag to indicate whether the job is statically or synamically allocated.

◆ _fetchOrAllocateJob()

static _taskPoolJob_t * _fetchOrAllocateJob ( _taskPoolCache_t *const  pCache)
static

Extracts and initializes one instance of a job from the cache or, if there is none available, it allocates and initialized a new one.

Parameters
[in]pCacheThe instance of the cache to extract the job from.

◆ _recycleJob()

static void _recycleJob ( _taskPoolCache_t *const  pCache,
_taskPoolJob_t *const  pJob 
)
static

Recycles one instance of a job into the cache or, if the cache is full, it destroys it.

Parameters
[in]pCacheThe instance of the cache to recycle the job into.
[in]pJobThe job to recycle.

◆ _destroyJob()

static void _destroyJob ( _taskPoolJob_t *const  pJob)
static

Destroys one instance of a job.

Parameters
[in]pJobThe job to destroy.

◆ _taskPoolWorker()

static void _taskPoolWorker ( void *  pUserContext)
static

The procedure for a task pool worker thread.

Parameters
[in]pUserContextThe user context.

◆ _timerEventCompare()

static int32_t _timerEventCompare ( const IotLink_t *const  pTimerEventLink1,
const IotLink_t *const  pTimerEventLink2 
)
static

Comparer for the time list.

param[in] pTimerEventLink1 The link to the first timer event. param[in] pTimerEventLink1 The link to the first timer event.

◆ _rescheduleDeferredJobsTimer()

static void _rescheduleDeferredJobsTimer ( TimerHandle_t const  timer,
_taskPoolTimerEvent_t *const  pFirstTimerEvent 
)
static

Reschedules the timer for handling deferred jobs to the next timeout.

param[in] timer The timer to reschedule. param[in] pFirstTimerEvent The timer event that carries the timeout and job inforamtion.

◆ _timerCallback()

static void _timerCallback ( TimerHandle_t  xTimer)
static

The task pool timer procedure for scheduling deferred jobs.

param[in] timer The timer to handle.

◆ _performTaskPoolParameterValidation()

static IotTaskPoolError_t _performTaskPoolParameterValidation ( const IotTaskPoolInfo_t *const  pInfo)
static

Parameter validation for a task pool initialization.

Parameters
[in]pInfoThe initialization information for the task pool.

◆ _initTaskPoolControlStructures()

static void _initTaskPoolControlStructures ( _taskPool_t *const  pTaskPool)
static

Initializes a pre-allocated instance of a task pool.

Parameters
[in]pTaskPoolThe pre-allocated instance of the task pool to initialize.

◆ _createTaskPool()

static IotTaskPoolError_t _createTaskPool ( const IotTaskPoolInfo_t *const  pInfo,
_taskPool_t *const  pTaskPool 
)
static

Initializes a pre-allocated instance of a task pool.

Parameters
[in]pInfoThe initialization information for the task pool.
[out]pTaskPoolA pointer to the task pool data structure to initialize.

◆ _destroyTaskPool()

static void _destroyTaskPool ( _taskPool_t *const  pTaskPool)
static

Destroys one instance of a task pool.

Parameters
[in]pTaskPoolThe task pool to destroy.

◆ _scheduleInternal()

static IotTaskPoolError_t _scheduleInternal ( _taskPool_t *const  pTaskPool,
_taskPoolJob_t *const  pJob 
)
static

Places a job in the dispatch queue.

Parameters
[in]pTaskPoolThe task pool to scheduel the job with.
[in]pJobThe job to schedule.

◆ _matchJobByPointer()

static bool _matchJobByPointer ( const IotLink_t *const  pLink,
void *  pMatch 
)
static

Matches a deferred job in the timer queue with its timer event wrapper.

Parameters
[in]pLinkA pointer to the timer event link in the timer queue.
[in]pMatchA pointer to the job to match.

◆ _tryCancelInternal()

static IotTaskPoolError_t _tryCancelInternal ( _taskPool_t *const  pTaskPool,
_taskPoolJob_t *const  pJob,
IotTaskPoolJobStatus_t *const  pStatus 
)
static

Tries to cancel a job.

Parameters
[in]pTaskPoolThe task pool to cancel an operation against.
[in]pJobThe job to cancel.
[out]pStatusThe status of the job at the time of cancellation.

◆ IotTaskPool_CreateSystemTaskPool()

IotTaskPoolError_t IotTaskPool_CreateSystemTaskPool ( const IotTaskPoolInfo_t *const  pInfo)

Creates the one single instance of the system task pool.

This function should be called once by the application to initialize the one single instance of the system task pool. An application should initialize the system task pool early in the boot sequence, before initializing any other library and before posting any jobs. Early initialization it typically easy to accomplish by creating the system task pool before starting the scheduler.

This function does not allocate memory to hold the task pool data structures and state, but it may allocate memory to hold the dependent entities and data structures, e.g. the threads of the task pool. The system task pool handle is recoverable for later use by calling IotTaskPool_GetSystemTaskPool or the shortcut IOT_SYSTEM_TASKPOOL.

Parameters
[in]pInfoA pointer to the task pool initialization data.
Returns
One of the following:
Warning
This function should be called only once. Calling this function more that once will result in undefined behavior.

◆ IotTaskPool_CreateJob()

IotTaskPoolError_t IotTaskPool_CreateJob ( IotTaskPoolRoutine_t  userCallback,
void *  pUserContext,
IotTaskPoolJobStorage_t *const  pJobStorage,
IotTaskPoolJob_t *const  pJob 
)

Creates a job for the task pool around a user-provided storage.

This function may allocate memory to hold the state for a job.

Parameters
[in]userCallbackA user-specified callback for the job.
[in]pUserContextA user-specified context for the callback.
[in]pJobStorageThe storage for the job data structure.
[out]pJobA pointer to an instance of IotTaskPoolJob_t that will be initialized when this function returns successfully. This handle can be used to inspect the job status with IotTaskPool_GetStatus or cancel the job with IotTaskPool_TryCancel, etc....
Returns
One of the following:

◆ IotTaskPool_CreateRecyclableJob()

IotTaskPoolError_t IotTaskPool_CreateRecyclableJob ( IotTaskPool_t  taskPool,
IotTaskPoolRoutine_t  userCallback,
void *  pUserContext,
IotTaskPoolJob_t *const  pJob 
)

Creates a job for the task pool by allocating the job dynamically.

A recyclable job does not need to be allocated twice, but it can rather be reused through subsequent calls to IotTaskPool_CreateRecyclableJob.

Parameters
[in]taskPoolA handle to the task pool for which to create a recyclable job.
[in]userCallbackA user-specified callback for the job.
[in]pUserContextA user-specified context for the callback.
[out]pJobA pointer to an instance of IotTaskPoolJob_t that will be initialized when this function returns successfully. This handle can be used to inspect the job status with IotTaskPool_GetStatus or cancel the job with IotTaskPool_TryCancel, etc....
Returns
One of the following:
Warning
A recyclable job should be recycled with a call to IotTaskPool_RecycleJob rather than destroyed.

◆ IotTaskPool_DestroyRecyclableJob()

IotTaskPoolError_t IotTaskPool_DestroyRecyclableJob ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job 
)

This function un-initializes a job.

This function will destroy a job created with IotTaskPool_CreateRecyclableJob. A job should not be destroyed twice. A job that was previously scheduled but has not completed yet should not be destroyed, but rather the application should attempt to cancel it first by calling IotTaskPool_TryCancel. An attempt to destroy a job that was scheduled but not yet executed or canceled, may result in a IOT_TASKPOOL_ILLEGAL_OPERATION error.

Parameters
[in]taskPoolA handle to the task pool, e.g. as returned by a call to IotTaskPool_Create or IotTaskPool_CreateSystemTaskPool.
[in]jobA handle to a job that was create with a call to IotTaskPool_CreateJob.
Returns
One of the following:
Warning
The task pool will try and prevent destroying jobs that are currently queued for execution, but does not enforce strict ordering of operations. It is up to the user to make sure IotTaskPool_DestroyRecyclableJob is not called our of order.
Calling this function on job that was not previously created with IotTaskPool_CreateRecyclableJob will result in a IOT_TASKPOOL_ILLEGAL_OPERATION error.

◆ IotTaskPool_RecycleJob()

IotTaskPoolError_t IotTaskPool_RecycleJob ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job 
)

Recycles a job into the task pool job cache.

This function will try and recycle the job into the task pool cache. If the cache is full, the job memory is destroyed as if the user called IotTaskPool_DestroyRecyclableJob. The job should be recycled into the task pool instance from where it was allocated. Failure to do so will yield undefined results. A job should not be recycled twice. A job that was previously scheduled but not completed or canceled cannot be safely recycled. An attempt to do so will result in an IOT_TASKPOOL_ILLEGAL_OPERATION error.

Parameters
[in]taskPoolA handle to the task pool, e.g. as returned by a call to IotTaskPool_Create.
[out]jobA pointer to a job that was create with a call to IotTaskPool_CreateJob.
Returns
One of the following:
Warning
The taskPool used in this function should be the same used to create the job pointed to by job, or the results will be undefined.
Attempting to call this function on a statically allocated job will result in IOT_TASKPOOL_ILLEGAL_OPERATION error.
This function should be used to recycle a job in the task pool cache when after the job executed. Failing to call either this function or IotTaskPool_DestroyRecyclableJob will result is a memory leak. Statically allocated jobs do not need to be recycled or destroyed.

◆ IotTaskPool_Schedule()

IotTaskPoolError_t IotTaskPool_Schedule ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job,
uint32_t  flags 
)

This function schedules a job created with IotTaskPool_CreateJob or IotTaskPool_CreateRecyclableJob against the task pool pointed to by taskPool.

See Design for a description of the jobs lifetime and interaction with the threads used in the task pool library.

Parameters
[in]taskPoolA handle to the task pool that must have been previously initialized with. a call to IotTaskPool_Create.
[in]jobA job to schedule for execution. This must be first initialized with a call to IotTaskPool_CreateJob.
[in]flagsFlags to be passed by the user, e.g. to identify the job as high priority by specifying IOT_TASKPOOL_JOB_HIGH_PRIORITY.
Returns
One of the following:
Note
This function will not allocate memory, so it is guaranteed to succeed if the paramters are correct and the task pool was correctly initialized, and not yet destroyed.
Warning
The taskPool used in this function should be the same used to create the job pointed to by job, or the results will be undefined.

Example

// An example of a user context to pass to a callback through a task pool thread.
typedef struct JobUserContext
{
uint32_t counter;
} JobUserContext_t;
// An example of a user callback to invoke through a task pool thread.
static void ExecutionCb( IotTaskPool_t taskPool, IotTaskPoolJob_t job, void * context )
{
( void )taskPool;
( void )job;
JobUserContext_t * pUserContext = ( JobUserContext_t * )context;
pUserContext->counter++;
}
void TaskPoolExample( )
{
JobUserContext_t userContext = { 0 };
IotTaskPool_t taskPool;
// Configure the task pool to hold at least two threads and three at the maximum.
// Provide proper stack size and priority per the application needs.
const IotTaskPoolInfo_t tpInfo = { .minThreads = 2, .maxThreads = 3, .stackSize = 512, .priority = 0 };
// Create a task pool.
IotTaskPool_Create( &tpInfo, &taskPool );
// Statically allocate one job, schedule it.
IotTaskPool_CreateJob( &ExecutionCb, &userContext, &job );
IotTaskPoolError_t errorSchedule = IotTaskPool_Schedule( taskPool, &job, 0 );
switch ( errorSchedule )
{
break;
case IOT_TASKPOOL_BAD_PARAMETER: // Invalid parameters, such as a NULL handle, can trigger this error.
case IOT_TASKPOOL_ILLEGAL_OPERATION: // Scheduling a job that was previously scheduled or destroyed could trigger this error.
case IOT_TASKPOOL_NO_MEMORY: // Scheduling a with flag #IOT_TASKPOOL_JOB_HIGH_PRIORITY could trigger this error.
case IOT_TASKPOOL_SHUTDOWN_IN_PROGRESS: // Scheduling a job after trying to destroy the task pool could trigger this error.
// ASSERT
break;
default:
// ASSERT
}
//
// ... Perform other operations ...
//
IotTaskPool_Destroy( taskPool );
}

◆ IotTaskPool_ScheduleDeferred()

IotTaskPoolError_t IotTaskPool_ScheduleDeferred ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job,
uint32_t  timeMs 
)

This function schedules a job created with IotTaskPool_CreateJob against the task pool pointed to by taskPool to be executed after a user-defined time interval.

See Design for a description of the jobs lifetime and interaction with the threads used in the task pool library.

Parameters
[in]taskPoolA handle to the task pool that must have been previously initialized with. a call to IotTaskPool_Create.
[in]jobA job to schedule for execution. This must be first initialized with a call to IotTaskPool_CreateJob.
[in]timeMsThe time in milliseconds to wait before scheduling the job.
Returns
One of the following:
Note
This function will not allocate memory.
Warning
The taskPool used in this function should be the same used to create the job pointed to by job, or the results will be undefined.

◆ IotTaskPool_GetStatus()

IotTaskPoolError_t IotTaskPool_GetStatus ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job,
IotTaskPoolJobStatus_t *const  pStatus 
)

This function retrieves the current status of a job.

Parameters
[in]taskPoolA handle to the task pool that must have been previously initialized with a call to IotTaskPool_Create or IotTaskPool_CreateSystemTaskPool.
[in]jobThe job to cancel.
[out]pStatusThe status of the job at the time of cancellation.
Returns
One of the following:
Warning
This function is not thread safe and the job status returned in pStatus may be invalid by the time the calling thread has a chance to inspect it.

◆ IotTaskPool_TryCancel()

IotTaskPoolError_t IotTaskPool_TryCancel ( IotTaskPool_t  taskPool,
IotTaskPoolJob_t  job,
IotTaskPoolJobStatus_t *const  pStatus 
)

This function tries to cancel a job that was previously scheduled with IotTaskPool_Schedule.

A job can be canceled only if it is not yet executing, i.e. if its status is IOT_TASKPOOL_STATUS_READY or IOT_TASKPOOL_STATUS_SCHEDULED. Calling IotTaskPool_TryCancel on a job whose status is IOT_TASKPOOL_STATUS_COMPLETED, or IOT_TASKPOOL_STATUS_CANCELED will yield a IOT_TASKPOOL_CANCEL_FAILED return result.

Parameters
[in]taskPoolA handle to the task pool that must have been previously initialized with a call to IotTaskPool_Create.
[in]jobThe job to cancel.
[out]pStatusThe status of the job at the time of cancellation.
Returns
One of the following:
Warning
The taskPool used in this function should be the same used to create the job pointed to by job, or the results will be undefined.

◆ IotTaskPool_GetJobStorageFromHandle()

IotTaskPoolJobStorage_t* IotTaskPool_GetJobStorageFromHandle ( IotTaskPoolJob_t  job)

Returns a pointer to the job storage from an instance of a job handle of type IotTaskPoolJob_t. This function is guaranteed to succeed for a valid job handle.

Parameters
[in]jobThe job handle.
Returns
A pointer to the storage associated with the job handle job.
Warning
If the job handle used is invalid, the results will be undefined.

◆ IotTaskPool_strerror()

const char* IotTaskPool_strerror ( IotTaskPoolError_t  status)

Returns a string that describes an IotTaskPoolError_t.

Like the POSIX's strerror, this function returns a string describing a return code. In this case, the return code is a task pool library error code, status.

The string returned by this function MUST be treated as read-only: any attempt to modify its contents may result in a crash. Therefore, this function is limited to usage in logging.

Parameters
[in]statusThe status to describe.
Returns
A read-only string that describes status.
Warning
The string returned by this function must never be modified.

Variable Documentation

◆ _IotSystemTaskPool

_taskPool_t _IotSystemTaskPool = { .dispatchQueue = IOT_DEQUEUE_INITIALIZER }
static

The system task pool handle for all libraries to use. User application can use the system task pool as well knowing that the usage will be shared with the system libraries as well. The system task pool needs to be initialized before any library is used or before any code that posts jobs to the task pool runs.

Doxygen should ignore this section.

IOT_TASKPOOL_SHUTDOWN_IN_PROGRESS
Task pool operation failed because of an invalid parameter.
Definition: iot_taskpool_types.h:135
IOT_TASKPOOL_BAD_PARAMETER
Task pool operation failed because at least one parameter is invalid.
Definition: iot_taskpool_types.h:90
IotTaskPool_t
struct _taskPool * IotTaskPool_t
Opaque handle of a Task Pool instance.
Definition: iot_taskpool_types.h:213
IOT_TASKPOOL_ILLEGAL_OPERATION
Task pool operation failed because it is illegal.
Definition: iot_taskpool_types.h:105
IotTaskPoolInfo_t
Initialization information to create one task pool instance.
Definition: iot_taskpool_types.h:273
IotTaskPool_Create
IotTaskPoolError_t IotTaskPool_Create(const IotTaskPoolInfo_t *const pInfo, IotTaskPool_t *const pTaskPool)
Creates one instance of a task pool.
IOT_TASKPOOL_SUCCESS
Task pool operation completed successfully.
Definition: iot_taskpool_types.h:70
IOT_TASKPOOL_NO_MEMORY
Task pool operation failed because allocating memory failed.
Definition: iot_taskpool_types.h:119
IotTaskPool_CreateJob
IotTaskPoolError_t IotTaskPool_CreateJob(IotTaskPoolRoutine_t userCallback, void *pUserContext, IotTaskPoolJobStorage_t *const pJobStorage, IotTaskPoolJob_t *const pJob)
Creates a job for the task pool around a user-provided storage.
Definition: iot_taskpool.c:281
IotTaskPoolInfo_t::minThreads
uint32_t minThreads
Specifies the operating parameters for a task pool.
Definition: iot_taskpool_types.h:284
IotTaskPoolError_t
IotTaskPoolError_t
Return codes of task pool functions.
Definition: iot_taskpool_types.h:50
IotTaskPool_Schedule
IotTaskPoolError_t IotTaskPool_Schedule(IotTaskPool_t taskPool, IotTaskPoolJob_t job, uint32_t flags)
This function schedules a job created with IotTaskPool_CreateJob or IotTaskPool_CreateRecyclableJob a...
Definition: iot_taskpool.c:414
IotTaskPoolJob_t
struct _taskPoolJob * IotTaskPoolJob_t
Opaque handle of a Task Pool Job.
Definition: iot_taskpool_types.h:246
IotTaskPool_Destroy
IotTaskPoolError_t IotTaskPool_Destroy(IotTaskPool_t taskPool)
Destroys a task pool instance and collects all memory associated with a task pool and its satellite d...