Changeset 327 for branches


Ignore:
Timestamp:
Jun 28, 2012 5:06:13 AM (6 years ago)
Author:
kulshres
Message:

Merge branch 'mpi' of 'gitclone' to svn branch

The following changesets were committed:

commit 9e21803cc4832d22a211ef009ed3038e71d9f5b5
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Mar 30 15:32:53 2012 +0200

remove redundant file

commit 91bb51da289c4bdaae9c14b8c87fb919ad6ae3df
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Mar 30 15:30:23 2012 +0200

get rid of code duplication and fix build by reordering headers

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit 96999453f3c1cb11f9543dca419dcd80ceb9ba64
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Fri Mar 30 12:50:27 2012 +0000

get 'make distcheck' to work again

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

git-svn-id: https://projects.coin-or.org/svn/ADOL-C/trunk@314 94ac48a7-3327-4b6a-8511-9a4036a20e83

commit 31c41f41cefa819f33a85cc03b129519dc17ff12
Author: Benjamin Letschert <letschi@…>
Date: Thu Mar 29 13:57:37 2012 +0200

Fixing MPI-routines and setting them to namespace adtl in adouble.h

commit bd3ac7cd07a57445daf27461e0535b8cae8124ab
Author: Benjamin Letschert <letschi@…>
Date: Thu Mar 29 10:25:34 2012 +0200

adding MPI-routines for traceless mode

