ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/gclib/seqalign/GXAlign.h
(Generate patch)
# Line 5 | Line 5
5  
6   #define GDEBUG 1
7  
8 < #define MAX_SPACE 1000000
9 < #define LARGE 100000000
8 > #define MAX_SPACE 2000000
9  
10   enum {
11      EDIT_OP_MASK = 0x3,
# Line 137 | Line 136
136   };
137  
138  
140 struct GX3Val {
141        int I, C, D;
142 };
143
139   // ----- pool allocator -----
140 < struct GXAlnSpace {
141 <    GX3Val* space_array;
140 > // works as a linked list of allocated memory blocks
141 > struct GXMemPool {
142 >    char* memblock;
143      int used, size;
144 <    GXAlnSpace *next;
144 >    GXMemPool *next;
145      //methods
146 <    GXAlnSpace() {
147 <        uint32 amount=MAX_SPACE;
148 <        GCALLOC(space_array, sizeof(GX3Val)*amount);
149 <        if (space_array == NULL) {
146 >    GXMemPool() { //by default allocate a large block here (10M)
147 >        uint32 amount= MAX_SPACE<<3;
148 >        GCALLOC(memblock, amount);
149 >        if (memblock == NULL) {
150             GError("Failed to allocated GXAlnSpace for greedy extension!\n");
151             return;
152             }
# Line 159 | Line 155
155          next = NULL;
156          }
157      void refresh() {
158 <       GXAlnSpace* sp=this;
158 >       GXMemPool* sp=this;
159         while (sp) {
160            sp->used = 0;
161            sp = sp->next;
162            }
163         }
164 <    ~GXAlnSpace() {
165 <        GXAlnSpace* next_sp;
166 <        GXAlnSpace* sp=this->next;
164 >    ~GXMemPool() {
165 >        GXMemPool* next_sp;
166 >        GXMemPool* sp=this->next;
167          while (sp) {
168             next_sp = sp->next;
169 <           GFREE(sp->space_array);
169 >           GFREE(sp->memblock);
170             delete sp;
171             sp = next_sp;
172             }
173 <      GFREE(space_array);
173 >      GFREE(memblock);
174        }
175  
176 <  GX3Val* getSpace(int amount) {
177 <     GX3Val* v;
176 >  void* getSpace(int amount) { //amount to use or allocate memory, in bytes
177 >     //can use the first found memory block with enough room,
178 >    // or allocate a new large block
179 >    char* v;
180       if (amount < 0) return NULL;
181 <     GXAlnSpace* S=this;
181 >     GXMemPool* S=this;
182       while (used+amount > S->size) {
183 +        //no room in current block, get a new mem block
184          if (next == NULL) {
185 <           next=new GXAlnSpace();
185 >           next=new GXMemPool(); //allocates a large contiguous memory block
186             }
187          S = S->next;
188          }
189 <     v = S->space_array+S->used;
189 >     v = S->memblock+S->used;
190       S->used += amount;
191 <     return v;
191 >     //align to next 8-byte boundary
192 >     int m8 = S->used & 7; //modulo 8
193 >     if (m8)
194 >         S->used += 8 - m8;
195 >     return (void*)v;
196       }
197   };
198  
# Line 199 | Line 202
202    int** flast_d; //flast_d[][]
203    int* max_row_free;
204    int* uplow_free;
205 <  GXAlnSpace* space;
205 >  GXMemPool* space;
206    int max_d;
207    GXAlnMem(int max_len, int reward, int penalty, int Xdrop) {
208      flast_d=NULL;
# Line 214 | Line 217
217         GError("Error: cannot allocate GXAlnMem structure!\n");
218         }
219      flast_d[0] = (int*)malloc((max_d + max_d + 6) * sizeof(int) * 2);
220 +    //allocates two int rows - flast_d[1] too
221      if (flast_d[0] == NULL) {
222          GError("Error: failed to allocate flast_d[0] in GXAlnMem!\n");
223          }
224 <    flast_d[1] = flast_d[0] + max_d + max_d + 6;
224 >    flast_d[1] = flast_d[0] + max_d + max_d + 6; //int array for next row
225      uplow_free = NULL;
226      max_row_free = (int*) malloc(sizeof(int) * (max_d + 1 + d_diff));
227 <    space = new GXAlnSpace();
227 >    space = new GXMemPool();
228      }
229    ~GXAlnMem() {
230      delete space;
# Line 276 | Line 280
280         a_ofs=astart;
281         b_ofs=bstart;
282         a_len=0;
283 <       b_len=0;
284 <       for (uint32 i=0; i<ed_script->opnum; i++) {
285 <          int num=((ed_script->ops[i]) >> 2);
286 <          char op_type = 3 - ( ed_script->ops[i] & EDIT_OP_MASK );
287 <          if (op_type == 3 || op_type < 0 )
288 <             GError("Error: encountered op_type %d in ed_script?!\n", (int)op_type);
289 <          CSeqGap gap;
290 <          switch (op_type) {
291 <             case GAPALIGN_SUB: a_len+=num;
292 <                                b_len+=num;
293 <                                break;
294 <             case GAPALIGN_INS: a_len+=num;
295 <                                gap.offset=b_ofs+b_len;
296 <                                gap.len=num;
297 <                                b_gaps.Add(gap);
298 <                                break;
299 <             case GAPALIGN_DEL: b_len+=num;
300 <                                gap.offset=a_ofs+a_len;
301 <                                gap.len=num;
302 <                                a_gaps.Add(gap);
303 <                                break;
304 <             }
305 <          }
306 <       }
283 >           b_len=0;
284 >           if (ed_script==NULL) return;
285 >           for (uint32 i=0; i<ed_script->opnum; i++) {
286 >                  int num=((ed_script->ops[i]) >> 2);
287 >                  char op_type = 3 - ( ed_script->ops[i] & EDIT_OP_MASK );
288 >                  if (op_type == 3 || op_type < 0 )
289 >                         GError("Error: encountered op_type %d in ed_script?!\n", (int)op_type);
290 >                  CSeqGap gap;
291 >                  switch (op_type) {
292 >                         case GAPALIGN_SUB: a_len+=num;
293 >                                                                b_len+=num;
294 >                                                                break;
295 >                         case GAPALIGN_INS: a_len+=num;
296 >                                                                gap.offset=b_ofs+b_len;
297 >                                                                gap.len=num;
298 >                                                                b_gaps.Add(gap);
299 >                                                                break;
300 >                         case GAPALIGN_DEL: b_len+=num;
301 >                                                                gap.offset=a_ofs+a_len;
302 >                                                                gap.len=num;
303 >                                                                a_gaps.Add(gap);
304 >                                                                break;
305 >                         }
306 >                  }
307 >           }
308 >
309   #ifdef GDEBUG
310 <    void printAlignment(FILE* f, const char* sa, const char* sb) {
311 <        //print seq A
312 <       char al[1024]; //display buffer for seq A
313 <       int ap=0; //index in al[] for current character printed
314 <       int g=0;
315 <       int aend=a_ofs+a_len;
316 <       if (a_ofs<b_ofs) {
317 <           for (int i=0;i<b_ofs-a_ofs;i++) {
310 >        void printAlignment(FILE* f, const char* sa, const char* sb) {
311 >                //print seq A
312 >           char al[1024]; //display buffer for seq A
313 >           int ap=0; //index in al[] for current character printed
314 >           int g=0;
315 >           int aend=a_ofs+a_len;
316 >           if (a_ofs<b_ofs) {
317 >                   for (int i=0;i<b_ofs-a_ofs;i++) {
318                     fprintf(f, " ");
319                     al[++ap]=' ';
320                 }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines