Changeset 281 for branches


Ignore:
Timestamp:
Dec 5, 2011 5:38:15 AM (7 years ago)
Author:
kulshres
Message:

Merge branch 'mpi' of 'gitclone' to 'branches/MPI'

following commits were merged:

commit 0956f82caa88b1fbc3f194ad122a460124660e88
Author: Benjamin Letschert <letschi@…>
Date: Wed Nov 23 16:33:31 2011 +0100

deleting unused global integer variable for MPI-size process_count

commit 67b776fed7485105677ef3d3960d8bcad636803d
Author: Benjamin Letschert <letschi@…>
Date: Fri Nov 11 15:24:21 2011 +0100

Bugfix for nonl_ind_forward by deleting buffer
deleting buffer twice by serial ADOL-C

commit 7bff16645e8b9f19ca868ae2e128752ba4bd2d25
Author: Benjamin Letschert <letschi@…>
Date: Mon Oct 24 03:53:51 2011 +0200

Deleting LOC_INT in operation gather in uni5_for.c

commit 155677f69179d87cb44c8e358c28dfc170a63598
Author: Benjamin Letschert <letschi@…>
Date: Fri Oct 21 13:21:39 2011 +0200

Bugfix for gather operation,
changing order of calls for ADOLC_GET_TAYLOR

commit 1e363bf9aef2017c90732b3b181deb9f8327efb2
Author: Benjamin Letschert <letschi@…>
Date: Fri Oct 21 13:16:45 2011 +0200

Deleting operation reduce

commit dd9ede1f581d0c6d86a57fcea5e582a0c358483c
Author: Benjamin Letschert <letschi@…>
Date: Fri Oct 21 13:06:19 2011 +0200

Replace of code of the parallel speelpenning example in adolc-manual.tex

commit 6ff96b548a988bc359720d035f8a277ba58372f6
Author: Benjamin Letschert <letschi@…>
Date: Tue Oct 18 15:32:34 2011 +0200

Bugfix for parallel computing gradient and hessian

commit 1fadf475dd09124140ba575f604272c7fe8c3ca4
Author: Benjamin Letschert <letschi@…>
Date: Mon Oct 17 15:48:31 2011 +0200

Bugfix for int_forward_tight_mpi at operation MPI_Scatter

commit 707abf19a33af58031cc5c1b017ec89aa434510a
Author: Benjamin Letschert <letschi@…>
Date: Mon Oct 17 14:34:25 2011 +0200

Bugfix for parallel tapedoc output

commit a32291f114ac315b29a796a1391bb8e1f5af514b
Author: Benjamin Letschert <letschi@…>
Date: Mon Oct 17 14:28:54 2011 +0200

Bugfix for ADOLC_MPI_Reduce / ADOLC_MPI_Gather

