BGI/SOAPdenovo2/sparsePregraph/multi_threads.cpp

   1 /*
   2  * multi_threads.cpp
   3  *
   4  * Copyright (c) 2008-2012 BGI-Shenzhen <soap at genomics dot org dot cn>.
   5  *
   6  * This file is part of SOAPdenovo.
   7  *
   8  * SOAPdenovo is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * SOAPdenovo is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with SOAPdenovo.  If not, see <http://www.gnu.org/licenses/>.
  20  *
  21  */
  22
  23 #include "multi_threads.h"
  24 #include "global.h"
  25 #include "build_graph.h"
  26 #include "stdinc.h"
  27
  28 #include <unistd.h>
  29
  30 #include "build_preArc.h"
  31
  32 void creatThrds ( pthread_t * threads, PARAMETER * paras )
  33 {
  34         unsigned char i;
  35         int temp;
  36
  37         for ( i = 0; i < thrd_num_s; i++ )
  38         {
  39                 if ( ( temp = pthread_create ( &threads[i], NULL, threadRoutine, & ( paras[i] ) ) ) != 0 )
  40                 {
  41                         fprintf ( stderr, "ERROR: create threads failed.\n" );
  42                         exit ( 1 );
  43                 }
  44         }
  45
  46         //fprintf(stderr,"%d work threads created.\n",thrd_num_s);
  47         fprintf ( stderr, "%d work threads initialized.\n", thrd_num_s );
  48 }
  49
  50
  51
  52 void * threadRoutine ( void * para )
  53 {
  54         PARAMETER * prm;
  55         int i;
  56         unsigned char id;
  57         prm = ( PARAMETER * ) para;
  58         id = prm->threadID;
  59         struct hashtable2 * ht = prm->ht;
  60         int K_size = prm->K_size;
  61         int gap = prm->gap;
  62
  63         while ( 1 )
  64         {
  65                 if ( * ( prm->selfSignal ) == 3 )
  66                 {
  67                         * ( prm->selfSignal ) = 0;
  68                         break;
  69                 }
  70                 else if ( * ( prm->selfSignal ) == 10 )
  71                 {
  72                         run_process_threaded ( ht, locks, K_size, gap, read_num, thrd_num_s, prm->threadID, 1 );
  73                         * ( prm->selfSignal ) = 0;
  74                 }
  75                 else if ( * ( prm->selfSignal ) == 11 )
  76                 {
  77                         run_process_threaded ( ht, locks, K_size, gap, read_num, thrd_num_s, prm->threadID, 2 );
  78                         * ( prm->selfSignal ) = 0;
  79                 }
  80                 else if ( * ( prm->selfSignal ) == 12 )
  81                 {
  82                         for ( int i = prm->threadID ; i < read_num; i += thrd_num_s )
  83                         {
  84                                 int bad_flag = 0;
  85                                 filter_N ( seq_t[i], bad_flag );
  86
  87                                 if ( bad_flag ) {seq_t[i].clear(); continue;}
  88
  89                                 process_1read_preArc ( prm->preArcs, locks, prm->threadID, prm->v_ht, K_size, prm->cut_off_len, seq_t[i].c_str() );
  90                         }
  91
  92                         * ( prm->selfSignal ) = 0;
  93                 }
  94
  95                 usleep ( 1 );
  96         }
  97 }
  98
  99 void thread_wait ( pthread_t * threads )
 100 {
 101         int i;
 102
 103         for ( i = 0; i < thrd_num_s; i++ )
 104                 if ( threads[i] != 0 )
 105                         { pthread_join ( threads[i], NULL ); }
 106 }
 107
 108 void sendWorkSignal ( unsigned char SIG, unsigned char * thrdSignals )
 109 {
 110         int t;
 111
 112         for ( t = 0; t < thrd_num_s; t++ )
 113                 { thrdSignals[t + 1] = SIG; }
 114
 115         while ( 1 )
 116         {
 117                 usleep ( 10 );
 118
 119                 for ( t = 0; t < thrd_num_s; t++ )
 120                         if ( thrdSignals[t + 1] )
 121                                 { break; }
 122
 123                 if ( t == thrd_num_s )
 124                         { break; }
 125         }
 126 }
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147