static void TEST_CORE_Lock(void)
{
/* MT_LOCK API */
MT_LOCK x_lock;
/* dummy */
TEST_CORE_LockUserData = 111;
x_lock = MT_LOCK_Create(&TEST_CORE_LockUserData,
0, TEST_CORE_LockCleanup);
assert(x_lock);
verify(MT_LOCK_AddRef(x_lock) == x_lock);
verify(MT_LOCK_AddRef(x_lock) == x_lock);
verify(MT_LOCK_Delete(x_lock) == x_lock);
assert(TEST_CORE_LockUserData == 111);
verify(MT_LOCK_Do(x_lock, eMT_LockRead));
verify(MT_LOCK_Do(x_lock, eMT_Lock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Delete(x_lock) == x_lock);
assert(TEST_CORE_LockUserData == 111);
verify(MT_LOCK_Delete(x_lock) == 0);
assert(TEST_CORE_LockUserData == 222);
/* real */
x_lock = MT_LOCK_Create(&TEST_CORE_LockUserData,
TEST_CORE_LockHandler, TEST_CORE_LockCleanup);
assert(x_lock);
/* NB: Write after read is not usually an allowed lock nesting */
verify(MT_LOCK_Do(x_lock, eMT_LockRead));
verify(MT_LOCK_Do(x_lock, eMT_Lock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
/* Read after write is usually okay */
verify(MT_LOCK_Do(x_lock, eMT_Lock));
verify(MT_LOCK_Do(x_lock, eMT_LockRead));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
/* Try-locking sequence */
verify(MT_LOCK_Do(x_lock, eMT_TryLock));
verify(MT_LOCK_Do(x_lock, eMT_TryLockRead));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Do(x_lock, eMT_Unlock));
verify(MT_LOCK_Delete(x_lock) == 0);
}
int BlastHSPStreamRegisterMTLock(BlastHSPStream* hsp_stream,
MT_LOCK lock)
{
/* only one lock can be registered */
if (!hsp_stream || (hsp_stream->x_lock && lock)) {
MT_LOCK_Delete(lock);
return -1;
}
hsp_stream->x_lock = lock;
return 0;
}
/** Free the BlastHSPStream with its HSP list collector data structure.
* @param hsp_stream The HSP stream to free [in]
* @return NULL.
*/
BlastHSPStream* BlastHSPStreamFree(BlastHSPStream* hsp_stream)
{
int index=0;
BlastHSPPipe *p;
if (!hsp_stream) {
return NULL;
}
hsp_stream->x_lock = MT_LOCK_Delete(hsp_stream->x_lock);
Blast_HSPResultsFree(hsp_stream->results);
for (index=0; index < hsp_stream->num_hsplists; index++)
{
hsp_stream->sorted_hsplists[index] =
Blast_HSPListFree(hsp_stream->sorted_hsplists[index]);
}
sfree(hsp_stream->sort_by_score);
sfree(hsp_stream->sorted_hsplists);
if (hsp_stream->writer) {
(hsp_stream->writer->FreeFnPtr) (hsp_stream->writer);
hsp_stream->writer = NULL;
}
/* free un-used pipes */
while (hsp_stream->pre_pipe) {
p = hsp_stream->pre_pipe;
hsp_stream->pre_pipe = p->next;
sfree(p);
}
while (hsp_stream->tback_pipe) {
p = hsp_stream->tback_pipe;
hsp_stream->tback_pipe = p->next;
sfree(p);
}
sfree(hsp_stream);
return NULL;
}
/** Prohibit any future writing to the HSP stream when all results are written.
* Also perform sorting of results here to prepare them for reading.
* @param hsp_stream The HSP stream to close [in] [out]
*/
void BlastHSPStreamClose(BlastHSPStream* hsp_stream)
{
Int4 i, j, k;
Int4 num_hsplists;
BlastHSPResults *results;
if (!hsp_stream || !hsp_stream->results || hsp_stream->results_sorted)
return;
s_FinalizeWriter(hsp_stream);
if (hsp_stream->sort_by_score) {
if (hsp_stream->sort_by_score->sort_on_read) {
Blast_HSPResultsReverseSort(hsp_stream->results);
} else {
/* Reverse the order of HSP lists, because they will be returned
starting from end, for the sake of convenience */
Blast_HSPResultsReverseOrder(hsp_stream->results);
}
hsp_stream->results_sorted = TRUE;
hsp_stream->x_lock = MT_LOCK_Delete(hsp_stream->x_lock);
return;
}
results = hsp_stream->results;
num_hsplists = hsp_stream->num_hsplists;
/* concatenate all the HSPLists from 'results' */
for (i = 0; i < results->num_queries; i++) {
BlastHitList *hitlist = results->hitlist_array[i];
if (hitlist == NULL)
continue;
/* grow the list if necessary */
if (num_hsplists + hitlist->hsplist_count >
hsp_stream->num_hsplists_alloc) {
Int4 alloc = MAX(num_hsplists + hitlist->hsplist_count + 100,
2 * hsp_stream->num_hsplists_alloc);
hsp_stream->num_hsplists_alloc = alloc;
hsp_stream->sorted_hsplists = (BlastHSPList **)realloc(
hsp_stream->sorted_hsplists,
alloc * sizeof(BlastHSPList *));
}
for (j = k = 0; j < hitlist->hsplist_count; j++) {
BlastHSPList *hsplist = hitlist->hsplist_array[j];
if (hsplist == NULL)
continue;
hsplist->query_index = i;
hsp_stream->sorted_hsplists[num_hsplists + k] = hsplist;
k++;
}
hitlist->hsplist_count = 0;
num_hsplists += k;
}
/* sort in order of decreasing subject OID. HSPLists will be
read out from the end of hsplist_array later */
hsp_stream->num_hsplists = num_hsplists;
if (num_hsplists > 1) {
qsort(hsp_stream->sorted_hsplists, num_hsplists,
sizeof(BlastHSPList *), s_SortHSPListByOid);
}
hsp_stream->results_sorted = TRUE;
hsp_stream->x_lock = MT_LOCK_Delete(hsp_stream->x_lock);
}
