Applying current development branch to 1.4.x stable branch.
git-svn-id: https://pupnp.svn.sourceforge.net/svnroot/pupnp/branches/branch-1.4.x@30 119443c7-1b9e-41f8-b6fc-b9c35fce742c
This commit is contained in:
Marcelo Roberto Jimenez
32
threadutil/Makefile.am
Normal file
32
threadutil/Makefile.am
Normal file
@@ -0,0 +1,32 @@
|
||||
# $Id: Makefile.am,v 1.2 2006/02/27 21:38:56 r3mi Exp $
|
||||
#
|
||||
# "Makefile.am" for "libupnp/threadutil"
|
||||
#
|
||||
# (C) Copyright 2005 R<>mi Turboult <r3mi@users.sourceforge.net>
|
||||
#
|
||||
|
||||
AM_CPPFLAGS = -I$(srcdir)/inc -I$(srcdir)/src/inc
|
||||
AM_CFLAGS = $(PTHREAD_CFLAGS)
|
||||
|
||||
if ENABLE_DEBUG
|
||||
AM_CPPFLAGS += -DDEBUG -DSTATS
|
||||
else
|
||||
AM_CPPFLAGS += -DNO_DEBUG -DNDEBUG
|
||||
endif
|
||||
|
||||
|
||||
lib_LTLIBRARIES = libthreadutil.la
|
||||
|
||||
libthreadutil_la_LDFLAGS = -version-info $(LT_VERSION_THREADUTIL)
|
||||
|
||||
libthreadutil_la_SOURCES = \
|
||||
src/FreeList.c src/LinkedList.c \
|
||||
src/ThreadPool.c src/TimerThread.c \
|
||||
src/iasnprintf.c
|
||||
|
||||
upnpincludedir = $(includedir)/upnp
|
||||
upnpinclude_HEADERS = \
|
||||
inc/FreeList.h inc/LinkedList.h \
|
||||
inc/ThreadPool.h inc/TimerThread.h \
|
||||
inc/iasnprintf.h inc/ithread.h
|
||||
|
||||
144
threadutil/inc/FreeList.h
Normal file
144
threadutil/inc/FreeList.h
Normal file
@@ -0,0 +1,144 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef FREE_LIST_H
|
||||
#define FREE_LIST_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
//#include <malloc.h>
|
||||
|
||||
|
||||
#include "ithread.h"
|
||||
#include <errno.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Name: FreeListNode
|
||||
*
|
||||
* Description:
|
||||
* free list node. points to next free item.
|
||||
* memory for node is borrowed from allocated items.
|
||||
* Internal Use Only.
|
||||
*****************************************************************************/
|
||||
typedef struct FREELISTNODE
|
||||
{
|
||||
struct FREELISTNODE*next; //pointer to next free node
|
||||
} FreeListNode;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: FreeList
|
||||
*
|
||||
* Description:
|
||||
* Stores head and size of free list, as well as mutex for protection.
|
||||
* Internal Use Only.
|
||||
*****************************************************************************/
|
||||
typedef struct FREELIST
|
||||
{
|
||||
FreeListNode *head; //head of free list
|
||||
size_t element_size; //size of elements in free
|
||||
//list
|
||||
int maxFreeListLength; //max size of free structures
|
||||
//to keep
|
||||
int freeListLength; //current size of free list
|
||||
|
||||
}FreeList;
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes Free List. Must be called first.
|
||||
* And only once for FreeList.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* size_t - size of elements to store in free list
|
||||
* maxFreeListSize - max size that the free list can grow to
|
||||
* before returning memory to O.S.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int FreeListInit(FreeList *free_list,
|
||||
size_t elementSize,
|
||||
int maxFreeListSize);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListAlloc
|
||||
*
|
||||
* Description:
|
||||
* Allocates chunk of set size.
|
||||
* If a free item is available in the list, returnes the stored item.
|
||||
* Otherwise calls the O.S. to allocate memory.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* Non NULL on success. NULL on failure.
|
||||
*****************************************************************************/
|
||||
void * FreeListAlloc (FreeList *free_list);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListFree
|
||||
*
|
||||
* Description:
|
||||
* Returns an item to the Free List.
|
||||
* If the free list is smaller than the max size than
|
||||
* adds the item to the free list.
|
||||
* Otherwise returns the item to the O.S.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int FreeListFree (FreeList *free_list,void * element);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListDestroy
|
||||
*
|
||||
* Description:
|
||||
* Releases the resources stored with the free list.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int FreeListDestroy (FreeList *free_list);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // FREE_LIST_H
|
||||
330
threadutil/inc/LinkedList.h
Normal file
330
threadutil/inc/LinkedList.h
Normal file
@@ -0,0 +1,330 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef LINKED_LIST_H
|
||||
#define LINKED_LIST_H
|
||||
|
||||
#include "FreeList.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define EOUTOFMEM (-7 & 1<<29)
|
||||
|
||||
#define FREELISTSIZE 100
|
||||
#define LIST_SUCCESS 1
|
||||
#define LIST_FAIL 0
|
||||
|
||||
/****************************************************************************
|
||||
* Name: free_routine
|
||||
*
|
||||
* Description:
|
||||
* Function for freeing list items
|
||||
*****************************************************************************/
|
||||
typedef void (*free_function)(void *arg);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: cmp_routine
|
||||
*
|
||||
* Description:
|
||||
* Function for comparing list items
|
||||
* Returns 1 if itemA==itemB
|
||||
*****************************************************************************/
|
||||
typedef int (*cmp_routine)(void *itemA,void *itemB);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ListNode
|
||||
*
|
||||
* Description:
|
||||
* linked list node. stores generic item and pointers to next and prev.
|
||||
* Internal Use Only.
|
||||
*****************************************************************************/
|
||||
typedef struct LISTNODE
|
||||
{
|
||||
struct LISTNODE *prev; //previous node
|
||||
struct LISTNODE *next; //next node
|
||||
void *item; //item
|
||||
} ListNode;
|
||||
|
||||
/****************************************************************************
|
||||
* Name: LinkedList
|
||||
*
|
||||
* Description:
|
||||
* linked list (no protection). Internal Use Only.
|
||||
* Because this is for internal use, parameters are NOT checked for
|
||||
* validity.
|
||||
* The first item of the list is stored at node: head->next
|
||||
* The last item of the list is stored at node: tail->prev
|
||||
* If head->next=tail, then list is empty.
|
||||
* To iterate through the list:
|
||||
*
|
||||
* LinkedList g;
|
||||
* ListNode *temp = NULL;
|
||||
* for (temp = ListHead(g);temp!=NULL;temp = ListNext(g,temp))
|
||||
* {
|
||||
* }
|
||||
*
|
||||
*****************************************************************************/
|
||||
typedef struct LINKEDLIST
|
||||
{
|
||||
ListNode head; //head, first item is stored at: head->next
|
||||
ListNode tail; //tail, last item is stored at: tail->prev
|
||||
long size; //size of list
|
||||
FreeList freeNodeList; //free list to use
|
||||
free_function free_func; //free function to use
|
||||
cmp_routine cmp_func; //compare function to use
|
||||
} LinkedList;
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes LinkedList. Must be called first.
|
||||
* And only once for List.
|
||||
* Parameters:
|
||||
* list - must be valid, non null, pointer to a linked list.
|
||||
* cmp_func - function used to compare items. (May be NULL)
|
||||
* free_func - function used to free items. (May be NULL)
|
||||
* Returns:
|
||||
* 0 on success, EOUTOFMEM on failure.
|
||||
*****************************************************************************/
|
||||
int ListInit(LinkedList *list,cmp_routine cmp_func, free_function free_func);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddHead
|
||||
*
|
||||
* Description:
|
||||
* Adds a node to the head of the list.
|
||||
* Node gets immediately after list.head.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *ListAddHead(LinkedList *list, void *item);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddTail
|
||||
*
|
||||
* Description:
|
||||
* Adds a node to the tail of the list.
|
||||
* Node gets added immediately before list.tail.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *ListAddTail(LinkedList *list, void *item);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddAfter
|
||||
*
|
||||
* Description:
|
||||
* Adds a node after the specified node.
|
||||
* Node gets added immediately after bnode.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* ListNode * bnode - node to add after
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *ListAddAfter(LinkedList *list, void *item, ListNode *bnode);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddBefore
|
||||
*
|
||||
* Description:
|
||||
* Adds a node before the specified node.
|
||||
* Node gets added immediately before anode.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode * anode - node to add the in front of.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *ListAddBefore(LinkedList *list,void *item, ListNode *anode);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListDelNode
|
||||
*
|
||||
* Description:
|
||||
* Removes a node from the list
|
||||
* The memory for the node is freed.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode *dnode - done to delete.
|
||||
* freeItem - if !0 then item is freed using free function.
|
||||
* if 0 (or free function is NULL) then item is not freed
|
||||
* Returns:
|
||||
* The pointer to the item stored in the node or NULL if the item is freed.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
void *ListDelNode(LinkedList *list,ListNode *dnode, int freeItem);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListDestroy
|
||||
*
|
||||
* Description:
|
||||
* Removes all memory associated with list nodes.
|
||||
* Does not free LinkedList *list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* freeItem - if !0 then items are freed using the free_function.
|
||||
* if 0 (or free function is NULL) then items are not freed.
|
||||
* Returns:
|
||||
* 0 on success. Always returns 0.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
int ListDestroy(LinkedList *list, int freeItem);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListHead
|
||||
*
|
||||
* Description:
|
||||
* Returns the head of the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The head of the list. NULL if list is empty.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode* ListHead(LinkedList *list);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListTail
|
||||
*
|
||||
* Description:
|
||||
* Returns the tail of the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The tail of the list. NULL if list is empty.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode* ListTail(LinkedList *list);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListNext
|
||||
*
|
||||
* Description:
|
||||
* Returns the next item in the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The next item in the list. NULL if there are no more items in list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode* ListNext(LinkedList *list, ListNode * node);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListPrev
|
||||
*
|
||||
* Description:
|
||||
* Returns the previous item in the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The previous item in the list. NULL if there are no more items in list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode* ListPrev(LinkedList *list, ListNode * node);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListFind
|
||||
*
|
||||
* Description:
|
||||
* Finds the specified item in the list.
|
||||
* Uses the compare function specified in ListInit. If compare function
|
||||
* is NULL then compares items as pointers.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode *start - the node to start from, NULL if to start from
|
||||
* beginning.
|
||||
* void * item - the item to search for.
|
||||
* Returns:
|
||||
* The node containing the item. NULL if no node contains the item.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode* ListFind(LinkedList *list, ListNode *start, void * item);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListSize
|
||||
*
|
||||
* Description:
|
||||
* Returns the size of the list.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
|
||||
* Returns:
|
||||
* The number of items in the list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
int ListSize(LinkedList* list);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //LINKED_LIST_H
|
||||
541
threadutil/inc/ThreadPool.h
Normal file
541
threadutil/inc/ThreadPool.h
Normal file
@@ -0,0 +1,541 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef THREADPOOL_H
|
||||
#define THREADPOOL_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
//Size of job free list
|
||||
#define JOBFREELISTSIZE 100
|
||||
|
||||
#define INFINITE_THREADS -1
|
||||
|
||||
#define EMAXTHREADS (-8 & 1<<29)
|
||||
|
||||
//Invalid Policy
|
||||
#define INVALID_POLICY (-9 & 1<<29)
|
||||
|
||||
//Invalid JOB Id
|
||||
#define INVALID_JOB_ID (-2 & 1<<29)
|
||||
|
||||
typedef enum duration {SHORT_TERM,PERSISTENT} Duration;
|
||||
|
||||
typedef enum priority {LOW_PRIORITY,
|
||||
MED_PRIORITY,
|
||||
HIGH_PRIORITY} ThreadPriority;
|
||||
|
||||
#define DEFAULT_PRIORITY MED_PRIORITY //default priority used by TPJobInit
|
||||
#define DEFAULT_MIN_THREADS 1 //default minimum used by TPAttrInit
|
||||
#define DEFAULT_MAX_THREADS 10 //default max used by TPAttrInit
|
||||
#define DEFAULT_JOBS_PER_THREAD 10 //default jobs per thread used by TPAttrInit
|
||||
#define DEFAULT_STARVATION_TIME 500 //default starvation time used by TPAttrInit
|
||||
#define DEFAULT_IDLE_TIME 10 * 1000 //default idle time used by TPAttrInit
|
||||
#define DEFAULT_FREE_ROUTINE NULL //default free routine used TPJobInit
|
||||
|
||||
#define STATS 1 //always include stats because code change is minimal
|
||||
|
||||
|
||||
//Statistics
|
||||
#ifdef STATS
|
||||
#define STATSONLY(x) x
|
||||
#else
|
||||
#define STATSONLY(x)
|
||||
#endif
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define DEBUG 1
|
||||
#endif
|
||||
|
||||
//DEBUGGING
|
||||
#ifndef WIN32
|
||||
#ifdef DEBUG
|
||||
#define DBGONLY(x) x
|
||||
#else
|
||||
#define DBGONLY(x)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "LinkedList.h"
|
||||
#include <sys/timeb.h>
|
||||
#include "FreeList.h"
|
||||
|
||||
#include "ithread.h"
|
||||
#include <errno.h>
|
||||
#include <sys/timeb.h>
|
||||
#define EXPORT
|
||||
typedef int PolicyType;
|
||||
#define DEFAULT_POLICY SCHED_OTHER
|
||||
#define DEFAULT_SCHED_PARAM 0 //default priority
|
||||
|
||||
/****************************************************************************
|
||||
* Name: free_routine
|
||||
*
|
||||
* Description:
|
||||
* Function for freeing a thread argument
|
||||
*****************************************************************************/
|
||||
typedef void (*free_routine)(void *arg);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ThreadPoolAttr
|
||||
*
|
||||
* Description:
|
||||
* Attributes for thread pool. Used to set and change parameters of
|
||||
* thread pool
|
||||
*****************************************************************************/
|
||||
typedef struct THREADPOOLATTR
|
||||
{
|
||||
int minThreads; //minThreads, ThreadPool will always maintain at least
|
||||
//this many threads
|
||||
|
||||
int maxThreads; //maxThreads, ThreadPool will never have more than this
|
||||
//number of threads
|
||||
|
||||
int maxIdleTime; //maxIdleTime (in milliseconds)
|
||||
// this is the maximum time a thread will remain idle
|
||||
// before dying
|
||||
|
||||
int jobsPerThread; //jobs per thread to maintain
|
||||
|
||||
int starvationTime; //the time a low priority or med priority
|
||||
//job waits before getting bumped
|
||||
//up a priority (in milliseconds)
|
||||
|
||||
PolicyType schedPolicy; //scheduling policy to use
|
||||
|
||||
} ThreadPoolAttr;
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ThreadPool
|
||||
*
|
||||
* Description:
|
||||
* Internal ThreadPool Job
|
||||
*****************************************************************************/
|
||||
typedef struct THREADPOOLJOB
|
||||
{
|
||||
start_routine func; //function
|
||||
void *arg; //arg
|
||||
free_routine free_func; //free function
|
||||
struct timeb requestTime; //time of request
|
||||
int priority; //priority of request
|
||||
int jobId; //id
|
||||
} ThreadPoolJob;
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ThreadPoolStats
|
||||
*
|
||||
* Description:
|
||||
* Structure to hold statistics
|
||||
*****************************************************************************/
|
||||
|
||||
STATSONLY(
|
||||
|
||||
typedef struct TPOOLSTATS
|
||||
{
|
||||
double totalTimeHQ; //total time spent by all jobs in high priority Q
|
||||
int totalJobsHQ; //total jobs in HQ run so far
|
||||
double avgWaitHQ; //average wait in HQ
|
||||
double totalTimeMQ; //total time spent by all jobs in med priority Q
|
||||
int totalJobsMQ; //total jobs in MQ run so far
|
||||
double avgWaitMQ; //average wait in MQ
|
||||
double totalTimeLQ; //total time spent by all jobs in low priority Q
|
||||
int totalJobsLQ; //total jobs in LQ run so far
|
||||
double avgWaitLQ; //average wait in LQ
|
||||
double totalWorkTime; //total time spent working for all threads
|
||||
double totalIdleTime; //total time spent idle for all threads
|
||||
int workerThreads; //number of current workerThreads
|
||||
int idleThreads; //number of current idle threads
|
||||
int persistentThreads; //number of persistent threads
|
||||
int totalThreads; //total number of current threads
|
||||
int maxThreads; //max threads so far
|
||||
int currentJobsHQ; // current jobs in Q
|
||||
int currentJobsLQ; //current jobs in Q
|
||||
int currentJobsMQ; //current jobs in Q
|
||||
}ThreadPoolStats;
|
||||
|
||||
)
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ThreadPool
|
||||
*
|
||||
* Description:
|
||||
* A thread pool similar to the thread pool in the UPnP SDK.
|
||||
* Allows jobs to be scheduled for running by threads in a
|
||||
* thread pool. The thread pool is initialized with a
|
||||
* minimum and maximum thread number as well as a
|
||||
* max idle time
|
||||
* and a jobs per thread ratio. If a worker thread waits the whole
|
||||
* max idle time without receiving a job and the thread pool
|
||||
* currently has more threads running than the minimum
|
||||
* then the worker thread will exit. If when
|
||||
* scheduling a job the current job to thread ratio
|
||||
* becomes greater than the set ratio and the thread pool currently has
|
||||
* less than the maximum threads then a new thread will
|
||||
* be created.
|
||||
*
|
||||
*****************************************************************************/
|
||||
|
||||
typedef struct THREADPOOL
|
||||
{
|
||||
ithread_mutex_t mutex; //mutex to protect job qs
|
||||
ithread_cond_t condition; //condition variable to signal Q
|
||||
ithread_cond_t start_and_shutdown; //condition variable for start
|
||||
//and stop
|
||||
int lastJobId; //ids for jobs
|
||||
int shutdown; //whether or not we are shutting down
|
||||
int totalThreads; //total number of threads
|
||||
int persistentThreads; //number of persistent threads
|
||||
FreeList jobFreeList; //free list of jobs
|
||||
LinkedList lowJobQ; //low priority job Q
|
||||
LinkedList medJobQ; //med priority job Q
|
||||
LinkedList highJobQ; //high priority job Q
|
||||
ThreadPoolJob *persistentJob; //persistent job
|
||||
|
||||
ThreadPoolAttr attr; //thread pool attributes
|
||||
|
||||
//statistics
|
||||
STATSONLY(ThreadPoolStats stats;)
|
||||
|
||||
} ThreadPool;
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes and starts ThreadPool. Must be called first.
|
||||
* And only once for ThreadPool.
|
||||
* Parameters:
|
||||
* tp - must be valid, non null, pointer to ThreadPool.
|
||||
* attr - can be null
|
||||
*
|
||||
* if not null then attr contains the following fields:
|
||||
*
|
||||
* minWorkerThreads - minimum number of worker threads
|
||||
* thread pool will never have less than this
|
||||
* number of threads.
|
||||
* maxWorkerThreads - maximum number of worker threads
|
||||
* thread pool will never have more than this
|
||||
* number of threads.
|
||||
* maxIdleTime - maximum time that a worker thread will spend
|
||||
* idle. If a worker is idle longer than this
|
||||
* time and there are more than the min
|
||||
* number of workers running, than the
|
||||
* worker thread exits.
|
||||
* jobsPerThread - ratio of jobs to thread to try and maintain
|
||||
* if a job is scheduled and the number of jobs per
|
||||
* thread is greater than this number,and
|
||||
* if less than the maximum number of
|
||||
* workers are running then a new thread is
|
||||
* started to help out with efficiency.
|
||||
* schedPolicy - scheduling policy to try and set (OS dependent)
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure.
|
||||
* EAGAIN if not enough system resources to create minimum threads.
|
||||
* INVALID_POLICY if schedPolicy can't be set
|
||||
* EMAXTHREADS if minimum threads is greater than maximum threads
|
||||
*****************************************************************************/
|
||||
int ThreadPoolInit(ThreadPool *tp,
|
||||
ThreadPoolAttr *attr);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolAddPersistent
|
||||
*
|
||||
* Description:
|
||||
* Adds a persistent job to the thread pool.
|
||||
* Job will be run as soon as possible.
|
||||
* Call will block until job is scheduled.
|
||||
* Parameters:
|
||||
* tp - valid thread pool pointer
|
||||
* ThreadPoolJob - valid thread pool job with the following fields:
|
||||
*
|
||||
* func - ThreadFunction to run
|
||||
* arg - argument to function.
|
||||
* priority - priority of job.
|
||||
*
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure
|
||||
* EOUTOFMEM not enough memory to add job.
|
||||
* EMAXTHREADS not enough threads to add persistent job.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolAddPersistent (ThreadPool*tp,
|
||||
ThreadPoolJob *job,
|
||||
int *jobId);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolGetAttr
|
||||
*
|
||||
* Description:
|
||||
* Gets the current set of attributes
|
||||
* associated with the thread pool.
|
||||
* Parameters:
|
||||
* tp - valid thread pool pointer
|
||||
* out - non null pointer to store attributes
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolGetAttr(ThreadPool *tp,
|
||||
ThreadPoolAttr *out);
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolSetAttr
|
||||
*
|
||||
* Description:
|
||||
* Sets the attributes for the thread pool.
|
||||
* Only affects future calculations.
|
||||
* Parameters:
|
||||
* tp - valid thread pool pointer
|
||||
* attr - pointer to attributes, null sets attributes to default.
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure
|
||||
* Returns INVALID_POLICY if policy can not be set.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolSetAttr(ThreadPool *tp,
|
||||
ThreadPoolAttr *attr);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolAdd
|
||||
*
|
||||
* Description:
|
||||
* Adds a job to the thread pool.
|
||||
* Job will be run as soon as possible.
|
||||
* Parameters:
|
||||
* tp - valid thread pool pointer
|
||||
* func - ThreadFunction to run
|
||||
* arg - argument to function.
|
||||
* priority - priority of job.
|
||||
* poolid - id of job
|
||||
* free_function - function to use when freeing argument
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure
|
||||
* EOUTOFMEM if not enough memory to add job.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolAdd (ThreadPool*tp,
|
||||
ThreadPoolJob *job,
|
||||
int *jobId);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolRemove
|
||||
*
|
||||
* Description:
|
||||
* Removes a job from the thread pool.
|
||||
* Can only remove jobs which are not
|
||||
* currently running.
|
||||
* Parameters:
|
||||
* tp - valid thread pool pointer
|
||||
* jobid - id of job
|
||||
* out - space for removed job.
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure.
|
||||
* INVALID_JOB_ID if job not found.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolRemove(ThreadPool *tp,
|
||||
int jobId, ThreadPoolJob *out);
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolShutdown
|
||||
*
|
||||
* Description:
|
||||
* Shuts the thread pool down.
|
||||
* Waits for all threads to finish.
|
||||
* May block indefinitely if jobs do not
|
||||
* exit.
|
||||
* Parameters:
|
||||
* tp - must be valid tp
|
||||
* Returns:
|
||||
* 0 on success, nonzero on failure
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int ThreadPoolShutdown(ThreadPool *tp);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPJobInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes thread pool job.
|
||||
* Sets the priority to default defined in ThreadPool.h.
|
||||
* Sets the free_routine to default defined in ThreadPool.h
|
||||
* Parameters:
|
||||
* ThreadPoolJob *job - must be valid thread pool attributes.
|
||||
* start_routine func - function to run, must be valid
|
||||
* void * arg - argument to pass to function.
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPJobInit(ThreadPoolJob *job, start_routine func, void *arg);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPJobSetPriority
|
||||
*
|
||||
* Description:
|
||||
* Sets the max threads for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* maxThreads - value to set
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPJobSetPriority(ThreadPoolJob *job, ThreadPriority priority);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPJobSetFreeFunction
|
||||
*
|
||||
* Description:
|
||||
* Sets the max threads for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* maxThreads - value to set
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPJobSetFreeFunction(ThreadPoolJob *job, free_routine func);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes thread pool attributes.
|
||||
* Sets values to defaults defined in ThreadPool.h.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrInit(ThreadPoolAttr *attr);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetMaxThreads
|
||||
*
|
||||
* Description:
|
||||
* Sets the max threads for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* maxThreads - value to set
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetMaxThreads(ThreadPoolAttr *attr, int maxThreads);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetMinThreads
|
||||
*
|
||||
* Description:
|
||||
* Sets the min threads for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* minThreads - value to set
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetMinThreads(ThreadPoolAttr *attr, int minThreads);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetIdleTime
|
||||
*
|
||||
* Description:
|
||||
* Sets the idle time for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetIdleTime(ThreadPoolAttr *attr, int idleTime);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetJobsPerThread
|
||||
*
|
||||
* Description:
|
||||
* Sets the jobs per thread ratio
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* jobsPerThread - number of jobs per thread to maintain
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetJobsPerThread(ThreadPoolAttr *attr, int jobsPerThread);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetStarvationTime
|
||||
*
|
||||
* Description:
|
||||
* Sets the starvation time for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* int starvationTime - milliseconds
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetStarvationTime(ThreadPoolAttr *attr, int starvationTime);
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TPAttrSetSchedPolicy
|
||||
*
|
||||
* Description:
|
||||
* Sets the scheduling policy for the thread pool attributes.
|
||||
* Parameters:
|
||||
* attr - must be valid thread pool attributes.
|
||||
* PolicyType schedPolicy - must be a valid policy type.
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int TPAttrSetSchedPolicy(ThreadPoolAttr *attr, PolicyType schedPolicy);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ThreadPoolGetStats
|
||||
*
|
||||
* Description:
|
||||
* Returns various statistics about the
|
||||
* thread pool.
|
||||
* Only valid if STATS has been defined.
|
||||
* Parameters:
|
||||
* ThreadPool *tp - valid initialized threadpool
|
||||
* ThreadPoolStats *stats - valid stats, out parameter
|
||||
* Returns:
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
STATSONLY( EXPORT int ThreadPoolGetStats(ThreadPool *tp, ThreadPoolStats *stats););
|
||||
|
||||
STATSONLY(EXPORT void ThreadPoolPrintStats(ThreadPoolStats *stats););
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //ThreadPool
|
||||
191
threadutil/inc/TimerThread.h
Normal file
191
threadutil/inc/TimerThread.h
Normal file
@@ -0,0 +1,191 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef TIMERTHREAD_H
|
||||
#define TIMERTHREAD_H
|
||||
|
||||
#include "ithread.h"
|
||||
#include "LinkedList.h"
|
||||
#include "FreeList.h"
|
||||
#include "ThreadPool.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define INVALID_EVENT_ID (-10 & 1<<29)
|
||||
|
||||
//Timeout Types
|
||||
//absolute means in seconds from Jan 1, 1970
|
||||
//relative means in seconds from current time
|
||||
typedef enum timeoutType {ABS_SEC,REL_SEC} TimeoutType;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: TimerThread
|
||||
*
|
||||
* Description:
|
||||
* A timer thread similar to the one in the Upnp SDK that allows
|
||||
* the scheduling of a job to run at a specified time in the future
|
||||
* Because the timer thread uses the thread pool there is no
|
||||
* gurantee of timing, only approximate timing.
|
||||
* Uses ThreadPool, Mutex, Condition, Thread
|
||||
*
|
||||
*
|
||||
*****************************************************************************/
|
||||
typedef struct TIMERTHREAD
|
||||
{
|
||||
ithread_mutex_t mutex; //mutex to protect eventQ
|
||||
ithread_cond_t condition; //condition variable
|
||||
int lastEventId; //last event id
|
||||
LinkedList eventQ; //event q
|
||||
int shutdown; //whether or not we are shutdown
|
||||
FreeList freeEvents; //FreeList for events
|
||||
ThreadPool *tp; //ThreadPool to use
|
||||
} TimerThread;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: TimerEvent
|
||||
*
|
||||
* Description:
|
||||
*
|
||||
* Struct to contain information for a timer event.
|
||||
* Internal to the TimerThread
|
||||
*
|
||||
*****************************************************************************/
|
||||
typedef struct TIMEREVENT
|
||||
{
|
||||
ThreadPoolJob job;
|
||||
time_t eventTime; //absolute time for event in seconds since Jan 1, 1970
|
||||
Duration persistent; //long term or short term job
|
||||
int id; //id of job
|
||||
} TimerEvent;
|
||||
|
||||
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes and starts timer thread.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* tp - valid thread pool to use. Must be
|
||||
* started. Must be valid for lifetime
|
||||
* of timer. Timer must be shutdown
|
||||
* BEFORE thread pool.
|
||||
* Return:
|
||||
* 0 on success, nonzero on failure
|
||||
* Returns error from ThreadPoolAddPersistent on failure.
|
||||
*
|
||||
************************************************************************/
|
||||
int TimerThreadInit(TimerThread *timer,
|
||||
ThreadPool *tp);
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadSchedule
|
||||
*
|
||||
* Description:
|
||||
* Schedules an event to run at a specified time.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* time_t - time of event.
|
||||
* either in absolute seconds,
|
||||
* or relative seconds in the future.
|
||||
* timeoutType - either ABS_SEC, or REL_SEC.
|
||||
* if REL_SEC, then the event
|
||||
* will be scheduled at the
|
||||
* current time + REL_SEC.
|
||||
* job-> valid Thread pool job with following fields
|
||||
* func - function to schedule
|
||||
* arg - argument to function
|
||||
* priority - priority of job.
|
||||
*
|
||||
* id - id of timer event. (out, can be null)
|
||||
* Return:
|
||||
* 0 on success, nonzero on failure
|
||||
* EOUTOFMEM if not enough memory to schedule job.
|
||||
*
|
||||
************************************************************************/
|
||||
int TimerThreadSchedule(TimerThread* timer,
|
||||
time_t time,
|
||||
TimeoutType type,
|
||||
ThreadPoolJob *job,
|
||||
Duration duration,
|
||||
int *id);
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadRemove
|
||||
*
|
||||
* Description:
|
||||
* Removes an event from the timer Q.
|
||||
* Events can only be removed
|
||||
* before they have been placed in the
|
||||
* thread pool.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* id - id of event to remove.
|
||||
* ThreadPoolJob *out - space for thread pool job.
|
||||
* Return:
|
||||
* 0 on success,
|
||||
* INVALID_EVENT_ID on failure
|
||||
*
|
||||
************************************************************************/
|
||||
int TimerThreadRemove(TimerThread *timer,
|
||||
int id,
|
||||
ThreadPoolJob *out);
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadShutdown
|
||||
*
|
||||
* Description:
|
||||
* Shutdown the timer thread
|
||||
* Events scheduled in the future will NOT be run.
|
||||
* Timer thread should be shutdown BEFORE it's associated
|
||||
* thread pool.
|
||||
* Returns:
|
||||
* returns 0 if succesfull,
|
||||
* nonzero otherwise.
|
||||
* Always returns 0.
|
||||
***********************************************************************/
|
||||
int TimerThreadShutdown(TimerThread *timer);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //TIMER_THREAD_H
|
||||
66
threadutil/inc/iasnprintf.h
Normal file
66
threadutil/inc/iasnprintf.h
Normal file
@@ -0,0 +1,66 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#define EXPORT
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Allocates enough memory for the
|
||||
* Formatted string, up to max
|
||||
* specified.
|
||||
* With max set to -1, allocates
|
||||
* as much size as needed.
|
||||
* Memory must be freed using free.
|
||||
*/
|
||||
|
||||
EXPORT int iasnprintf(char **ret,
|
||||
int incr,
|
||||
int max,
|
||||
const char * fmt, ...)
|
||||
#ifndef SPARC_SOLARIS
|
||||
#if (__GNUC__ >= 3)
|
||||
__attribute__((format (__printf__, 4, 5)));
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
EXPORT void iasnprintfFree(char *);
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
548
threadutil/inc/ithread.h
Normal file
548
threadutil/inc/ithread.h
Normal file
@@ -0,0 +1,548 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef ITHREADH
|
||||
#define ITHREADH
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
#define DEBUG_ONLY(x) x
|
||||
#else
|
||||
#define DEBUG_ONLY(x)
|
||||
#endif
|
||||
|
||||
#include <pthread.h>
|
||||
#ifndef WIN32
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#define ITHREAD_MUTEX_FAST_NP PTHREAD_MUTEX_FAST_NP
|
||||
#define ITHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE_NP
|
||||
#define ITHREAD_MUTEX_ERRORCHECK_NP PTHREAD_MUTEX_ERRORCHECK_NP
|
||||
#define ITHREAD_CANCELED PTHREAD_CANCELED
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
* Name: ithread_t
|
||||
*
|
||||
* Description:
|
||||
* Thread handle.
|
||||
* typedef to pthread_t.
|
||||
* Internal Use Only.
|
||||
***************************************************************************/
|
||||
typedef pthread_t ithread_t;
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ithread_attr_t
|
||||
*
|
||||
* Description:
|
||||
* Thread attribute.
|
||||
* typedef to pthread_attr_t
|
||||
* Internal Use Only
|
||||
***************************************************************************/
|
||||
typedef pthread_attr_t ithread_attr_t;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: start_routine
|
||||
*
|
||||
* Description:
|
||||
* Thread start routine
|
||||
* Internal Use Only.
|
||||
***************************************************************************/
|
||||
typedef void * (*start_routine) (void *arg);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ithread_cond_t
|
||||
*
|
||||
* Description:
|
||||
* condition variable.
|
||||
* typedef to pthread_cond_t
|
||||
* Internal Use Only.
|
||||
***************************************************************************/
|
||||
typedef pthread_cond_t ithread_cond_t;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ithread_mutexattr_t
|
||||
*
|
||||
* Description:
|
||||
* Mutex attribute.
|
||||
* typedef to pthread_mutexattr_t
|
||||
* Internal Use Only
|
||||
***************************************************************************/
|
||||
typedef pthread_mutexattr_t ithread_mutexattr_t;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ithread_mutex_t
|
||||
*
|
||||
* Description:
|
||||
* Mutex.
|
||||
* typedef to pthread_mutex_t
|
||||
* Internal Use Only.
|
||||
***************************************************************************/
|
||||
typedef pthread_mutex_t ithread_mutex_t;
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: ithread_condattr_t
|
||||
*
|
||||
* Description:
|
||||
* Condition attribute.
|
||||
* typedef to pthread_condattr_t
|
||||
* NOT USED
|
||||
* Internal Use Only
|
||||
***************************************************************************/
|
||||
typedef pthread_condattr_t ithread_condattr_t;
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutexattr_init
|
||||
*
|
||||
* Description:
|
||||
* Initializes a mutex attribute variable.
|
||||
* Used to set the type of the mutex.
|
||||
* Parameters:
|
||||
* ithread_mutexattr_init * attr (must be valid non NULL pointer to
|
||||
* pthread_mutexattr_t)
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutexattr_init
|
||||
***************************************************************************/
|
||||
|
||||
#define ithread_mutexattr_init pthread_mutexattr_init
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutexattr_destroy
|
||||
*
|
||||
* Description:
|
||||
* Releases any resources held by the mutex attribute.
|
||||
* Currently there are no resources associated with the attribute
|
||||
* Parameters:
|
||||
* ithread_mutexattr_t * attr (must be valid non NULL pointer to
|
||||
* pthread_mutexattr_t)
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutexattr_destroy
|
||||
***************************************************************************/
|
||||
#define ithread_mutexattr_destroy pthread_mutexattr_destroy
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutexattr_setkind_np
|
||||
*
|
||||
* Description:
|
||||
* Sets the mutex type in the attribute.
|
||||
* Valid types are: ITHREAD_MUTEX_FAST_NP
|
||||
* ITHREAD_MUTEX_RECURSIVE_NP
|
||||
* ITHREAD_MUTEX_ERRORCHECK_NP
|
||||
*
|
||||
* Parameters:
|
||||
* ithread_mutexattr_t * mutex (must be valid non NULL pointer to
|
||||
* ithread_mutexattr_t)
|
||||
* int kind (one of ITHREAD_MUTEX_FAST_NP or ITHREAD_MUTEX_RECURSIVE_NP
|
||||
* or ITHREAD_MUTEX_ERRORCHECK_NP)
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Returns EINVAL if the kind is not supported.
|
||||
* See man page for pthread_mutexattr_setkind_np
|
||||
*****************************************************************************/
|
||||
#define ithread_mutexattr_setkind_np pthread_mutexattr_setkind_np
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutexattr_getkind_np
|
||||
*
|
||||
* Description:
|
||||
* Gets the mutex type in the attribute.
|
||||
* Valid types are: ITHREAD_MUTEX_FAST_NP
|
||||
* ITHREAD_MUTEX_RECURSIVE_NP
|
||||
* ITHREAD_MUTEX_ERRORCHECK_NP
|
||||
*
|
||||
* Parameters:
|
||||
* ithread_mutexattr_t * mutex (must be valid non NULL pointer to
|
||||
* pthread_mutexattr_t)
|
||||
* int *kind (one of ITHREAD_MUTEX_FAST_NP or ITHREAD_MUTEX_RECURSIVE_NP
|
||||
* or ITHREAD_MUTEX_ERRORCHECK_NP)
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutexattr_getkind_np
|
||||
*****************************************************************************/
|
||||
#define ithread_mutexattr_getkind_np pthread_mutexattr_getkind_np
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutex_init
|
||||
*
|
||||
* Description:
|
||||
* Initializes mutex.
|
||||
* Must be called before use.
|
||||
*
|
||||
* Parameters:
|
||||
* ithread_mutex_t * mutex (must be valid non NULL pointer to pthread_mutex_t)
|
||||
* const ithread_mutexattr_t * mutex_attr
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutex_init
|
||||
*****************************************************************************/
|
||||
#define ithread_mutex_init pthread_mutex_init
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutex_lock
|
||||
*
|
||||
* Description:
|
||||
* Locks mutex.
|
||||
* Parameters:
|
||||
* ithread_mutex_t * mutex (must be valid non NULL pointer to pthread_mutex_t)
|
||||
* mutex must be initialized.
|
||||
*
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutex_lock
|
||||
*****************************************************************************/
|
||||
#define ithread_mutex_lock pthread_mutex_lock
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutex_unlock
|
||||
*
|
||||
* Description:
|
||||
* Unlocks mutex.
|
||||
*
|
||||
* Parameters:
|
||||
* ithread_mutex_t * mutex (must be valid non NULL pointer to pthread_mutex_t)
|
||||
* mutex must be initialized.
|
||||
*
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutex_unlock
|
||||
*****************************************************************************/
|
||||
#define ithread_mutex_unlock pthread_mutex_unlock
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_mutex_destroy
|
||||
*
|
||||
* Description:
|
||||
* Releases any resources held by the mutex.
|
||||
* Mutex can no longer be used after this call.
|
||||
* Mutex is only destroyed when there are no longer any threads waiting on it.
|
||||
* Mutex cannot be destroyed if it is locked.
|
||||
* Parameters:
|
||||
* ithread_mutex_t * mutex (must be valid non NULL pointer to pthread_mutex_t)
|
||||
* mutex must be initialized.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* See man page for pthread_mutex_destroy
|
||||
*****************************************************************************/
|
||||
#define ithread_mutex_destroy pthread_mutex_destroy
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cond_init
|
||||
*
|
||||
* Description:
|
||||
* Initializes condition variable.
|
||||
* Must be called before use.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to pthread_cond_t)
|
||||
* const ithread_condattr_t * cond_attr (ignored)
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_cond_init
|
||||
*****************************************************************************/
|
||||
#define ithread_cond_init pthread_cond_init
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cond_signal
|
||||
*
|
||||
* Description:
|
||||
* Wakes up exactly one thread waiting on condition.
|
||||
* Associated mutex MUST be locked by thread before entering this call.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to
|
||||
* ithread_cond_t)
|
||||
* cond must be initialized
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_cond_signal
|
||||
*****************************************************************************/
|
||||
#define ithread_cond_signal pthread_cond_signal
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cond_broadcast
|
||||
*
|
||||
* Description:
|
||||
* Wakes up all threads waiting on condition.
|
||||
* Associated mutex MUST be locked by thread before entering this call.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to
|
||||
* ithread_cond_t)
|
||||
* cond must be initialized
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_cond_broadcast
|
||||
*****************************************************************************/
|
||||
#define ithread_cond_broadcast pthread_cond_broadcast
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cond_wait
|
||||
*
|
||||
* Description:
|
||||
* Atomically releases mutex and waits on condition.
|
||||
* Associated mutex MUST be locked by thread before entering this call.
|
||||
* Mutex is reacquired when call returns.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to
|
||||
* ithread_cond_t)
|
||||
* cond must be initialized
|
||||
* ithread_mutex_t *mutex (must be valid non NULL pointer to
|
||||
* ithread_mutex_t)
|
||||
* Mutex must be locked.
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_cond_wait
|
||||
*****************************************************************************/
|
||||
#define ithread_cond_wait pthread_cond_wait
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: pthread_cond_timedwait
|
||||
*
|
||||
* Description:
|
||||
* Atomically releases the associated mutex and waits on the condition.
|
||||
* If the condition is not signaled in the specified time
|
||||
* than the
|
||||
* call times out and returns.
|
||||
* Associated mutex MUST be locked by thread before entering
|
||||
* this call.
|
||||
* Mutex is reacquired when call returns.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to
|
||||
* ithread_cond_t)
|
||||
* cond must be initialized
|
||||
* ithread_mutex_t *mutex (must be valid non NULL pointer to
|
||||
* ithread_mutex_t)
|
||||
* Mutex must be locked.
|
||||
* const struct timespec *abstime (absolute time, measured
|
||||
* from Jan 1, 1970)
|
||||
* Returns:
|
||||
* 0 on success. ETIMEDOUT on timeout. Nonzero on failure.
|
||||
* See man page for pthread_cond_timedwait
|
||||
***************************************************************************/
|
||||
|
||||
#define ithread_cond_timedwait pthread_cond_timedwait
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cond_destroy
|
||||
*
|
||||
* Description:
|
||||
* Releases any resources held by the condition variable.
|
||||
* Condition variable can no longer be used after this call.
|
||||
* Parameters:
|
||||
* ithread_cond_t * cond (must be valid non NULL pointer to
|
||||
* ithread_cond_t)
|
||||
* cond must be initialized.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* See man page for pthread_cond_destroy
|
||||
***************************************************************************/
|
||||
#define ithread_cond_destroy pthread_cond_destroy
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_create
|
||||
*
|
||||
* Description:
|
||||
* Creates a thread with the given start routine
|
||||
* and argument.
|
||||
* Parameters:
|
||||
* ithread_t * thread (must be valid non NULL pointer to pthread_t)
|
||||
* ithread_attr_t *attr, IGNORED
|
||||
* void * (start_routine) (void *arg) (start routine)
|
||||
* void * arg - argument.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Returns EAGAIN if a new thread can not be created.
|
||||
* Returns EINVAL if there is a problem with the arguments.
|
||||
* See man page fore pthread_create
|
||||
***************************************************************************/
|
||||
#define ithread_create pthread_create
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_cancel
|
||||
*
|
||||
* Description:
|
||||
* Cancels a thread.
|
||||
* Parameters:
|
||||
* ithread_t * thread (must be valid non NULL pointer to ithread_t)
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* See man page for pthread_cancel
|
||||
***************************************************************************/
|
||||
#define ithread_cancel pthread_cancel
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_exit
|
||||
*
|
||||
* Description:
|
||||
* Returns a return code from a thread.
|
||||
* Implicitly called when the start routine returns.
|
||||
* Parameters:
|
||||
* void * return_code return code to return
|
||||
* See man page for pthread_exit
|
||||
***************************************************************************/
|
||||
#define ithread_exit pthread_exit
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_get_current_thread_id
|
||||
*
|
||||
* Description:
|
||||
* Returns the handle of the currently running thread.
|
||||
* Returns:
|
||||
* The handle of the currently running thread.
|
||||
* See man page for pthread_self
|
||||
***************************************************************************/
|
||||
#define ithread_get_current_thread_id pthread_self
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_self
|
||||
*
|
||||
* Description:
|
||||
* Returns the handle of the currently running thread.
|
||||
* Returns:
|
||||
* The handle of the currently running thread.
|
||||
* See man page for pthread_self
|
||||
***************************************************************************/
|
||||
#define ithread_self pthread_self
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_detach
|
||||
*
|
||||
* Description:
|
||||
* Makes a thread's resources reclaimed immediately
|
||||
* after it finishes
|
||||
* execution.
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_detach
|
||||
***************************************************************************/
|
||||
#define ithread_detach pthread_detach
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ithread_join
|
||||
*
|
||||
* Description:
|
||||
* Suspends the currently running thread until the
|
||||
* specified thread
|
||||
* has finished.
|
||||
* Returns the return code of the thread, or ITHREAD_CANCELED
|
||||
* if the thread has been canceled.
|
||||
* Parameters:
|
||||
* ithread_t *thread (valid non null thread identifier)
|
||||
* void ** return (space for return code)
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for pthread_join
|
||||
***************************************************************************/
|
||||
#define ithread_join pthread_join
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function: isleep
|
||||
*
|
||||
* Description:
|
||||
* Suspends the currently running thread for the specified number
|
||||
* of seconds
|
||||
* Always returns 0.
|
||||
* Parameters:
|
||||
* unsigned int seconds - number of seconds to sleep.
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for sleep (man 3 sleep)
|
||||
*****************************************************************************/
|
||||
#define isleep sleep
|
||||
|
||||
/****************************************************************************
|
||||
* Function: isleep
|
||||
*
|
||||
* Description:
|
||||
* Suspends the currently running thread for the specified number
|
||||
* of milliseconds
|
||||
* Always returns 0.
|
||||
* Parameters:
|
||||
* unsigned int milliseconds - number of milliseconds to sleep.
|
||||
* Returns:
|
||||
* 0 on success, Nonzero on failure.
|
||||
* See man page for sleep (man 3 sleep)
|
||||
*****************************************************************************/
|
||||
#define imillisleep(x) usleep(1000*x)
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef LIBUPNP_EXPORTS
|
||||
// set up declspec for dll export to make functions visible to library users
|
||||
#define EXPORT_SPEC __declspec(dllexport)
|
||||
#else
|
||||
#define EXPORT_SPEC __declspec(dllimport)
|
||||
#endif
|
||||
#else
|
||||
#define EXPORT_SPEC
|
||||
#endif
|
||||
|
||||
|
||||
//NK: Added for satisfying the gcc compiler
|
||||
EXPORT_SPEC int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif //ITHREADH
|
||||
177
threadutil/src/FreeList.c
Normal file
177
threadutil/src/FreeList.c
Normal file
@@ -0,0 +1,177 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "FreeList.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes Free List. Must be called first.
|
||||
* And only once for FreeList.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* size_t - size of elements to store in free list
|
||||
* maxFreeListSize - max size that the free list can grow to
|
||||
* before returning memory to O.S.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int
|
||||
FreeListInit( FreeList * free_list,
|
||||
size_t elementSize,
|
||||
int maxFreeListLength )
|
||||
{
|
||||
assert( free_list != NULL );
|
||||
|
||||
if( free_list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
free_list->element_size = elementSize;
|
||||
free_list->maxFreeListLength = maxFreeListLength;
|
||||
free_list->head = NULL;
|
||||
free_list->freeListLength = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListAlloc
|
||||
*
|
||||
* Description:
|
||||
* Allocates chunk of set size.
|
||||
* If a free item is available in the list, returnes the stored item.
|
||||
* Otherwise calls the O.S. to allocate memory.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* Non NULL on success. NULL on failure.
|
||||
*****************************************************************************/
|
||||
void *
|
||||
FreeListAlloc( FreeList * free_list )
|
||||
{
|
||||
FreeListNode *ret = NULL;
|
||||
|
||||
assert( free_list != NULL );
|
||||
|
||||
if( free_list == NULL )
|
||||
return NULL;
|
||||
|
||||
if( free_list->head ) {
|
||||
ret = free_list->head;
|
||||
free_list->head = free_list->head->next;
|
||||
free_list->freeListLength--;
|
||||
} else {
|
||||
ret = malloc( free_list->element_size );
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListFree
|
||||
*
|
||||
* Description:
|
||||
* Returns an item to the Free List.
|
||||
* If the free list is smaller than the max size than
|
||||
* adds the item to the free list.
|
||||
* Otherwise returns the item to the O.S.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a free list.
|
||||
* element - must be a pointer allocated by FreeListAlloc
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int
|
||||
FreeListFree( FreeList * free_list,
|
||||
void *element )
|
||||
{
|
||||
|
||||
FreeListNode *temp = NULL;
|
||||
|
||||
assert( free_list != NULL );
|
||||
|
||||
if( free_list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
if( ( element != NULL ) &&
|
||||
( ( free_list->freeListLength + 1 ) <
|
||||
free_list->maxFreeListLength ) ) {
|
||||
free_list->freeListLength++;
|
||||
temp = ( FreeListNode * ) element;
|
||||
temp->next = free_list->head;
|
||||
free_list->head = temp;
|
||||
|
||||
} else {
|
||||
|
||||
free( element );
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeListDestroy
|
||||
*
|
||||
* Description:
|
||||
* Releases the resources stored with the free list.
|
||||
* Parameters:
|
||||
* free_list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
*****************************************************************************/
|
||||
int
|
||||
FreeListDestroy( FreeList * free_list )
|
||||
{
|
||||
FreeListNode *temp = NULL;
|
||||
int i = 0;
|
||||
|
||||
assert( free_list != NULL );
|
||||
|
||||
if( free_list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
while( free_list->head ) {
|
||||
i++;
|
||||
temp = free_list->head->next;
|
||||
free( free_list->head );
|
||||
free_list->head = temp;
|
||||
}
|
||||
|
||||
free_list->freeListLength = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
533
threadutil/src/LinkedList.c
Normal file
533
threadutil/src/LinkedList.c
Normal file
@@ -0,0 +1,533 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "LinkedList.h"
|
||||
#ifdef __FreeBSD__
|
||||
#include <stdlib.h>
|
||||
#else
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
#include <assert.h>
|
||||
|
||||
static int
|
||||
freeListNode( ListNode * node,
|
||||
LinkedList * list )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
return FreeListFree( &list->freeNodeList, node );
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: CreateListNode
|
||||
*
|
||||
* Description:
|
||||
* Creates a list node. Dynamically.
|
||||
*
|
||||
* Parameters:
|
||||
* void * item - the item to store
|
||||
* Returns:
|
||||
* The new node, NULL on failure.
|
||||
*****************************************************************************/
|
||||
static ListNode *
|
||||
CreateListNode( void *item,
|
||||
LinkedList * list )
|
||||
{
|
||||
|
||||
ListNode *temp = NULL;
|
||||
|
||||
assert( list != NULL );
|
||||
|
||||
temp = ( ListNode * ) FreeListAlloc( &list->freeNodeList );
|
||||
if( temp ) {
|
||||
temp->prev = NULL;
|
||||
temp->next = NULL;
|
||||
temp->item = item;
|
||||
}
|
||||
return temp;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes LinkedList. Must be called first.
|
||||
* And only once for List.
|
||||
* Parameters:
|
||||
* list - must be valid, non null, pointer to a linked list.
|
||||
* cmp_func - function used to compare items. (May be NULL)
|
||||
* free_func - function used to free items. (May be NULL)
|
||||
* Returns:
|
||||
* 0 on success, EOUTOFMEM on failure.
|
||||
*****************************************************************************/
|
||||
int
|
||||
ListInit( LinkedList * list,
|
||||
cmp_routine cmp_func,
|
||||
free_function free_func )
|
||||
{
|
||||
|
||||
int retCode = 0;
|
||||
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
list->size = 0;
|
||||
list->cmp_func = cmp_func;
|
||||
list->free_func = free_func;
|
||||
|
||||
retCode =
|
||||
FreeListInit( &list->freeNodeList, sizeof( ListNode ),
|
||||
FREELISTSIZE );
|
||||
|
||||
assert( retCode == 0 );
|
||||
|
||||
list->head.item = NULL;
|
||||
list->head.next = &list->tail;
|
||||
list->head.prev = NULL;
|
||||
|
||||
list->tail.item = NULL;
|
||||
list->tail.prev = &list->head;
|
||||
list->tail.next = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddHead
|
||||
*
|
||||
* Description:
|
||||
* Adds a node to the head of the list.
|
||||
* Node gets immediately after list.head.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListAddHead( LinkedList * list,
|
||||
void *item )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return NULL;
|
||||
|
||||
return ListAddAfter( list, item, &list->head );
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddTail
|
||||
*
|
||||
* Description:
|
||||
* Adds a node to the tail of the list.
|
||||
* Node gets added immediately before list.tail.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListAddTail( LinkedList * list,
|
||||
void *item )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return NULL;
|
||||
|
||||
return ListAddBefore( list, item, &list->tail );
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddAfter
|
||||
*
|
||||
* Description:
|
||||
* Adds a node after the specified node.
|
||||
* Node gets added immediately after bnode.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* void * item - item to be added
|
||||
* ListNode * bnode - node to add after
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListAddAfter( LinkedList * list,
|
||||
void *item,
|
||||
ListNode * bnode )
|
||||
{
|
||||
ListNode *newNode = NULL;
|
||||
|
||||
assert( list != NULL );
|
||||
|
||||
if( ( list == NULL ) || ( bnode == NULL ) )
|
||||
return NULL;
|
||||
|
||||
newNode = CreateListNode( item, list );
|
||||
if( newNode ) {
|
||||
ListNode *temp = bnode->next;
|
||||
|
||||
bnode->next = newNode;
|
||||
newNode->prev = bnode;
|
||||
newNode->next = temp;
|
||||
temp->prev = newNode;
|
||||
list->size++;
|
||||
return newNode;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListAddBefore
|
||||
*
|
||||
* Description:
|
||||
* Adds a node before the specified node.
|
||||
* Node gets added immediately before anode.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode * anode - node to add the in front of.
|
||||
* void * item - item to be added
|
||||
* Returns:
|
||||
* The pointer to the ListNode on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListAddBefore( LinkedList * list,
|
||||
void *item,
|
||||
ListNode * anode )
|
||||
{
|
||||
ListNode *newNode = NULL;
|
||||
|
||||
assert( list != NULL );
|
||||
|
||||
if( ( list == NULL ) || ( anode == NULL ) )
|
||||
return NULL;
|
||||
|
||||
newNode = CreateListNode( item, list );
|
||||
|
||||
if( newNode ) {
|
||||
ListNode *temp = anode->prev;
|
||||
|
||||
anode->prev = newNode;
|
||||
newNode->next = anode;
|
||||
newNode->prev = temp;
|
||||
temp->next = newNode;
|
||||
list->size++;
|
||||
return newNode;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListDelNode
|
||||
*
|
||||
* Description:
|
||||
* Removes a node from the list
|
||||
* The memory for the node is freed but the
|
||||
* the memory for the items are not.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode *dnode - done to delete.
|
||||
* Returns:
|
||||
* The pointer to the item stored in node on success, NULL on failure.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
void *
|
||||
ListDelNode( LinkedList * list,
|
||||
ListNode * dnode,
|
||||
int freeItem )
|
||||
{
|
||||
void *temp;
|
||||
|
||||
assert( list != NULL );
|
||||
assert( dnode != &list->head );
|
||||
assert( dnode != &list->tail );
|
||||
|
||||
if( ( list == NULL ) ||
|
||||
( dnode == &list->head ) ||
|
||||
( dnode == &list->tail ) || ( dnode == NULL ) ) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
temp = dnode->item;
|
||||
dnode->prev->next = dnode->next;
|
||||
dnode->next->prev = dnode->prev;
|
||||
|
||||
freeListNode( dnode, list );
|
||||
list->size--;
|
||||
|
||||
if( freeItem && list->free_func ) {
|
||||
list->free_func( temp );
|
||||
temp = NULL;
|
||||
}
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListDestroy
|
||||
*
|
||||
* Description:
|
||||
* Removes all memory associated with list nodes.
|
||||
* Does not free LinkedList *list.
|
||||
* Items stored in the list are not freed, only nodes are.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* Returns:
|
||||
* 0 on success. Nonzero on failure.
|
||||
* Always returns 0.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
int
|
||||
ListDestroy( LinkedList * list,
|
||||
int freeItem )
|
||||
{
|
||||
ListNode *dnode = NULL;
|
||||
ListNode *temp = NULL;
|
||||
|
||||
if( list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
for( dnode = list->head.next; dnode != &list->tail; ) {
|
||||
temp = dnode->next;
|
||||
ListDelNode( list, dnode, freeItem );
|
||||
dnode = temp;
|
||||
}
|
||||
|
||||
list->size = 0;
|
||||
FreeListDestroy( &list->freeNodeList );
|
||||
return 0;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListHead
|
||||
*
|
||||
* Description:
|
||||
* Returns the head of the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The head of the list. NULL if list is empty.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListHead( LinkedList * list )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return NULL;
|
||||
|
||||
if( list->size == 0 )
|
||||
return NULL;
|
||||
else
|
||||
return list->head.next;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListTail
|
||||
*
|
||||
* Description:
|
||||
* Returns the tail of the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The tail of the list. NULL if list is empty.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListTail( LinkedList * list )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return NULL;
|
||||
|
||||
if( list->size == 0 )
|
||||
return NULL;
|
||||
else
|
||||
return list->tail.prev;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListNext
|
||||
*
|
||||
* Description:
|
||||
* Returns the next item in the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The next item in the list. NULL if there are no more items in list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListNext( LinkedList * list,
|
||||
ListNode * node )
|
||||
{
|
||||
assert( list != NULL );
|
||||
assert( node != NULL );
|
||||
|
||||
if( ( list == NULL ) || ( node == NULL ) )
|
||||
return NULL;
|
||||
|
||||
if( node->next == &list->tail )
|
||||
return NULL;
|
||||
else
|
||||
return node->next;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListPrev
|
||||
*
|
||||
* Description:
|
||||
* Returns the previous item in the list.
|
||||
*
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
*
|
||||
* Returns:
|
||||
* The previous item in the list. NULL if there are no more items in list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListPrev( LinkedList * list,
|
||||
ListNode * node )
|
||||
{
|
||||
assert( list != NULL );
|
||||
assert( node != NULL );
|
||||
|
||||
if( ( list == NULL ) || ( node == NULL ) )
|
||||
return NULL;
|
||||
|
||||
if( node->prev == &list->head )
|
||||
return NULL;
|
||||
else
|
||||
return node->prev;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListFind
|
||||
*
|
||||
* Description:
|
||||
* Finds the specified item in the list.
|
||||
* Uses the compare function specified in ListInit. If compare function
|
||||
* is NULL then compares items as pointers.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
* ListNode *start - the node to start from, NULL if to start from
|
||||
* beginning.
|
||||
* void * item - the item to search for.
|
||||
* Returns:
|
||||
* The node containing the item. NULL if no node contains the item.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
ListNode *
|
||||
ListFind( LinkedList * list,
|
||||
ListNode * start,
|
||||
void *item )
|
||||
{
|
||||
|
||||
ListNode *finger = NULL;
|
||||
|
||||
if( list == NULL )
|
||||
return NULL;
|
||||
|
||||
if( start == NULL )
|
||||
start = &list->head;
|
||||
|
||||
assert( start );
|
||||
|
||||
finger = start->next;
|
||||
|
||||
assert( finger );
|
||||
|
||||
while( finger != &list->tail ) {
|
||||
if( list->cmp_func ) {
|
||||
if( list->cmp_func( item, finger->item ) )
|
||||
return finger;
|
||||
} else {
|
||||
if( item == finger->item )
|
||||
return finger;
|
||||
}
|
||||
finger = finger->next;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: ListSize
|
||||
*
|
||||
* Description:
|
||||
* Returns the size of the list.
|
||||
* Parameters:
|
||||
* LinkedList *list - must be valid, non null, pointer to a linked list.
|
||||
|
||||
* Returns:
|
||||
* The number of items in the list.
|
||||
* Precondition:
|
||||
* The list has been initialized.
|
||||
*****************************************************************************/
|
||||
int
|
||||
ListSize( LinkedList * list )
|
||||
{
|
||||
assert( list != NULL );
|
||||
|
||||
if( list == NULL )
|
||||
return EINVAL;
|
||||
|
||||
return list->size;
|
||||
}
|
||||
1545
threadutil/src/ThreadPool.c
Normal file
1545
threadutil/src/ThreadPool.c
Normal file
File diff suppressed because it is too large
Load Diff
519
threadutil/src/TimerThread.c
Normal file
519
threadutil/src/TimerThread.c
Normal file
@@ -0,0 +1,519 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "TimerThread.h"
|
||||
#include <assert.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Function: FreeTimerEvent
|
||||
*
|
||||
* Description:
|
||||
* Deallocates a dynamically allocated TimerEvent.
|
||||
* Parameters:
|
||||
* TimerEvent *event - must be allocated with CreateTimerEvent
|
||||
*****************************************************************************/
|
||||
static void
|
||||
FreeTimerEvent( TimerThread * timer,
|
||||
TimerEvent * event )
|
||||
{
|
||||
|
||||
assert( timer != NULL );
|
||||
|
||||
FreeListFree( &timer->freeEvents, event );
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: TimerThreadWorker
|
||||
*
|
||||
* Description:
|
||||
* Implements timer thread.
|
||||
* Waits for next event to occur and schedules
|
||||
* associated job into threadpool.
|
||||
* Internal Only.
|
||||
* Parameters:
|
||||
* void * arg -> is cast to TimerThread *
|
||||
*****************************************************************************/
|
||||
static void *
|
||||
TimerThreadWorker( void *arg )
|
||||
{
|
||||
TimerThread *timer = ( TimerThread * ) arg;
|
||||
ListNode *head = NULL;
|
||||
|
||||
TimerEvent *nextEvent = NULL;
|
||||
|
||||
time_t currentTime = 0;
|
||||
time_t nextEventTime = 0;
|
||||
struct timespec timeToWait;
|
||||
|
||||
int tempId;
|
||||
|
||||
assert( timer != NULL );
|
||||
|
||||
ithread_mutex_lock( &timer->mutex );
|
||||
|
||||
while( 1 )
|
||||
{
|
||||
|
||||
//mutex should always be locked at top of loop
|
||||
|
||||
//Check for shutdown
|
||||
|
||||
if( timer->shutdown )
|
||||
{
|
||||
|
||||
timer->shutdown = 0;
|
||||
ithread_cond_signal( &timer->condition );
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
return NULL;
|
||||
|
||||
}
|
||||
|
||||
nextEvent = NULL;
|
||||
|
||||
//Get the next event if possible
|
||||
if( timer->eventQ.size > 0 )
|
||||
{
|
||||
head = ListHead( &timer->eventQ );
|
||||
|
||||
nextEvent = ( TimerEvent * ) head->item;
|
||||
nextEventTime = nextEvent->eventTime;
|
||||
}
|
||||
|
||||
currentTime = time( NULL );
|
||||
|
||||
//If time has elapsed, schedule job
|
||||
|
||||
if( ( nextEvent != NULL ) && ( currentTime >= nextEventTime ) )
|
||||
{
|
||||
|
||||
if( nextEvent->persistent ) {
|
||||
|
||||
ThreadPoolAddPersistent( timer->tp, &nextEvent->job,
|
||||
&tempId );
|
||||
} else {
|
||||
|
||||
ThreadPoolAdd( timer->tp, &nextEvent->job, &tempId );
|
||||
}
|
||||
|
||||
ListDelNode( &timer->eventQ, head, 0 );
|
||||
FreeTimerEvent( timer, nextEvent );
|
||||
|
||||
continue;
|
||||
|
||||
}
|
||||
|
||||
if( nextEvent != NULL ) {
|
||||
timeToWait.tv_nsec = 0;
|
||||
timeToWait.tv_sec = nextEvent->eventTime;
|
||||
|
||||
ithread_cond_timedwait( &timer->condition, &timer->mutex,
|
||||
&timeToWait );
|
||||
|
||||
} else {
|
||||
ithread_cond_wait( &timer->condition, &timer->mutex );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: CalculateEventTime
|
||||
*
|
||||
* Description:
|
||||
* Calculates the appropriate timeout in absolute seconds since
|
||||
* Jan 1, 1970
|
||||
* Internal Only.
|
||||
* Parameters:
|
||||
* time_t *timeout - timeout
|
||||
*
|
||||
*****************************************************************************/
|
||||
static int
|
||||
CalculateEventTime( time_t * timeout,
|
||||
TimeoutType type )
|
||||
{
|
||||
time_t now;
|
||||
|
||||
assert( timeout != NULL );
|
||||
|
||||
if( type == ABS_SEC )
|
||||
return 0;
|
||||
else if( type == REL_SEC ) {
|
||||
time( &now );
|
||||
( *timeout ) += now;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* Function: CreateTimerEvent
|
||||
*
|
||||
* Description:
|
||||
* Creates a Timer Event. (Dynamically allocated)
|
||||
* Internal to timer thread.
|
||||
* Parameters:
|
||||
* func - thread function to run.
|
||||
* arg - argument to function.
|
||||
* priority - priority of job.
|
||||
* eventTime - the absoule time of the event
|
||||
* in seconds from Jan, 1970
|
||||
* id - id of job
|
||||
*
|
||||
* Returns:
|
||||
* TimerEvent * on success, NULL on failure.
|
||||
****************************************************************************/
|
||||
static TimerEvent *
|
||||
CreateTimerEvent( TimerThread * timer,
|
||||
ThreadPoolJob * job,
|
||||
Duration persistent,
|
||||
time_t eventTime,
|
||||
int id )
|
||||
{
|
||||
TimerEvent *temp = NULL;
|
||||
|
||||
assert( timer != NULL );
|
||||
assert( job != NULL );
|
||||
|
||||
temp = ( TimerEvent * ) FreeListAlloc( &timer->freeEvents );
|
||||
if( temp == NULL )
|
||||
return temp;
|
||||
temp->job = ( *job );
|
||||
temp->persistent = persistent;
|
||||
temp->eventTime = eventTime;
|
||||
temp->id = id;
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadInit
|
||||
*
|
||||
* Description:
|
||||
* Initializes and starts timer thread.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* tp - valid thread pool to use. Must be
|
||||
* started. Must be valid for lifetime
|
||||
* of timer. Timer must be shutdown
|
||||
* BEFORE thread pool.
|
||||
* Return:
|
||||
* 0 on success, nonzero on failure
|
||||
* Returns error from ThreadPoolAddPersistent if failure.
|
||||
************************************************************************/
|
||||
int
|
||||
TimerThreadInit( TimerThread * timer,
|
||||
ThreadPool * tp )
|
||||
{
|
||||
|
||||
int rc = 0;
|
||||
|
||||
ThreadPoolJob timerThreadWorker;
|
||||
|
||||
assert( timer != NULL );
|
||||
assert( tp != NULL );
|
||||
|
||||
if( ( timer == NULL ) || ( tp == NULL ) ) {
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
rc += ithread_mutex_init( &timer->mutex, NULL );
|
||||
|
||||
assert( rc == 0 );
|
||||
|
||||
rc += ithread_mutex_lock( &timer->mutex );
|
||||
assert( rc == 0 );
|
||||
|
||||
rc += ithread_cond_init( &timer->condition, NULL );
|
||||
assert( rc == 0 );
|
||||
|
||||
rc += FreeListInit( &timer->freeEvents, sizeof( TimerEvent ), 100 );
|
||||
assert( rc == 0 );
|
||||
|
||||
timer->shutdown = 0;
|
||||
timer->tp = tp;
|
||||
timer->lastEventId = 0;
|
||||
rc += ListInit( &timer->eventQ, NULL, NULL );
|
||||
|
||||
assert( rc == 0 );
|
||||
|
||||
if( rc != 0 ) {
|
||||
rc = EAGAIN;
|
||||
} else {
|
||||
|
||||
TPJobInit( &timerThreadWorker, TimerThreadWorker, timer );
|
||||
TPJobSetPriority( &timerThreadWorker, HIGH_PRIORITY );
|
||||
|
||||
rc = ThreadPoolAddPersistent( tp, &timerThreadWorker, NULL );
|
||||
}
|
||||
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
|
||||
if( rc != 0 ) {
|
||||
ithread_cond_destroy( &timer->condition );
|
||||
ithread_mutex_destroy( &timer->mutex );
|
||||
FreeListDestroy( &timer->freeEvents );
|
||||
ListDestroy( &timer->eventQ, 0 );
|
||||
}
|
||||
|
||||
return rc;
|
||||
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadSchedule
|
||||
*
|
||||
* Description:
|
||||
* Schedules an event to run at a specified time.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* time_t - time of event.
|
||||
* either in absolute seconds,
|
||||
* or relative seconds in the future.
|
||||
* timeoutType - either ABS_SEC, or REL_SEC.
|
||||
* if REL_SEC, then the event
|
||||
* will be scheduled at the
|
||||
* current time + REL_SEC.
|
||||
*
|
||||
* func - function to schedule
|
||||
* arg - argument to function
|
||||
* priority - priority of job.
|
||||
* id - id of timer event. (out)
|
||||
* Return:
|
||||
* 0 on success, nonzero on failure
|
||||
* EOUTOFMEM if not enough memory to schedule job
|
||||
************************************************************************/
|
||||
int
|
||||
TimerThreadSchedule( TimerThread * timer,
|
||||
time_t timeout,
|
||||
TimeoutType type,
|
||||
ThreadPoolJob * job,
|
||||
Duration duration,
|
||||
int *id )
|
||||
{
|
||||
|
||||
int rc = EOUTOFMEM;
|
||||
int found = 0;
|
||||
int tempId = 0;
|
||||
|
||||
ListNode *tempNode = NULL;
|
||||
TimerEvent *temp = NULL;
|
||||
TimerEvent *newEvent = NULL;
|
||||
|
||||
assert( timer != NULL );
|
||||
assert( job != NULL );
|
||||
|
||||
if( ( timer == NULL ) || ( job == NULL ) ) {
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
CalculateEventTime( &timeout, type );
|
||||
ithread_mutex_lock( &timer->mutex );
|
||||
|
||||
if( id == NULL )
|
||||
id = &tempId;
|
||||
|
||||
( *id ) = INVALID_EVENT_ID;
|
||||
|
||||
newEvent = CreateTimerEvent( timer, job, duration, timeout,
|
||||
timer->lastEventId );
|
||||
|
||||
if( newEvent == NULL ) {
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
return rc;
|
||||
}
|
||||
|
||||
tempNode = ListHead( &timer->eventQ );
|
||||
//add job to Q
|
||||
//Q is ordered by eventTime
|
||||
//with the head of the Q being the next event
|
||||
|
||||
while( tempNode != NULL ) {
|
||||
temp = ( TimerEvent * ) tempNode->item;
|
||||
if( temp->eventTime >= timeout )
|
||||
{
|
||||
|
||||
if( ListAddBefore( &timer->eventQ, newEvent, tempNode ) !=
|
||||
NULL )
|
||||
rc = 0;
|
||||
found = 1;
|
||||
break;
|
||||
|
||||
}
|
||||
tempNode = ListNext( &timer->eventQ, tempNode );
|
||||
}
|
||||
|
||||
//add to the end of Q
|
||||
if( !found ) {
|
||||
|
||||
if( ListAddTail( &timer->eventQ, newEvent ) != NULL )
|
||||
rc = 0;
|
||||
|
||||
}
|
||||
//signal change in Q
|
||||
if( rc == 0 ) {
|
||||
|
||||
ithread_cond_signal( &timer->condition );
|
||||
} else {
|
||||
FreeTimerEvent( timer, newEvent );
|
||||
}
|
||||
( *id ) = timer->lastEventId++;
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadRemove
|
||||
*
|
||||
* Description:
|
||||
* Removes an event from the timer Q.
|
||||
* Events can only be removed
|
||||
* before they have been placed in the
|
||||
* thread pool.
|
||||
*
|
||||
* Parameters:
|
||||
* timer - valid timer thread pointer.
|
||||
* id - id of event to remove.
|
||||
* out - space for returned job (Can be NULL)
|
||||
* Return:
|
||||
* 0 on success.
|
||||
* INVALID_EVENT_ID on error.
|
||||
*
|
||||
************************************************************************/
|
||||
int
|
||||
TimerThreadRemove( TimerThread * timer,
|
||||
int id,
|
||||
ThreadPoolJob * out )
|
||||
{
|
||||
int rc = INVALID_EVENT_ID;
|
||||
ListNode *tempNode = NULL;
|
||||
TimerEvent *temp = NULL;
|
||||
|
||||
assert( timer != NULL );
|
||||
|
||||
if( timer == NULL ) {
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
ithread_mutex_lock( &timer->mutex );
|
||||
|
||||
tempNode = ListHead( &timer->eventQ );
|
||||
|
||||
while( tempNode != NULL ) {
|
||||
temp = ( TimerEvent * ) tempNode->item;
|
||||
if( temp->id == id )
|
||||
{
|
||||
|
||||
ListDelNode( &timer->eventQ, tempNode, 0 );
|
||||
if( out != NULL )
|
||||
( *out ) = temp->job;
|
||||
FreeTimerEvent( timer, temp );
|
||||
rc = 0;
|
||||
break;
|
||||
}
|
||||
tempNode = ListNext( &timer->eventQ, tempNode );
|
||||
}
|
||||
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
return rc;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Function: TimerThreadShutdown
|
||||
*
|
||||
* Description:
|
||||
* Shutdown the timer thread
|
||||
* Events scheduled in the future will NOT be run.
|
||||
* Timer thread should be shutdown BEFORE it's associated
|
||||
* thread pool.
|
||||
* Returns:
|
||||
* returns 0 if succesfull,
|
||||
* nonzero otherwise.
|
||||
* Always returns 0.
|
||||
***********************************************************************/
|
||||
int
|
||||
TimerThreadShutdown( TimerThread * timer )
|
||||
{
|
||||
ListNode *tempNode2 = NULL;
|
||||
ListNode *tempNode = NULL;
|
||||
|
||||
assert( timer != NULL );
|
||||
|
||||
if( timer == NULL ) {
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
ithread_mutex_lock( &timer->mutex );
|
||||
|
||||
timer->shutdown = 1;
|
||||
tempNode = ListHead( &timer->eventQ );
|
||||
|
||||
//Delete nodes in Q
|
||||
//call registered free function
|
||||
//on argument
|
||||
while( tempNode != NULL ) {
|
||||
TimerEvent *temp = ( TimerEvent * ) tempNode->item;
|
||||
|
||||
tempNode2 = ListNext( &timer->eventQ, tempNode );
|
||||
ListDelNode( &timer->eventQ, tempNode, 0 );
|
||||
if( temp->job.free_func ) {
|
||||
temp->job.free_func( temp->job.arg );
|
||||
}
|
||||
FreeTimerEvent( timer, temp );
|
||||
tempNode = tempNode2;
|
||||
}
|
||||
|
||||
ListDestroy( &timer->eventQ, 0 );
|
||||
FreeListDestroy( &timer->freeEvents );
|
||||
|
||||
ithread_cond_broadcast( &timer->condition );
|
||||
|
||||
while( timer->shutdown ) //wait for timer thread to shutdown
|
||||
{
|
||||
ithread_cond_wait( &timer->condition, &timer->mutex );
|
||||
}
|
||||
|
||||
ithread_mutex_unlock( &timer->mutex );
|
||||
|
||||
//destroy condition
|
||||
while( ithread_cond_destroy( &timer->condition ) != 0 ) {
|
||||
}
|
||||
|
||||
//destroy mutex
|
||||
while( ithread_mutex_destroy( &timer->mutex ) != 0 ) {
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
152
threadutil/src/iasnprintf.c
Normal file
152
threadutil/src/iasnprintf.c
Normal file
@@ -0,0 +1,152 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2000-2003 Intel Corporation
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
// * Neither name of Intel Corporation nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <assert.h>
|
||||
#ifdef __FreeBSD__
|
||||
#include <stdlib.h>
|
||||
#else
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
#include "iasnprintf.h"
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#define vsnprintf _vsnprintf
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Allocates enough memory for the
|
||||
* Formatted string, up to max
|
||||
* specified.
|
||||
* With max set to -1, it allocates as
|
||||
* much size as needed.
|
||||
* Memory must be freed using free.
|
||||
*/
|
||||
|
||||
int
|
||||
iasnprintf( char **ret,
|
||||
int incr,
|
||||
int max,
|
||||
const char *fmt,
|
||||
... )
|
||||
{
|
||||
int size = incr;
|
||||
int retc = 0;
|
||||
va_list ap;
|
||||
char *temp = NULL;
|
||||
|
||||
assert( ret );
|
||||
assert( fmt );
|
||||
( *ret ) = ( char * )malloc( incr );
|
||||
|
||||
if( ( *ret ) == NULL ) return -1;
|
||||
|
||||
while( 1 ) {
|
||||
va_start( ap, fmt );
|
||||
retc = vsnprintf( ( *ret ), size, fmt, ap );
|
||||
va_end( ap );
|
||||
|
||||
if( retc < 0 ) {
|
||||
//size not big enough
|
||||
//and vsnprintf does NOT return the
|
||||
//necessary number of bytes
|
||||
if( ( max != -1 ) && ( size == max ) ) //max reached
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
incr *= 2; //increase increment
|
||||
//increase size and try again
|
||||
if( ( max != -1 ) && ( ( size + incr ) > max ) ) {
|
||||
incr = ( max - size );
|
||||
}
|
||||
|
||||
temp = ( char * )realloc( ( *ret ), size + incr );
|
||||
if( temp == NULL ) {
|
||||
break;
|
||||
}
|
||||
size += incr;
|
||||
( *ret ) = temp;
|
||||
|
||||
} else {
|
||||
if( ( retc + 1 ) > size ) {
|
||||
//size not big enough
|
||||
//and vsnprintf
|
||||
//returns the necessary
|
||||
//number of bytes
|
||||
if( ( max != -1 ) && ( retc + 1 > max ) ) {
|
||||
retc = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
temp = ( char * )realloc( ( *ret ), retc + 1 );
|
||||
if( temp == NULL ) {
|
||||
retc = -1;
|
||||
break;
|
||||
}
|
||||
size = retc + 1;
|
||||
( *ret ) = temp; //size increased try again
|
||||
} else if( ( retc + 1 ) < size ) {
|
||||
//size is bigger than needed
|
||||
//try and reallocate smaller
|
||||
|
||||
temp = ( char * )realloc( ( *ret ), retc + 1 );
|
||||
if( temp != NULL ) {
|
||||
( *ret ) = temp;
|
||||
}
|
||||
break;
|
||||
} else //size is just right, exit
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if( retc < 0 ) {
|
||||
free( ( *ret ) );
|
||||
( *ret ) = NULL;
|
||||
}
|
||||
|
||||
return retc;
|
||||
}
|
||||
|
||||
void
|
||||
iasnprintfFree( char *fChar )
|
||||
{
|
||||
free( fChar );
|
||||
fChar = NULL;
|
||||
}
|
||||
Reference in New Issue
Block a user