/* =============================================================================
* TMinsertEdge
* =============================================================================
*/
static void
TMinsertEdge (TM_ARGDECL net_t* netPtr, long fromId, long toId)
{
vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
bool_t status;
net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);
list_t* parentIdListPtr = childNodePtr->parentIdListPtr;
status = TMLIST_INSERT(parentIdListPtr, (void*)fromId);
assert(status);
net_node_t* parentNodePtr = (net_node_t*)vector_at(nodeVectorPtr, fromId);
list_t* childIdListPtr = parentNodePtr->childIdListPtr;
status = TMLIST_INSERT(childIdListPtr, (void*)toId);
assert(status);
}
/* =============================================================================
* TMhashtable_insert
* =============================================================================
*/
bool_t
TMhashtable_insert (TM_ARGDECL
hashtable_t* hashtablePtr, void* keyPtr, void* dataPtr)
{
long numBucket = hashtablePtr->numBucket;
long i = hashtablePtr->hash(keyPtr) % numBucket;
pair_t findPair;
findPair.firstPtr = keyPtr;
pair_t* pairPtr = (pair_t*)TMLIST_FIND(hashtablePtr->buckets[i], &findPair);
if (pairPtr != NULL) {
return FALSE;
}
pair_t* insertPtr = TMPAIR_ALLOC(keyPtr, dataPtr);
if (insertPtr == NULL) {
return FALSE;
}
/* Add new entry */
if (TMLIST_INSERT(hashtablePtr->buckets[i], insertPtr) == FALSE) {
TMPAIR_FREE(insertPtr);
return FALSE;
}
#ifdef HASHTABLE_SIZE_FIELD
long newSize = TM_SHARED_READ(hashtablePtr->size) + 1;
assert(newSize > 0);
TM_SHARED_WRITE(hashtablePtr->size, newSize);
#endif
return TRUE;
}
static void
TMinsertEdge (al_t* lock, net_t* netPtr, long fromId, long toId)
{
vector_t* nodeVectorPtr = LocalLoad(&netPtr->nodeVectorPtr);
bool_t status;
net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);
list_t* parentIdListPtr = LocalLoad(&childNodePtr->parentIdListPtr);
status = TMLIST_INSERT(lock, parentIdListPtr, (void*)fromId);
assert(status);
net_node_t* parentNodePtr = (net_node_t*)vector_at(nodeVectorPtr, fromId);
list_t* childIdListPtr = LocalLoad(&parentNodePtr->childIdListPtr);
status = TMLIST_INSERT(lock, childIdListPtr, (void*)toId);
assert(status);
}
/* =============================================================================
* TMtable_insert
* -- Returns TRUE if successful, else FALSE
* =============================================================================
*/
bool_t
TMtable_insert (TM_ARGDECL table_t* tablePtr, ulong_t hash, void* dataPtr)
{
long i = hash % tablePtr->numBucket;
if (!TMLIST_INSERT(tablePtr->buckets[i], dataPtr)) {
return FALSE;
}
return TRUE;
}
/* =============================================================================
* customer_addReservationInfo
* -- Returns TRUE if success, else FALSE
* =============================================================================
*/
__attribute__((transaction_safe)) bool_t
customer_addReservationInfo (
customer_t* customerPtr,
reservation_type_t type, long id, long price)
{
reservation_info_t* reservationInfoPtr;
reservationInfoPtr = RESERVATION_INFO_ALLOC(type, id, price);
list_t* reservationInfoListPtr = customerPtr->reservationInfoListPtr;
return TMLIST_INSERT(reservationInfoListPtr, (void*)reservationInfoPtr);
}
/* =============================================================================
* customer_addReservationInfo
* -- Returns TRUE if success, else FALSE
* =============================================================================
*/
bool_t
customer_addReservationInfo (TM_ARGDECL
customer_t* customerPtr,
reservation_type_t type, long id, long price)
{
reservation_info_t* reservationInfoPtr;
reservationInfoPtr = RESERVATION_INFO_ALLOC(type, id, price);
assert(reservationInfoPtr != NULL);
list_t* reservationInfoListPtr =
(list_t*)TM_SHARED_READ_P(customerPtr->reservationInfoListPtr);
return TMLIST_INSERT(reservationInfoListPtr, (void*)reservationInfoPtr);
}
/* =============================================================================
* TMdecoder_process
* =============================================================================
*/
int_error_t
TMdecoder_process (TM_ARGDECL decoder_t* decoderPtr, char* bytes, long numByte)
{
bool_t status;
/*
* Basic error checking
*/
if (numByte < (long)PACKET_HEADER_LENGTH) {
return ERROR_SHORT;
}
packet_t* packetPtr = (packet_t*)bytes;
long flowId = packetPtr->flowId;
long fragmentId = packetPtr->fragmentId;
long numFragment = packetPtr->numFragment;
long length = packetPtr->length;
if (flowId < 0) {
return ERROR_FLOWID;
}
if ((fragmentId < 0) || (fragmentId >= numFragment)) {
return ERROR_FRAGMENTID;
}
if (length < 0) {
return ERROR_LENGTH;
}
#if 0
/*
* With the above checks, this one is redundant
*/
if (numFragment < 1) {
return ERROR_NUMFRAGMENT;
}
#endif
/*
* Add to fragmented map for reassembling
*/
if (numFragment > 1) {
MAP_T* fragmentedMapPtr = decoderPtr->fragmentedMapPtr;
list_t* fragmentListPtr =
(list_t*)TMMAP_FIND(fragmentedMapPtr, (void*)flowId);
if (fragmentListPtr == NULL) {
fragmentListPtr = TMLIST_ALLOC(&decoder_comparator);
assert(fragmentListPtr);
status = TMLIST_INSERT(fragmentListPtr, (void*)packetPtr);
assert(status);
status = TMMAP_INSERT(fragmentedMapPtr,
(void*)flowId,
(void*)fragmentListPtr);
assert(status);
} else {
list_iter_t it;
TMLIST_ITER_RESET(&it, fragmentListPtr);
assert(TMLIST_ITER_HASNEXT(&it, fragmentListPtr));
packet_t* firstFragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
long expectedNumFragment = firstFragmentPtr->numFragment;
if (numFragment != expectedNumFragment) {
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_NUMFRAGMENT;
}
status = TMLIST_INSERT(fragmentListPtr, (void*)packetPtr);
assert(status);
/*
* If we have all the fragments we can reassemble them
*/
if (TMLIST_GETSIZE(fragmentListPtr) == numFragment) {
long numByte = 0;
long i = 0;
TMLIST_ITER_RESET(&it, fragmentListPtr);
while (TMLIST_ITER_HASNEXT(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
if(fragmentPtr->flowId != flowId)
printf("fragflow %lx floId %lx\n", fragmentPtr->flowId, flowId);
assert(fragmentPtr->flowId == flowId);
if (fragmentPtr->fragmentId != i) {
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
return ERROR_INCOMPLETE; /* should be sequential */
}
numByte += fragmentPtr->length;
i++;
}
char* data = (char*)TM_MALLOC(numByte + 1);
assert(data);
data[numByte] = '\0';
char* dst = data;
TMLIST_ITER_RESET(&it, fragmentListPtr);
while (TMLIST_ITER_HASNEXT(&it, fragmentListPtr)) {
packet_t* fragmentPtr =
(packet_t*)TMLIST_ITER_NEXT(&it, fragmentListPtr);
memcpy(dst, (void*)fragmentPtr->data, fragmentPtr->length);
dst += fragmentPtr->length;
}
assert(dst == data + numByte);
decoded_t* decodedPtr = (decoded_t*)TM_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = TMQUEUE_PUSH(decodedQueuePtr, (void*)decodedPtr);
assert(status);
TMLIST_FREE(fragmentListPtr);
status = TMMAP_REMOVE(fragmentedMapPtr, (void*)flowId);
assert(status);
}
}
} else {
/*
* This is the only fragment, so it is ready
*/
if (fragmentId != 0) {
return ERROR_FRAGMENTID;
}
char* data = (char*)TM_MALLOC(length + 1);
assert(data);
data[length] = '\0';
memcpy(data, (void*)packetPtr->data, length);
decoded_t* decodedPtr = (decoded_t*)TM_MALLOC(sizeof(decoded_t));
assert(decodedPtr);
decodedPtr->flowId = flowId;
decodedPtr->data = data;
queue_t* decodedQueuePtr = decoderPtr->decodedQueuePtr;
status = TMQUEUE_PUSH(decodedQueuePtr, (void*)decodedPtr);
assert(status);
}
return ERROR_NONE;
}
/* =============================================================================
* TMelement_addNeighbor
* =============================================================================
*/
void
TMelement_addNeighbor (TM_ARGDECL element_t* elementPtr, element_t* neighborPtr)
{
TMLIST_INSERT(elementPtr->neighborListPtr, (void*)neighborPtr);
}
/* =============================================================================
* router_solve
* =============================================================================
*/
void
router_solve (void* argPtr)
{
TM_THREAD_ENTER();
router_solve_arg_t* routerArgPtr = (router_solve_arg_t*)argPtr;
router_t* routerPtr = routerArgPtr->routerPtr;
maze_t* mazePtr = routerArgPtr->mazePtr;
vector_t* myPathVectorPtr = PVECTOR_ALLOC(1);
assert(myPathVectorPtr);
queue_t* workQueuePtr = mazePtr->workQueuePtr;
grid_t* gridPtr = mazePtr->gridPtr;
grid_t* myGridPtr =
PGRID_ALLOC(gridPtr->width, gridPtr->height, gridPtr->depth);
assert(myGridPtr);
long bendCost = routerPtr->bendCost;
queue_t* myExpansionQueuePtr = PQUEUE_ALLOC(-1);
/*
* Iterate over work list to route each path. This involves an
* 'expansion' and 'traceback' phase for each source/destination pair.
*/
while (1) {
pair_t* coordinatePairPtr;
TM_BEGIN();
if (TMQUEUE_ISEMPTY(workQueuePtr)) {
coordinatePairPtr = NULL;
} else {
coordinatePairPtr = (pair_t*)TMQUEUE_POP(workQueuePtr);
}
TM_END();
if (coordinatePairPtr == NULL) {
break;
}
coordinate_t* srcPtr = (coordinate_t*)coordinatePairPtr->firstPtr;
coordinate_t* dstPtr = (coordinate_t*)coordinatePairPtr->secondPtr;
bool success = false;
vector_t* pointVectorPtr = NULL;
TM_BEGIN();
grid_copy(myGridPtr, gridPtr); /* ok if not most up-to-date */
if (PdoExpansion(routerPtr, myGridPtr, myExpansionQueuePtr,
srcPtr, dstPtr)) {
pointVectorPtr = PdoTraceback(gridPtr, myGridPtr, dstPtr, bendCost);
/*
* TODO: fix memory leak
*
* pointVectorPtr will be a memory leak if we abort this transaction
*/
if (pointVectorPtr) {
TMGRID_ADDPATH(gridPtr, pointVectorPtr);
TM_LOCAL_WRITE_L(success, true);
}
}
TM_END();
if (success) {
bool status = PVECTOR_PUSHBACK(myPathVectorPtr, (void*)pointVectorPtr);
assert(status);
}
}
/*
* Add my paths to global list
*/
list_t* pathVectorListPtr = routerArgPtr->pathVectorListPtr;
TM_BEGIN();
TMLIST_INSERT(pathVectorListPtr, (void*)myPathVectorPtr);
TM_END();
PGRID_FREE(myGridPtr);
PQUEUE_FREE(myExpansionQueuePtr);
#if DEBUG
puts("\nFinal Grid:");
grid_print(gridPtr);
#endif /* DEBUG */
TM_THREAD_EXIT();
}
/* =============================================================================
* router_solve
* =============================================================================
*/
void
router_solve (void* argPtr)
{
TM_THREAD_ENTER();
long threadId = thread_getId();
router_solve_arg_t* routerArgPtr = (router_solve_arg_t*)argPtr;
router_t* routerPtr = routerArgPtr->routerPtr;
maze_t* mazePtr = routerArgPtr->mazePtr;
long* numPathArray = routerArgPtr->numPathArray;
vector_t* myPathVectorPtr = PVECTOR_ALLOC(1);
assert(myPathVectorPtr);
queue_t* workQueuePtr = mazePtr->workQueuePtr;
grid_t* gridPtr = mazePtr->gridPtr;
grid_t* myGridPtr =
PGRID_ALLOC(gridPtr->width, gridPtr->height, gridPtr->depth);
assert(myGridPtr);
long bendCost = routerPtr->bendCost;
queue_t* myExpansionQueuePtr = PQUEUE_ALLOC(-1);
long numPath = 0;
/*
* Iterate over work list to route each path. This involves an
* 'expansion' and 'traceback' phase for each source/destination pair.
*/
while ((global_timedExecution && !global_isTerminated) || (!global_timedExecution)) {
//while (1) {
wait_for_turn(threadId);
if (global_timedExecution && global_isTerminated)
break;
ulong_t beginTime;
pair_t* coordinatePairPtr;
TM_BEGIN();
beginTime = get_thread_time();
if (TMQUEUE_ISEMPTY(workQueuePtr)) {
if (TMQUEUE_ISEMPTY(workQueuePtr))
coordinatePairPtr = NULL;
} else {
coordinatePairPtr = (pair_t*)TMQUEUE_POP(workQueuePtr);
}
TM_END();
//add_throughput(threadId , get_thread_time() - beginTime);
if (coordinatePairPtr == NULL) {
break;
}
coordinate_t* srcPtr = (coordinate_t*)coordinatePairPtr->firstPtr;
coordinate_t* dstPtr = (coordinate_t*)coordinatePairPtr->secondPtr;
bool_t success = FALSE;
vector_t* pointVectorPtr = NULL;
TM_BEGIN();
beginTime = get_thread_time();
grid_copy(myGridPtr, gridPtr); /* ok if not most up-to-date */
if (PdoExpansion(routerPtr, myGridPtr, myExpansionQueuePtr,
srcPtr, dstPtr)) {
pointVectorPtr = PdoTraceback(gridPtr, myGridPtr, dstPtr, bendCost);
/*
* TODO: fix memory leak
*
* pointVectorPtr will be a memory leak if we abort this transaction
*/
if (pointVectorPtr) {
TMGRID_ADDPATH(gridPtr, pointVectorPtr);
TM_LOCAL_WRITE_L(success, TRUE);
}
}
TM_END();
add_throughput(threadId , get_thread_time() - beginTime);
numPath++;
if (success) {
bool_t status = PVECTOR_PUSHBACK(myPathVectorPtr,
(void*)pointVectorPtr);
assert(status);
}
}
numPathArray[threadId] = numPath;
/*
* Add my paths to global list
*/
list_t* pathVectorListPtr = routerArgPtr->pathVectorListPtr;
TM_BEGIN();
TMLIST_INSERT(pathVectorListPtr, (void*)myPathVectorPtr);
TM_END();
PGRID_FREE(myGridPtr);
PQUEUE_FREE(myExpansionQueuePtr);
#if DEBUG
puts("\nFinal Grid:");
grid_print(gridPtr);
#endif /* DEBUG */
TM_THREAD_EXIT();
}
