Changeset 12431


Ignore:
Timestamp:
06/15/12 16:30:09 (13 years ago)
Author:
Mathieu Morlighem
Message:

changing xmalloc to xNew and xfree to xDelete

Location:
issm/trunk-jpl/src/c/toolkits
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/GetOwnershipBoundariesFromRange.cpp

    r9320 r12431  
    2828
    2929        /*Gather all range values into allranges, for all nodes*/
    30         allranges=(int*)xmalloc(num_procs*sizeof(int));
     30        allranges=xNew<int>(num_procs);
    3131        MPI_Allgather(&range,1,MPI_INT,allranges,1,MPI_INT,MPI_COMM_WORLD);
    3232
    … …  
    4242        *plower_row=lower_row;
    4343        *pupper_row=upper_row;
    44 
    45         /*Free ressources:*/
    46         xfree((void**)&allranges);
    47 
     44        xDelete<int>(allranges);
    4845}

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/MatMultPatch.cpp

    r9826 r12431  
    6464        }
    6565        else{
    66                 result=1;\
     66                result=1;
    6767        }
    6868        return result;
    … …  
    8989        range=upper_row-lower_row+1;
    9090        if (range){
    91                 index=(int*)xmalloc(range*sizeof(int));
    92                 values=(double*)xmalloc(range*sizeof(double));
     91                index=xNew<int>(range);
     92                values=xNew<double>(range);
    9393                for (int i=0;i<range;i++){
    9494                        *(index+i)=lower_row+i;
    … …  
    103103
    104104        /*Free ressources:*/
    105         xfree((void**)&index);
    106         xfree((void**)&values);
     105        xDelete<int>(index);
     106        xDelete<double>(values);       
    107107
    108108        /*Assign output pointers:*/

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/MatPartition.cpp

    r11911 r12431  
    7777                count=0;
    7878                if (range){
    79                         node_rows=(int*)xmalloc(range*sizeof(int)); //this is the maximum number of rows one node can extract.
     79                        node_rows=xNew<int>(range); //this is the maximum number of rows one node can extract.
    8080               
    8181                        for (i=0;i<row_partition_vector_size;i++){
    … …  
    9898               
    9999                /*Same deal for columns*/
    100                 node_cols=(int*)xmalloc(col_partition_vector_size*sizeof(int));
     100                node_cols=xNew<int>(col_partition_vector_size);
    101101                for (i=0;i<col_partition_vector_size;i++){
    102102                        *(node_cols+i)=(int)*(col_partition_vector+i)-1;
    … …  
    128128
    129129        /*Free ressources:*/
    130         xfree((void**)&node_rows);
    131         xfree((void**)&node_cols);
     130        xDelete<int>(node_rows);
     131        xDelete<int>(node_cols);
    132132        ISFree(&col_index);
    133133        ISFree(&row_index);

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/MatToSerial.cpp

    r11695 r12431  
    3232        double* outmatrix=NULL;
    3333       
    34        
    3534        /*get matrix size: */
    3635        MatGetSize(matrix,&M,&N);
    … …  
    4241       
    4342        /*Local and global allocation*/
    44         if (my_rank==0)outmatrix=(double*)xmalloc(M*N*sizeof(double));
     43        if (my_rank==0)outmatrix=xNew<double>(M*N);
    4544       
    4645        if (range){
    47                 local_matrix=(double*)xmalloc(N*range*sizeof(double));
    48                 idxm=(int*)xmalloc(range*sizeof(int)); 
    49                 idxn=(int*)xmalloc(N*sizeof(int)); 
     46                local_matrix=xNew<double>(N*range);
     47                idxm=xNew<int>(range); 
     48                idxn=xNew<int>(N); 
    5049         
    5150                for (i=0;i<N;i++){
    … …  
    7877                //Still have the local_matrix on node 0 to take care of.
    7978                memcpy(outmatrix,local_matrix,N*range*sizeof(double));
    80 
    8179        }
    8280       
    8381        /*Assign output pointer: */
    8482        *poutmatrix=outmatrix;
    85        
    86         xfree((void**)&idxm);
    87         xfree((void**)&idxn);
    88         xfree((void**)&local_matrix);
    89 
     83        xDelete<int>(idxm);
     84        xDelete<int>(idxn);
     85        xDelete<double>(local_matrix);
    9086}

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/PetscMatrixToDoubleMatrix.cpp

    r12102 r12431  
    3636        MatGetSize(petsc_matrix,&rows,&cols);
    3737
    38         idxm=(int*)xmalloc(rows*sizeof(int));
    39         idxn=(int*)xmalloc(cols*sizeof(int));
     38        idxm=xNew<int>(rows);
     39        idxn=xNew<int>(cols);
    4040
    4141        for(i=0;i<rows;i++)idxm[i]=i;
    4242        for(i=0;i<cols;i++)idxn[i]=i;
    4343
    44         matrix=(double*)xmalloc(rows*cols*sizeof(double));
     44        matrix=xNew<double>(rows*cols);
    4545        MatGetValues(petsc_matrix,rows,idxm,cols,idxn,matrix);
     46
     47        xDelete<int>(idxm);
     48        xDelete<int>(idxn);
    4649
    4750        /*Assign output pointers: */

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/PetscVectorToDoubleVector.cpp

    r12102 r12431  
    2828                VecGetSize(petsc_vector,&rows);
    2929                if(rows){
    30                         idxm=(int*)xmalloc(rows*sizeof(int));
    31                         vector=(double*)xmalloc(rows*sizeof(double));
     30                        idxm=xNew<int>(rows);
     31                        vector=xNew<double>(rows);
    3232                        for(i=0;i<rows;i++)idxm[i]=i;
    33 
    3433                        VecGetValues(petsc_vector,rows,idxm,vector);
     34                        xDelete<int>(idxm);
    3535                }
    3636        }

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/SerialToVec.cpp

    r11843 r12431  
    3838
    3939        if (range){
    40                 idxn=(int*)xmalloc(range*sizeof(int));
    41                 values=(double*)xmalloc(range*sizeof(double));
     40                idxn=xNew<int>(range);
     41                values=xNew<double>(range);
    4242                for (i=0;i<range;i++){
    4343                        idxn[i]=lower_row+i;
    … …  
    5454
    5555        /*Free ressources:*/
    56         xfree((void**)&idxn);
    57         xfree((void**)&values);
     56        xDelete<int>(idxn);
     57        xDelete<double>(values);
    5858
    5959        return outvector;

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/VecMerge.cpp

    r9320 r12431  
    4545        if (range){
    4646                /*This node owns rows of vector B, get them*/
    47                 idxm=(int*)xmalloc(range*sizeof(int));
    48                 values=(double*)xmalloc(range*sizeof(double));
     47                idxm=xNew<int>(range);
     48                values=xNew<double>(range);
    4949                for (i=0;i<range;i++){
    5050                        *(idxm+i)=lower_row+i;
    … …  
    6363
    6464        /*Free ressources:*/
    65         xfree((void**)&idxm);
    66         xfree((void**)&values);
    67 
     65        xDelete<int>(idxm);
     66        xDelete<double>(values);
    6867}

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/VecPartition.cpp

    r9320 r12431  
    5656
    5757                if (range){
    58                         node_rows=(int*)xmalloc(range*sizeof(int)); //this is the maximum number of rows one node can extract.
     58                        node_rows=xNew<int>(range); //this is the maximum number of rows one node can extract.
    5959               
    6060                        count=0;
    … …  
    7171                                       
    7272        if (count){
    73                         values=(double*)xmalloc(count*sizeof(double)); //holder for the values to be extracted from vectorA
     73                        values=xNew<double>(count); //holder for the values to be extracted from vectorA
    7474                }
    7575                else{
    76                         xfree((void**)&node_rows); //count=0 means no values was condensed out for this node. null node_rows for use in VecGetValues.
     76                        xDelete<int>(node_rows); //count=0 means no values was condensed out for this node. null node_rows for use in VecGetValues.
    7777                        values=NULL;
    7878                }
    … …  
    110110                VecAssemblyBegin(outvector);
    111111                VecAssemblyEnd(outvector);
    112                
    113112        }
    114113       
    115114        /*Assign output pointers:*/
    116115        *poutvector=outvector;
    117 
    118         /*Free ressources:*/
    119         xfree((void**)&node_rows);
    120         xfree((void**)&values);
    121 
     116        xDelete<int>(node_rows);
     117        xDelete<double>(values);
    122118}

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/VecToMPISerial.cpp

    r11695 r12431  
    4242
    4343        /*Allocate gathered vector on all nodes .*/
    44         gathered_vector=(double*)xmalloc(vector_size*sizeof(double));
     44        gathered_vector=xNew<double>(vector_size);
    4545       
    4646        /*Allocate local vectors*/
    … …  
    5050
    5151        if (range){
    52                 idxn=(int*)xmalloc(range*sizeof(int));
     52                idxn=xNew<int>(range);
    5353                for (i=0;i<range;i++){
    5454                        *(idxn+i)=lower_row+i;
    5555                }
    56                 local_vector=(double*)xmalloc(range*sizeof(double));
     56                local_vector=xNew<double>(range);
    5757                /*Extract values from MPI vector to serial local_vector on each node*/
    5858                VecGetValues(vector,range,idxn,local_vector);
    … …  
    8787       
    8888        /*free ressources: */
    89         xfree((void**)&idxn);
    90         xfree((void**)&local_vector);
     89        xDelete<int>(idxn);
     90        xDelete<double>(local_vector);
    9191       
    9292        return 1;

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/VecTranspose.cpp

    r1 r12431  
    3333
    3434        if (range){
    35                 idxm=(int*)xmalloc(range*sizeof(int));
    36                 tidxm=(int*)xmalloc(range*sizeof(int));
     35                idxm=xNew<int>(range);
     36                tidxm=xNew<int>(range);
    3737                for (i=0;i<range;i++){
    3838                        *(idxm+i)=lower_row+i;
    3939                }
    40                 values=(double*)xmalloc(range*sizeof(double));
    41                 tvalues=(double*)xmalloc(range*sizeof(double));
     40                values=xNew<double>(range);
     41                tvalues=xNew<double>(range);
    4242               
    4343                VecGetValues(vector,range,idxm,values);
    … …  
    5656
    5757        /*Free ressources: */
    58         xfree((void**)&idxm);
    59         xfree((void**)&values);
    60         xfree((void**)&tidxm);
    61         xfree((void**)&tvalues);
     58        xDelete<int>(idxm);
     59        xDelete<double>(values);
     60        xDelete<int>(tidxm);
     61        xDelete<double>(tvalues);
    6262
    6363        /*Assign output pointers: */

  • issm/trunk-jpl/src/c/toolkits/plapack/patches/CyclicalFactorization.cpp

    r3595 r12431  
    4444        int i;
    4545
    46         decomp=xmalloc(input*sizeof(int));
     46        decomp=xNew<int>(input);
    4747        *decomp=input;
    4848        for (i=0;i<input;i++){
    … …  
    5757                }
    5858        }
    59 
    6059        *pdecomp=decomp;
    6160}

  • issm/trunk-jpl/src/c/toolkits/plapack/patches/PlapackInvertMatrix.cpp

    r6412 r12431  
    1313#include "../../scalapack/FortranMapping.h"
    1414
    15 void PlapackInvertMatrixLocalCleanup(PLA_Obj* pa,PLA_Template* ptempl,double** parrayA,
    16                 int** pidxnA,MPI_Comm* pcomm_2d);
     15void PlapackInvertMatrixLocalCleanup(PLA_Obj* pa,PLA_Template* ptempl,double** parrayA,int** pidxnA,MPI_Comm* pcomm_2d);
    1716       
    1817int PlapackInvertMatrix(Mat* A,Mat* inv_A,int status,int con){
    19         /*inv_A does not yet exist, inv_A was just xmalloced, that's all*/
     18        /*inv_A does not yet exist, inv_A was just allocated, that's all*/
    2019
    2120        /*Error management*/
    2221        int i,j;
    23        
    2422
    2523        /*input*/
    … …  
    9492        /* Set the datatype */
    9593        datatype = MPI_DOUBLE;
    96 
    9794       
    9895        /* Copy A into a*/
    … …  
    104101        upper_row--;
    105102        range=upper_row-lower_row+1;
    106         arrayA=xmalloc(nA*sizeof(double));
    107         idxnA=xmalloc(nA*sizeof(int));
     103        arrayA = xNew<double>(nA);
     104        idxnA  = xNew<int>(nA);
    108105        for (i=0;i<nA;i++){
    109106                *(idxnA+i)=i;
    … …  
    128125        PLA_Obj_free(&a);
    129126        PLA_Temp_free(&templ);
    130         xfree((void**)&arrayA);
    131         xfree((void**)&idxnA);
     127        xDelete<double>(arrayA);
     128        xDelete<int>(idxnA);
    132129       
    133130        /*Finalize PLAPACK*/
    134131        PLA_Finalize();
    135132        MPI_Comm_free(&comm_2d);
    136 
    137133}

  • issm/trunk-jpl/src/c/toolkits/plapack/patches/PlapackToPetsc.cpp

    r3332 r12431  
    4545       
    4646        /*Vector physically based block cyclic distribution: */
    47         row_nodes=xmalloc(mA*sizeof(int));
    48         col_nodes=xmalloc(nA*sizeof(int));
     47        row_nodes=xNew<int>(mA);
     48        col_nodes=xNew<int>(nA);
    4949        for (i=0;i<mA;i++){
    5050                i0=i/nb;
    … …  
    6060        PLA_Temp_comm_col_rank(templ,&myrow);
    6161
    62         idxm=xmalloc(mA*sizeof(int));
     62        idxm=xNew<int>(mA);
    6363        count=0;
    6464        for (i=0;i<mA;i++){
    … …  
    7070        idxm_count=count;
    7171
    72         idxn=xmalloc(nA*sizeof(int));
     72        idxn=xNew<int>(nA);
    7373        count=0;
    7474        for (i=0;i<nA;i++){
    … …  
    9292
    9393        /*Free ressources:*/
    94         xfree((void**)&row_nodes);
    95         xfree((void**)&col_nodes);
    96         xfree((void**)&idxm);
    97         xfree((void**)&idxn);
     94        xDelete<int>(row_nodes);
     95        xDelete<int>(col_nodes);
     96        xDelete<int>(idxm);
     97        xDelete<int>(idxn);
    9898}
Note: See TracChangeset for help on using the changeset viewer.