// just a few methods specific to the PointerArray static void PointerArraySpecificDemo() { PointerArray<DemoElement> test; DemoElement* p; p = gNew DemoElement(11, 22, 33, 44); if (p) test.AppendPtr(p); p = gNew DemoElement(55, 66, 77, 88); if (p) test.InsertPtr(0, p); if (test.PopPtr(&p)) gDelete(p); }
unsigned sendData(const UdpPermitToSendMsg &permit, bool isLocal, TokenBucket *bucket, bool &moreRequested, unsigned &maxPackets) { moreRequested = false; maxPackets = permit.max_data; PointerArray toSend; unsigned totalSent = cleanRetryData(permit, toSend); while (toSend.length() < maxPackets && dataQueued()) { DataBuffer *buffer = popQueuedData(); if (buffer) // Aborted slave queries leave NULL records on queue { UdpPacketHeader *header = (UdpPacketHeader*) buffer->data; toSend.append(buffer); totalSent += header->length; #ifdef __linux__ if (isLocal && (totalSent> 100000)) break; #endif } } maxPackets = toSend.length(); for (unsigned idx = 0; idx < maxPackets; idx++) { DataBuffer *buffer = (DataBuffer *) toSend.item(idx); UdpPacketHeader *header = (UdpPacketHeader*) buffer->data; bool isRetry = (header->udpSequence != 0); if (isRetry) { if (checkTraceLevel(TRACE_RETRY_DATA, 1)) DBGLOG("UdpSender: Resending packet to destination node %u sequence %u", permit.destNodeIndex, header->udpSequence); atomic_inc(&packetsRetried); } else header->udpSequence = nextUdpSequence(); unsigned length = header->length; if (bucket) { MTIME_SECTION(timer, "bucket_wait"); bucket->wait((length / 1024)+1); } try { if (udpSendCompletedInData) { if (idx == maxPackets-1) { // MORE - is this safe ? Any other thread looking at the data right now? Don't _think_ so... if (false && dataQueued()) // Causes some problems because no flow control info gets through at all { moreRequested = true; header->udpSequence |= (UDP_SEQUENCE_COMPLETE|UDP_SEQUENCE_MORE); } else header->udpSequence |= UDP_SEQUENCE_COMPLETE; } } #ifdef _SIMULATE_LOST_PACKETS if (isRetry || (header->udpSequence % 100) != 0) #endif data_socket->write(buffer->data, length); header->udpSequence &= ~UDP_SEQUENCE_BITS; } catch(IException *e) { StringBuffer s; DBGLOG("UdpSender: write exception - write(%p, %u) - %s", buffer->data, length, e->errorMessage(s).str()); e->Release(); } catch(...) { DBGLOG("UdpSender: write exception - unknown exception"); } if (!isRetry && maxRetryData) { unsigned slot = (retryDataIdx + retryDataCount) % maxRetryData; if (retryDataCount < maxRetryData) retryDataCount++; else { if (udpTraceLevel > 0) DBGLOG("Overflow in resend packet buffer for destination node %u - discarding packet sequence %u", permit.destNodeIndex, header->udpSequence); ::Release(retryData[slot]); } retryData[slot] = buffer; } else { ::Release(buffer); } } return totalSent; }
unsigned cleanRetryData(const UdpPermitToSendMsg &permit, PointerArray &retries) { // Any saved packets < lastReceived that are not listed as missing can be deleted SpinBlock b(lock); unsigned totalData = 0; if (checkTraceLevel(TRACE_RETRY_DATA, 3)) { unsigned minUdpSequence; if (retryDataCount) minUdpSequence = ((UdpPacketHeader *) retryData[retryDataIdx]->data)->udpSequence; else minUdpSequence = maxUdpSequence; StringBuffer permitStr; permit.toString(permitStr); DBGLOG("UdpSender: cleanRetryData (%s), total %u available between %u and %u", permitStr.str(), retryDataCount, minUdpSequence, maxUdpSequence); } unsigned lastReceived = permit.lastSequenceSeen; unsigned missingIndex = 0; unsigned missingCount = permit.missingCount; unsigned i = 0; if (maxRetryData) { while (i < retryDataCount && retries.length() < permit.max_data) { unsigned idx = (retryDataIdx + i) % maxRetryData; DataBuffer *buffer = retryData[idx]; if (buffer) { UdpPacketHeader *header = (UdpPacketHeader*) buffer->data; unsigned thisSequence = header->udpSequence; if (thisSequence > lastReceived) break; if (!missingCount || thisSequence < permit.missingSequences[missingIndex]) { ::Release(buffer); retryData[idx] = NULL; if (i) i++; // MORE - leaves holes - is this smart? Alternatively could close up... Should be rare anyway else { retryDataIdx = (retryDataIdx + 1) % maxRetryData; retryDataCount--; } } else if (thisSequence == permit.missingSequences[missingIndex]) { totalData += header->length; retries.append(buffer); i++; missingIndex++; missingCount--; } else { missingIndex++; missingCount--; } } else { if (i) i++; else { // Removing leading nulls retryDataCount--; retryDataIdx = (retryDataIdx + 1) % maxRetryData; } } } } if (checkTraceLevel(TRACE_RETRY_DATA, 3)) DBGLOG("UdpSender: cleanRetryData found %u to resend total size %u, total %u still available", retries.length(), totalData, retryDataCount); return totalData; }
void AirportManager__updateAirportPriorityList(AirportManager *pThis) {_ATC_LINK(1);{_ATC_PROC(1,1);{_ATC_BLOC(1,48);{ AirportManagerComponent *lAirportManagerComponent = ((T_ptr)0) ; PointerArray *lAirportLoadingEvents = ((T_ptr)0) ; T_uint32 lCount = 0; T_int32 lI = 0; T_int32 lJ = 0; T_int32 lK = 0; AirportLoadingEvent *lAirportLoadingEvent = ((T_ptr)0) ; T_int16 lAirportList[ 6 ]; T_boolean lUpdatedList = 0 ; T_boolean lNewAirport = 0 ; DatabaseServices *lDatabaseServices = ((T_ptr)0) ; MapObjectServices *lMapObjectServices = ((T_ptr)0) ; MapObjectServices *lPreloadedAirport = ((T_ptr)0) ; T_PtrChar lPreloadedAirportICAO = ((T_ptr)0) ; lAirportManagerComponent = CAirportManagerComponent->getInstance(); lDatabaseServices = (DatabaseServices*)(lAirportManagerComponent->getConnectedFacet(lAirportManagerComponent, E_AIRPORT_MANAGER_DATABASE_SERVICES_RECEPTACLE_INDEX)); lMapObjectServices = (MapObjectServices*)(lAirportManagerComponent->getConnectedFacet(lAirportManagerComponent, E_AIRPORT_MANAGER_MAP_OBJECT_SERVICES_RECEPTACLE_INDEX)); {_ATC_LOOP_bef(1,1);for (lI = 0; lI < 6 ; lI++) {_ATC_LOOP_in(1,1);{_ATC_BLOC(1,0);{ lAirportList[lI] = -1 ; }}}} switch (pThis->_flightPhase) { case E_GND_TAXI_OUT: case E_GND_TAKE_OFF: case E_FLT_CLIMB: case E_GND_PREFLIGHT: case E_GND_ACCELERATION:{_ATC_BLOC(1,4); { lAirportList[0] = pThis->_requestedAirportForDisplay; lAirportList[1] = pThis->_originAirport; lAirportList[2] = pThis->_nearestAirport; lAirportList[3] = pThis->_destinationAirport; lAirportList[4] = pThis->_airportToBeDisplayedInPlan; lAirportList[5] = pThis->_alternateAirport; }} break; case E_FLT_CRUISE:{_ATC_BLOC(1,5); { lAirportList[0] = pThis->_requestedAirportForDisplay; lAirportList[1] = pThis->_destinationAirport; lAirportList[2] = pThis->_BTVAirport; lAirportList[3] = pThis->_airportToBeDisplayedInPlan; lAirportList[4] = pThis->_alternateAirport; }} break; case E_GND_ENGSTOPPED: case E_FLT_APPROACH: case E_GND_LANDING: case E_GND_TAXI_IN: case E_GND_BRAKING:{_ATC_BLOC(1,6); { lAirportList[0] = pThis->_requestedAirportForDisplay; lAirportList[1] = pThis->_destinationAirport; lAirportList[2] = pThis->_nearestAirport; lAirportList[3] = pThis->_BTVAirport; lAirportList[4] = pThis->_airportToBeDisplayedInPlan; lAirportList[5] = pThis->_alternateAirport; }} break; default:{_ATC_BLOC(1,7); { }} break; } lI = 0; lJ = 0; {_ATC_LOOP_bef(1,21);while ((lI < 4 ) && (lJ < 6 )) {_ATC_LOOP_in(1,21);{_ATC_BLOC(1,20);{ if (lAirportList[lJ] != -1 ) {_ATC_BLOC(1,18);{ lK = lJ - 1; lNewAirport = 1 ; {_ATC_LOOP_bef(1,11);while (lK >= 0) {_ATC_LOOP_in(1,11);{_ATC_BLOC(1,10);{ if (lAirportList[lK] == lAirportList[lJ]) {_ATC_BLOC(1,8);{ lNewAirport = 0 ; }} else {_ATC_BLOC(1,9);{ }} lK--; }}}} if (lNewAirport == 1 ) {_ATC_BLOC(1,16);{ if ( pThis->_airportPriorityList[lI] != lAirportList[lJ]) {_ATC_BLOC(1,14);{ pThis->_airportPriorityList[lI] = lAirportList[lJ]; lUpdatedList = 1 ; }} else {_ATC_BLOC(1,15);{ }} lI++; }} else {_ATC_BLOC(1,17);{ }} }} else {_ATC_BLOC(1,19);{ }} lJ++; }}}} {_ATC_LOOP_bef(1,25);while (lI < 4 ) {_ATC_LOOP_in(1,25);{_ATC_BLOC(1,24);{ pThis->_airportPriorityList[lI] = -1 ; lI++; }}}} if (lUpdatedList == 1 ) {_ATC_BLOC(1,46);{ lAirportLoadingEvents = (PointerArray*)(lAirportManagerComponent->getConnectedFacet(lAirportManagerComponent, E_AIRPORT_MANAGER_AIRPORT_LOADING_EVENT_RECEPTACLE_INDEX)); lCount = lAirportLoadingEvents->getCount(lAirportLoadingEvents); {_ATC_LOOP_bef(1,29);for( lI = 0; lI < lCount; lI++ ) {_ATC_LOOP_in(1,29);{_ATC_BLOC(1,28);{ lAirportLoadingEvent = (AirportLoadingEvent*)(lAirportLoadingEvents->get(lAirportLoadingEvents, lI)); lAirportLoadingEvent->airportPriorityListUpdated(lAirportLoadingEvent, pThis->_airportPriorityList); }}}} {_ATC_LOOP_bef(1,43);for( lI = 0; lI < 4 ; lI++ ) {_ATC_LOOP_in(1,43);{_ATC_BLOC(1,42);{ if (pThis->_airportPriorityList[lI] != -1 ) {_ATC_BLOC(1,36);{ lPreloadedAirport = lDatabaseServices->getAirportInstance(lDatabaseServices, pThis->_airportPriorityList[lI]); lPreloadedAirportICAO = lMapObjectServices->getCharData(lMapObjectServices, lPreloadedAirport, 11 ); switch (lI) { case 0:{_ATC_BLOC(1,32); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT1.data[0], (const T_char *)lPreloadedAirportICAO, 32 ); FT_ICAO_OF_PRELOADED_ARPT1.length = CStringUtilities->length(&FT_ICAO_OF_PRELOADED_ARPT1.data[0]); }} break; case 1:{_ATC_BLOC(1,33); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT2.data[0], (const T_char *)lPreloadedAirportICAO, 32 ); FT_ICAO_OF_PRELOADED_ARPT2.length = CStringUtilities->length(&FT_ICAO_OF_PRELOADED_ARPT2.data[0]); }} break; case 2:{_ATC_BLOC(1,34); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT3.data[0], (const T_char *)lPreloadedAirportICAO, 32 ); FT_ICAO_OF_PRELOADED_ARPT3.length = CStringUtilities->length(&FT_ICAO_OF_PRELOADED_ARPT3.data[0]); }} break; case 3: default:{_ATC_BLOC(1,35); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT4.data[0], (const T_char *)lPreloadedAirportICAO, 32 ); FT_ICAO_OF_PRELOADED_ARPT4.length = CStringUtilities->length(&FT_ICAO_OF_PRELOADED_ARPT4.data[0]); }} break; } }} else {_ATC_BLOC(1,41);{ switch (lI) { case 0:{_ATC_BLOC(1,37); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT1.data[0], "", 32 ); FT_ICAO_OF_PRELOADED_ARPT1.length = 0; }} break; case 1:{_ATC_BLOC(1,38); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT2.data[0], "", 32 ); FT_ICAO_OF_PRELOADED_ARPT2.length = 0; }} break; case 2:{_ATC_BLOC(1,39); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT3.data[0], "", 32 ); FT_ICAO_OF_PRELOADED_ARPT3.length = 0; }} break; case 3: default:{_ATC_BLOC(1,40); { CStringUtilities->ncopy(&FT_ICAO_OF_PRELOADED_ARPT4.data[0], "", 32 ); FT_ICAO_OF_PRELOADED_ARPT4.length = 0; }} break; } }} }}}} }} else {_ATC_BLOC(1,47);{ }} {_ATC_PROC(1,0);return;} }}}}
void collapseDuplexGroup(string sorted_duplex_group_file, string collapsed_dg_file, string logFile, string errorFile, int maxGap, int maxTotal) { ofstream LOG(logFile, ios_base::app); ofstream ERR(errorFile, ios_base::app); LOG << "Start to collapseDuplexGroup " << sorted_duplex_group_file << " ===> " << collapsed_dg_file << endl; int merged_dgCount = 0; int firstPossible=0; PointerArray<DuplexGroup *> dgArray; long long fileLines = countFileLines(sorted_duplex_group_file); ProcessAlert alert(fileLines, 100000, 10); ifstream DUPLEXGROUP(sorted_duplex_group_file); char strand1, strand2; string chr1, chr2, supportReads; int start1, end1, start2, end2, support; while(DUPLEXGROUP>>chr1>>start1>>end1>>strand1>>chr2>>start2>>end2>>strand2>>supportReads>>support) { char buffer[200]; sprintf(buffer, "firstPossible: %d, merged_dgCount: %d", firstPossible, merged_dgCount); LOG << alert.alert(string(buffer)); DuplexGroup *dg = new DuplexGroup(chr1, start1, end1, strand1, chr2, start2,end2, strand2, support, supportReads); //dgArray.append(dg); //if(supportReads == "23198;10015265;10015267;10015268") // cout << dgArray[dgArray.arrayLen()-1]->supportRead << endl; int lastDGovarlapped = 0; bool merged = false; for(int idx=firstPossible; idx<dgArray.arrayLen();idx++) { int overlapped = dgArray[idx]->overlapDG(dg, maxGap, maxTotal); /* if(supportReads == "23198;10015265;10015267;10015268" and idx==dgArray.arrayLen()-1) { cout << dgArray[dgArray.arrayLen()-1]->supportRead << endl; cout <<overlapped << endl; } */ if (overlapped == -1){ if(not lastDGovarlapped) firstPossible = idx + 1; } else if(overlapped > 0){ lastDGovarlapped = 1; dgArray[idx]->mergeDuplexGroup(dg); //dgArray.del(dgArray.arrayLen()-1); merged = true; delete dg; merged_dgCount++; break; } else{ lastDGovarlapped = 1; } } if(not merged) dgArray.append(dg); //cout << merged_dgCount << endl; } LOG << alert.finish(); DUPLEXGROUP.close(); ofstream COLLAPSE(collapsed_dg_file); for(int i=0; i<dgArray.arrayLen(); i++) COLLAPSE << dgArray[i]->chr1 << "\t" << dgArray[i]->start1 << "\t" << dgArray[i]->end1 << "\t" << dgArray[i]->strand1 << "\t" << dgArray[i]->chr2 << "\t" << dgArray[i]->start2 << "\t" << dgArray[i]->end2 << "\t" << dgArray[i]->strand2 << "\t" << dgArray[i]->supportRead << "\t" << dgArray[i]->support << "\n"; COLLAPSE.close(); LOG.close(); ERR.close(); }
void genDuplexGroup(string read_pair_file, string duplex_group_file, string logFile, string errorFile, int OVERLAP, bool multiDG) { ofstream LOG(logFile, ios_base::app); ofstream ERR(errorFile, ios_base::app); LOG << "Start to genDuplexGroup " << read_pair_file << " ===> " << duplex_group_file << endl; long long fileLines = countFileLines(read_pair_file); ProcessAlert alert(fileLines, 100000, 10); ifstream READPAIR(read_pair_file); char strand1, strand2; string chr1, chr2; int start1, end1, id1, score1, start2, end2, id2, score2; int counter = 0; int firstPossible = 0; int dgCount = 0; PointerArray<DuplexGroup *> dgArray; while(READPAIR>>chr1>>start1>>end1>>id1>>score1>>strand1>>chr2>>start2>>end2>>id2>>score2>>strand2) { char buffer[200]; sprintf(buffer, "firstPossible: %d, duplexCount: %d", firstPossible, dgCount); LOG << alert.alert(string(buffer)); Read read(chr1, start1, end1, strand1, chr2, start2, end2, strand2, id1); int nonOverlapped = 1; int lastDGoverlapped = 0; for(int i=firstPossible;i<dgCount;i++) { int overlap = dgArray[i]->overlapRead(read); //cout << overlap << endl; if(overlap >= OVERLAP) { lastDGoverlapped = 1; nonOverlapped = 0; dgArray[i]->addRead(read); //cout << "find one" << endl; if (! multiDG) break; }else if (overlap == -1){ if(not lastDGoverlapped) firstPossible = i + 1; }else { lastDGoverlapped = 1; } } if (nonOverlapped) { DuplexGroup *dg = new DuplexGroup(read); dgArray.append( dg ); dgCount++; } counter++; } LOG << alert.finish(); READPAIR.close(); ofstream DUPLEXGROUP(duplex_group_file); for(int i=0; i<dgArray.arrayLen(); i++) DUPLEXGROUP << dgArray[i]->chr1 << "\t" << dgArray[i]->start1 << "\t" << dgArray[i]->end1 << "\t" << dgArray[i]->strand1 << "\t" << dgArray[i]->chr2 << "\t" << dgArray[i]->start2 << "\t" << dgArray[i]->end2 << "\t" << dgArray[i]->strand2 << "\t" << dgArray[i]->supportRead << "\t" << dgArray[i]->support << endl; DUPLEXGROUP.close(); LOG.close(); ERR.close(); }