/**
* Monitors and displays the progress of the download job.
*
* A new status message is output whenever the job's status changes or,
* when transferring data, every 2 seconds displays how much data
* has been transferred.
*/
HRESULT
MonitorJobProgress( _In_ IBackgroundCopyJob *Job )
{
HRESULT hr;
LPWSTR JobName;
BG_JOB_STATE State;
int PreviousState = -1;
bool Exit = false;
int ProgressCounter = 0;
hr = Job->GetDisplayName( &JobName );
printf( "Progress report for download job '%ws'.\n", JobName );
// display the download progress
while( !Exit )
{
hr = Job->GetState( &State );
if( State != PreviousState )
{
switch( State )
{
case BG_JOB_STATE_QUEUED:
printf( "Job is in the queue and waiting to run.\n" );
break;
case BG_JOB_STATE_CONNECTING:
printf( "BITS is trying to connect to the remote server.\n" );
break;
case BG_JOB_STATE_TRANSFERRING:
printf( "BITS has started downloading data.\n" );
DisplayProgress( Job );
break;
case BG_JOB_STATE_ERROR:
printf( "ERROR: BITS has encountered a non-recoverable error (error code %08X).\n", GetLastError() );
printf( " Exiting job.\n" );
Exit = true;
break;
case BG_JOB_STATE_TRANSIENT_ERROR:
printf( "ERROR: BITS has encountered a recoverable error.\n" );
DisplayError( Job );
printf( " Continuing to retry.\n" );
break;
case BG_JOB_STATE_TRANSFERRED:
DisplayProgress( Job );
printf( "The job has been successfully completed.\n" );
printf( "Finalizing local files.\n" );
Job->Complete();
break;
case BG_JOB_STATE_ACKNOWLEDGED:
printf( "Finalization complete.\n" );
Exit = true;
break;
case BG_JOB_STATE_CANCELLED:
printf( "WARNING: The job has been cancelled.\n" );
Exit = true;
break;
default:
printf( "WARNING: Unknown BITS state %d.\n", State );
Exit = true;
}
PreviousState = State;
}
else if (State == BG_JOB_STATE_TRANSFERRING )
{
// display job progress every 2 seconds
if( ++ProgressCounter % TWO_SECOND_LOOP == 0 )
{
DisplayProgress( Job );
}
}
Sleep(HALF_SECOND_AS_MILLISECONDS);
}
printf("\n");
if( SUCCEEDED(hr) )
{
hr = DisplayFileHeaders( Job );
}
return hr;
}
MultipleAlignment* Align(PDBChain **chains, int numChains, int displayStatus) {
int i, j;
int numAlignments = numChains;
MultipleAlignment** alignments = (MultipleAlignment**) malloc(numAlignments * sizeof(MultipleAlignment*));
int numAlignedAlignments = numChains * (numChains-1)/2;
MultipleAlignment** alignedAlignments = (MultipleAlignment**) malloc(numAlignedAlignments * sizeof(MultipleAlignment*));
double *pairScores;
int numTotalAlignments = (numChains-1) * (numChains-1);
int len = 1;
int d = 10;
MultipleAlignment *ma;
/* Indices of chains used in pairwise alignments. Simplest way to divide up work
* for the first pass. */
int *indices = (int*) malloc(sizeof(int) * 2 * numTotalAlignments);
/* Used for output */
char progressTemplate[64];
int backspace2 = 0;
int backspace = 0;
/* Keeps track of which alignment we're on. For display only. */
int count = 0;
int pass = 1;
for (i=0; i<numChains; i++) {
alignments[i] = CreateSingleStrandAlignment(Distill(chains[i], i));
}
pairScores = (double*) malloc(sizeof(double) * numChains*numChains);
while (numTotalAlignments >= d) {
len ++;
d*=10;
}
/* Structure pair list. Simplest way of breaking up first pass for threading */
for (i=0; i<numChains; i++) {
for (j=0; j<i; j++) {
indices[count*2] = i;
indices[count*2+1] = j;
count++;
}
}
count = 0;
if (displayStatus) {
backspace2 = fprintf(stderr, "Pass %i, ", pass);
}
#ifndef _OPENMP
{
if (displayStatus) {
sprintf(progressTemplate, "Single threaded [%%%ii/%i]", len, numTotalAlignments);
DisplayProgress(&backspace, progressTemplate, count);
}
#else
#pragma omp parallel default(shared)
{
#pragma omp single
if (displayStatus) {
int threads = omp_get_num_threads();
if (threads > 1) sprintf(progressTemplate, "%i threads [%%%ii/%i]", threads, len, numTotalAlignments);
else sprintf(progressTemplate, "1 thread [%%%ii/%i]", len, numTotalAlignments);
DisplayProgress(&backspace, progressTemplate, count);
}
#pragma omp for schedule(dynamic, 1)
#endif
for (i=0; i<numAlignedAlignments; i++) {
alignedAlignments[i] = AlignAlignments(alignments[indices[i*2]], alignments[indices[i*2+1]], 0, 0, 0);
pairScores[indices[i*2]*numChains + indices[i*2+1]] =
pairScores[indices[i*2+1]*numChains + indices[i*2]] = alignedAlignments[i]->score;
if (displayStatus) {
#ifdef _OPENMP
#pragma omp critical
#endif
DisplayProgress(&backspace, progressTemplate, ++count);
}
}
}
free(indices);
pass++;
while (numAlignedAlignments) {
int best = 0;
int index1, index2;
for (i=1; i<numAlignedAlignments; i++) {
if (alignedAlignments[i]->score > alignedAlignments[best]->score) {
best = i;
}
}
ma = alignedAlignments[best];
alignedAlignments[best] = alignedAlignments[--numAlignedAlignments];
/* Remove anything containing the elements of ma from both
* sets of alignments.
*/
index1 = ma->chains[0]->id;
index2 = ma->chains[ma->numChains-1]->id;
for (i=numAlignedAlignments-1; i >= 0; i--) {
for (j=0; j<alignedAlignments[i]->numChains; j++) {
if (alignedAlignments[i]->chains[j]->id == index1 ||
alignedAlignments[i]->chains[j]->id == index2) {
CleanupAlignment(alignedAlignments[i]);
alignedAlignments[i] = alignedAlignments[--numAlignedAlignments];
break;
}
}
}
for (i=numAlignments-1; i >= 0; i--) {
for (j=0; j<alignments[i]->numChains; j++) {
if (alignments[i]->chains[j]->id == index1 ||
alignments[i]->chains[j]->id == index2) {
CleanupAlignment(alignments[i]);
alignments[i] = alignments[--numAlignments];
break;
}
}
}
if (displayStatus) {
backspace2 += backspace;
backspace = 0;
DisplayProgress(&backspace2, "Pass %i, ", pass++);
DisplayProgress(&backspace, progressTemplate, count);
}
#ifdef _OPENMP
#pragma omp parallel for default(shared) schedule(dynamic, 1)
#endif
/* Run all the new alignments and add ma to the list of alignments I've kept. */
for (i=numAlignments-1; i >= 0; i--) {
double bestScore = 0;
int best1=0, best2=0;
/* Need private (thread) variables. */
int j, k;
for (j=0; j<alignments[i]->numChains; j++) {
for (k=0; k<ma->numChains; k++) {
double score = pairScores[ma->chains[k]->id * numChains + alignments[i]->chains[j]->id];
if (score > bestScore) {
bestScore = score;
best1 = j;
best2 = k;
}
}
}
alignedAlignments[numAlignedAlignments+i] = AlignAlignments(alignments[i], ma, best1, best2, 0);
if (displayStatus) {
#ifdef _OPENMP
#pragma omp critical
#endif
DisplayProgress(&backspace, progressTemplate, ++count);
}
}
numAlignedAlignments += numAlignments;
alignments[numAlignments++] = ma;
}
free(pairScores);
/* The only alignment left. */
ma = alignments[0];
free(alignments);
free(alignedAlignments);
return ma;
}
