void SndFileSource::process() { //open first file if (mSoundFile || openNextFile()) { // read audio data do { sf_count_t res = sf_readf_short(mSoundFile, mAlsaFrame.getSoundBuffer(), mAlsaFrame.getDimensionT(AlsaFrame::Time).mResolution); if (res > 0) { // keep constant frame size, populate with zeros if (res < mAlsaFrame.getDimensionT(AlsaFrame::Time).mResolution) memset(mAlsaFrame.getSoundBuffer() + res*mAlsaFrame.getDimensionT(AlsaFrame::Channels).mResolution, 0, (mAlsaFrame.getDimensionT(AlsaFrame::Time).mResolution - res)*sizeof(qint16)*mAlsaFrame.getDimensionT(AlsaFrame::Channels).mResolution); mAlsaFrame.incrementTimeStamp(); emit framesReady(); return; } } //open next file while (openNextFile()); } //error openning file emit processingCompleted(); }
bool fillBuffer() { while ( pc == pe ) { if ( ! fileunread ) { bool const ok = openNextFile(); if ( ! ok ) return false; } uint64_t const toreadbytes = std::min(decodeBuffer.size(), (fileunread+1) / 2 ); uint64_t const toreadsyms = std::min( 2*toreadbytes, fileunread ); istr->read(reinterpret_cast<char *>(decodeBuffer.get()), toreadbytes); if ( istr->gcount() != static_cast<int64_t>(toreadbytes) ) { ::libmaus::exception::LibMausException se; se.getStream() << "CompactDecoder4::fillBuffer failed to fill buffer." << std::endl; se.finish(); throw se; } for ( uint64_t i = 0; i < toreadbytes; ++i ) { buffer[2*i+0] = decodeBuffer[i] & ((1u<<4)-1); buffer[2*i+1] = decodeBuffer[i] >> 4; } pc = buffer.begin(); pe = pc + toreadsyms; fileunread -= toreadsyms; assert ( pc != pe ); if ( skip ) { assert ( skip == 1 ); skip = 0; pc++; } } return true; }
void push(libmaus2::dazzler::align::Overlap const & OVL) { if ( OVL.aread != previd ) { numids += 1; if ( numids > idsperfile ) { openNextFile(); numids = 1; } } OVL.serialiseWithPath(*Pstream,small); novl += 1; previd = OVL.aread; }
/***************************************************************************** * Write: standard write on a file descriptor. *****************************************************************************/ static ssize_t Write( sout_access_out_t *p_access, block_t *p_buffer ) { size_t i_write = 0; sout_access_out_sys_t *p_sys = p_access->p_sys; while( p_buffer ) { if ( p_sys->i_handle >= 0 && ( p_sys->b_splitanywhere || ( p_buffer->i_flags & BLOCK_FLAG_TYPE_I ) ) && ( p_buffer->i_dts-p_sys->i_opendts ) > p_sys->i_seglenm ) { closeCurrentSegment( p_access, p_sys, false ); } if ( p_buffer->i_buffer > 0 && p_sys->i_handle < 0 ) { p_sys->i_opendts = p_buffer->i_dts; if ( openNextFile( p_access, p_sys ) < 0 ) return -1; } ssize_t val = write ( p_sys->i_handle, p_buffer->p_buffer, p_buffer->i_buffer ); if ( val == -1 ) { if ( errno == EINTR ) continue; block_ChainRelease ( p_buffer ); return -1; } if ( (size_t)val >= p_buffer->i_buffer ) { block_t *p_next = p_buffer->p_next; block_Release (p_buffer); p_buffer = p_next; } else { p_buffer->p_buffer += val; p_buffer->i_buffer -= val; } i_write += val; } return i_write; }
/************************************************* Function: prlRead2HashTable Description: 1. Imports the reads from the lib file one by one. 2. Chops the reads into kmers and store them in KmerSets. 3. Removes the kmers with low coverage. 4. Marks the linear kmers. 5. Counts the kmer frequences. Input: 1. libfile : the reads config file 2. outfile : the output file prefix Output: None. Return: 1 if exits normally. *************************************************/ boolean prlRead2HashTable ( char * libfile, char * outfile ) { char * cach1; char * cach2; unsigned char asm_ctg = 1; long long i; char * next_name, name[256]; FILE * fo; time_t start_t, stop_t; int maxReadNum; int libNo; pthread_t threads[thrd_num]; unsigned char thrdSignal[thrd_num + 1]; PARAMETER paras[thrd_num]; boolean flag, pairs = 0; WORDFILTER = createFilter ( overlaplen ); maxReadLen = 0; maxNameLen = 256; scan_libInfo ( libfile ); alloc_pe_mem ( num_libs ); if ( !maxReadLen ) { maxReadLen = 100; } if ( gLineLen < maxReadLen ) { gStr = ( char * ) ckalloc ( ( maxReadLen + 1 ) * sizeof ( char ) ); } //init maxReadLen4all = maxReadLen; fprintf ( stderr, "In %s, %d lib(s), maximum read length %d, maximum name length %d.\n\n", libfile, num_libs, maxReadLen, maxNameLen ); next_name = ( char * ) ckalloc ( ( maxNameLen + 1 ) * sizeof ( char ) ); kmerBuffer = ( Kmer * ) ckalloc ( buffer_size * sizeof ( Kmer ) ); hashBanBuffer = ( ubyte8 * ) ckalloc ( buffer_size * sizeof ( ubyte8 ) ); prevcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); nextcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); maxReadNum = buffer_size / ( maxReadLen - overlaplen + 1 ); //printf("buffer size %d, max read len %d, max read num %d\n",buffer_size,maxReadLen,maxReadNum); int maxAIOSize = 32768; aioBuffer1 = ( char * ) ckalloc ( ( maxAIOSize ) * sizeof ( char ) ); aioBuffer2 = ( char * ) ckalloc ( ( maxAIOSize ) * sizeof ( char ) ); readBuffer1 = ( char * ) ckalloc ( ( maxAIOSize + ( maxReadLen * 4 + 1024 ) ) * sizeof ( char ) ); //(char *)ckalloc(maxAIOSize*sizeof(char)); //1024 readBuffer2 = ( char * ) ckalloc ( ( maxAIOSize + ( maxReadLen * 4 + 1024 ) ) * sizeof ( char ) ); //1024 cach1 = ( char * ) ckalloc ( ( maxReadLen * 4 + 1024 ) * sizeof ( char ) ); //1024 cach2 = ( char * ) ckalloc ( ( maxReadLen * 4 + 1024 ) * sizeof ( char ) ); //1024 memset ( cach1, '\0', ( maxReadLen * 4 + 1024 ) ); //1024 memset ( cach2, '\0', ( maxReadLen * 4 + 1024 ) ); //1024 seqBuffer = ( char ** ) ckalloc ( maxReadNum * sizeof ( char * ) ); lenBuffer = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); indexArray = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); for ( i = 0; i < maxReadNum; i++ ) { seqBuffer[i] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } rcSeq = ( char ** ) ckalloc ( ( thrd_num + 1 ) * sizeof ( char * ) ); if ( 1 ) { kmerCounter = ( long long * ) ckalloc ( ( thrd_num + 1 ) * sizeof ( long long ) ); KmerSets = ( KmerSet ** ) ckalloc ( thrd_num * sizeof ( KmerSet * ) ); ubyte8 init_size = 1024; ubyte8 k = 0; if ( initKmerSetSize ) { #ifdef MER127 init_size = ( ubyte8 ) ( ( double ) initKmerSetSize * 1024.0f * 1024.0f * 1024.0f / ( double ) thrd_num / 40 ); #else init_size = ( ubyte8 ) ( ( double ) initKmerSetSize * 1024.0f * 1024.0f * 1024.0f / ( double ) thrd_num / 24 ); //is it true? #endif do { ++k; } while ( k * 0xFFFFFFLLU < init_size ); } for ( i = 0; i < thrd_num; i++ ) { //KmerSets[i] = init_kmerset(1024,0.77f); KmerSets[i] = init_kmerset ( ( ( initKmerSetSize ) ? ( k * 0xFFFFFFLLU ) : ( init_size ) ), 0.77f ); thrdSignal[i + 1] = 0; paras[i].threadID = i; paras[i].mainSignal = &thrdSignal[0]; paras[i].selfSignal = &thrdSignal[i + 1]; kmerCounter[i + 1] = 0; rcSeq[i + 1] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } creatThrds ( threads, paras ); } thrdSignal[0] = kmerCounter[0] = 0; time ( &start_t ); kmer_c = n_solexa = read_c = i = libNo = readNumBack = gradsCounter = 0; while ( openNextFile ( &libNo, pairs, asm_ctg ) ) { //read bam file if ( lib_array[libNo].curr_type == 4 ) { int type = 0; //deside the PE reads is good or bad while ( ( flag = read1seqInLibBam ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), &libNo, pairs, 1, &type ) ) != 0 ) { if ( type == -1 ) //if the reads is bad, go back. { i--; if ( lenBuffer[read_c - 1] >= overlaplen + 1 ) { kmer_c -= lenBuffer[read_c - 1] - overlaplen + 1; read_c--; } n_solexa -= 2; continue; } if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { continue; } /* if(lenBuffer[read_c]>70) lenBuffer[read_c] = 50; else if(lenBuffer[read_c]>40) lenBuffer[read_c] = 40; */ indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } } } //read PE fasta or fastq else if ( lib_array[libNo].curr_type == 1 || lib_array[libNo].curr_type == 2 ) { initAIO ( &aio1, aioBuffer1, fileno ( lib_array[libNo].fp1 ), maxAIOSize ); initAIO ( &aio2, aioBuffer2, fileno ( lib_array[libNo].fp2 ), maxAIOSize ); int offset1, offset2, flag1, flag2, rt1, rt2; offset1 = offset2 = 0; rt1 = aio_read ( &aio1 ); rt2 = aio_read ( &aio2 ); flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); if ( flag1 && flag2 ) { int start1, start2, turn; start1 = start2 = 0; turn = 1; while ( start1 < offset1 || start2 < offset2 ) { if ( turn == 1 ) { turn = 2; readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer1, &start1, offset1, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { if ( start1 >= offset1 ) { start1 = 0; offset1 = 0; flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( start1 >= offset1 ) { start1 = 0; offset1 = 0; flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); } if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } continue; } if ( turn == 2 ) { turn = 1; readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer2, &start2, offset2, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { if ( ( flag2 == 2 ) && ( start2 >= offset2 ) ) { break; } if ( start2 >= offset2 ) { start2 = 0; offset2 = 0; flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( ( flag2 == 2 ) && ( start2 >= offset2 ) ) { break; } if ( start2 >= offset2 ) { start2 = 0; offset2 = 0; flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); } if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } continue; } } } else { fprintf(stderr, "Error: aio_read error.\n"); } } //read single fasta, single fastq and PE fasta in one file else { initAIO ( &aio1, aioBuffer1, fileno ( lib_array[libNo].fp1 ), maxAIOSize ); int offset, flag1, rt; offset = 0; rt = aio_read ( &aio1 ); while ( ( flag1 = AIORead ( &aio1, &offset, readBuffer1, cach1, &rt, lib_array[libNo].curr_type ) ) ) { int start = 0; while ( start < offset ) { readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer1, &start, offset, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; } if ( read_c > maxReadNum - 1024 ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } if ( flag1 == 2 ) { break; } } } } if ( read_c ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer } time ( &stop_t ); fprintf ( stderr, "Time spent on hashing reads: %ds, %lld read(s) processed.\n", ( int ) ( stop_t - start_t ), i ); //record insert size info if ( pairs ) { if ( gradsCounter ) { fprintf ( stderr, "%d pe insert size, the largest boundary is %lld.\n\n", gradsCounter, pes[gradsCounter - 1].PE_bound ); } else { fprintf ( stderr, "No paired reads found.\n" ); } sprintf ( name, "%s.peGrads", outfile ); fo = ckopen ( name, "w" ); fprintf ( fo, "grads&num: %d\t%lld\n", gradsCounter, n_solexa ); for ( i = 0; i < gradsCounter; i++ ) { fprintf ( fo, "%d\t%lld\t%d\n", pes[i].insertS, pes[i].PE_bound, pes[i].rank ); } fclose ( fo ); } free_pe_mem (); free_libs (); if ( 1 ) { unsigned long long alloCounter = 0; unsigned long long allKmerCounter = 0; for ( i = 0; i < thrd_num; i++ ) { alloCounter += count_kmerset ( ( KmerSets[i] ) ); allKmerCounter += kmerCounter[i + 1]; free ( ( void * ) rcSeq[i + 1] ); } fprintf ( stderr, "%lli node(s) allocated, %lli kmer(s) in reads, %lli kmer(s) processed.\n", alloCounter, kmerCounter[0], allKmerCounter ); } free ( ( void * ) rcSeq ); free ( ( void * ) kmerCounter ); for ( i = 0; i < maxReadNum; i++ ) { free ( ( void * ) seqBuffer[i] ); } free ( ( void * ) seqBuffer ); free ( ( void * ) lenBuffer ); free ( ( void * ) indexArray ); free ( ( void * ) kmerBuffer ); free ( ( void * ) hashBanBuffer ); free ( ( void * ) nextcBuffer ); free ( ( void * ) prevcBuffer ); free ( ( void * ) next_name ); free ( ( void * ) aioBuffer1 ); free ( ( void * ) aioBuffer2 ); free ( ( void * ) readBuffer1 ); free ( ( void * ) readBuffer2 ); free ( ( void * ) cach1 ); free ( ( void * ) cach2 ); fprintf ( stderr, "done hashing nodes\n" ); if ( deLowKmer ) { time ( &start_t ); deLowCov ( thrdSignal ); time ( &stop_t ); fprintf ( stderr, "Time spent on delowcvgNode: %ds.\n", ( int ) ( stop_t - start_t ) ); } time ( &start_t ); Mark1in1outNode ( thrdSignal ); freqStat ( outfile ); time ( &stop_t ); fprintf ( stderr, "Time spent on marking linear nodes: %ds.\n", ( int ) ( stop_t - start_t ) ); sendWorkSignal ( 3, thrdSignal ); //exit thread_wait ( threads ); return 1; }
void prlRead2edge (char *libfile, char *outfile) { char *cach1; char *cach2; unsigned char asm_ctg = 1; long long i; char name[256], *src_name, *next_name; FILE *outfp = NULL; int maxReadNum, libNo; boolean flag, pairs = 0; pthread_t threads[thrd_num]; unsigned char thrdSignal[thrd_num + 1]; PARAMETER paras[thrd_num]; maxReadLen = 0; maxNameLen = 256; scan_libInfo (libfile); alloc_pe_mem (num_libs); if (!maxReadLen) { maxReadLen = 100; } maxReadLen4all = maxReadLen; printf ("In file: %s, max seq len %d, max name len %d\n\n", libfile, maxReadLen, maxNameLen); if (repsTie) { sprintf (name, "%s.path", outfile); outfp = ckopen (name, "wb"); } src_name = (char *) ckalloc ((maxNameLen + 1) * sizeof (char)); next_name = (char *) ckalloc ((10*maxNameLen + 1) * sizeof (char)); kmerBuffer = (Kmer *) ckalloc (buffer_size * sizeof (Kmer)); mixBuffer = (Kmer *) ckalloc (buffer_size * sizeof (Kmer)); hashBanBuffer = (ubyte8 *) ckalloc (buffer_size * sizeof (ubyte8)); nodeBuffer = (kmer_t **) ckalloc (buffer_size * sizeof (kmer_t *)); smallerBuffer = (boolean *) ckalloc (buffer_size * sizeof (boolean)); flagArray = (boolean *) ckalloc (buffer_size * sizeof (boolean)); maxReadNum = buffer_size / (maxReadLen - overlaplen + 1); //printf("buffer for at most %d reads\n",maxReadNum); int maxAIOSize = 32768;/* aioBuffer1 = (char *) ckalloc ((maxAIOSize) * sizeof (char)); aioBuffer2 = (char *) ckalloc ((maxAIOSize) * sizeof (char)); readBuffer1 = (char *) ckalloc ((maxAIOSize + 1024) * sizeof (char)); //(char *)ckalloc(maxAIOSize*sizeof(char)); readBuffer2 = (char *) ckalloc ((maxAIOSize + 1024) * sizeof (char)); cach1 = (char *) ckalloc (1024 * sizeof (char)); cach2 = (char *) ckalloc (1024 * sizeof (char)); memset(cach1,'\0',1024); memset(cach2,'\0',1024);*/ aioBuffer1 = (char *) ckalloc ((maxAIOSize) * sizeof (char)); aioBuffer2 = (char *) ckalloc ((maxAIOSize) * sizeof (char)); readBuffer1 = (char *) ckalloc ((maxAIOSize + (maxReadLen+1024)) * sizeof (char)); //(char *)ckalloc(maxAIOSize*sizeof(char)); //1024 readBuffer2 = (char *) ckalloc ((maxAIOSize + (maxReadLen+1024)) * sizeof (char)); //1024 cach1 = (char *) ckalloc ((maxReadLen+1024) * sizeof (char)); //1024 cach2 = (char *) ckalloc ((maxReadLen+1024) * sizeof (char)); //1024 memset(cach1,'\0',(maxReadLen+1024)); //1024 memset(cach2,'\0',(maxReadLen+1024)); //1024 seqBuffer = (char **) ckalloc (maxReadNum * sizeof (char *)); lenBuffer = (int *) ckalloc (maxReadNum * sizeof (int)); indexArray = (int *) ckalloc ((maxReadNum + 1) * sizeof (int)); for (i = 0; i < maxReadNum; i++) { seqBuffer[i] = (char *) ckalloc (maxReadLen * sizeof (char)); } memoAlloc4preArc (); flags = (char **) ckalloc ((thrd_num + 1) * sizeof (char *)); deletion = (int *) ckalloc ((thrd_num + 1) * sizeof (int)); rcSeq = (char **) ckalloc ((thrd_num + 1) * sizeof (char *)); if (repsTie) { markerOnEdge = (unsigned char *) ckalloc ((num_ed + 1) * sizeof (unsigned char)); for (i = 1; i <= num_ed; i++) { markerOnEdge[i] = 0; } fwriteBuf = (unsigned int *) ckalloc ((maxReadLen - overlaplen + 1) * sizeof (unsigned int)); } thrdSignal[0] = 0; if (1) { preArc_mem_managers = (MEM_MANAGER **) ckalloc (thrd_num * sizeof (MEM_MANAGER *)); arcCounters = (unsigned int *) ckalloc (thrd_num * sizeof (unsigned int)); for (i = 0; i < thrd_num; i++) { arcCounters[i] = 0; preArc_mem_managers[i] = createMem_manager (preARCBLOCKSIZE, sizeof (preARC)); deletion[i + 1] = 0; flags[i + 1] = (char *) ckalloc (2 * maxReadLen * sizeof (char)); rcSeq[i + 1] = (char *) ckalloc (maxReadLen * sizeof (char)); thrdSignal[i + 1] = 0; paras[i].threadID = i; paras[i].mainSignal = &thrdSignal[0]; paras[i].selfSignal = &thrdSignal[i + 1]; } creatThrds (threads, paras); } if (1) { deletion[0] = 0; flags[0] = (char *) ckalloc (2 * maxReadLen * sizeof (char)); rcSeq[0] = (char *) ckalloc (maxReadLen * sizeof (char)); } kmer_c = n_solexa = read_c = i = libNo = readNumBack = gradsCounter = 0; int t0, t1, t2, t3, t4, t5, t6; t0 = t1 = t2 = t3 = t4 = t5 = t6 = 0; time_t read_start, read_end, time_bef, time_aft; time (&read_start); while (openNextFile (&libNo, pairs, asm_ctg)) { if (lib_array[libNo].curr_type == 4) { int type = 0; //deside the PE reads is good or bad while ((flag = read1seqInLibBam (seqBuffer[read_c], next_name, &(lenBuffer[read_c]), &libNo, pairs, 1, &type)) != 0) { if (type == -1) //if the reads is bad, go back. { i--; if (lenBuffer[read_c - 1] >= overlaplen + 1) { kmer_c -= lenBuffer[read_c - 1] - overlaplen + 1; read_c--; } n_solexa -= 2; continue; } if ((++i) % 1000000 == 0) { printf ("--- %lldth reads\n", i); } if (lenBuffer[read_c] < overlaplen + 1) { continue; } //if(lenBuffer[read_c]>70) // lenBuffer[read_c] = 70; //else if(lenBuffer[read_c]>40) // lenBuffer[read_c] = 40; indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if (read_c == maxReadNum) { indexArray[read_c] = kmer_c; time (&read_end); t0 += read_end - read_start; time (&time_bef); sendWorkSignal (2, thrdSignal); time (&time_aft); t1 += time_aft - time_bef; time (&time_bef); sendWorkSignal (1, thrdSignal); time (&time_aft); t2 += time_aft - time_bef; time (&time_bef); sendWorkSignal (3, thrdSignal); time (&time_aft); t3 += time_aft - time_bef; time (&time_bef); sendWorkSignal (4, thrdSignal); time (&time_aft); t4 += time_aft - time_bef; time (&time_bef); sendWorkSignal (6, thrdSignal); time (&time_aft); t5 += time_aft - time_bef; time (&time_bef); //recordPreArc(); if (repsTie) { recordPathBin (outfp); } time (&time_aft); t6 += time_aft - time_bef; //output_path(read_c,edge_no,flags,outfp); kmer_c = 0; read_c = 0; time (&read_start); } } } else if (lib_array[libNo].curr_type == 1 || lib_array[libNo].curr_type == 2) { initAIO (&aio1, aioBuffer1, fileno (lib_array[libNo].fp1), maxAIOSize); initAIO (&aio2, aioBuffer2, fileno (lib_array[libNo].fp2), maxAIOSize); int offset1, offset2, flag1, flag2, rt1, rt2; offset1 = offset2 = 0; rt1 = aio_read (&aio1); rt2 = aio_read (&aio2); flag1 = AIORead (&aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type); flag2 = AIORead (&aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type); if(flag1 && flag2) { int start1, start2, turn; start1 = start2 = 0; turn = 1; while (start1 < offset1 || start2 < offset2) { if (turn == 1) { turn = 2; readseqInLib (seqBuffer[read_c], next_name, &(lenBuffer[read_c]), readBuffer1, &start1, offset1, libNo); if ((++i) % 1000000 == 0) printf ("--- %lldth reads\n", i); /* if (lenBuffer[read_c] < overlaplen + 1) continue;*/ if (lenBuffer[read_c] < overlaplen + 1) { if(start1>=offset1) { start1=0; flag1=AIORead (&aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if(start1>=offset1){ start1=0; flag1=AIORead (&aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type); } if (read_c == maxReadNum) { indexArray[read_c] = kmer_c; time (&read_end); t0 += read_end - read_start; time (&time_bef); sendWorkSignal (2, thrdSignal); time (&time_aft); t1 += time_aft - time_bef; time (&time_bef); sendWorkSignal (1, thrdSignal); time (&time_aft); t2 += time_aft - time_bef; time (&time_bef); sendWorkSignal (3, thrdSignal); time (&time_aft); t3 += time_aft - time_bef; time (&time_bef); sendWorkSignal (4, thrdSignal); time (&time_aft); t4 += time_aft - time_bef; time (&time_bef); sendWorkSignal (6, thrdSignal); time (&time_aft); t5 += time_aft - time_bef; time (&time_bef); //recordPreArc(); if (repsTie) recordPathBin (outfp); time (&time_aft); t6 += time_aft - time_bef; //output_path(read_c,edge_no,flags,outfp); kmer_c = 0; read_c = 0; time (&read_start); } continue; } if (turn == 2) { turn = 1; readseqInLib (seqBuffer[read_c], next_name, &(lenBuffer[read_c]), readBuffer2, &start2, offset2, libNo); if ((++i) % 1000000 == 0) printf ("--- %lldth reads\n", i); /* if (lenBuffer[read_c] < overlaplen + 1) continue;*/ if (lenBuffer[read_c] < overlaplen + 1) { if((flag2 == 2) && (start2 >= offset2)) break; if(start2 >= offset2) { start2=0; flag2 = AIORead (&aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if((flag2 == 2) && (start2 >= offset2)) break; if(start2 >= offset2){ start2=0; flag2 = AIORead (&aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type); } if (read_c == maxReadNum){ indexArray[read_c] = kmer_c; time (&read_end); t0 += read_end - read_start; time (&time_bef); sendWorkSignal (2, thrdSignal); time (&time_aft); t1 += time_aft - time_bef; time (&time_bef); sendWorkSignal (1, thrdSignal); time (&time_aft); t2 += time_aft - time_bef; time (&time_bef); sendWorkSignal (3, thrdSignal); time (&time_aft); t3 += time_aft - time_bef; time (&time_bef); sendWorkSignal (4, thrdSignal); time (&time_aft); t4 += time_aft - time_bef; time (&time_bef); sendWorkSignal (6, thrdSignal); time (&time_aft); t5 += time_aft - time_bef; time (&time_bef); //recordPreArc(); if (repsTie) recordPathBin (outfp); time (&time_aft); t6 += time_aft - time_bef; //output_path(read_c,edge_no,flags,outfp); kmer_c = 0; read_c = 0; time (&read_start); } continue; } } } } else { initAIO (&aio1, aioBuffer1, fileno (lib_array[libNo].fp1), maxAIOSize); int offset, flag1, rt; offset = 0; rt = aio_read (&aio1); while ((flag1 = AIORead (&aio1, &offset, readBuffer1, cach1, &rt, lib_array[libNo].curr_type))) { int start = 0; while (start < offset) { readseqInLib (seqBuffer[read_c], next_name, &(lenBuffer[read_c]), readBuffer1, &start, offset, libNo); if ((++i) % 1000000 == 0) printf ("--- %lld reads\n", i); if (lenBuffer[read_c] < overlaplen + 1) continue; indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if (read_c > maxReadNum - 1024) { indexArray[read_c] = kmer_c; time (&read_end); t0 += read_end - read_start; time (&time_bef); sendWorkSignal (2, thrdSignal); time (&time_aft); t1 += time_aft - time_bef; time (&time_bef); sendWorkSignal (1, thrdSignal); time (&time_aft); t2 += time_aft - time_bef; time (&time_bef); sendWorkSignal (3, thrdSignal); time (&time_aft); t3 += time_aft - time_bef; time (&time_bef); sendWorkSignal (4, thrdSignal); time (&time_aft); t4 += time_aft - time_bef; time (&time_bef); sendWorkSignal (6, thrdSignal); time (&time_aft); t5 += time_aft - time_bef; time (&time_bef); //recordPreArc(); if (repsTie) recordPathBin (outfp); time (&time_aft); t6 += time_aft - time_bef; //output_path(read_c,edge_no,flags,outfp); kmer_c = 0; read_c = 0; time (&read_start); } } if (flag1 == 2) break; } } } printf ("%lld reads processed\n", i); printf ("time %d,%d,%d,%d,%d,%d,%d\n", t0, t1, t2, t3, t4, t5, t6); if (read_c) { indexArray[read_c] = kmer_c; sendWorkSignal (2, thrdSignal); sendWorkSignal (1, thrdSignal); sendWorkSignal (3, thrdSignal); sendWorkSignal (4, thrdSignal); sendWorkSignal (6, thrdSignal); //recordPreArc(); if (repsTie) { recordPathBin (outfp); } } printf ("%lld markers outputed\n", markCounter); sendWorkSignal (5, thrdSignal); thread_wait (threads); output_arcs (outfile); memoFree4preArc (); if (1) // multi-threads { arcCounter = 0; for (i = 0; i < thrd_num; i++) { arcCounter += arcCounters[i]; free ((void *) flags[i + 1]); deletion[0] += deletion[i + 1]; free ((void *) rcSeq[i + 1]); } } if (1) { free ((void *) flags[0]); free ((void *) rcSeq[0]); } printf ("done mapping reads, %d reads deleted, %lld arcs created\n", deletion[0], arcCounter); if (repsTie) { free ((void *) markerOnEdge); free ((void *) fwriteBuf); } free ((void *) arcCounters); free ((void *) rcSeq); for (i = 0; i < maxReadNum; i++) { free ((void *) seqBuffer[i]); } free ((void *) seqBuffer); free ((void *) lenBuffer); free ((void *) indexArray); free ((void *) flags); free ((void *) deletion); free ((void *) kmerBuffer); free ((void *) mixBuffer); free ((void *) smallerBuffer); free ((void *) flagArray); free ((void *) hashBanBuffer); free ((void *) nodeBuffer); free ((void *) src_name); free ((void *) next_name); free ((void *) aioBuffer1); free ((void *) aioBuffer2); free ((void *) readBuffer1); free ((void *) readBuffer2); free ((void *) cach1); free ((void *) cach2); if (repsTie) { fclose (outfp); } free_pe_mem (); free_libs (); }
CLoadFile::CLoadFile(const boost::filesystem::path & fname, int minimalVersion /*= version*/) : serializer(this) { registerTypes(serializer); openNextFile(fname, minimalVersion); }