/[escript]/branches/arrayview_from_1695_trunk/finley/src/NodeFile_createDenseLabelings.c
ViewVC logotype

Diff of /branches/arrayview_from_1695_trunk/finley/src/NodeFile_createDenseLabelings.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1780 by jfenwick, Mon Aug 11 03:33:40 2008 UTC revision 1781 by jfenwick, Thu Sep 11 05:03:14 2008 UTC
# Line 101  dim_t Finley_NodeFile_createDenseDOFLabe Line 101  dim_t Finley_NodeFile_createDenseDOFLabe
101                 new_numGlobalDOFs=loc_offsets[0];                 new_numGlobalDOFs=loc_offsets[0];
102                 loc_offsets[0]=0;                 loc_offsets[0]=0;
103              #endif              #endif
104              #pragma omp parallel for private(n) schedule(static)              #pragma omp parallel
105              for (n=0; n<myDOFs; ++n) DOF_buffer[n]+=loc_offsets[in->MPIInfo->rank];              {
106              /* now entries are collected from the buffer again by sending the entries around in a circle */                  #pragma omp for private(n) schedule(static)
107              #pragma omp parallel for private(n) schedule(static)                  for (n=0; n<myDOFs; ++n) DOF_buffer[n]+=loc_offsets[in->MPIInfo->rank];
108              for (n=0; n<in->numNodes; ++n) set_new_DOF[n]=TRUE;                  /* now entries are collected from the buffer again by sending the entries around in a circle */
109                    #pragma omp for private(n) schedule(static)
110                    for (n=0; n<in->numNodes; ++n) set_new_DOF[n]=TRUE;
111                }
112              dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);              dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);
113              source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);              source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);
114              buffer_rank=in->MPIInfo->rank;              buffer_rank=in->MPIInfo->rank;
# Line 273  dim_t Finley_NodeFile_createDenseReduced Line 276  dim_t Finley_NodeFile_createDenseReduced
276    TMPMEMFREE(offsets);    TMPMEMFREE(offsets);
277    return globalNumReducedDOFs;    return globalNumReducedDOFs;
278  }  }
279  dim_t Finley_NodeFile_createDenseNodeLabeling(Finley_NodeFile* in)  dim_t Finley_NodeFile_createDenseNodeLabeling(Finley_NodeFile* in, index_t* node_distribution, const index_t* dof_distribution)
280  {  {
281    index_t min_nodeID, max_nodeID, unset_nodeID=-1,set_nodeID=1, nodeID_0, nodeID_1, *Node_buffer=NULL, k;    index_t myFirstDOF, myLastDOF, max_id, min_id, loc_max_id, loc_min_id, dof, id, itmp, nodeID_0, nodeID_1, dof_0, dof_1, *Node_buffer=NULL;
282    Paso_MPI_rank buffer_rank, dest, source, *distribution=NULL;    dim_t n, my_buffer_len, buffer_len, globalNumNodes, myNewNumNodes;
283    dim_t p, buffer_len,n, myNodes, *offsets=NULL, *loc_offsets=NULL, globalNumNodes=0, myNewNodes;    Paso_MPI_rank p, dest, source, buffer_rank;
284      const index_t unset_nodeID=-1, set_nodeID=1;
285      const dim_t header_len=2;
286    #ifdef PASO_MPI    #ifdef PASO_MPI
287    MPI_Status status;    MPI_Status status;
288    #endif    #endif
289      Paso_MPI_rank myRank=in->MPIInfo->rank;
290    
291    /* get the global range of node ids */    /* find the range of node ids controled by me */
   Finley_NodeFile_setGlobalIdRange(&min_nodeID,&max_nodeID,in);  
292    
293    distribution=TMPMEMALLOC(in->MPIInfo->size+1, index_t);    myFirstDOF=dof_distribution[in->MPIInfo->rank];
294    offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);    myLastDOF=dof_distribution[in->MPIInfo->rank+1];
295    loc_offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);    max_id=-INDEX_T_MAX;
296      min_id=INDEX_T_MAX;
297    if ( ! (Finley_checkPtr(distribution) || Finley_checkPtr(offsets) || Finley_checkPtr(loc_offsets)) ) {    #pragma omp parallel private(loc_max_id,loc_min_id)
298        /* distribute the range of node ids */    {
299        buffer_len=Paso_MPIInfo_setDistribution(in->MPIInfo,min_nodeID,max_nodeID,distribution);           loc_max_id=max_id;
300        myNodes=distribution[in->MPIInfo->rank+1]-distribution[in->MPIInfo->rank];           loc_min_id=min_id;
301        /* allocate buffers */           #pragma omp for private(n,dof,id) schedule(static)
302        Node_buffer=TMPMEMALLOC(buffer_len,index_t);           for (n=0;n<in->numNodes;n++) {
303        if (! Finley_checkPtr(Node_buffer)) {             dof=in->globalDegreesOfFreedom[n];
304              /* fill Node_buffer by the unset_nodeID marker to check if nodes are defined */             id=in->Id[n];
305              #pragma omp parallel for private(n) schedule(static)             if ((myFirstDOF<= dof) && (dof< myLastDOF)) {
306              for (n=0;n<buffer_len;n++) Node_buffer[n]=unset_nodeID;                loc_max_id=MAX(loc_max_id,id);
307                              loc_min_id=MIN(loc_min_id,id);
308              /* fill the buffer by sending portions around in a circle */             }
309              dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);           }
310              source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);           #pragma omp critical
311              buffer_rank=in->MPIInfo->rank;           {
312              for (p=0; p< in->MPIInfo->size; ++p) {                max_id=MAX(loc_max_id,max_id);
313                   if (p>0) {  /* the initial send can be skipped */                min_id=MIN(loc_min_id,min_id);
314                       #ifdef PASO_MPI           }
315                       MPI_Sendrecv_replace(Node_buffer, buffer_len, MPI_INT,     }
316                                            dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,     /* allocate a buffer */
317                                            in->MPIInfo->comm,&status);     my_buffer_len=max_id> min_id ? max_id-min_id+1 :0;
318                       #endif  
319                       in->MPIInfo->msg_tag_counter++;     #ifdef PASO_MPI
320                   }     MPI_Allreduce( &my_buffer_len, &buffer_len, 1, MPI_INT, MPI_MAX, in->MPIInfo->comm );
321                   buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);     #else
322                   nodeID_0=distribution[buffer_rank];     buffer_len=my_buffer_len;
323                   nodeID_1=distribution[buffer_rank+1];     #endif
324                   #pragma omp parallel for private(n,k) schedule(static)  
325                   for (n=0;n<in->numNodes;n++) {     Node_buffer=TMPMEMALLOC(buffer_len+header_len,index_t);
326                       k=in->Id[n];     if (! Finley_checkPtr(Node_buffer)) {
327                       if ((nodeID_0<=k) && (k<nodeID_1)) {         /* mark and count the nodes in use */
328                           Node_buffer[k-nodeID_0] = set_nodeID;         #pragma omp parallel
329                       }         {
330                   }             #pragma omp for private(n) schedule(static)
331               for (n=0;n<buffer_len+header_len;n++) Node_buffer[n]=unset_nodeID;
332               #pragma omp for private(n) schedule(static)
333               for (n=0;n<in->numNodes;n++) in->globalNodesIndex[n]=-1;
334               #pragma omp for private(n,dof,id) schedule(static)
335               for (n=0;n<in->numNodes;n++) {
336                   dof=in->globalDegreesOfFreedom[n];
337                   id=in->Id[n];
338                   if ((myFirstDOF<= dof) && (dof< myLastDOF)) Node_buffer[id-min_id+header_len]=set_nodeID;
339               }
340           }
341           myNewNumNodes=0;
342           for (n=0;n<my_buffer_len;n++) {
343                if (Node_buffer[header_len+n]==set_nodeID) {
344                     Node_buffer[header_len+n]=myNewNumNodes;
345                     myNewNumNodes++;
346              }              }
347              /* count the entries in the Node_buffer */         }
348              /* TODO: OMP parallel */         /* make the local number of nodes globally available */
349              myNewNodes=0;         #ifdef PASO_MPI
350              for (n=0; n<myNodes; ++n) {           MPI_Allgather(&myNewNumNodes,1,MPI_INT,node_distribution,1,MPI_INT,in->MPIInfo->comm);
351                  if ( Node_buffer[n] == set_nodeID) {         #else
352                        Node_buffer[n]=myNewNodes;           node_distribution[0]=myNewNumNodes;
353                        myNewNodes++;         #endif
354           globalNumNodes=0;
355           for (p=0; p< in->MPIInfo->size; ++p) {
356               itmp=node_distribution[p];
357               node_distribution[p]=globalNumNodes;
358               globalNumNodes+=itmp;
359           }
360           node_distribution[in->MPIInfo->size]=globalNumNodes;
361    
362           /* offset nodebuffer */
363           itmp=node_distribution[in->MPIInfo->rank];
364           #pragma omp for private(n) schedule(static)
365           for (n=0;n<my_buffer_len;n++) Node_buffer[n+header_len]+=itmp;
366    
367           /* now we send this buffer around to assign global node index: */
368           dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);
369           source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);
370           Node_buffer[0]=min_id;
371           Node_buffer[1]=max_id;
372           buffer_rank=in->MPIInfo->rank;
373           for (p=0; p< in->MPIInfo->size; ++p) {
374                 nodeID_0=Node_buffer[0];
375                 nodeID_1=Node_buffer[1];
376                 dof_0=dof_distribution[buffer_rank];
377                 dof_1=dof_distribution[buffer_rank+1];
378                 if (nodeID_0<=nodeID_1) {
379                    #pragma omp for private(n,dof,id) schedule(static)
380                    for (n=0;n<in->numNodes;n++) {
381                        dof=in->globalDegreesOfFreedom[n];
382                        id=in->Id[n]-nodeID_0;
383                        if ( (dof_0<= dof) && (dof< dof_1) && (id>=0) && (id<=nodeID_1-nodeID_0)) in->globalNodesIndex[n]=Node_buffer[id+header_len];
384                  }                  }
385              }               }
386              memset(loc_offsets,0,in->MPIInfo->size*sizeof(dim_t));               if (p<in->MPIInfo->size-1) {  /* the last send can be skipped */
387              loc_offsets[in->MPIInfo->rank]=myNewNodes;                   #ifdef PASO_MPI
388              #ifdef PASO_MPI                   MPI_Sendrecv_replace(Node_buffer, buffer_len+header_len, MPI_INT,
389                 MPI_Allreduce(loc_offsets,offsets,in->MPIInfo->size, MPI_INT, MPI_SUM, in->MPIInfo->comm );                                        dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,
390                 globalNumNodes=0;                                        in->MPIInfo->comm,&status);
391                 for (n=0; n< in->MPIInfo->size; ++n) {                   #endif
392                        loc_offsets[n]=globalNumNodes;                   in->MPIInfo->msg_tag_counter+=1;
393                        globalNumNodes+=offsets[n];               }
394                 }               buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);
395              #else         }
396                 globalNumNodes=loc_offsets[0];     }
397                 loc_offsets[0]=0;     TMPMEMFREE(Node_buffer);
398              #endif     return globalNumNodes;
             #pragma omp parallel for private(n) schedule(static)  
             for (n=0; n<myNodes; ++n) Node_buffer[n]+=loc_offsets[in->MPIInfo->rank];  
             /* now entries are collected from the buffer again by sending the entries around in a circle */  
             #pragma omp parallel for private(n) schedule(static)  
             for (n=0; n<in->numNodes; ++n) in->globalNodesIndex[n]=loc_offsets[0]-1;  
             dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);  
             source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);  
             buffer_rank=in->MPIInfo->rank;  
             for (p=0; p< in->MPIInfo->size; ++p) {  
                  nodeID_0=distribution[buffer_rank];  
                  nodeID_1=distribution[buffer_rank+1];  
                  #pragma omp parallel for private(n,k) schedule(static)  
                  for (n=0;n<in->numNodes;n++) {  
                       k=in->Id[n];  
                       if ( ( nodeID_0<=k) && (k<nodeID_1) ) in->globalNodesIndex[n]=Node_buffer[k-nodeID_0];  
                  }  
                  if (p<in->MPIInfo->size-1) {  /* the last send can be skipped */  
                      #ifdef PASO_MPI  
                      MPI_Sendrecv_replace(Node_buffer, buffer_len, MPI_INT,  
                                           dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,  
                                           in->MPIInfo->comm,&status);  
                      #endif  
                      in->MPIInfo->msg_tag_counter+=1;  
                  }  
                  buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);  
             }  
       }  
       TMPMEMFREE(Node_buffer);  
   }  
   TMPMEMFREE(distribution);  
   TMPMEMFREE(loc_offsets);  
   TMPMEMFREE(offsets);  
   return globalNumNodes;  