Location:
branches/MPI
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/MPI/ADOL-C/src/adolc_mpi.cpp

    r281 r327  
    2424#include <adolc/convolut.h>
    2525
    26 #define ADOLC_MPI_Datatype MPI_Datatype
    27 #define MPI_ADOUBLE MPI_DOUBLE
    28 #define ADOLC_MPI_COMM_WORLD MPI_COMM_WORLD
    29 #define ADOLC_MPI_Comm MPI_Comm
    30 
    3126int mpi_initialized = 0;
    3227int all_root = 0;
     
    7469int ADOLC_MPI_Finalize( ){
    7570    return MPI_Finalize();
    76 }
    77 
    78 MPI_Op adolc_to_mpi_op(ADOLC_MPI_Op op) {
    79     switch (op) {
    80         case ADOLC_MPI_MAX: return MPI_MAX;
    81         case ADOLC_MPI_MIN: return MPI_MIN;
    82         case ADOLC_MPI_SUM: return MPI_SUM;
    83         case ADOLC_MPI_PROD: return MPI_PROD;
    84         case ADOLC_MPI_LAND: return MPI_LAND;
    85         case ADOLC_MPI_BAND: return MPI_BAND;
    86         case ADOLC_MPI_LOR: return MPI_LOR;
    87         case ADOLC_MPI_BOR: return MPI_BOR;
    88         case ADOLC_MPI_LXOR: return MPI_LXOR;
    89         case ADOLC_MPI_BXOR: return MPI_BXOR;
    90         case ADOLC_MPI_MINLOC: return MPI_MINLOC;
    91         case ADOLC_MPI_MAXLOC: return MPI_MAXLOC;
    92     }
    9371}
    9472
  • branches/MPI/ADOL-C/src/adolc_mpi.h

    r311 r327  
    2323#include <adolc/interfaces_mpi.h>
    2424
    25 #define ADOLC_MPI_Datatype MPI_Datatype
    26 #define MPI_ADOUBLE MPI_DOUBLE
    27 #define ADOLC_MPI_COMM_WORLD MPI_COMM_WORLD
    28 #define ADOLC_MPI_Comm MPI_Comm
    29 
    30 typedef enum ADOLC_MPI_Op_t {
    31     ADOLC_MPI_MAX=100,
    32     ADOLC_MPI_MIN,
    33     ADOLC_MPI_SUM,
    34     ADOLC_MPI_PROD,
    35     ADOLC_MPI_LAND,
    36     ADOLC_MPI_BAND,
    37     ADOLC_MPI_LOR,
    38     ADOLC_MPI_BOR,
    39     ADOLC_MPI_LXOR,
    40     ADOLC_MPI_BXOR,
    41     ADOLC_MPI_MINLOC,
    42     ADOLC_MPI_MAXLOC
    43 } ADOLC_MPI_Op;
    44 
    4525BEGIN_C_DECLS
    4626
     
    5131ADOLC_DLL_EXPORT int ADOLC_MPI_Barrier(ADOLC_MPI_Comm comm);
    5232ADOLC_DLL_EXPORT int ADOLC_MPI_Finalize() ;
    53 
    54 MPI_Op adolc_to_mpi_op(ADOLC_MPI_Op);
    5533
    5634END_C_DECLS
  • branches/MPI/ADOL-C/src/adouble.h

    r207 r327  
    99           class (badouble).  See below for further explanation.
    1010
    11  Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    12                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
    13  
     11 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
     12               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     13               Benjamin Letschert
     14
    1415 This file is part of ADOL-C. This software is provided as open source.
    1516 Any use, reproduction, or distribution of the software constitutes
     
    2021#if !defined(ADOLC_ADOUBLE_H)
    2122#define ADOLC_ADOUBLE_H 1
     23
     24#include <adolc/common.h>
     25#if defined(HAVE_MPI)
     26#if defined(ADOLC_ADOLC_MPI_H) || defined(ADOLC_TAPELESS)
     27
     28#define ADOLC_MPI_Datatype MPI_Datatype
     29#define MPI_ADOUBLE MPI_DOUBLE
     30#define ADOLC_MPI_COMM_WORLD MPI_COMM_WORLD
     31#define ADOLC_MPI_Comm MPI_Comm
     32
     33BEGIN_C_DECLS
     34
     35typedef enum ADOLC_MPI_Op_t {
     36    ADOLC_MPI_MAX=100,
     37    ADOLC_MPI_MIN,
     38    ADOLC_MPI_SUM,
     39    ADOLC_MPI_PROD,
     40    ADOLC_MPI_LAND,
     41    ADOLC_MPI_BAND,
     42    ADOLC_MPI_LOR,
     43    ADOLC_MPI_BOR,
     44    ADOLC_MPI_LXOR,
     45    ADOLC_MPI_BXOR,
     46    ADOLC_MPI_MINLOC,
     47    ADOLC_MPI_MAXLOC
     48} ADOLC_MPI_Op;
     49
     50#if 0
     51// I am quite sure we don't ever need to call this -KK
     52static MPI_Op adolc_to_mpi_op(ADOLC_MPI_Op op) {
     53    switch (op) {
     54     case ADOLC_MPI_MAX: return MPI_MAX;
     55     case ADOLC_MPI_MIN: return MPI_MIN;
     56     case ADOLC_MPI_SUM: return MPI_SUM;
     57     case ADOLC_MPI_PROD: return MPI_PROD;
     58     case ADOLC_MPI_LAND: return MPI_LAND;
     59     case ADOLC_MPI_BAND: return MPI_BAND;
     60     case ADOLC_MPI_LOR: return MPI_LOR;
     61     case ADOLC_MPI_BOR: return MPI_BOR;
     62     case ADOLC_MPI_LXOR: return MPI_LXOR;
     63     case ADOLC_MPI_BXOR: return MPI_BXOR;
     64     case ADOLC_MPI_MINLOC: return MPI_MINLOC;
     65     case ADOLC_MPI_MAXLOC: return MPI_MAXLOC;
     66    }
     67}
     68#endif
     69
     70END_C_DECLS
     71
     72#endif
     73#endif
    2274
    2375/****************************************************************************/
     
    3587using std::istream;
    3688
    37 #include <adolc/common.h>
    3889
    3990/* NOTICE: There are automatic includes at the end of this file! */
     
    473524
    474525#include <limits>
     526#if defined(HAVE_MPI)
     527#include <mpi.h>
     528#endif
    475529
    476530namespace adtl {
     
    14771531    return in;
    14781532}
    1479 }
     1533
     1534#if defined( HAVE_MPI )
     1535
     1536#if defined(NUMBER_DIRECTIONS)
     1537int MPI_ND = ADOLC_numDir+1;
     1538#else
     1539int MPI_ND =2;
     1540#endif
     1541
     1542int ADOLC_MPI_Init( int* a,
     1543                    char*** b
     1544){
     1545    return MPI_Init(a,b);
     1546}
     1547int ADOLC_MPI_Comm_size( ADOLC_MPI_Comm comm,
     1548                         int* size
     1549){
     1550    return MPI_Comm_size(comm,size);
     1551}
     1552int ADOLC_MPI_Comm_rank( ADOLC_MPI_Comm comm,
     1553                         int* rank
     1554){
     1555    return MPI_Comm_rank(comm, rank);
     1556}
     1557
     1558int ADOLC_MPI_Get_processor_name( char* a,
     1559                                  int* b
     1560){
     1561    return MPI_Get_processor_name(a,b);
     1562}
     1563
     1564int ADOLC_MPI_Barrier( ADOLC_MPI_Comm comm ){
     1565    return MPI_Barrier(comm);
     1566}
     1567
     1568int ADOLC_MPI_Finalize( ){
     1569    return MPI_Finalize();
     1570}
     1571
     1572int ADOLC_MPI_Send( adouble *buf,
     1573                    int count,
     1574                    ADOLC_MPI_Datatype datatype,
     1575                    int dest,
     1576                    int tag,
     1577                    ADOLC_MPI_Comm comm
     1578){
     1579    int l,i,j,h = count*MPI_ND;
     1580    int ierr =0;
     1581    double *trade = (double*) malloc(h*sizeof(double));
     1582
     1583//     trade = malloc(h);
     1584    for (i=0; i< count;i++ ){
     1585        trade[i*MPI_ND] = buf[i].getValue();
     1586#if defined (NUMBER_DIRECTIONS )
     1587        FOR_I_EQ_0_LT_NUMDIR
     1588          trade[i*MPI_ND+_i+1] = buf[i].getADValue(_i) ;
     1589#else
     1590        trade[i*MPI_ND +1] = buf[i].getADValue();
     1591#endif
     1592    }
     1593    ierr = MPI_Send(trade, h, datatype, dest, tag, comm);
     1594    free(trade);
     1595    return ierr;
     1596}
     1597
     1598int ADOLC_MPI_Recv(adouble *buf,
     1599                   int count,
     1600                   ADOLC_MPI_Datatype datatype,
     1601                   int source, int tag,
     1602                   ADOLC_MPI_Comm comm
     1603) {
     1604    int j, i, h = count*MPI_ND;
     1605    double *trade = (double*) malloc(h*sizeof(double));
     1606    int ierr =0;
     1607
     1608    MPI_Status status;
     1609    ierr = MPI_Recv(trade,h, datatype, source, tag, comm, &status);
     1610    if (buf==NULL)
     1611       buf = new adouble[count];
     1612    for (i=0; i< count;i++){
     1613        buf[i].setValue(trade[i*MPI_ND]);
     1614#if defined (NUMBER_DIRECTIONS )
     1615        FOR_I_EQ_0_LT_NUMDIR
     1616           buf[i].setADValue(_i,trade[i*MPI_ND +1 + _i]);
     1617#else
     1618       buf[i].setADValue(trade[i*MPI_ND +1]);
     1619#endif
     1620      }
     1621    free(trade);
     1622    return ierr;
     1623}
     1624int ADOLC_MPI_Bcast( adouble *buf,
     1625                     int count,
     1626                     ADOLC_MPI_Datatype datatype,
     1627                     int root,
     1628                     ADOLC_MPI_Comm comm )
     1629{
     1630    int i,id, ierr=0;
     1631    int h = count * MPI_ND;
     1632    double *trade = (double*) malloc(h*sizeof(double));
     1633    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     1634
     1635    if ( id == root)
     1636       for(i= 0; i < count; i++){
     1637          trade[i*MPI_ND] = buf[i].getValue();
     1638#if defined (NUMBER_DIRECTIONS )
     1639          FOR_I_EQ_0_LT_NUMDIR
     1640                 trade[i*MPI_ND+_i+1] = buf[i].getADValue(_i) ;
     1641#else
     1642          trade[i*MPI_ND +1] = buf[i].getADValue();
     1643#endif
     1644       }
     1645    ierr = MPI_Bcast(trade,count,datatype,root, comm);
     1646
     1647    if ( id != root){
     1648       if (buf==NULL)
     1649          buf = new adouble[count];
     1650       for(i=0; i< count;i++)
     1651          buf[i].setValue(trade[i*MPI_ND]);
     1652#if defined (NUMBER_DIRECTIONS )
     1653          FOR_I_EQ_0_LT_NUMDIR
     1654          buf[i].setADValue(_i,trade[i*MPI_ND + _i+1]);
     1655#else
     1656          buf[i].setADValue(trade[i*MPI_ND +1]);
     1657#endif
     1658    }
     1659
     1660    free(trade);
     1661    return ierr;
     1662}
     1663
     1664int ADOLC_MPI_Gather(
     1665    adouble *sendbuf, adouble *recvbuf, int count, ADOLC_MPI_Datatype type, int root, ADOLC_MPI_Comm comm)
     1666{
     1667        int h_s = count*MPI_ND;
     1668        int h_r =h_s;
     1669     int i,id,size, ierr=0;
     1670     double *trade_s = (double*) malloc(h_s*sizeof(double)), *trade_r = NULL;
     1671
     1672
     1673    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     1674    MPI_Comm_size(MPI_COMM_WORLD, &size);
     1675
     1676    if (id == root){
     1677           h_r *= size;
     1678           trade_r = (double*) malloc(h_r*sizeof(double));
     1679        }
     1680
     1681    for(i= 0; i < count; i++) {
     1682       trade_s[i*MPI_ND] = sendbuf[i].getValue();
     1683#if defined (NUMBER_DIRECTIONS )
     1684          FOR_I_EQ_0_LT_NUMDIR
     1685                 trade_s[i*MPI_ND+_i+1] = sendbuf[i].getADValue(_i) ;
     1686#else
     1687          trade_s[i*MPI_ND +1] = sendbuf[i].getADValue();
     1688#endif
     1689    }
     1690
     1691    ierr = MPI_Gather(trade_s,count,type,trade_r,count,type, root, comm);
     1692
     1693    if ( id == root){
     1694       if( recvbuf == NULL)
     1695           recvbuf = new adouble[count*size];
     1696       for(i=0; i< count*size;i++){
     1697          recvbuf[i].setValue(trade_r[i*MPI_ND]);
     1698#if defined (NUMBER_DIRECTIONS )
     1699          FOR_I_EQ_0_LT_NUMDIR
     1700          recvbuf[i].setADValue(_i,trade_r[i*MPI_ND + _i+1]);
     1701#else
     1702          recvbuf[i].setADValue(trade_r[i*MPI_ND +1]);
     1703#endif
     1704          }
     1705    }
     1706    free(trade_s);
     1707    if (id == root)
     1708           free(trade_r);
     1709    return ierr;
     1710}
     1711
     1712
     1713int ADOLC_MPI_Reduce(
     1714    adouble *send_buf, adouble *rec_buf, int count, ADOLC_MPI_Datatype type,
     1715    ADOLC_MPI_Op op, int root, ADOLC_MPI_Comm comm)
     1716{
     1717    int i,j,id,size, ierr=0;
     1718    adouble tmp, *tmp_adoubles = NULL;
     1719    ierr = ADOLC_MPI_Gather(send_buf,tmp_adoubles,count,type,root,comm);
     1720
     1721    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     1722    MPI_Comm_size(MPI_COMM_WORLD, &size);
     1723
     1724    if ( id == root){
     1725       if( rec_buf == NULL)
     1726           rec_buf = new adtl::adouble[count];
     1727       switch (op) {
     1728               case ADOLC_MPI_MAX: for(i=0; i < count; i++ ) {
     1729                                       tmp = tmp_adoubles[i];
     1730                                       for(j=1; j< size ; j++)
     1731                                          if ( tmp <= tmp_adoubles[j*count+i] )
     1732                                             tmp = tmp_adoubles[j*count+i];
     1733                                       rec_buf[i] = tmp;
     1734                                   }
     1735                                   break;
     1736               case ADOLC_MPI_MIN: for(i=0; i < count; i++ ) {
     1737                                      tmp = tmp_adoubles[i];
     1738                                      for(j=1; j< size ; j++)
     1739                                         if ( tmp >= tmp_adoubles[j*count+i] )
     1740                                            tmp = tmp_adoubles[j*count+i];
     1741                                      rec_buf[i] = tmp;
     1742                                   }
     1743                                   break;
     1744               case ADOLC_MPI_SUM: for(i=0; i < count; i++ ) {
     1745                                      tmp =0.;
     1746                                      for(j=0; j< size ; j++)
     1747                                         tmp += tmp_adoubles[j*count+i];
     1748                                       rec_buf[i] = tmp;
     1749                                   }
     1750                                   break;
     1751               case ADOLC_MPI_PROD:for(i=0; i < count; i++ ) {
     1752                                      tmp = 1.;
     1753                                      for(j=0; j< size ; j++)
     1754                                         tmp *= tmp_adoubles[j*count+i];
     1755                                      rec_buf[i] = tmp;
     1756                                    }
     1757                                    break;
     1758               default:             printf("Operation %d not yet implemented!\n",op);
     1759                                    break;
     1760       }
     1761       delete[] tmp_adoubles;
     1762    }
     1763
     1764    return ierr;
     1765}
     1766
     1767int ADOLC_MPI_Scatter(
     1768    adouble *sendbuf, int sendcount, adouble *recvbuf,
     1769    int recvcount, ADOLC_MPI_Datatype type, int root, ADOLC_MPI_Comm comm)
     1770{
     1771    int i,id,size, ierr=0;
     1772    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     1773    MPI_Comm_size(MPI_COMM_WORLD, &size);
     1774    int h_s = sendcount*MPI_ND*size;
     1775    int h_r = recvcount*MPI_ND;
     1776    double *trade_r = (double*) malloc(h_r*sizeof(double)), *trade_s=NULL;
     1777
     1778    if (id == root)
     1779        trade_s = (double*) malloc( h_s*sizeof(double));
     1780
     1781    if ( id == root){
     1782       for(i= 0; i < sendcount*size; i++)
     1783          trade_s[i*MPI_ND] = sendbuf[i].getValue();
     1784#if defined (NUMBER_DIRECTIONS )
     1785          FOR_I_EQ_0_LT_NUMDIR
     1786                 trade_s[i*MPI_ND+_i+1] = sendbuf[i].getADValue(_i) ;
     1787#else
     1788          trade_s[i*MPI_ND +1] = sendbuf[i].getADValue();
     1789#endif
     1790    }
     1791
     1792    ierr = MPI_Scatter(trade_s,sendcount,type,trade_r,recvcount,type, root, comm);
     1793
     1794    if( recvbuf == NULL)
     1795       recvbuf = new adouble[recvcount];
     1796    for(i=0; i< recvcount;i++){
     1797         recvbuf[i].setValue(trade_r[i*MPI_ND]);
     1798#if defined (NUMBER_DIRECTIONS )
     1799          FOR_I_EQ_0_LT_NUMDIR
     1800          recvbuf[i].setADValue(_i,trade_r[i*MPI_ND + _i+1]);
     1801#else
     1802          recvbuf[i].setADValue(trade_r[i*MPI_ND +1]);
     1803#endif
     1804         }
     1805    free(trade_r);
     1806    if (id == root)
     1807      free(trade_s);
     1808    return ierr;
     1809}
     1810
     1811int ADOLC_MPI_Allgather(
     1812    adouble *sendbuf, int sendcount,ADOLC_MPI_Datatype stype, adouble *recvbuf, int recvcount, ADOLC_MPI_Datatype rtype, ADOLC_MPI_Comm comm)
     1813{
     1814     int h_s = sendcount*MPI_ND;
     1815     int h_r = recvcount*MPI_ND;
     1816     int i,id,size, ierr=0;
     1817     MPI_Comm_rank(MPI_COMM_WORLD, &id);
     1818     MPI_Comm_size(MPI_COMM_WORLD, &size);
     1819
     1820     double *trade_s = (double*) malloc(h_s*sizeof(double));
     1821     double *trade_r = (double*) malloc(h_r*sizeof(double)*size);
     1822
     1823    for(i= 0; i < sendcount; i++) {
     1824       trade_s[i*MPI_ND] = sendbuf[i].getValue();
     1825#if defined (NUMBER_DIRECTIONS )
     1826          FOR_I_EQ_0_LT_NUMDIR
     1827              trade_s[i*MPI_ND+_i+1] = sendbuf[i].getADValue(_i) ;
     1828#else
     1829          trade_s[i*MPI_ND +1] = sendbuf[i].getADValue();
     1830#endif
     1831    }
     1832
     1833    ierr = MPI_Allgather(trade_s,h_s,stype, trade_r, h_r, rtype, comm);
     1834
     1835    if( recvbuf == NULL)
     1836        recvbuf = new adouble[recvcount*size];
     1837    for(i=0; i< recvcount*size;i++){
     1838        recvbuf[i].setValue(trade_r[i*MPI_ND]);
     1839#if defined (NUMBER_DIRECTIONS )
     1840        FOR_I_EQ_0_LT_NUMDIR
     1841           recvbuf[i].setADValue(_i,trade_r[i*MPI_ND + _i+1]);
     1842#else
     1843        recvbuf[i].setADValue(trade_r[i*MPI_ND +1]);
     1844#endif
     1845    }
     1846    free(trade_s);
     1847    free(trade_r);
     1848    return ierr;
     1849}
     1850
     1851int ADOLC_MPI_Allreduce(
     1852    adouble *send_buf, adouble *rec_buf, int count, ADOLC_MPI_Datatype type,
     1853    ADOLC_MPI_Op op, ADOLC_MPI_Comm comm)
     1854{
     1855    int i,j,id,size, ierr=0;
     1856     MPI_Comm_size(MPI_COMM_WORLD, &size);
     1857    adouble tmp, *tmp_adoubles = new adouble[count*size];
     1858    ierr = ADOLC_MPI_Allgather(send_buf,count,type,tmp_adoubles,count,type,comm);
     1859
     1860    if( rec_buf == NULL)
     1861       rec_buf = new adouble[count];
     1862    switch (op) {
     1863               case ADOLC_MPI_MAX: for(i=0; i < count; i++ ) {
     1864                                       tmp = tmp_adoubles[i];
     1865                                       for(j=1; j< size ; j++)
     1866                                          if ( tmp <= tmp_adoubles[j*count+i] )
     1867                                             tmp = tmp_adoubles[j*count+i];
     1868                                       rec_buf[i] = tmp;
     1869                                   }
     1870                                   break;
     1871               case ADOLC_MPI_MIN: for(i=0; i < count; i++ ) {
     1872                                      tmp = tmp_adoubles[i];
     1873                                      for(j=1; j< size ; j++)
     1874                                         if ( tmp >= tmp_adoubles[j*count+i] )
     1875                                            tmp = tmp_adoubles[j*count+i];
     1876                                      rec_buf[i] = tmp;
     1877                                   }
     1878                                   break;
     1879               case ADOLC_MPI_SUM: for(i=0; i < count; i++ ) {
     1880                                      cout << "i="<<i<<"   count="<< count << endl;
     1881                                      tmp =0.;
     1882                                      for(j=0; j< size ; j++){
     1883                                         cout <<"j="<<j<<" :   "<< tmp_adoubles[j*count+i] << endl;
     1884                                         tmp += tmp_adoubles[j*count+i];
     1885                                         }
     1886                                       rec_buf[i] = tmp;
     1887                                   }
     1888                                   break;
     1889               case ADOLC_MPI_PROD:for(i=0; i < count; i++ ) {
     1890                                      tmp = 1.;
     1891                                      for(j=0; j< size ; j++)
     1892                                         tmp *= tmp_adoubles[j*count+i];
     1893                                      rec_buf[i] = tmp;
     1894                                    }
     1895                                    break;
     1896               default:             printf("Operation %d not yet implemented!\n",op);
     1897                                    break;
     1898    }
     1899    delete[] tmp_adoubles;
     1900    return ierr;
     1901}
     1902
     1903#endif // END MPI
     1904} // END NAMESPACE adtl
    14801905
    14811906/****************************************************************************/
  • branches/MPI/ADOL-C/src/fo_rev.c

    r311 r327  
    208208#include <adolc/oplate.h>
    209209#include "taping_p.h"
     210
     211#include <math.h>
     212
     213#if defined(_MPI_)
     214#include <adolc/adolc_mpi.h>
     215#endif
     216
    210217#include <adolc/externfcts.h>
    211218#include "externfcts_p.h"
    212 
    213 #include <math.h>
    214 
    215 #if defined(_MPI_)
    216 #include <adolc/adolc_mpi.h>
    217 #endif
    218219
    219220BEGIN_C_DECLS
  • branches/MPI/ADOL-C/src/interfaces_mpi.cpp

    r273 r327  
    1414
    1515#include <adolc/common.h>
    16 #include <adolc/adouble.h>
    1716#include <adolc/adolc_mpi.h>
    1817#include <adolc/interfaces_mpi.h>
  • branches/MPI/ADOL-C/src/uni5_for.c

    r311 r327  
    3434#include "taping_p.h"
    3535#include <adolc/oplate.h>
    36 #include <adolc/externfcts.h>
    37 #include "externfcts_p.h"
    3836
    3937#include <math.h>
     
    4644#include <adolc/adolc_mpi.h>
    4745#endif
     46
     47#include <adolc/externfcts.h>
     48#include "externfcts_p.h"
    4849
    4950/****************************************************************************/
  • branches/MPI/Makefile.am

    r252 r327  
    2222                       ADOL-C/doc/tapebasic.pdf ADOL-C/doc/tapebasic.eps \
    2323                       ADOL-C/doc/tap_point.pdf ADOL-C/doc/tap_point.eps \
    24                        autoconf/shave.in autoconf/shave-libtool.in \
    25                        autoconf/dolt.m4 autoconf/shave.m4 \
    2624                       MSVisualStudio/v10/adolc.sln MSVisualStudio/v10/adolc.vcxproj \
     25                       MSVisualStudio/v10/ColPack_Readme_VC++.txt \
     26                       MSVisualStudio/v10/ColPack.vcxproj \
    2727                       MSVisualStudio/v10/sparse/config.h.in MSVisualStudio/v10/nosparse/config.h.in \
    2828                       MSVisualStudio/v10/x64/sparse/config.h.in MSVisualStudio/v10/x64/nosparse/config.h.in \
     
    3232                       MSVisualStudio/v10/installer.sh \
    3333                       adolc.spec.in adolc.spec \
    34                        update_versions.sh \
    35                        ThirdParty/ColPack/ColPack.vcxproj \
    36                        ThirdParty/ColPack/Readme_VC++.txt
     34                       update_versions.sh
    3735
    3836SUBDIRS              = ADOL-C
    39 
    40 MAINTAINERCLEANFILES = Makefile.in aclocal.m4 configure ADOL-C/src/config.h.in \
    41                        ADOL-C/src/stamp-h.in *~ *.orig
    42 
    43 DISTCLEANFILES = doltcompile doltlibtool
    4437
    4538test: all
Note: See TracChangeset for help on using the changeset viewer.