void OperThreadWin::StopThread()
{
MutexLock lock( &operMutex );
if ( !tNode )
{
threadId = -1;
return;
}
MutexLock lockNode( &tNode->mutex );
tNode->stopped = true;
tNode->data = 0;
if ( !this->cbExecuted ) //!!!
{
tNode->cbRet = -1;
tNode->cbCond.Signal(); // на всякий случай, вдруг сигнал о каллбаке послан, но сообщение еще до окна не дошло
}
tNode->win = 0;
tNode->prev = 0;
if ( operStopList ) { operStopList->prev = tNode; }
tNode->next = operStopList;
operStopList = tNode;
tNode = 0;
threadId = -1;
}
void OperThreadWin::SetStopFlag()
{
if ( tNode )
{
MutexLock lockNode( &tNode->mutex );
tNode->stopped = true;
}
}
static void reConnectAnnotation(IDnum * currentPreNodeID, Annotation * annot,
Coordinate * currentPosition,
IDnum sequenceIndex,
PreGraph * preGraph,
PreMarker ** previous)
{
IDnum nextPreNodeID = getStartID(annot);
#ifdef _OPENMP
lockNode(nextPreNodeID);
#endif
*previous = addPreMarker_pg(preGraph,
nextPreNodeID,
sequenceIndex,
currentPosition,
*previous);
#ifdef _OPENMP
unLockNode(nextPreNodeID);
#endif
while (*currentPreNodeID != getFinishID(annot)) {
nextPreNodeID = (*currentPreNodeID) + 1;
#ifdef _OPENMP
lockNode(nextPreNodeID);
#endif
*previous = addPreMarker_pg(preGraph,
nextPreNodeID,
sequenceIndex,
currentPosition,
*previous);
#ifdef _OPENMP
unLockNode(nextPreNodeID);
#endif
*currentPreNodeID = nextPreNodeID;
}
}
void* __123___OperThread( void* param )
{
if ( !param ) { return nullptr; }
clPtr<OperThreadParam> pTp( ( OperThreadParam* )param );
// release the reference added before thread start
pTp->DecRefCount();
try
{
pTp->RunFunc();
}
catch ( ... )
{
fprintf( stderr, "__123___OperThread(): exception in OperThread!!!\n" );
}
MutexLock lock( &operMutex );
MutexLock lockNode( &pTp->node->mutex );
if ( pTp->node->stopped )
{
if ( pTp->node->prev )
{
pTp->node->prev->next = pTp->node->next;
}
else
{
operStopList = pTp->node->next;
}
if ( pTp->node->next )
{
pTp->node->next->prev = pTp->node->prev;
}
}
else
{
ASSERT( pTp->node->win );
}
if ( pTp->node->win )
{
// reset pointer to the Node in corresponding ThreadWin since we are going to delete it
pTp->node->win->tNode = nullptr;
}
pTp->node->stopped = true; //!!!
lockNode.Unlock(); //!!!
#ifdef _DEBUG
printf( "stop: %s\n", pTp->node->threadInfo.data( ) );
#endif
delete( pTp->node );
pTp->node = nullptr;
return nullptr;
}
static void createPreMarkers(RoadMapArray * rdmaps, PreGraph * preGraph,
IDnum * chains)
{
IDnum sequenceIndex;
IDnum referenceCount = rdmaps->referenceCount;
#ifndef _OPENMP
Annotation *annot = rdmaps->annotations;
#endif
#ifdef _OPENMP
int threads = omp_get_max_threads();
if (threads > 8)
threads = 8;
#pragma omp parallel for num_threads(threads)
#endif
for (sequenceIndex = 1;
sequenceIndex <= referenceCount;
sequenceIndex++) {
#ifdef _OPENMP
Annotation *annot = getAnnotationInArray(rdmaps->annotations, annotationOffset[sequenceIndex - 1]);
#endif
RoadMap *rdmap;
Coordinate currentPosition, currentInternalPosition;
IDnum currentPreNodeID, nextInternalPreNodeID;
IDnum annotIndex, lastAnnotIndex;
PreMarker * previous;
if (sequenceIndex % 1000000 == 0)
velvetLog("Connecting %li / %li\n", (long) sequenceIndex,
(long) sequenceCount_pg(preGraph));
rdmap = getRoadMapInArray(rdmaps, sequenceIndex - 1);
annotIndex = 0;
lastAnnotIndex = getAnnotationCount(rdmap);
nextInternalPreNodeID = chooseNextInternalPreNode
(chains[sequenceIndex] - 1, sequenceIndex,
preGraph, chains);
previous = NULL;
currentPosition = 0;
currentInternalPosition = 0;
currentPreNodeID = 0;
// Recursion up to last annotation
while (annotIndex < lastAnnotIndex
|| nextInternalPreNodeID != 0) {
if (annotIndex == lastAnnotIndex
|| (nextInternalPreNodeID != 0
&& currentInternalPosition <
getPosition(annot))) {
#ifdef _OPENMP
lockNode(nextInternalPreNodeID);
#endif
previous = addPreMarker_pg(preGraph,
nextInternalPreNodeID,
sequenceIndex,
¤tPosition,
previous);
#ifdef _OPENMP
unLockNode(nextInternalPreNodeID);
#endif
currentPreNodeID = nextInternalPreNodeID;
nextInternalPreNodeID =
chooseNextInternalPreNode
(currentPreNodeID, sequenceIndex,
preGraph, chains);
currentInternalPosition +=
getPreNodeLength_pg(currentPreNodeID,
preGraph);
} else {
reConnectAnnotation(¤tPreNodeID, annot,
¤tPosition,
sequenceIndex,
preGraph,
&previous);
annot = getNextAnnotation(annot);
annotIndex++;
}
}
}
}
static void threadSequenceThroughGraph(TightString * tString,
KmerOccurenceTable * kmerTable,
Graph * graph,
IDnum seqID, Category category,
boolean readTracking,
boolean double_strand,
ReferenceMapping * referenceMappings,
Coordinate referenceMappingCount,
IDnum refCount,
Annotation * annotations,
IDnum annotationCount,
boolean second_in_pair)
{
Kmer word;
Kmer antiWord;
Coordinate readNucleotideIndex;
Coordinate kmerIndex;
KmerOccurence *kmerOccurence;
int wordLength = getWordLength(graph);
PassageMarkerI marker = NULL_IDX;
PassageMarkerI previousMarker = NULL_IDX;
Node *node = NULL;
Node *previousNode = NULL;
Coordinate coord = 0;
Coordinate previousCoord = 0;
Nucleotide nucleotide;
boolean reversed;
IDnum refID;
Coordinate refCoord = 0;
ReferenceMapping * refMap;
Annotation * annotation = annotations;
Coordinate index = 0;
Coordinate uniqueIndex = 0;
Coordinate annotIndex = 0;
IDnum annotCount = 0;
SmallNodeList * nodePile = NULL;
// Neglect any string shorter than WORDLENGTH :
if (getLength(tString) < wordLength)
return;
clearKmer(&word);
clearKmer(&antiWord);
// Fill in the initial word :
for (readNucleotideIndex = 0;
readNucleotideIndex < wordLength - 1; readNucleotideIndex++) {
nucleotide = getNucleotide(readNucleotideIndex, tString);
pushNucleotide(&word, nucleotide);
if (double_strand || second_in_pair) {
#ifdef COLOR
reversePushNucleotide(&antiWord, nucleotide);
#else
reversePushNucleotide(&antiWord, 3 - nucleotide);
#endif
}
}
// Go through sequence
while (readNucleotideIndex < getLength(tString)) {
nucleotide = getNucleotide(readNucleotideIndex++, tString);
pushNucleotide(&word, nucleotide);
if (double_strand || second_in_pair) {
#ifdef COLOR
reversePushNucleotide(&antiWord, nucleotide);
#else
reversePushNucleotide(&antiWord, 3 - nucleotide);
#endif
}
// Update annotation if necessary
if (annotCount < annotationCount && annotIndex == getAnnotationLength(annotation)) {
annotation = getNextAnnotation(annotation);
annotCount++;
annotIndex = 0;
}
// Search for reference mapping
if (category == REFERENCE) {
if (referenceMappings)
refMap = findReferenceMapping(seqID, index, referenceMappings, referenceMappingCount);
else
refMap = NULL;
if (refMap) {
node = getNodeInGraph(graph, refMap->nodeID);
if (refMap->nodeID > 0) {
coord = refMap->nodeStart + (index - refMap->referenceStart);
} else {
coord = getNodeLength(node) - refMap->nodeStart - refMap->length + (index - refMap->referenceStart);
}
} else {
node = NULL;
if (previousNode)
break;
}
}
// Search for reference-based mapping
else if (annotCount < annotationCount && uniqueIndex >= getPosition(annotation) && getAnnotSequenceID(annotation) <= refCount && getAnnotSequenceID(annotation) >= -refCount) {
refID = getAnnotSequenceID(annotation);
if (refID > 0)
refCoord = getStart(annotation) + annotIndex;
else
refCoord = getStart(annotation) - annotIndex;
refMap = findReferenceMapping(refID, refCoord, referenceMappings, referenceMappingCount);
// If success
if (refMap) {
if (refID > 0) {
node = getNodeInGraph(graph, refMap->nodeID);
if (refMap->nodeID > 0) {
coord = refMap->nodeStart + (refCoord - refMap->referenceStart);
} else {
coord = getNodeLength(node) - refMap->nodeStart - refMap->length + (refCoord - refMap->referenceStart);
}
} else {
node = getNodeInGraph(graph, -refMap->nodeID);
if (refMap->nodeID > 0) {
coord = getNodeLength(node) - refMap->nodeStart - (refCoord - refMap->referenceStart) - 1;
} else {
coord = refMap->nodeStart + refMap->length - (refCoord - refMap->referenceStart) - 1;
}
}
} else {
node = NULL;
if (previousNode)
break;
}
}
// Search in table
else {
reversed = false;
if (double_strand) {
if (compareKmers(&word, &antiWord) <= 0) {
kmerOccurence =
findKmerInKmerOccurenceTable(&word,
kmerTable);
} else {
kmerOccurence =
findKmerInKmerOccurenceTable(&antiWord,
kmerTable);
reversed = true;
}
} else {
if (!second_in_pair) {
kmerOccurence =
findKmerInKmerOccurenceTable(&word,
kmerTable);
} else {
kmerOccurence =
findKmerInKmerOccurenceTable(&antiWord,
kmerTable);
reversed = true;
}
}
if (kmerOccurence) {
if (!reversed) {
node = getNodeInGraph(graph, getKmerOccurenceNodeID(kmerOccurence));
coord = getKmerOccurencePosition(kmerOccurence);
} else {
node = getNodeInGraph(graph, -getKmerOccurenceNodeID(kmerOccurence));
coord = getNodeLength(node) - getKmerOccurencePosition(kmerOccurence) - 1;
}
} else {
node = NULL;
if (previousNode)
break;
}
}
// Increment positions
if (annotCount < annotationCount && uniqueIndex >= getPosition(annotation))
annotIndex++;
else
uniqueIndex++;
// Fill in graph
if (node)
{
#ifdef OPENMP
lockNode(node);
#endif
kmerIndex = readNucleotideIndex - wordLength;
if (previousNode == node
&& previousCoord == coord - 1) {
if (category / 2 >= CATEGORIES) {
setPassageMarkerFinish(marker,
kmerIndex +
1);
setFinishOffset(marker,
getNodeLength(node)
- coord - 1);
} else {
#ifndef SINGLE_COV_CAT
incrementVirtualCoverage(node, category / 2, 1);
incrementOriginalVirtualCoverage(node, category / 2, 1);
#else
incrementVirtualCoverage(node, 1);
#endif
}
#ifdef OPENMP
unLockNode(node);
#endif
} else {
if (category / 2 >= CATEGORIES) {
marker =
newPassageMarker(seqID,
kmerIndex,
kmerIndex + 1,
coord,
getNodeLength
(node) -
coord - 1);
transposePassageMarker(marker,
node);
connectPassageMarkers
(previousMarker, marker,
graph);
previousMarker = marker;
} else {
if (readTracking) {
if (!isNodeMemorized(node, nodePile)) {
addReadStart(node,
seqID,
coord,
graph,
kmerIndex);
memorizeNode(node, &nodePile);
} else {
blurLastShortReadMarker
(node, graph);
}
}
#ifndef SINGLE_COV_CAT
incrementVirtualCoverage(node, category / 2, 1);
incrementOriginalVirtualCoverage(node, category / 2, 1);
#else
incrementVirtualCoverage(node, 1);
#endif
}
#ifdef OPENMP
lockTwoNodes(node, previousNode);
#endif
createArc(previousNode, node, graph);
#ifdef OPENMP
unLockTwoNodes(node, previousNode);
#endif
}
previousNode = node;
previousCoord = coord;
}
index++;
}
if (readTracking && category / 2 < CATEGORIES)
unMemorizeNodes(&nodePile);
}
static void ghostThreadSequenceThroughGraph(TightString * tString,
KmerOccurenceTable *
kmerTable, Graph * graph,
IDnum seqID, Category category,
boolean readTracking,
boolean double_strand,
ReferenceMapping * referenceMappings,
Coordinate referenceMappingCount,
IDnum refCount,
Annotation * annotations,
IDnum annotationCount,
boolean second_in_pair)
{
Kmer word;
Kmer antiWord;
Coordinate readNucleotideIndex;
KmerOccurence *kmerOccurence;
int wordLength = getWordLength(graph);
Nucleotide nucleotide;
IDnum refID;
Coordinate refCoord;
ReferenceMapping * refMap = NULL;
Coordinate uniqueIndex = 0;
Coordinate annotIndex = 0;
IDnum annotCount = 0;
boolean reversed;
SmallNodeList * nodePile = NULL;
Annotation * annotation = annotations;
Node *node;
Node *previousNode = NULL;
// Neglect any read which will not be short paired
if ((!readTracking && category % 2 == 0)
|| category / 2 >= CATEGORIES)
return;
// Neglect any string shorter than WORDLENGTH :
if (getLength(tString) < wordLength)
return;
// Verify that all short reads are reasonnably short
if (getLength(tString) > USHRT_MAX) {
velvetLog("Short read of length %lli, longer than limit %i\n",
(long long) getLength(tString), SHRT_MAX);
velvetLog("You should better declare this sequence as long, because it genuinely is!\n");
exit(1);
}
clearKmer(&word);
clearKmer(&antiWord);
// Fill in the initial word :
for (readNucleotideIndex = 0;
readNucleotideIndex < wordLength - 1; readNucleotideIndex++) {
nucleotide = getNucleotide(readNucleotideIndex, tString);
pushNucleotide(&word, nucleotide);
if (double_strand || second_in_pair) {
#ifdef COLOR
reversePushNucleotide(&antiWord, nucleotide);
#else
reversePushNucleotide(&antiWord, 3 - nucleotide);
#endif
}
}
// Go through sequence
while (readNucleotideIndex < getLength(tString)) {
// Shift word:
nucleotide = getNucleotide(readNucleotideIndex++, tString);
pushNucleotide(&word, nucleotide);
if (double_strand || second_in_pair) {
#ifdef COLOR
reversePushNucleotide(&antiWord, nucleotide);
#else
reversePushNucleotide(&antiWord, 3 - nucleotide);
#endif
}
// Update annotation if necessary
if (annotCount < annotationCount && annotIndex == getAnnotationLength(annotation)) {
annotation = getNextAnnotation(annotation);
annotCount++;
annotIndex = 0;
}
// Search for reference mapping
if (annotCount < annotationCount && uniqueIndex >= getPosition(annotation) && getAnnotSequenceID(annotation) <= refCount && getAnnotSequenceID(annotation) >= -refCount) {
refID = getAnnotSequenceID(annotation);
if (refID > 0)
refCoord = getStart(annotation) + annotIndex;
else
refCoord = getStart(annotation) - annotIndex;
refMap = findReferenceMapping(refID, refCoord, referenceMappings, referenceMappingCount);
// If success
if (refMap) {
if (refID > 0)
node = getNodeInGraph(graph, refMap->nodeID);
else
node = getNodeInGraph(graph, -refMap->nodeID);
} else {
node = NULL;
if (previousNode)
break;
}
}
// if not.. look in table
else {
reversed = false;
if (double_strand) {
if (compareKmers(&word, &antiWord) <= 0) {
kmerOccurence =
findKmerInKmerOccurenceTable(&word,
kmerTable);
} else {
kmerOccurence =
findKmerInKmerOccurenceTable(&antiWord,
kmerTable);
reversed = true;
}
} else {
if (!second_in_pair) {
kmerOccurence =
findKmerInKmerOccurenceTable(&word,
kmerTable);
} else {
kmerOccurence =
findKmerInKmerOccurenceTable(&antiWord,
kmerTable);
reversed = true;
}
}
if (kmerOccurence) {
if (!reversed)
node = getNodeInGraph(graph, getKmerOccurenceNodeID(kmerOccurence));
else
node = getNodeInGraph(graph, -getKmerOccurenceNodeID(kmerOccurence));
} else {
node = NULL;
if (previousNode)
break;
}
}
if (annotCount < annotationCount && uniqueIndex >= getPosition(annotation))
annotIndex++;
else
uniqueIndex++;
previousNode = node;
// Fill in graph
if (node && !isNodeMemorized(node, nodePile))
{
#ifdef OPENMP
lockNode(node);
#endif
incrementReadStartCount(node, graph);
#ifdef OPENMP
unLockNode(node);
#endif
memorizeNode(node, &nodePile);
}
}
unMemorizeNodes(&nodePile);
}