399  }  }
400    
401  dim_t Finley_NodeFile_createDenseReducedNodeLabeling(Finley_NodeFile* in, index_t* reducedNodeMask)  dim_t Finley_NodeFile_createDenseReducedNodeLabeling(Finley_NodeFile* in,index_t* reducedNodeMask)
402  {  {
403    index_t min_nodeID, max_nodeID, unset_nodeID=-1,set_nodeID=1, nodeID_0, nodeID_1, *Node_buffer=NULL, k;    index_t min_node, max_node, unset_node=-1,set_node=1, node_0, node_1, *Nodes_buffer=NULL, k;
404    Paso_MPI_rank buffer_rank, dest, source, *distribution=NULL;    Paso_MPI_rank buffer_rank, dest, source, *distribution=NULL;
405    dim_t p, buffer_len,n, myNodes, *offsets=NULL, *loc_offsets=NULL, globalNumReducedNodes=0, myNewNodes;    dim_t p, buffer_len,n, myNodes, *offsets=NULL, *loc_offsets=NULL, globalNumReducedNodes=0, myNewNodes;
406    #ifdef PASO_MPI    #ifdef PASO_MPI
# Line 391  dim_t Finley_NodeFile_createDenseReduced Line 408  dim_t Finley_NodeFile_createDenseReduced
408    #endif    #endif
409    
410    /* get the global range of node ids */    /* get the global range of node ids */
411    Finley_NodeFile_setGlobalIdRange(&min_nodeID,&max_nodeID,in);    Finley_NodeFile_setGlobalNodeIDIndexRange(&min_node,&max_node,in);
412    
413    distribution=TMPMEMALLOC(in->MPIInfo->size+1, index_t);    distribution=TMPMEMALLOC(in->MPIInfo->size+1, index_t);
414    offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);    offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);
415    loc_offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);    loc_offsets=TMPMEMALLOC(in->MPIInfo->size, dim_t);
416    
417    if ( ! (Finley_checkPtr(distribution) || Finley_checkPtr(offsets) || Finley_checkPtr(loc_offsets) )) {    if ( ! (Finley_checkPtr(distribution) || Finley_checkPtr(offsets) || Finley_checkPtr(loc_offsets) ) ) {
418        /* distribute the range of node ids */        /* distribute the range of node ids */
419        buffer_len=Paso_MPIInfo_setDistribution(in->MPIInfo,min_nodeID,max_nodeID,distribution);        buffer_len=Paso_MPIInfo_setDistribution(in->MPIInfo,min_node,max_node,distribution);
420        myNodes=distribution[in->MPIInfo->rank+1]-distribution[in->MPIInfo->rank];        myNodes=distribution[in->MPIInfo->rank+1]-distribution[in->MPIInfo->rank];
421        /* allocate buffers */        /* allocate buffers */
422        Node_buffer=TMPMEMALLOC(buffer_len,index_t);        Nodes_buffer=TMPMEMALLOC(buffer_len,index_t);
423        if (! Finley_checkPtr(Node_buffer)) {        if (! Finley_checkPtr(Nodes_buffer)) {
424              /* fill Node_buffer by the unset_nodeID marker to check if nodes are defined */              /* fill Nodes_buffer by the unset_node marker to check if nodes are defined */
425              #pragma omp parallel for private(n) schedule(static)              #pragma omp parallel for private(n) schedule(static)
426              for (n=0;n<buffer_len;n++) Node_buffer[n]=unset_nodeID;              for (n=0;n<buffer_len;n++) Nodes_buffer[n]=unset_node;
427                            
428              /* fill the buffer by sending portions around in a circle */              /* fill the buffer by sending portions around in a circle */
429              dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);              dest=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank + 1);
# Line 415  dim_t Finley_NodeFile_createDenseReduced Line 432  dim_t Finley_NodeFile_createDenseReduced
432              for (p=0; p< in->MPIInfo->size; ++p) {              for (p=0; p< in->MPIInfo->size; ++p) {
433                   if (p>0) {  /* the initial send can be skipped */                   if (p>0) {  /* the initial send can be skipped */
434                       #ifdef PASO_MPI                       #ifdef PASO_MPI
435                       MPI_Sendrecv_replace(Node_buffer, buffer_len, MPI_INT,                       MPI_Sendrecv_replace(Nodes_buffer, buffer_len, MPI_INT,
436                                            dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,                                            dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,
437                                            in->MPIInfo->comm,&status);                                            in->MPIInfo->comm,&status);
438                       #endif                       #endif
439                       in->MPIInfo->msg_tag_counter++;                       in->MPIInfo->msg_tag_counter++;
440                   }                   }
441                   buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);                   buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);
442                   nodeID_0=distribution[buffer_rank];                   node_0=distribution[buffer_rank];
443                   nodeID_1=distribution[buffer_rank+1];                   node_1=distribution[buffer_rank+1];
444                   #pragma omp parallel for private(n,k) schedule(static)                   #pragma omp parallel for private(n,k) schedule(static)
445                   for (n=0;n<in->numNodes;n++) {                   for (n=0;n<in->numNodes;n++) {
446                       if (reducedNodeMask[n] >-1) {                       if (reducedNodeMask[n] >-1) {
447                          k=in->Id[n];                          k=in->globalNodesIndex[n];
448                          if ((nodeID_0<=k) && (k<nodeID_1)) {                          if ((node_0<=k) && (k<node_1)) {
449                              Node_buffer[k-nodeID_0] = set_nodeID;                              Nodes_buffer[k-node_0] = set_node;
450                          }                          }
451                       }                       }
452                   }                   }
453              }              }
454              /* count the entries in the Node_buffer */              /* count the entries in the Nodes_buffer */
455              /* TODO: OMP parallel */              /* TODO: OMP parallel */
456              myNewNodes=0;              myNewNodes=0;
457              for (n=0; n<myNodes; ++n) {              for (n=0; n<myNodes; ++n) {
458                  if ( Node_buffer[n] == set_nodeID) {                  if ( Nodes_buffer[n] == set_node) {
459                        Node_buffer[n]=myNewNodes;                        Nodes_buffer[n]=myNewNodes;
460                        myNewNodes++;                        myNewNodes++;
461                  }                  }
462              }              }
# Line 457  dim_t Finley_NodeFile_createDenseReduced Line 474  dim_t Finley_NodeFile_createDenseReduced
474                 loc_offsets[0]=0;                 loc_offsets[0]=0;
475              #endif              #endif
476              #pragma omp parallel for private(n) schedule(static)              #pragma omp parallel for private(n) schedule(static)
477              for (n=0; n<myNodes; ++n) Node_buffer[n]+=loc_offsets[in->MPIInfo->rank];              for (n=0; n<myNodes; ++n) Nodes_buffer[n]+=loc_offsets[in->MPIInfo->rank];
478              /* now entries are collected from the buffer again by sending the entries around in a circle */              /* now entries are collected from the buffer again by sending the entries around in a circle */
479              #pragma omp parallel for private(n) schedule(static)              #pragma omp parallel for private(n) schedule(static)
480              for (n=0; n<in->numNodes; ++n) in->globalReducedNodesIndex[n]=loc_offsets[0]-1;              for (n=0; n<in->numNodes; ++n) in->globalReducedNodesIndex[n]=loc_offsets[0]-1;
# Line 465  dim_t Finley_NodeFile_createDenseReduced Line 482  dim_t Finley_NodeFile_createDenseReduced
482              source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);              source=Paso_MPIInfo_mod(in->MPIInfo->size, in->MPIInfo->rank - 1);
483              buffer_rank=in->MPIInfo->rank;              buffer_rank=in->MPIInfo->rank;
484              for (p=0; p< in->MPIInfo->size; ++p) {              for (p=0; p< in->MPIInfo->size; ++p) {
485                   nodeID_0=distribution[buffer_rank];                   node_0=distribution[buffer_rank];
486                   nodeID_1=distribution[buffer_rank+1];                   node_1=distribution[buffer_rank+1];
487                   #pragma omp parallel for private(n,k) schedule(static)                   #pragma omp parallel for private(n,k) schedule(static)
488                   for (n=0;n<in->numNodes;n++) {                   for (n=0;n<in->numNodes;n++) {
489                       if (reducedNodeMask[n] >-1) {                        if (reducedNodeMask[n] >-1) {
490                          k=in->Id[n];                           k=in->globalNodesIndex[n];
491                          if ( (nodeID_0<=k) && (k<nodeID_1)) in->globalReducedNodesIndex[n]=Node_buffer[k-nodeID_0];                           if ( (node_0<=k) && (k<node_1)) in->globalReducedNodesIndex[n]=Nodes_buffer[k-node_0];
492                       }                        }
493                   }                   }
494                   if (p<in->MPIInfo->size-1) {  /* the last send can be skipped */                   if (p<in->MPIInfo->size-1) {  /* the last send can be skipped */
495                       #ifdef PASO_MPI                       #ifdef PASO_MPI
496                       MPI_Sendrecv_replace(Node_buffer, buffer_len, MPI_INT,                       MPI_Sendrecv_replace(Nodes_buffer, buffer_len, MPI_INT,
497                                            dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,                                            dest, in->MPIInfo->msg_tag_counter, source, in->MPIInfo->msg_tag_counter,
498                                            in->MPIInfo->comm,&status);                                            in->MPIInfo->comm,&status);
499                       #endif                       #endif
# Line 485  dim_t Finley_NodeFile_createDenseReduced Line 502  dim_t Finley_NodeFile_createDenseReduced
502                   buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);                   buffer_rank=Paso_MPIInfo_mod(in->MPIInfo->size, buffer_rank-1);
503              }              }
504        }        }
505        TMPMEMFREE(Node_buffer);        TMPMEMFREE(Nodes_buffer);
506    }    }
507    TMPMEMFREE(distribution);    TMPMEMFREE(distribution);
508    TMPMEMFREE(loc_offsets);    TMPMEMFREE(loc_offsets);

Legend:
Removed from v.1780  
changed lines
  Added in v.1781

  ViewVC Help
Powered by ViewVC 1.1.26