void timedmatvec_( int *errorflag,
int n,//matrix order
int nnz,// nonzeros num in A
int *rows,//nnz for coo with row indices of nonzeros in A, n+1 for csr, 1-based ndexes of where row begins
int *cols,//array of length nna with col indices of nonzeros in A
double *vals,//nnz
int whichone,//1 COO,2 CSR
double *x,//1D dense vector
double *y,
double *timetaken//
)
{
int k, i;
double t;
printf("n = %d\n", n);
printf("nnz = %d\n", nnz);
printf("whichone = %d\n", whichone);
*errorflag = 0;
*timetaken = -17.0;
if(n<1) *errorflag=-2;
if(nnz<0) *errorflag=-3;
if(!rows) *errorflag=-4;
if(!cols) *errorflag=-5;
if(!vals) *errorflag=-6;
if((whichone!=1) || (whichone!=2)) *errorflag=-7;
if(!x) *errorflag=-8;
if(!y) *errorflag=-9;
double t1,t2;
t1=elapsedtime();
if(whichone==1){
}
return;
}
void taskteam::showtimings()
{
// timing
ftime(&endtime);
std::cout << " taskteam " << get_teamid() << " total runtime: "
<< elapsedtime(starttime, endtime) << std::endl;
std::cout << " " << workers.size() << " threads were used" << std::endl
<< " the task ran " << ntaskteam_runs << " times" << std::endl
<< " thread cumulative timings were as follows:" << std::endl
<< "\tid,\t\tt(s)\tr" << std::endl;
for(std::map<pthread_t, double>::const_iterator it = cumulativetimes.begin();
it != cumulativetimes.end(); ++it) {
std::cout << "\t" << it->first
<< "\t" << cumulativetimes[it->first]
<< "\t" << cumulativeruns[it->first]
<< std::endl;
}
}
int taskteam::do_work()
{
// ! ! ! ! wait if there are threads working ??
lockteam();
assert(taskfcn != NULL);
timeb teamstart;
ftime(&teamstart);
std::cout << "-- Task team starting" << std::endl;
ntasks_todo = tasks.size();;
ready = true;
int err = pthread_cond_broadcast(&start);
if(err != 0){
std::cerr << "error starting the team" << std::endl;
}
while( !tasks.empty() ) {
err = pthread_cond_wait(&finish, &mutex);
if(err != 0){
std::cerr << "error waiting for work" << std::endl;
}
}
ntaskteam_runs++;
timeb teamend;
ftime(&teamend);
//std::cout.setf(std::ios::scientific, std::ios::floatfield);
std::cout << "-- Task team finished "
<< ", taking " << std::setprecision(4)
<< elapsedtime(teamstart, teamend)
<< "s" <<std::endl;
ready = false;
unlockteam();
assert( tasks.empty() );
assert( ntasks_todo == 0 );
return 0;
}
BamX::BamX(pars & Params1) // optional constructor
{
// parameters
Params=Params1;
Nread=0;
Npair=0;
Nproper=0;
Nout=0;
LFlow=INT_MIN;
LFhigh=INT_MAX;
region.limit=false;
IlluminizeBam=0;
outFragTailBam=false;
outInterChromBam=false;
outUniqueMultipleBam=false;
outUniquePartialBam=false;
outUniqueUnmappedBam=false;
outAllPairsBam=false;
outReadPairPosBam=false;
//output file
//samfile_t *fp;
bam_header_t *bam_header;
string s = Params.getInput();
BamUtil bam1(s);
Bam = bam1;
string filename=extractfilename(s);
// parameters
string fragPosFile = Params.getString("ReadPairPosFile");
string r = Params.getString("ChromRegion");
int maxReads = Params.getInt("MaxReads");
Qmin = Params.getInt("Qmin");
LRmin = Params.getInt("MinReadLength");
maxmismatchPC=Params.getDouble("FractionMaxMisMatches");
FragLengthWindow=Params.getInt("FragmentLengthWindow");
int cmd_MateMode=Params.getInt("ReadPairSenseConfig");
string ReferenceFastaFile=Params.getString("ReferenceFastaFile");
FragmentTailPercent=Params.getDouble("FragmentTailPercent");
IlluminizeBam=Params.getInt("Illuminize")>0;
outputDirectory=Params.getString("OutputDirectory");
int minLR=Params.getInt("MinReadLength");
int SplitBracketMin=Params.getInt("SplitBracketMin");
int SplitBaseQmin=Params.getInt("SplitBaseQmin");
string StatFile=Params.getString("StatFile");
if (StatFile.size()>0) {
hists H1(StatFile);
hist HLF=H1.h["LF"];
hist HLR=H1.h["LR"];
Params.setHist("LF",HLF);
Params.setHist("LR",HLR);
H1.h.clear(); // free some memory
if (FragmentTailPercent>0) {
LFlow=int(HLF.p2xTrim(FragmentTailPercent/100.));
LFhigh=int(HLF.p2xTrim(1-FragmentTailPercent/100.));
}
}
int dbg = Params.getInt("Dbg");
time(&tprev);
if (ReferenceFastaFile.size()>0) {
FastaObj RF1(ReferenceFastaFile, "");
Reference=RF1;
RF1.seq.clear(); // free some memory
}
bam_header= Bam.fp->header;
string bamheadertext = bam_header->text;
ReadGroup = extractBamTag(bamheadertext,"@RG");
outAllPairsBam=(r.size()>0);
if (!outAllPairsBam) {
outFragTailBam=true; //FragmentTailPercent>=0;
outInterChromBam=true;
outUniqueMultipleBam=true;
outUniquePartialBam=true;
outUniqueUnmappedBam=true;
}
// output Bams
outputBam.clear();
/*
// test BamHeaderContainer
vector<BamHeaderContainer> x;
string sv=SpannerVersion;
string q="@PG\tID:FragmentTail\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
while (true) {
string outfile=outputDirectory+"/"+filename+".fragtail.bam";
q=q+"\n@PG\tID:FragmentTail\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
BamHeaderContainer x1( bam_header, q);
x.push_back(x1);
bam_header_t* h1=x[x.size()-1].header();
cout<< h1->text << endl;
}
cout << x.size() << endl;
*/
samfile_t *fpFT=0;
samfile_t *fpIC=0;
samfile_t *fpUM=0;
samfile_t *fpUP=0;
samfile_t *fpUZ=0;
samfile_t *fpAP=0;
samfile_t *fpWP=0;
//region
if (r.size()>0) {
int r1,r2,r3;
C_region r0(r);
region=r0;
string bamRegion=region.region;
size_t k=bamRegion.find("chr");
if (k!=string::npos) {
bamRegion=bamRegion.substr(3);
}
if ( bam_parse_region(bam_header, bamRegion.c_str(), &r1, &r2, &r3)==0) {
region.limit=true;
region.anchor=r1;
region.start=r2;
region.end=r3;
} else {
cerr << "region not found\t" << r << endl;
exit(111);
}
}
//fragPosFile
if (fragPosFile.size()>0) {
FragmentPosFileObj fp(fragPosFile);
if (fp.fragmentPosList.size()>0) {
FragPos=fp;
} else {
cerr << "Read Pair Pos file not found\t" << fragPosFile << endl;
exit(112);
}
outFragTailBam=false;
outInterChromBam=false;
outUniqueMultipleBam=false;
outUniquePartialBam=false;
outUniqueUnmappedBam=false;
outReadPairPosBam=true;
}
if (outAllPairsBam) {
string outfile=outputDirectory+"/"+filename+"."+r+".bam";
string sv=SpannerVersion;
string q="@PG\tID:Region\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["AP"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["AP"].header();
if ((fpAP = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(160);
}
}
if (outFragTailBam) {
string outfile=outputDirectory+"/"+filename+".fragtail.bam";
string sv=SpannerVersion;
string q="@PG\tID:FragmentTail\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["FT"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["FT"].header();
if ((fpFT = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(161);
}
}
if (outInterChromBam) {
string outfile=outputDirectory+"/"+filename+".interchrom.bam";
string sv=SpannerVersion;
string q="@PG\tID:InterChromPairs\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["IC"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["IC"].header();
if ((fpIC = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(162);
}
}
if (outUniqueMultipleBam) {
string outfile=outputDirectory+"/"+filename+".uMult.bam";
string sv=SpannerVersion;
string q="@PG\tID:uniqMultiplyMappedPairs\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["UM"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["IUM"].header();
if ((fpUM = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(163);
}
}
if (outUniquePartialBam) {
string outfile=outputDirectory+"/"+filename+".uPart.bam";
string sv=SpannerVersion;
string q="@PG\tID:uniqPartiallyMappedPairs\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["UP"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["UP"].header();
if ((fpUP = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(164);
}
}
if (outUniqueUnmappedBam) {
string outfile=outputDirectory+"/"+filename+".uUnmapped.bam";
string sv=SpannerVersion;
string q="@PG\tID:uniqUnMappedPairs\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["UZ"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["UZ"].header();
if ((fpUZ = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(165);
}
}
if (outReadPairPosBam) {
string outfile=outputDirectory+"/"+filename+".weirdpairs.bam";
string sv=SpannerVersion;
string q="@PG\tID:weirdpairs\tPN:SpannerX\tVN"+sv+"\tCL:"+Params.getCmdLine();
outputBam["WP"]=BamHeaderContainer(bam_header,q);
bam_header_t* h1=outputBam["WP"].header();
if ((fpWP = samopen(outfile.c_str(), "wb", h1)) == 0) {
fprintf(stderr, "samopen: Fail to open output BAM file %s\n", filename.c_str());
exit(165);
}
}
cout << ReadGroup << endl << endl;
//extractMateMode();
if (cmd_MateMode>=0) MateMode=cmd_MateMode;
BamContainerPair bampair;
bool more = true;
while (more)
{
bampair=Bam.getNextBamPair();
// skip if neither end within region
more=(bampair.BamEnd.size()>1);
Npair++;
if (Npair>=maxReads) break;
//
if ( (dbg!=0)&&(elapsedtime()>float(dbg))) {
time(&tprev);
cout << " pairs:" << Npair << "\toutput:" << Nout;
cout << "\tchr:" << bampair.BamEnd[0].b.core.tid+1;
cout << "\tpos:" << bampair.BamEnd[0].b.core.pos;
cout << endl;
}
if (!more) continue;
if (region.limit) {
bool overlap = false;
for (int e=0; e<=1; e++) {
int a1=bampair.BamEnd[e].b.core.tid;
int p1=bampair.BamEnd[e].b.core.pos;
int p2=p1+bampair.BamEnd[e].len;
overlap=region.overlap(a1,p1,p2);
if (overlap) break;
}
if (!overlap) continue;
}
bampair.Illuminize(IlluminizeBam);
bampair.calcFragmentLengths();
more=(bampair.BamEnd[1].packeddata.size()>1);
//if (bampair.BamEnd[0].b.core.tid==bampair.BamEnd[1].b.core.tid)
// cout<< bampair << endl;
bool bothmap = ((bampair.BamEnd[0].b.core.flag&BAM_FUNMAP)==0)&&((bampair.BamEnd[0].b.core.flag&BAM_FMUNMAP)==0);
if (outAllPairsBam) {
Nout++;
int s1=samwrite(fpAP, &(bampair.BamEnd[0].b));
int s2=samwrite(fpAP, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to pairs.bam" << endl;
exit(150);
}
}
if (outReadPairPosBam) {
int ichr1=bampair.BamEnd[0].b.core.tid+1;
int istd1=bampair.BamEnd[0].sense=='+'? 0: 1;
int ista1=bampair.BamEnd[0].b.core.pos+1;
int iq1=bampair.BamEnd[0].q;
int ichr2=bampair.BamEnd[1].b.core.tid+1;
int istd2=bampair.BamEnd[1].sense=='+'? 0: 1;
int ista2=bampair.BamEnd[1].b.core.pos+1;
int iq2=bampair.BamEnd[1].q;
FragmentPosObj fp1(0,ichr1,istd1,ista1,0,ichr2,istd2,ista2,0,iq1, iq2,0);
/*
if ((fp1.chr1==10)&&(fp1.start1>=89687801)&&(fp1.end1<=89700722)) {
cout << "read "<< fp1 << endl;
}
*/
if (FragPos.find(fp1)) {
Nout++;
int s1=samwrite(fpWP, &(bampair.BamEnd[0].b));
int s2=samwrite(fpWP, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to weirdpairs.bam" << endl;
exit(156);
}
}
}
bool ok[2];
for (int e=0; e<2; e++) {
uint8_t* bq=bam1_qual(&(bampair.BamEnd[e].b));
int LR=bampair.BamEnd[0].b.core.l_qseq;
double bok=0;
for (int ib=0; ib<LR; ib++) {
if (bq[ib]>SplitBaseQmin) {
bok++;
}
}
ok[e]=(bok>LRmin);
}
if (! (ok[0]&ok[1]) )
continue;
if ( (outFragTailBam) & ((bampair.BamEnd[0].q>=Qmin)|(bampair.BamEnd[1].q>=Qmin)) ) {
bool FT=(bampair.FragmentLength>LFhigh)|((bampair.FragmentLength<LFlow)&(bampair.FragmentLength>INT_MIN))&bothmap;
if (FT && (fpFT!=0)) {
Nout++;
int s1=samwrite(fpFT, &(bampair.BamEnd[0].b));
int s2=samwrite(fpFT, &(bampair.BamEnd[1].b));
//if (outputBam["FT"].write(&(bampair.BamEnd[0].b),&(bampair.BamEnd[1].b))) {
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to fragtail.bam" << endl;
exit(151);
}
}
}
if ((outInterChromBam) & ((bampair.BamEnd[0].q>=Qmin)&(bampair.BamEnd[1].q>=Qmin))) {
bool IC=(bampair.BamEnd[0].b.core.tid!=bampair.BamEnd[1].b.core.tid)&&bothmap;
if (IC && (fpIC!=0)) {
Nout++;
int s1=samwrite(fpIC, &(bampair.BamEnd[0].b));
int s2=samwrite(fpIC, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to interchrom.bam" << endl;
exit(152);
}
}
}
if ((outUniqueMultipleBam) & ((bampair.BamEnd[0].q>=Qmin)|(bampair.BamEnd[1].q>=Qmin))){
int im=bampair.BamEnd[0].nmap>1? 0: 1;
int iu=bampair.BamEnd[0].q>=Qmin? 0: 1;
bool UM=(bampair.BamEnd[iu].nmap>1)&&(iu!=im)&&bothmap;
if (UM && (fpUM!=0)) {
Nout++;
int s1=samwrite(fpUM, &(bampair.BamEnd[0].b));
int s2=samwrite(fpUM, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to uMult.bam" << endl;
exit(153);
}
}
}
if ( (outUniquePartialBam) && ((bampair.BamEnd[0].q>=Qmin)|(bampair.BamEnd[1].q>=Qmin)) && bothmap) {
int c0=bampair.BamEnd[0].clip[0]+bampair.BamEnd[0].clip[1];
int LR=bampair.BamEnd[0].b.core.l_qseq;
bool split0=((LR-c0)>SplitBracketMin)&(c0>SplitBracketMin);
int ib0=0;
if ((split0)&(bampair.BamEnd[0].clip[0]>SplitBracketMin)) {
ib0=bampair.BamEnd[0].clip[0];
} else if ((split0)&(bampair.BamEnd[0].clip[1]>SplitBracketMin) ) {
ib0=LR-bampair.BamEnd[0].clip[1];
}
split0=split0&(ib0>0);
if (split0) {
uint8_t* bq=bam1_qual(&(bampair.BamEnd[0].b));
for (int ib=(ib0-SplitBracketMin); ib<(ib0+SplitBracketMin); ib++) {
if (bq[ib]<SplitBaseQmin) {
split0=false;
break;
}
}
}
int c1=bampair.BamEnd[1].clip[0]+bampair.BamEnd[1].clip[1];
LR=bampair.BamEnd[1].b.core.l_qseq;
bool split1=((LR-c0)>SplitBracketMin)&(c1>SplitBracketMin);;
int ib1=0;
if ((split1)&(bampair.BamEnd[1].clip[0]>SplitBracketMin)) {
ib1=bampair.BamEnd[1].clip[0];
} else if ((split1)&(bampair.BamEnd[1].clip[1]>SplitBracketMin) ) {
ib1=LR-bampair.BamEnd[1].clip[1];
}
split1=split1&(ib1>0);
if (split1) {
uint8_t* bq=bam1_qual(&(bampair.BamEnd[1].b));
for (int ib=(ib1-SplitBracketMin); ib<(ib1+SplitBracketMin); ib++) {
if (bq[ib]<SplitBaseQmin) {
split1=false;
break;
}
}
}
bool UP=(split0|split1)&((c1+c0)>minLR);
if (UP && (fpUP!=0)) {
Nout++;
int s1=samwrite(fpUP, &(bampair.BamEnd[0].b));
int s2=samwrite(fpUP, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to uPart.bam" << endl;
exit(154);
}
}
}
if ( (outUniqueUnmappedBam) & ((bampair.BamEnd[0].q>=Qmin)|(bampair.BamEnd[1].q>=Qmin)) ) {
bool z0=((bampair.BamEnd[0].b.core.flag&BAM_FUNMAP)>0);
bool z1=((bampair.BamEnd[1].b.core.flag&BAM_FUNMAP)>0);
uint8_t* bq=bam1_qual(&(bampair.BamEnd[0].b));
for (int nb,ib=0; ib<bampair.BamEnd[0].b.core.l_qseq; ib++) {
if (bq[ib]<SplitBaseQmin) {
nb++;
}
}
bool UZ=(z0|z1)&(!(z1&z0));
if (UZ && (fpUZ!=0)) {
Nout++;
int s1=samwrite(fpUZ, &(bampair.BamEnd[0].b));
int s2=samwrite(fpUZ, &(bampair.BamEnd[1].b));
if ((s1*s2)>0) {
continue;
} else {
cerr << "bad write to uUnmapped.bam" << endl;
exit(155);
}
}
}
//cout<< bampair.Orientation << "\t"<< bampair.FragmentLength << "\t" <<bampair.BamEnd[1].b.core.pos << endl;
}
if (outReadPairPosBam) {
samclose(fpWP);
} else {
if (outAllPairsBam) {
samclose(fpAP);
} else {
samclose(fpFT);
samclose(fpIC);
samclose(fpUP);
samclose(fpUM);
samclose(fpUZ);
}
}
/*
for (ioutputBam=outputBam.begin(); ioutputBam!=outputBam.end(); ioutputBam++) {
(*ioutputBam).second.close();
}
if (FragmentTailPercent>0)
outputBam["FT"].close();
*/
samclose(Bam.fp);
}
void timedmatvec_( int *errorflag,
int n,
int nnz,
int *rows,
int *cols,
double *vals,
int whichone,
double *x,
double *y,
double *timetaken)
{
//------------------------------------------------------------------------------
//
// Perform and time the sparse matrix*vector product y = A*x, where
// n = order of the matrix A
// nnz = number of nonzeros in the matrix A
// x and y are dense vectors stored in 1D arrays
// timetaken = time in seconds for a single matrix-vector product
// whichone = 1 if data structure is COO
// 2 if data structure is CSR
// cols = array of length nnz with col indices of nonzeros in A
// vals = array of length nnz with nonzero values in A
// rows = array of length nnz for COO, with row indices of nonzeros in A
// = array of length n+1 for CSR, giving 1-based indexes of
// where each row begins in the arrays cols and vals.
//
// All indices are 1-based, and should not be shifted in a preprocessing
// or postprocessing phase.
//
// errorflag is interpreted as
// errflag = -k, k-th argument is invalid on entry
// errflag = 0, everything is OK
// errflag = k, something went wrong
// where k is a positive integer
//
// All arrays are already allocated on entry. Notice that n, nnz, and whichone
// are passed in by value, not address. So a Fortran caller needs to specify
// that calling convention for those arguments.
//
//------------------------------------------------------------------------------
int k, i;
double t,tstart1,tstart2;
*errorflag = 0;
*timetaken = -17.0;
//error checking : n cannot be negative
if(n < 0)
{
printf("\n Error -1: The order of the matrix cannot be negative\n");
*errorflag = -1;
exit(0);
}
//error checking : nnz cannot be greater than n
if(nzperrow > n)
{
printf("\n Error -2: nzperrow cannot be grater than n\n");
*errorflag = -2;
exit(0);
}
if(nmin < 0 || nmax < 0)
{
printf("\n Error -3: Either nmin or nmax is negative\n");
*errorflag = -3;
exit(0);
}
tstart1 = elapsedtime(); // take the initial time
//if whichone = 1 then then perform Sparse matrix - vector multiplication using COO data structure
if(1 == whichone)
{
for(k=0;k<nnz;k++)
{
*(y + rows[k]-1) = *(y + rows[k]-1) + vals[k] * (*(x + cols[k]-1));
}
}
else
{
//if whichone = 1 then then perform Sparse matrix - vector multiplication using CSR data structure
for(i=0;i<n;i++)
{
for(k=(rows[i]-1);k<(rows[i+1]-1);k++)
{
*(y+i) = *(y+i) + vals[k] * (*(x + cols[k]-1));
}
}
}
*timetaken = elapsedtime() - tstart1; //Capture the difference between the start date and end date
return;
}
void* taskteam::do_thread_work(void* arg)
{
int err;
while(true) {
lockteam();
// wait until there is some work to do
while( !ready || tasks.empty() ) {
// cout << this << " waiting for start " << threads_ready << std::endl;
err = pthread_cond_wait(&start, &mutex);
if(err != 0){
std::cerr << "start error" << std::endl;
}
}
// get the next work unit
void * task_arg = tasks.front();
tasks.pop();
// Call the fcn to perform the task
timeb taskstart;
ftime(&taskstart);
std::cout << " Executing in thread (" << pthread_self() << ") "
<< " task:" << task_arg
<< std::endl;
unlockteam();
taskfcn(task_arg, &mutex);
timeb taskend;
ftime(&taskend);
double timetaken = elapsedtime(taskstart, taskend);
if(cumulativetimes.find(pthread_self()) == cumulativetimes.end() ){
cumulativetimes[pthread_self()] = timetaken;
cumulativeruns[pthread_self()] = 1;
} else {
cumulativetimes[pthread_self()] += timetaken;
cumulativeruns[pthread_self()]++;
}
lockteam();
std::cout << " Finished in thread (" << pthread_self() << ") "
<< " task:" << task_arg
<< ", taking " << timetaken << "s" <<std::endl;
ntasks_todo--;
// check if all the work is done
// not same as tasks.empty(), as tasks can be in process
// of executing.
if( ntasks_todo == 0 ) {
// indicate that we are done
err = pthread_cond_broadcast(&finish);
if(err != 0){
std::cerr << "finish error" << std::endl;
}
}
unlockteam();
}
return NULL;
}
QVariant TestItem::data(int role) const
{
switch(role) {
case DurationRole:
return duration();
case ChecksumRole:
return checksum();
case DependsRole:
return depends();
case TestNameRole:
return testname();
case RequiresRole:
return requires();
case DescriptionRole:
return description();
case CommandRole:
return command();
case EnvironRole:
return environ();
case PluginRole:
return plugin();
case TypeRole:
return type();
case UserRole:
return user();
case ViaRole:
return via();
case GroupRole:
return group();
case CheckRole:
return check();
case ObjectPathRole:
return objectpath();
case RunstatusRole:
return runstatus();
case ElapsedtimeRole:
return elapsedtime();
case GroupstatusRole:
return groupstatus();
case ParentNameRole:
break;
case ParentIdRole:
break;
case DepthRole:
return depth();
case BranchRole:
return branch();
case RerunRole:
return rerun();
default:
return QVariant();
}
// Prevents non-void return warning from the compiler
return QVariant();
}