/* =============================================================================
* TMlist_free
* =============================================================================
*/
void
TMlist_free (TM_ARGDECL list_t* listPtr)
{
list_node_t* nextPtr = (list_node_t*)TM_SHARED_READ_P(listPtr->head.nextPtr);
TMfreeList(TM_ARG nextPtr);
TM_FREE(listPtr);
}
/* =============================================================================
* TMhashtable_alloc
* -- Returns NULL on failure
* -- Negative values for resizeRatio or growthFactor select default values
* =============================================================================
*/
hashtable_t*
TMhashtable_alloc (TM_ARGDECL
long initNumBucket,
ulong_t (*hash)(const void*),
long (*comparePairs)(const pair_t*, const pair_t*),
long resizeRatio,
long growthFactor)
{
hashtable_t* hashtablePtr;
hashtablePtr = (hashtable_t*)TM_MALLOC(sizeof(hashtable_t));
if (hashtablePtr == NULL) {
return NULL;
}
hashtablePtr->buckets = TMallocBuckets(TM_ARG initNumBucket, comparePairs);
if (hashtablePtr->buckets == NULL) {
TM_FREE(hashtablePtr);
return NULL;
}
hashtablePtr->numBucket = initNumBucket;
#ifdef HASHTABLE_SIZE_FIELD
hashtablePtr->size = 0;
#endif
hashtablePtr->hash = hash;
hashtablePtr->comparePairs = comparePairs;
hashtablePtr->resizeRatio = ((resizeRatio < 0) ?
HASHTABLE_DEFAULT_RESIZE_RATIO : resizeRatio);
hashtablePtr->growthFactor = ((growthFactor < 0) ?
HASHTABLE_DEFAULT_GROWTH_FACTOR : growthFactor);
return hashtablePtr;
}
/* =============================================================================
* TMheap_insert
* -- Returns false on failure
* =============================================================================
*/
bool
TMheap_insert (TM_ARGDECL heap_t* heapPtr, void* dataPtr)
{
long size = (long)TM_SHARED_READ_L(heapPtr->size);
long capacity = (long)TM_SHARED_READ_L(heapPtr->capacity);
if ((size + 1) >= capacity) {
long newCapacity = capacity * 2;
void** newElements = (void**)TM_MALLOC(newCapacity * sizeof(void*));
if (newElements == NULL) {
return false;
}
TM_SHARED_WRITE_L(heapPtr->capacity, newCapacity);
long i;
void** elements = TM_SHARED_READ_P(heapPtr->elements);
for (i = 0; i <= size; i++) {
newElements[i] = (void*)TM_SHARED_READ_P(elements[i]);
}
TM_FREE(elements);
TM_SHARED_WRITE_P(heapPtr->elements, newElements);
}
size++;
TM_SHARED_WRITE_L(heapPtr->size, size);
void** elements = (void**)TM_SHARED_READ_P(heapPtr->elements);
TM_SHARED_WRITE_P(elements[size], dataPtr);
TMsiftUp(TM_ARG heapPtr, size);
return true;
}
/* =============================================================================
* customer_free
* =============================================================================
*/
void
customer_free (TM_ARGDECL customer_t* customerPtr)
{
list_t* reservationInfoListPtr =
(list_t*)TM_SHARED_READ_P(customerPtr->reservationInfoListPtr);
TMLIST_FREE(reservationInfoListPtr);
TM_FREE(customerPtr);
}
void
TMregion_free (TM_ARGDECL region_t* regionPtr)
{
PVECTOR_FREE(regionPtr->badVectorPtr);
TMLIST_FREE(regionPtr->borderListPtr);
TMLIST_FREE(regionPtr->beforeListPtr);
TMQUEUE_FREE(regionPtr->expandQueuePtr);
TM_FREE(regionPtr);
}
/* =============================================================================
* TMfreeBuckets
* =============================================================================
*/
static void
TMfreeBuckets (TM_ARGDECL list_t** buckets, long numBucket)
{
long i;
for (i = 0; i < numBucket; i++) {
TMLIST_FREE_DATA( buckets[i]);
}
TM_FREE(buckets);
}
/****************************************************************************
* task_manager_stop
****************************************************************************/
int task_manager_stop(int handle, int timeout)
{
int status;
tm_request_t request_msg;
tm_response_t response_msg;
if (IS_INVALID_HANDLE(handle) || timeout < TM_RESPONSE_WAIT_INF) {
return TM_INVALID_PARAM;
}
memset(&request_msg, 0, sizeof(tm_request_t));
/* Set the request msg */
request_msg.cmd = TASKMGRCMD_STOP;
request_msg.handle = handle;
request_msg.caller_pid = getpid();
request_msg.timeout = timeout;
if (timeout != TM_NO_RESPONSE) {
TM_ASPRINTF(&request_msg.q_name, "%s%d", TM_PRIVATE_MQ, request_msg.caller_pid);
if (request_msg.q_name == NULL) {
return TM_OUT_OF_MEMORY;
}
}
status = taskmgr_send_request(&request_msg);
if (status < 0) {
if (request_msg.q_name != NULL) {
TM_FREE(request_msg.q_name);
}
return status;
}
if (timeout != TM_NO_RESPONSE) {
status = taskmgr_receive_response(request_msg.q_name, &response_msg, timeout);
TM_FREE(request_msg.q_name);
}
return status;
}
/* =============================================================================
* TMqueue_push
* =============================================================================
*/
bool_t
TMqueue_push (TM_ARGDECL queue_t* queuePtr, void* dataPtr)
{
long pop = (long)TM_SHARED_READ(queuePtr->pop);
long push = (long)TM_SHARED_READ(queuePtr->push);
long capacity = (long)TM_SHARED_READ(queuePtr->capacity);
assert(pop != push);
/* Need to resize */
long newPush = (push + 1) % capacity;
if (newPush == pop) {
long newCapacity = capacity * QUEUE_GROWTH_FACTOR;
void** newElements = (void**)TM_MALLOC(newCapacity * sizeof(void*));
if (newElements == NULL) {
return FALSE;
}
long dst = 0;
void** elements = (void**)TM_SHARED_READ_P(queuePtr->elements);
if (pop < push) {
long src;
for (src = (pop + 1); src < push; src++, dst++) {
newElements[dst] = (void*)TM_SHARED_READ_P(elements[src]);
}
} else {
long src;
for (src = (pop + 1); src < capacity; src++, dst++) {
newElements[dst] = (void*)TM_SHARED_READ_P(elements[src]);
}
for (src = 0; src < push; src++, dst++) {
newElements[dst] = (void*)TM_SHARED_READ_P(elements[src]);
}
}
TM_FREE(elements);
TM_SHARED_WRITE_P(queuePtr->elements, newElements);
TM_SHARED_WRITE(queuePtr->pop, newCapacity - 1);
TM_SHARED_WRITE(queuePtr->capacity, newCapacity);
push = dst;
newPush = push + 1; /* no need modulo */
}
void** elements = (void**)TM_SHARED_READ_P(queuePtr->elements);
TM_SHARED_WRITE_P(elements[push], dataPtr);
TM_SHARED_WRITE(queuePtr->push, newPush);
return TRUE;
}
/* =============================================================================
* TMdecoder_getComplete
* -- If none, returns NULL
* =============================================================================
*/
char*
TMdecoder_getComplete (TM_ARGDECL decoder_t* decoderPtr, long* decodedFlowIdPtr)
{
char* data;
decoded_t* decodedPtr = (decoded_t*)TMQUEUE_POP(decoderPtr->decodedQueuePtr);
if (decodedPtr) {
*decodedFlowIdPtr = decodedPtr->flowId;
data = decodedPtr->data;
TM_FREE(decodedPtr);
} else {
*decodedFlowIdPtr = -1;
data = NULL;
}
return data;
}
/* =============================================================================
* reservation_info_free
* =============================================================================
*/
void
reservation_info_free (TM_ARGDECL reservation_info_t* reservationInfoPtr)
{
TM_FREE(reservationInfoPtr);
}
/* =============================================================================
* TMrbtree_free
* =============================================================================
*/
void
TMrbtree_free (TM_ARGDECL rbtree_t* r)
{
TMfreeNode(TM_ARG r->root);
TM_FREE(r);
}
/* =============================================================================
* TMreleaseNode
* =============================================================================
*/
static TM_CALLABLE void
TMreleaseNode (TM_ARGDECL node_t* n)
{
TM_FREE(n);
}
/* =============================================================================
* TMhashtable_free
* =============================================================================
*/
void
TMhashtable_free (TM_ARGDECL hashtable_t* hashtablePtr)
{
TMfreeBuckets(TM_ARG hashtablePtr->buckets, hashtablePtr->numBucket);
TM_FREE(hashtablePtr);
}
/* =============================================================================
* TMfreeNode
* =============================================================================
*/
static void
TMfreeNode (TM_ARGDECL list_node_t* nodePtr)
{
TM_FREE(nodePtr);
}
/* =============================================================================
* TMqueue_free
* =============================================================================
*/
void
TMqueue_free (TM_ARGDECL queue_t* queuePtr)
{
TM_FREE((void**)TM_SHARED_READ_P(queuePtr->elements));
TM_FREE(queuePtr);
}
/* =============================================================================
* TMelement_free
* =============================================================================
*/
void
TMelement_free (TM_ARGDECL element_t* elementPtr)
{
TMLIST_FREE(elementPtr->neighborListPtr);
TM_FREE(elementPtr);
}