Location:
branches/MPI/ADOL-C
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/MPI/ADOL-C/doc/adolc-manual.tex

    r273 r281  
    40154015\end{verbatim}
    40164016%
    4017 \subsection{Parallel Speelpenning example codes}
    4018 \label{SpeelPar}
    4019 %
    4020 \begin{verbatim}
    4021 #define HAVE_MPI_MPI_H 1        // using parallel mode
    4022 #include <adolc/adouble.h>      // use of active doubles
    4023 #include <adolc/adouble_mpi.h>  // use of parallel MPI functions
    4024 #include <adolc(adalloc.h>
    4025 ...
    4026 using namespace std;
    4027 #define CMMCTR ADOLC_MPI_COMM_WORLD
    4028 #define tag 1
    4029 
    4030 int main(int* argc,char** argv) {
    4031     int n,i,j, id, size, root=0; // root process has id 0
    4032     int tape_stats[STAT_SIZE];
    4033 
    4034     ADOLC_MPI_Init(argc,&argv);                // initialisation
    4035     ADOLC_MPI_Comm_size(CMMCTR,&size);   // get count of processes
    4036     ADOLC_MPI_Comm_rank(CMMCTR,&id);     // get id of process
    4037 
    4038     if(id == root){
    4039        cout <<"PARALLEL SPEELPENNINGS PRODUCT\n\n"
    4040             <<"number of independent variables = ?\n";
    4041        cin >> n;
    4042     }
    4043 
    4044     MPI_Bcast(&n,1, ADOLC_MPI_INT, root, CMMCTR);
    4045     // every process knows the count independent variables
    4046 
    4047     int n_tmp = n/size;  // split count to #size arrays of length n_tmp
    4048     double *xp = new double[n];
    4049     double  yp = 0.0;
    4050     adouble *x = new adouble[n], *x_tmp = new adouble[n_tmp];
    4051     adouble  y , tmp=1;
    4052 
    4053     if( id == root)     // some initialization
    4054        for(i=0; i<n; i++) xp[i] = (i+1.0)/(2.0+i);
    4055 
    4056     trace_on(id, size, tag);  // tag = 1, keep = 0 by default
    4057     if(id == root){
    4058        for(i=0; i<n; i++)  x[i] <<= xp[i];  // or  x <<= xp outside the loop
    4059        for(i=1; i< size; i++)
    4060            ADOLC_MPI_Send(&x[i*n_tmp], n_tmp, MPI_ADOUBLE, i, tag, CMMCTR);
    4061        for(i=0; i< n_tmp;i++) x_tmp[i] = x[i];
    4062     } else
    4063        ADOLC_MPI_Recv(x_tmp, n_tmp, MPI_ADOUBLE,root, tag, CMMCTR);
    4064     /* now all independent variables are sent for computing */
    4065 
    4066     for(i=0; i < n_tmp ; i++) tmp *= x[i];
    4067 
    4068     ADOLC_MPI_Barrier(CMMCTR); // synchronise all processes
    4069     ADOLC_MPI_Reduce( &tmp, &y , 1 , MPI_ADOUBLE, ADOLC_MPI_PROD, root, CMMCTR);
    4070  
    4071     if(id == root){
    4072           y >>= yp;
    4073           cout << The result is << yp << endl;
    4074     }
    4075     trace_off();   // end of tape
    4076 
    4077     double *grad = NULL;
    4078     if ( id == root) grad = new double[n];
    4079     gradient(id,size,tag, 1, n, x, grad);
    4080     if(id == root){
    4081         cout << "The gradient is "<< endl << "\t";
    4082         for(i=0; i < n ; i++) cout << "  "<< grad[i];
    4083         cout << endl;
    4084         delete[] grad;
    4085     }
    4086 
    4087     double **hess = NULL;
    4088     if ( id == root) hess = myarrayI2(n);
    4089 
    4090     hessian(id,size,tag, 1, n, x, hess);
    4091     if(id == root){
    4092         print_mat("Hessian",n,n,hess);
    4093         myfreeI2(n,hess);
    4094     }
    4095     delete[] x;
    4096     delete[] x_tmp;
    4097     ADOLC_MPI_Finalize();
    4098 }
    4099 \end{verbatim}
    4100 %
    41014017\subsection{Power Example ({\tt powexam.cpp})}
    41024018%
     
    43994315%\vspace*{-4mm}
    44004316%
     4317\subsection{Parallel Speelpenning example codes}
     4318\label{SpeelPar}
     4319%
     4320Two methods are shown in this example for parallel computing by using different MPI functions to spread the variables and their computing. The first example with \verb=tag1= evaluates the jacobian of the functions
     4321\[
     4322y \; = \; f(x)\; =\; \left( \sum\limits_{i=0}^{n-1} x_i^2 \ , \  \sum\limits_{i=0}^{n-1} \cos(x_i)+\exp(x_i) \ , \   \sum\limits_{i=0}^{n-1} x_i \right)^T \ :
     4323\]
     4324%
     4325\begin{verbatim}
     4326#define HAVE_MPI_MPI_H 1           // using parallel mode
     4327#include <adolc/adouble.h>         // use of active doubles
     4328#include <adolc/adouble_mpi.h>     // use of parallel MPI functions
     4329#include <adolc/interfaces_mpi.h>  // use of parallel driver functions
     4330#include <adolc/drivers/drivers.h>
     4331#include <adolc/adalloc.h>
     4332#include <math.h>
     4333#include <cstdlib>
     4334#include <cstdio>
     4335
     4336#define tag1 0  // first tag for computing jacobian
     4337#define tag2 1  // second tag for gradient and hessian
     4338
     4339#define CMMCTR ADOLC_MPI_COMM_WORLD  // shortcut
     4340
     4341using namespace std;
     4342
     4343int main(int* argc,char** argv) {
     4344    int n, m = 3, i, j, id, size;
     4345    int root = 0;                      // root process has id 0
     4346    int tape_stats[STAT_SIZE];
     4347
     4348    ADOLC_MPI_Init(argc,&argv);        // initialisation
     4349    ADOLC_MPI_Comm_size(CMMCTR,&size); // get count of processes
     4350    ADOLC_MPI_Comm_rank(CMMCTR,&id);   // get id of process
     4351
     4352    if(id == root){
     4353       cout <<"PARALLEL SPEELPENNINGS PRODUCT\n\n"
     4354            <<"number of independent variables = ?\n";
     4355       cin >> n;
     4356    }
     4357
     4358    MPI_Bcast(&n,1, ADOLC_MPI_INT, root, CMMCTR);
     4359    // every process knows the count of independent variables
     4360
     4361    int n_dist = (int) n/size;
     4362    double x[n];
     4363    for(i=0;i<n;i++)
     4364        x[i] =  log(2.0 +i);   // some initialization
     4365
     4366    adouble *xad;
     4367
     4368/*************************************************************/
     4369/********** function evaluation for first example ************/
     4370/*************************************************************/
     4371    double *c = new double[m];
     4372
     4373    xad = new adouble[n];                 // allocation of
     4374    adouble *cad = new adouble[m];        // needed arrays
     4375    for( i = 0; i < m; i++)
     4376       cad_[i]=0.0;
     4377
     4378    trace_on( id, size, tag1);
     4379    if( id == root ){
     4380           for (i=0;i<n;i++)
     4381                  xad[i] <<= x[i];
     4382          // setting independent variables
     4383          }
     4384
     4385    ADOLC_MPI_Bcast(xad, n, MPI_ADOUBLE, root, CMMCTR);
     4386
     4387    for(i = myid*n_dist; i < (myid+1)*n_dist; i++){
     4388       cad[0] += xad[i]*xad[i];
     4389       cad[1] += cos(xad[i]) + exp(xad[i]);
     4390       cad[2] += xad[i];
     4391    }  // some evaluations
     4392
     4393    ADOLC_MPI_Barrier( CMMCTR );   // optional
     4394
     4395    ADOLC_MPI_Reduce( cad, cad,m, MPI_ADOUBLE, ADOLC_MPI_SUM, root, CMMCTR);
     4396
     4397    if ( id == root ) {
     4398       for(i = 0; i < m; i++ )
     4399          cad[i] >>= c[i];
     4400    }
     4401    trace_off();
     4402    delete[] xad;
     4403    delete[] cad;
     4404
     4405    if ( id == root ){
     4406        printf("\n c = [ %2.4lf %2.4lf %2.4lf]\n", c[0], c[1], c[2]);
     4407    }
     4408
     4409    tape_doc( id, size, tag1, m, n, x, c);
     4410
     4411    double **jac = NULL;
     4412    if ( id == root )
     4413       jac = myalloc2(m,n);
     4414
     4415    jacobian( id, size, tag1, m, n, x, jac);
     4416    if ( id == root )
     4417       printmat("Jacobian ",m,n,jac);
     4418
     4419     double **x_pp = NULL;
     4420     if ( id == root )
     4421        x_pp = myallocI2(n);
     4422
     4423    fov_forward( id, size, tag1, m, n, n, x, x_pp, c, jac);
     4424    if ( id == root ){
     4425       printmat("jac output",m, n, jac);
     4426       myfree2(jac);
     4427       myfreeI2(n,x_pp);
     4428    }
     4429\end{verbatim}
     4430%
     4431The second example with \verb=tag2= evaluates the gradient and hessian of the function
     4432\[
     4433y \; = \; f(x)\; =\; \prod_{i=0}^{n-1} x_i .
     4434\]
     4435%
     4436\begin{verbatim}
     4437/*************************************************************/
     4438/********* function evaluation for second example ************/
     4439/*************************************************************/
     4440
     4441    xad = new adouble[n];
     4442    adouble* xad_tmp = new adouble[n_dist];
     4443    adouble res_ad, res_ad_tmp;
     4444    double res;
     4445
     4446    trace_on( id, size, tag2);
     4447    if ( id == root ){
     4448       for (i = 0; i < n; i++)
     4449           xad[i] <<= x[i];
     4450    }
     4451    res_ad_tmp = 1.0;
     4452
     4453    ADOLC_MPI_Scatter( xad, n_dist, xad_tmp, n_dist,
     4454                       MPI_ADOUBLE, root, CMMCTR    );
     4455
     4456    for(i = 0; i < n_dist; i++)
     4457       res_ad_tmp *= xad_tmp[i]; // some evaluation
     4458
     4459    ADOLC_MPI_Barrier( CMMCTR );  // optional
     4460
     4461    ADOLC_MPI_Reduce( &res_ad_tmp, &res_ad, 1, MPI_ADOUBLE,
     4462                      ADOLC_MPI_PROD, root, CMMCTR         );
     4463
     4464    if ( id == root )
     4465          res_ad >>= res;
     4466
     4467    trace_off();
     4468    delete[] xad;
     4469    delete[] xad_tmp;
     4470
     4471    if ( id == root )
     4472       printf("\n result = %2.4lf \n", res);
     4473
     4474    tape_doc( id, size, tag2, 1, n, x, &res);
     4475
     4476    double *grad = NULL;
     4477    if ( id == root ){
     4478       grad = myalloc1(n);
     4479       x_pp = myalloc2(n,n);
     4480    }
     4481
     4482    gradient( id, size, tag2, n, x, grad);
     4483    if (id == root ){  // output of  computed gradient
     4484       printf("gradient\n");
     4485       for(i=0; i<n ; i++)
     4486          printf("\t%2.4lf\n", grad[i]);
     4487       printf("\n");
     4488       myfree1(grad);
     4489    }
     4490
     4491    hessian(myid,procsize,tag2,n,x,x_pp);
     4492    if ( id == root ){ // output of  computed hessian
     4493       printmat("Hessian", n, n, x_pp);
     4494       myfree2(x_pp);
     4495    }
     4496
     4497    delete[] x;
     4498    delete[] c;
     4499    ADOLC_MPI_Finalize();
     4500    return 0;
     4501}
     4502\end{verbatim}
     4503%
    44014504\section*{Acknowledgements}
    44024505%
  • branches/MPI/ADOL-C/src/adolc_mpi.cpp

    r274 r281  
    3030
    3131int mpi_initialized = 0;
    32 int process_count = 1;
    3332int all_root = 0;
    3433
     
    5453){
    5554    int ierr = MPI_Comm_size(comm,size);
    56     process_count = size[0];
    5755    return ierr;
    5856}
     
    202200    ADOLC_MPI_Op op, int root, ADOLC_MPI_Comm comm)
    203201{
    204     int i,j,id, ierr=0;
     202    int i,j,id,size, ierr=0;
    205203    adouble tmp, *tmp_adoubles = NULL;
    206204    double *trade_s, *trade_r;
    207205
    208206    MPI_Comm_rank(MPI_COMM_WORLD, &id);
    209 // equal to ADOLC_MPI_Gather -------------------
    210     trade_s = myalloc1(count);
    211     if (id == root)
    212       trade_r = myalloc1(count*process_count);
    213     else trade_r = NULL;
    214 
    215     for(i= 0; i < count; i++) {
    216        trade_s[i] = send_buf[i].getValue();
    217     }
    218     ierr = MPI_Gather(trade_s,count,type,trade_r,count,type, root, comm);
    219 
    220     if ( id == root){
    221            tmp_adoubles = new adouble[count*process_count];
    222        for(i=0; i< count*process_count;i++){
    223           tmp_adoubles[i].setValue(trade_r[i]);
    224           }
    225     }
    226 // ------------------------------------------------------
    227     put_op(reduce);
    228     ADOLC_PUT_LOCINT(count);
    229     for (i=0; i< count;i++)
    230        ADOLC_PUT_LOCINT(send_buf[i].loc());
    231     ADOLC_PUT_LOCINT(count);
    232     ADOLC_PUT_LOCINT(root);
    233     ADOLC_PUT_LOCINT(id);
    234     ADOLC_PUT_LOCINT(count*process_count);
    235     if( id==root){
    236       for(i=0; i < count*process_count;i++)
    237         ADOLC_PUT_LOCINT(tmp_adoubles[i].loc());
    238     }
    239     ADOLC_PUT_LOCINT(count*process_count);
    240     ADOLC_PUT_LOCINT(root);
    241     ADOLC_PUT_LOCINT(id);
    242     ADOLC_PUT_LOCINT(op);
     207    MPI_Comm_size(MPI_COMM_WORLD, &size);
     208    ierr = ADOLC_MPI_Gather(send_buf,tmp_adoubles,count,type,root,comm);
    243209
    244210    if ( id == root){
    245211       if( rec_buf == NULL)
    246            rec_buf = (adouble*) calloc(count, sizeof(adouble));
    247           switch (op) {
     212           rec_buf = new adouble[count];
     213       switch (op) {
    248214               case ADOLC_MPI_MAX: for(i=0; i < count; i++ ) {
    249215                                       tmp = tmp_adoubles[i];
    250                                        for(j=1; j< process_count ; j++)
     216                                       for(j=1; j< size ; j++)
    251217                                          if ( tmp <= tmp_adoubles[j*count+i] )
    252218                                             tmp = tmp_adoubles[j*count+i];
     
    256222               case ADOLC_MPI_MIN: for(i=0; i < count; i++ ) {
    257223                                      tmp = tmp_adoubles[i];
    258                                       for(j=1; j< process_count ; j++)
     224                                      for(j=1; j< size ; j++)
    259225                                         if ( tmp >= tmp_adoubles[j*count+i] )
    260226                                            tmp = tmp_adoubles[j*count+i];
     
    263229                                   break;
    264230               case ADOLC_MPI_SUM: for(i=0; i < count; i++ ) {
    265                                       tmp = 0;
    266                                       for(j=0; j< process_count ; j++)
     231                                      tmp =0.;
     232                                      for(j=0; j< size ; j++)
    267233                                         tmp += tmp_adoubles[j*count+i];
    268234                                       rec_buf[i] = tmp;
     
    270236                                   break;
    271237               case ADOLC_MPI_PROD:for(i=0; i < count; i++ ) {
    272                                       tmp = 1;
    273                                       for(j=0; j< process_count ; j++)
     238                                      tmp = 1.;
     239                                      for(j=0; j< size ; j++)
    274240                                         tmp *= tmp_adoubles[j*count+i];
    275241                                      rec_buf[i] = tmp;
     
    278244               default:             printf("Operation %d not yet implemented!\n",op);
    279245                                    break;
     246       }
     247       delete[] tmp_adoubles;
     248    }
     249
     250    return ierr;
     251}
     252
     253int ADOLC_MPI_Gather(
     254    adouble *sendbuf, adouble *recvbuf, int count, ADOLC_MPI_Datatype type, int root, MPI_Comm comm)
     255{
     256    int i,id,size, ierr=0;
     257    double *trade_s, *trade_r;
     258
     259    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     260    MPI_Comm_size(MPI_COMM_WORLD, &size);
     261
     262    trade_s = (double*) myalloc1(count);
     263    if (id == root)
     264      trade_r = (double*) myalloc1(count*size);
     265    else trade_r = NULL;
     266
     267    for(i= 0; i < count; i++) {
     268       trade_s[i] = sendbuf[i].getValue();
     269    }
     270    ierr = MPI_Gather(trade_s,count,type,trade_r,count,type, root, comm);
     271
     272    if ( id == root){
     273       if( recvbuf == NULL)
     274           recvbuf = new adouble[count*size];
     275       for(i=0; i< count*size;i++){
     276          recvbuf[i].setValue(trade_r[i]);
    280277          }
    281 
    282     delete[] tmp_adoubles;
    283     }
    284 
     278    }
    285279    free(trade_s);
    286280    free(trade_r);
    287281
    288     return ierr;
    289 }
    290 
    291 int ADOLC_MPI_Gather(
    292     adouble *sendbuf, adouble *recvbuf, int count, ADOLC_MPI_Datatype type, int root, MPI_Comm comm)
    293 {
    294     int i,id, ierr=0;
    295     double *trade_s, *trade_r;
    296 
    297     MPI_Comm_rank(MPI_COMM_WORLD, &id);
    298 
    299     trade_s = (double*) myalloc1(count);
    300     if (id == root)
    301       trade_r = (double*) myalloc1(count*process_count);
    302     else trade_r = NULL;
    303 
    304     for(i= 0; i < count; i++) {
    305        trade_s[i] = sendbuf[i].getValue();
    306     }
    307     ierr = MPI_Gather(trade_s,count,type,trade_r,count,type, root, comm);
    308 
    309     if ( id == root){
    310        if( recvbuf == NULL)
    311            recvbuf = new adouble[count*process_count];
    312        for(i=0; i< count*process_count;i++){
    313           recvbuf[i].setValue(trade_r[i]);
    314           }
    315     }
    316     free(trade_s);
    317     free(trade_r);
    318 
    319282    put_op(gather);
    320283    ADOLC_PUT_LOCINT(count);
     
    324287    ADOLC_PUT_LOCINT(root);
    325288    ADOLC_PUT_LOCINT(id);
    326     ADOLC_PUT_LOCINT(count*process_count);
    327     if( id==root) for(i=0; i < count*process_count;i++)
     289    ADOLC_PUT_LOCINT(count*size);
     290    if( id==root) for(i=0; i < count*size;i++)
    328291        ADOLC_PUT_LOCINT(recvbuf[i].loc());
    329     ADOLC_PUT_LOCINT(count*process_count);
     292    ADOLC_PUT_LOCINT(count*size);
    330293    ADOLC_PUT_LOCINT(root);
    331294    ADOLC_PUT_LOCINT(id);
     
    338301    int recvcount, ADOLC_MPI_Datatype type, int root, MPI_Comm comm)
    339302{
    340     int i,id, ierr=0;
     303    int i,id,size, ierr=0;
    341304    double *trade_s, *trade_r;
    342305
    343306    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     307    MPI_Comm_size(MPI_COMM_WORLD, &size);
    344308
    345309    trade_r = (double*) myalloc1(recvcount);
    346310    if (id == root)
    347       trade_s = (double*) myalloc1(sendcount*process_count);
     311      trade_s = (double*) myalloc1(sendcount*size);
    348312    else trade_s = NULL;
    349313
    350314    if ( id == root){
    351        for(i= 0; i < sendcount*process_count; i++)
     315       for(i= 0; i < sendcount*size; i++)
    352316          trade_s[i] = sendbuf[i].getValue();
    353317    }
     
    365329
    366330    put_op(scatter);
    367     ADOLC_PUT_LOCINT(sendcount*process_count);
     331    ADOLC_PUT_LOCINT(sendcount*size);
    368332    ADOLC_PUT_LOCINT(root);
    369333    ADOLC_PUT_LOCINT(id);
    370334    if( id == root ) {
    371       for(i=0; i< sendcount*process_count ;i++)
     335      for(i=0; i< sendcount*size ;i++)
    372336        ADOLC_PUT_LOCINT(sendbuf[i].loc());
    373337    }
    374     ADOLC_PUT_LOCINT(sendcount*process_count);
     338    ADOLC_PUT_LOCINT(sendcount*size);
    375339    ADOLC_PUT_LOCINT(root);
    376340    ADOLC_PUT_LOCINT(id);
     
    460424               return rc;
    461425          }
    462           rc = fos_reverse_mpi(id,size,tag,0,0,&one,result);
     426          rc = fos_reverse_mpi(id,size,tag,0,0,&one,NULL);
    463427     }
    464428     return rc;
  • branches/MPI/ADOL-C/src/adolc_mpi.h

    r273 r281  
    6161
    6262extern int mpi_initialized;
    63 extern int process_count;
    6463extern int all_root;
    6564
  • branches/MPI/ADOL-C/src/fo_rev.c

    r274 r281  
    417417     double *trade, *rec_buf;
    418418     unsigned long int *trade_ulong, *rec_ulong;
    419      int target, tag ,use_reduce=0;
    420      ADOLC_MPI_Op mpi_op;
     419     int target, tag;
    421420#endif
    422421
     
    19171916                      trade[mpi_ii] = (double) upp_A[loc_recv[mpi_i]][l];
    19181917                   ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    1919                    for(l=0; l<p;l++,mpi_ii++)
     1918                   for(l=0; l<p;l++)
    19201919                      upp_A[loc_recv[mpi_i]][l] = 0;
    19211920                }
     
    19401939                   trade[2*mpi_ii] = rp_T[loc_recv[mpi_i]];
    19411940                   trade[2*mpi_ii+1] = rp_A[loc_recv[mpi_i]];
    1942                    ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    1943                    rp_A[loc_recv[mpi_i]] = 0.;
     1941                }
     1942                for(mpi_i=0; mpi_i<count; mpi_i++){
     1943                   ADOLC_GET_TAYLOR(loc_recv[count-1-mpi_i]);
     1944                   rp_A[loc_recv[count-1-mpi_i]] = 0.;
    19441945                }
    19451946                MPI_Send(trade,2*count,MPI_DOUBLE,target,tag,MPI_COMM_WORLD);
     
    19541955                   for(l=0; l<p;l++,mpi_ii++)
    19551956                      trade[mpi_ii] = rpp_A[loc_recv[mpi_i]][l];
    1956                    ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    1957                    for(l=0; l<p;l++,mpi_ii++)
    1958                       rpp_A[loc_recv[mpi_i]][l] = 0.;
     1957                 }
     1958                 for(mpi_i=0; mpi_i<count;mpi_i++){
     1959                   ADOLC_GET_TAYLOR(loc_recv[count-1-mpi_i]);
     1960                   for(l=0; l<p;l++)
     1961                      rpp_A[loc_recv[count-1-mpi_i]][l] = 0.;
    19591962                }
    19601963                MPI_Send(trade,(p+1)*count,MPI_DOUBLE,target,tag,MPI_COMM_WORLD);
     
    19761979                   loc_recv[mpi_i] = get_locint_r(); // Recv Buffer
    19771980                count2 = get_locint_r(); // count
    1978                 count2 *= process_count;
     1981                count2 *= mpi_size;
    19791982
    19801983#if defined(_INT_REV_)
     
    19911994                   ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    19921995                   for(l=0; l<p;l++,mpi_ii++){
    1993                        trade[p*mpi_i+l] = (double) upp_A[loc_recv[mpi_i]][l];
     1996                       trade[mpi_ii] = (double) upp_A[loc_recv[mpi_i]][l];
    19941997                      upp_A[loc_recv[mpi_i]][l] = 0;
    19951998                   }
     
    19992002                if (myid == root){
    20002003                   mpi_ii=0;
    2001                    for(arg=0; arg< process_count; arg++)
     2004                   for(arg=0; arg< mpi_size; arg++)
    20022005                      for (mpi_i=0; mpi_i < count; mpi_i++) {
    20032006                       rp_T[loc_recv[mpi_i]] = rec_buf[mpi_ii];
     
    20492052                if (myid == root){
    20502053                   mpi_ii=0;
    2051                    for(arg=0; arg< process_count; arg++)
     2054                   for(arg=0; arg< mpi_size; arg++)
    20522055                      for(mpi_i=0; mpi_i < count; mpi_i++) {
    20532056                         rp_T[loc_recv[mpi_i]] = rec_buf[mpi_ii];
     
    20692072                    mpi_ii++;
    20702073                    for(l=0;l<p;l++,mpi_ii++){
    2071                        trade[mpi_i+1] = rpp_A[loc_recv[mpi_i]][l];
     2074                       trade[mpi_ii] = rpp_A[loc_recv[mpi_i]][l];
    20722075                       rpp_A[loc_recv[mpi_i]][l]=0.;
    20732076                    }
     
    20782081                if (myid == root){
    20792082                   mpi_ii=0;
    2080                    for(arg=0; arg< process_count; arg++)
     2083                   for(arg=0; arg< mpi_size; arg++)
    20812084                      for(mpi_i=0; mpi_i < count; mpi_i++) {
    20822085                         rp_T[loc_recv[mpi_i]] = rec_buf[mpi_ii];
     
    20902093                free(loc_recv);
    20912094                break;
    2092             case reduce:
    2093                 use_reduce=0;
    2094                 mpi_op = get_locint_r();
    2095                 if(mpi_op == ADOLC_MPI_SUM) use_reduce=1;
    20962095            case gather:
    20972096                myid = get_locint_r(); // process id
     
    21002099                if (root == myid){
    21012100                   loc_recv = (locint*) malloc (count2*sizeof(locint));
    2102                    for(mpi_i=0;mpi_i<count2;mpi_i++)
    2103                       loc_recv[count2-1-mpi_i] = get_locint_r(); // Receive Buffer
     2101                   for(mpi_i=0; mpi_i < count2; mpi_i++)
     2102                      loc_recv[count2- mpi_i -1 ] = get_locint_r();
    21042103                }
    21052104                arg = get_locint_r(); // count*process_count
     
    21092108                loc_send = (locint*) calloc(count,sizeof(locint));
    21102109                for(mpi_i=0;mpi_i<count;mpi_i++)
    2111                    loc_send[count-1-mpi_i] = get_locint_r(); // Send Buffer
     2110                   loc_send[count-1-mpi_i] = get_locint_r(); // Receive Buffer
    21122111                arg = get_locint_r(); // count
    21132112
     
    21222121                     rec_buf[mpi_ii] = rp_T[loc_recv[mpi_i]];
    21232122                     mpi_ii++;
    2124                      ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    21252123                     for(l=0;l<p;l++,mpi_ii++){
    21262124                        rec_buf[mpi_ii] = (double) upp_A[loc_recv[mpi_i]][l];
     
    21282126                     }
    21292127                  }
     2128                  for(mpi_i=0;mpi_i<count2;mpi_i++)
     2129                     ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i]);
    21302130               }
    21312131               MPI_Scatter(rec_buf,count*(p+1),MPI_DOUBLE,trade,count*(p+1),MPI_DOUBLE, root,MPI_COMM_WORLD);
     
    21722172                       rec_buf[2*mpi_i] = rp_T[loc_recv[mpi_i]];
    21732173                       rec_buf[2*mpi_i+1] = rp_A[loc_recv[mpi_i]];
    2174                        ADOLC_GET_TAYLOR(loc_recv[mpi_i])
    21752174                       rp_A[loc_recv[mpi_i]]=0.;
    21762175                    }
    2177                 }
    2178                 MPI_Scatter(rec_buf,count,MPI_DOUBLE,trade,count,MPI_DOUBLE, root,MPI_COMM_WORLD);
     2176                    for(mpi_i=0;mpi_i<count2;mpi_i++)
     2177                       ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i])
     2178                }
     2179                MPI_Scatter(rec_buf,count*2,MPI_DOUBLE,trade,count*2,MPI_DOUBLE, root,MPI_COMM_WORLD);
    21792180                if (myid == root)
    21802181                   free(rec_buf);
     
    21942195                       rec_buf[mpi_ii] = rp_T[loc_recv[mpi_i]];
    21952196                       mpi_ii++;
    2196                        ADOLC_GET_TAYLOR(loc_recv[mpi_i])
    21972197                       for(l=0;l<p;l++,mpi_ii++){
    21982198                         rec_buf[mpi_ii] = rpp_A[loc_recv[mpi_i]][l];
     
    22002200                       }
    22012201                    }
     2202                    for(mpi_i=0;mpi_i<count2;mpi_i++)
     2203                       ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i])
    22022204                }
    22032205                MPI_Scatter(rec_buf,count*(p+1),MPI_DOUBLE,trade,count*(p+1),MPI_DOUBLE, root,MPI_COMM_WORLD);
     
    22162218                   free(loc_recv);
    22172219                free(loc_send);
    2218                 use_reduce=0;
    22192220                break;
    22202221                /*--------------------------------------------------------------------------*/
     
    22472248                   rec_buf[mpi_ii] = rp_T[loc_recv[mpi_i]];
    22482249                   mpi_ii++;
    2249                    ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    22502250                   for(l=0;l<p;l++,mpi_ii++){
    22512251                      rec_buf[mpi_ii] = (double) upp_A[loc_recv[mpi_i]][l];
    2252                       upp_A[loc_recv[mpi_i]] = 0;
     2252                      upp_A[loc_recv[mpi_i]][l] = 0;
    22532253                   }
    22542254                }
     2255                for(mpi_i=0;mpi_i<count2;mpi_i++)
     2256                   ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i])
    22552257                MPI_Gather(rec_buf , count2*(p+1), MPI_DOUBLE,trade,count2*(p+1), MPI_DOUBLE, root, MPI_COMM_WORLD);
    22562258                free(rec_buf);
     
    22612263                      mpi_ii++;
    22622264                      for(l=0;l<p;l++,mpi_ii++)
    2263                          upp_A[loc_send[mpi_i]] += (unsigned long int) trade[mpi_ii];
     2265                         upp_A[loc_send[mpi_i]][l] += (unsigned long int) trade[mpi_ii];
    22642266                   }
    22652267                   free(trade);
     
    22982300                   rec_buf[2*mpi_i] = rp_T[loc_recv[mpi_i]];
    22992301                   rec_buf[2*mpi_i+1] = rp_A[loc_recv[mpi_i]];
    2300                    ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    23012302                   rp_A[loc_recv[mpi_i]]=0;
    23022303                }
     2304                for (mpi_i=0; mpi_i < count2; mpi_i++)
     2305                   ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i])
    23032306                MPI_Gather( rec_buf ,count2*2, MPI_DOUBLE,trade,count2*2,MPI_DOUBLE, root, MPI_COMM_WORLD);
    23042307                free(rec_buf);
     
    23212324                   rec_buf[mpi_ii] = rp_T[loc_recv[mpi_i]];
    23222325                   mpi_ii++;
    2323                    ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
    23242326                   for(l=0;l<p;l++,mpi_ii++){
    23252327                      rec_buf[mpi_ii] = rpp_A[loc_recv[mpi_i]][l];
     
    23272329                   }
    23282330                }
     2331                for(mpi_i=0; mpi_i< count2; mpi_i++)
     2332                   ADOLC_GET_TAYLOR(loc_recv[count2-1-mpi_i])
    23292333                MPI_Gather(rec_buf , count2*(p+1), MPI_DOUBLE,trade,count2*(p+1), MPI_DOUBLE, root, MPI_COMM_WORLD);
    23302334                free(rec_buf);
  • branches/MPI/ADOL-C/src/ho_rev.c

    r274 r281  
    650650        int mpi_i,mpi_ii, myid, root, count,count2;
    651651     locint *loc_recv, *loc_send;
    652      int target, tag, use_reduce=0;
    653      ADOLC_MPI_Op mpi_op;
     652     int target, tag;
    654653#endif /* is used by Parallelisation */
    655654
     
    22502249                }
    22512250                if (myid == root)
    2252                    rec_buf = myalloc1(count*process_count*(k+k1));
     2251                   rec_buf = myalloc1(count*mpi_size*(k+k1));
    22532252                MPI_Gather( trade , (k+k1)*count, MPI_DOUBLE, rec_buf,(k+k1)*count, MPI_DOUBLE, root, MPI_COMM_WORLD);
    22542253                free(trade);
    22552254                if(myid == root){
    22562255                   mpi_ii=0;
    2257                    for(arg=0; arg< process_count ;arg++){
     2256                   for(arg=0; arg< mpi_size ;arg++){
    22582257                      for(mpi_i=0; mpi_i< count; mpi_i++){
    22592258                         for(l=0;l<k;l++,mpi_ii++)
     
    22802279                }
    22812280                if (myid == root)
    2282                    rec_buf = myalloc1(count*process_count*(k+pk1));
     2281                   rec_buf = myalloc1(count*mpi_size*(k+pk1));
    22832282                MPI_Gather( trade , (k+pk1)*count, MPI_DOUBLE, rec_buf,(k+pk1)*count, MPI_DOUBLE, root, MPI_COMM_WORLD);
    22842283                free(trade);
    22852284                if(myid == root){
    22862285                   mpi_ii=0;
    2287                    for(arg=0; arg< process_count ;arg++){
     2286                   for(arg=0; arg< mpi_size ;arg++){
    22882287                      for(mpi_i=0; mpi_i< count; mpi_i++){
    22892288                         for(l=0;l<k;l++,mpi_ii++)
     
    23002299                /*--------------------------------------------------------------------------*/
    23012300
    2302             case reduce:
    2303                 use_reduce=0;
    2304                 mpi_op=get_locint_r();
    2305                 if(mpi_op == ADOLC_MPI_SUM) use_reduce=1;
    23062301            case gather:
    23072302                myid = get_locint_r(); // process id
     
    23332328                         rpp_A[loc_recv[mpi_i]][l] = 0.;
    23342329                      }
    2335                       GET_TAYL(loc_recv[mpi_i],k,p);
    23362330                   }
     2331                   for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ )
     2332                      GET_TAYL(loc_recv[count2-1-mpi_i],k,p);
    23372333                }
    23382334                trade = myalloc1((k+k1)*count);
     
    23582354                         rpp_A[loc_recv[mpi_i]][l] = 0.;
    23592355                      }
    2360                       GET_TAYL(loc_recv[mpi_i],k,p);
    23612356                   }
     2357                   for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ )
     2358                      GET_TAYL(loc_recv[count2-1-mpi_i],k,p);
    23622359                }
    23632360                trade = myalloc1((k+pk1)*count);
     
    23712368                }
    23722369#endif
    2373                 use_reduce=0;
    23742370                if(myid==root) free(loc_recv);
    23752371                free(loc_send);
     
    23942390               res = get_locint_r(); // sendcount (count*process_count)
    23952391#if defined(_HOS_)
    2396                 rec_buf = myalloc1(count2*(k+k1));
    23972392                trade = NULL;
    23982393                rec_buf = myalloc1(count2*(k+k1));
     
    24052400                      rpp_A[loc_recv[mpi_i]][l] = 0.;
    24062401                   }
    2407                    GET_TAYL(loc_recv[mpi_i],k,p);
    2408                 }
     2402                }
     2403                for(mpi_i=0 ; mpi_i< count2 ;mpi_i++ )
     2404                   GET_TAYL(loc_recv[count2-1-mpi_i],k,p);
    24092405                if (myid == root)
    24102406                   trade = myalloc1(count*(k+k1));
     
    24332429                      rpp_A[loc_recv[mpi_i]][l] = 0.;
    24342430                   }
    2435                    GET_TAYL(loc_recv[mpi_i],k,p);
    2436                 }
     2431                }
     2432                for(mpi_i=0 ; mpi_i< count2 ;mpi_i++ )
     2433                   GET_TAYL(loc_recv[count2-1-mpi_i],k,p);
    24372434                if (myid == root)
    24382435                   trade = myalloc1(count*(k+pk1));
  • branches/MPI/ADOL-C/src/oplate.h

    r273 r281  
    8989  barrier_op,
    9090  broadcast,
    91   reduce,
    9291  gather,
    9392  scatter
  • branches/MPI/ADOL-C/src/tapedoc/tapedoc.c

    r273 r281  
    112112                             "barrier Op",
    113113                       "broadcast Op",
    114                        "reduce Op",
    115114                       "gather Op",
    116115                       "scatter Op"
     
    318317
    319318#if defined(HAVE_MPI)
    320     int mpi_i,mpi_ii,count,count2,dest,tag,buf,use_reduce=0;
     319    int mpi_i,mpi_ii,count,count2,dest,tag,buf;
    321320#endif
    322321    operation=get_op_f();
     
    12601259             filewrite(operation, 3, loc_a, val_a, 0, cst_d);
    12611260             break;
    1262        case reduce:
    1263              use_reduce=1;
    12641261       case gather:
    12651262             count  = get_locint_f(); // count
     
    12741271               for(mpi_i=0; mpi_i<count2;mpi_i++)
    12751272                  mpi_ii = get_locint_f(); // rest buffer
    1276                mpi_ii = get_locint_f();
    12771273             }
    1278              if(use_reduce==1) mpi_ii=get_locint_f();
     1274             mpi_ii = get_locint_f(); // count2
     1275             mpi_ii = get_locint_f(); // root
     1276             mpi_ii = get_locint_f(); // id
     1277
    12791278
    12801279             loc_a[0] = buf;
     
    12901289               for(mpi_i=0; mpi_i<count;mpi_i++)
    12911290                 mpi_ii = get_locint_f(); // rest buffer
    1292                count = get_locint_f();
    12931291             }
     1292             count  = get_locint_f();
    12941293             dest   = get_locint_f(); // root
    12951294             tag    = get_locint_f(); // id
  • branches/MPI/ADOL-C/src/uni5_for.c

    r274 r281  
    10401040     double *trade, *rec_buf, *mpi_tmp;
    10411041     MPI_Status status_MPI;
    1042      int mpi_i,mpi_ii, s_r_c=1,use_reduce=0;
     1042     int mpi_i,mpi_ii, s_r_c=1;
    10431043     locint *loc_send, *loc_recv;
    1044      ADOLC_MPI_Op mpi_op;
    10451044     int myid,root, count, count2, target,tag;
    10461045#if defined(_NONLIND_)
     
    11121111#else                                                                /* INDOPRO */
    11131112#if defined(_INDO_)
    1114     ind_dom = (locint **)  malloc(sizeof(locint*) * ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
     1113    ind_dom = (locint**)  malloc(sizeof(locint*) * ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
    11151114
    11161115    for(i=0;i<ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];i++)
    11171116    {
    1118         ind_dom[i] = (locint *)  malloc(sizeof(locint) * (NUMNNZ+2));
     1117        ind_dom[i] = (locint*)  malloc(sizeof(locint)*(NUMNNZ+2));
    11191118        ind_dom[i][0] = 0;
    11201119        ind_dom[i][1] = NUMNNZ;
     
    42204219#endif /* END ZOS  */
    42214220#if defined(_FOS_)
    4222            trade = myalloc1( count+2 );
     4221           trade = myalloc1( count*2 );
    42234222           if (myid ==root){
    42244223               for(mpi_i =0; mpi_i < count; mpi_i++){
     
    44994498           free(loc_send);
    45004499           break;
    4501       case reduce:
    4502            use_reduce=1;
    45034500      case gather:
    45044501           count = get_locint_f(); // count
     
    45184515           arg = get_locint_f(); // root
    45194516           arg = get_locint_f(); // myid
    4520            if (use_reduce == 1)
    4521               mpi_op = get_locint_f();
    45224517
    45234518#if defined(_ZOS_)
     
    46934688              for(mpi_i =0; mpi_i < count2; mpi_i++ ){
    46944689                 IF_KEEP_WRITE_TAYLOR(loc_recv[mpi_i],keep,k,p)
    4695                  dp_T0[loc_recv[mpi_i]] = trade[2*mpi_i];
    4696                  tmp_counts[mpi_i]  = (int) trade[2*mpi_i+1];
     4690                 dp_T0[loc_recv[mpi_i]] = rec_buf[2*mpi_i];
     4691                 tmp_counts[mpi_i]  = (int) rec_buf[2*mpi_i+1];
    46974692              }
    46984693              for(mpi_i =0; mpi_i < count; mpi_i++ ){
     
    49744969              free(loc_recv);
    49754970           free(loc_send);
    4976            use_reduce=0;
    49774971           break;
    49784972      case scatter:
     
    51905184           if(myid == root){
    51915185              trade_loc = (int*) calloc(count*anz,sizeof(int));
    5192               for(mpi_i =0; mpi_i < count; mpi_i++ )
     5186              for(mpi_i =0; mpi_i < count; mpi_i++ ){
    51935187                 for (i=2; i < ind_dom[loc_send[mpi_i]][0]+2; i++){
    51945188                    trade_loc[l] = ind_dom[loc_send[mpi_i]][i];
    51955189                    l++;
    51965190                    }
    5197               for(i=ind_dom[loc_send[mpi_i]][0]; i < anz ; i++  ){
     5191                 for(i=ind_dom[loc_send[mpi_i]][0]; i < anz ; i++  ){
    51985192                    trade_loc[l] = -10;
    51995193                    l++;
    52005194                 }
     5195              }
    52015196           }
    52025197           rec_buf_loc = ( int*) malloc(anz*count2*sizeof(int) );
     
    54815476       for(l=1; l < crs[i][0]+1; l++)
    54825477          crs[i][l] = nonl_dom[i][l+1];
    5483        free(nonl_dom[i]);
     5478       free( nonl_dom[i]);
    54845479    }
    5485     for ( i=0;i<indcheck;i++)
    5486        free( nonl_dom[i]);
    54875480    free(nonl_dom);
    54885481#endif
Note: See TracChangeset for help on using the changeset viewer.