Changeset 273 for branches


Ignore:
Timestamp:
Oct 10, 2011 11:18:53 AM (7 years ago)
Author:
kulshres
Message:

Merge branch 'mpi' into svn-mpi

The following changes from trunk and mpi development branches
were merged:

commit 474ffd3473af595e46cb0d3800e84aa89e2156c5
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Oct 10 14:57:53 2011 +0000

Revert "nonlinear frontiers" from trunk

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

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

commit 098fe2f7789de91539521f1a1e6269b115f99f40
Author: Benjamin Letschert <letschi@…>
Date: Thu Oct 6 11:45:07 2011 +0200

Bugfix in fo_rev.c and ho_rev.c

commit 3f9b2023086039220a71f98b8b3382c4eeea2aae
Author: Benjamin Letschert <letschi@…>
Date: Tue Oct 4 16:35:18 2011 +0200

Fixing of LOC_INTS for ADOLC_MPI_Scatter in fo_rev.c and ho_rev.c

commit 2ed1c9b9b84a64578344988036efa2612854c183
Author: Benjamin Letschert <letschi@…>
Date: Tue Oct 4 16:11:15 2011 +0200

FIX the difference between ADOLC_MPI_SUM and ADOLC_MPI_PROD by ADOLC_MPI_GATHER

commit 293d29e20850ab2640045f823195679e38356cfc
Author: Benjamin Letschert <letschi@…>
Date: Thu Sep 29 09:43:02 2011 +0200

Bugfix for GET_LOCINT _R in ho_rev.c

commit a08d97d603eff071ebf15e4323fa78727eea8bfa
Author: Benjamin Letschert <letschi@…>
Date: Wed Sep 28 14:01:54 2011 +0200

Fix correct call of hov_reverse

commit f958ac969a3cc5e8748b489d39d106664189923f
Author: Benjamin Letschert <letschi@…>
Date: Wed Sep 28 14:01:00 2011 +0200

Fix switch-case query by ADOLC_MPI_Reduce

commit 972a5fe2377682ed4d0e4f50a5a6357d82d9086c
Author: Benjamin Letschert <letschi@…>
Date: Wed Sep 28 13:57:08 2011 +0200

Fix of MPI routines in fo_rev.c

commit 45adffae64eb6d5867da66fab633b1118d8b53eb
Author: Benjamin Letschert <letschi@…>
Date: Mon Sep 26 15:01:17 2011 +0200

Adding Gather,Scatter and Reduce operation to tapedoc

commit a9e7461fb2c2f021bc061111c6eec33f4ded1f87
Author: Benjamin Letschert <letschi@…>
Date: Tue Sep 20 16:10:59 2011 +0200

Fixing ADOLC_LOC_INT addressing

commit f403fa097da8a39badc68eb7c8d83e285414040e
Author: Benjamin Letschert <letschi@…>
Date: Mon Sep 19 15:50:11 2011 +0200

Adding INT_FORWARD and INT_REVERSE to parallel interfaces_mpi

commit ba95089d1f8785c07b20a0cd1eac346f0d9707f5
Author: Benjamin Letschert <letschi@…>
Date: Mon Sep 19 15:46:24 2011 +0200

Fixing ADOLC_PUT_LOCINT by ADOLC_MPI_Gather and ADLOC_MPI_Scatter

commit 43d764c69eb469b9b4f44db3aee96bd5e6e28aa8
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Wed Aug 24 09:51:54 2011 +0000

add const to jac_solv argument

Signed-off-by: Wolfgang Lorenz <wl-chmw@…>
Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

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

commit 30bb7a6350ab64c400cfa0d03ace926accf3aad6
Author: Benjamin Letschert <letschi@…>
Date: Mon Aug 15 16:12:19 2011 +0200

Revert "Fixing reduce operator in uni5_for.c"

These two commits were completely wrong.

This reverts commit d759ded7b9a507cb46601b8c7197c6c4f1147893.
and commit 4eed283af4f85661aed70978f44ce7fb7a97a9d9

Conflicts:

ADOL-C/src/uni5_for.c

commit 4eed283af4f85661aed70978f44ce7fb7a97a9d9
Author: Benjamin Letschert <letschi@…>
Date: Mon Aug 15 15:15:11 2011 +0200

Adding missing semicolons in uni5_for.c

commit d759ded7b9a507cb46601b8c7197c6c4f1147893
Author: Benjamin Letschert <letschi@…>
Date: Mon Aug 15 14:14:59 2011 +0200

Fixing reduce operator in uni5_for.c

commit e3e47ed985f7043798f508b612b3b30c2b7de069
Author: Benjamin Letschert <letschi@…>
Date: Mon Aug 15 13:50:21 2011 +0200

Fixing ADOLC_LOCINT and ADOLC_OPs in ADOLC_MPI_Reduce()

commit c11808fa46757a800053116805b76be4b0a47845
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Fri Aug 12 11:08:09 2011 +0000

indentation correction

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

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

commit 34bbe6042b8e2f7ccf9fc8c9d86480a39ca898a2
Author: Benjamin Letschert <letschi@…>
Date: Thu Aug 11 15:38:37 2011 +0200

Fixing sendbuffer and receive buffer locations and memory allocations in uni5_for.c

commit 79cabd996a19d9c7fc5abcf71c4869af4cfbf067
Author: Benjamin Letschert <letschi@…>
Date: Thu Aug 11 15:36:09 2011 +0200

Adding ADOLC_MPI_Gather and ADOLC_MPI_Scatter for forward mode

commit 848f380d6b8c2cc1fd2ad79411adedccd012d041
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Tue Aug 9 11:39:23 2011 +0000

regenerate build file

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

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

commit 88d41ad577c73b9b4fa94604b8d70b284759fe8a
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Tue Aug 9 11:39:06 2011 +0000

allow openmp to work with the new memory manager

needs further testing to ensure consistency of derivatives

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

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

commit ce9ed1f175b4d72c6eab90bc5d403797b58db08b
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sat Jul 16 11:34:21 2011 +0000

Build fix when openmp is enabled

Signed-off-by: Wolfgang Lorenz <wl-chmw@…>
Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

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

commit 72e2ce4b22dd95262e2d1692a75629dfddfff791
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Thu Jul 14 19:15:25 2011 +0000

nlfsworking but slow

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

commit e358ea04da74220b9d3fb624853ff0d495a653b9
Author: Benjamin Letschert <letschi@…>
Date: Thu Jul 7 14:24:40 2011 +0200

Adding Manual for parallel ADOL-C to adolc-manual.tex

Signed-off-by: Benjamin Letschert <letschi@…>

commit 89f8b0f0d546be2acc3311a46219792e439f08f4
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Jul 4 20:36:56 2011 +0000

further work on nlfs

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

commit a8d9b357b4c34bc49cf7a0ed1289d5ddaf98ce0b
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Jul 4 14:39:24 2011 +0000

nlfs up and running, next task: speed up, first step

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

commit 31fbee17f217fdcd35dd24c112616b10585b7399
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sun Jul 3 20:27:49 2011 +0000

nlfs once more

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

commit 51fbd2137d1a3f371c2fd04cbf9005d75a37bca1
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sun Jul 3 18:45:45 2011 +0000

next try of pattern estimation

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

commit 10c7c942901641eab437701f4cb9ab94a904af03
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sun Jul 3 18:45:15 2011 +0000

next try of pattern estimation

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

commit 83b869383a23b0a670b771d29c35987f6dd498e4
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Fri Jul 1 13:49:58 2011 +0000

first full version of sparsity estimation based on fod

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

commit 690196fad755dfe98b00bfa26cc10828709bd430
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Thu Jun 30 20:23:02 2011 +0000

next try for sparsity estimation: extended csod_forward_*

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

commit 6e51587a2db6d8fadf721e7caa6eb0ec971daf69
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Thu Jun 30 13:23:02 2011 +0000

corresponding csod_forward_* files

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

commit 999c7a8b4845f4e87775342a9e8cdfee750b8d58
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Thu Jun 30 13:20:56 2011 +0000

change nlf to csod due to overwrites, different handling required

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

commit 97454dee5be34fb440c19616be4c27e06fd62b12
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sun Jun 26 19:05:17 2011 +0000

new files nlf_forward_*.c for propagation of nonlinear frontiers

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

commit 1edf40e9770a8a141f3f3eaa8d82b1e2916cc240
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Sun Jun 19 20:36:37 2011 +0000

nlf: handling of eq_*_prod => extension of tape stats

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

commit 39cc692f5d381e58bfc37eeae5bf456c21a1ccb0
Author: kulshres <kulshres@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Jun 13 20:30:31 2011 +0000

change version and regenerate files

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

commit 5f71db4938731c70bbfd0356ac0d5bee4f3af8a9
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Mon Jun 13 18:57:34 2011 +0000

correct typos

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

commit e605b75e25227fb2ef2ea1bbee2595a21835f620
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Fri Jun 10 07:30:09 2011 +0000

reset values in usrparms.h

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

commit 8785416957555407d28910a8c0f81cdfbf81dae9
Author: awalther <awalther@94ac48a7-3327-4b6a-8511-9a4036a20e83>
Date: Fri Jun 10 07:27:40 2011 +0000

first version of nonlinear frontiers, missing: eq_plus_a and eq_plus_mult make install

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

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

Legend:

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

    r190 r273  
    22%
    33% Copyright (C) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    4 %               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
     4%               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     5%               Benjamin Letschert
    56%
    67% This file is part of ADOL-C. This software is provided as open source.
     
    37123713%
    37133714%
     3715\section{Parallel ADOL-C by using MPI}
     3716\label{parallel}
     3717%
     3718\subsection{Installation of ADOL-C by using MPI}
     3719\label{InstPar}
     3720%
     3721Before configuring ADOL-C one has to make sure that at least one MPI version is installed. The configuration searches for MPI headers and libraries in the standard directories. If MPI is installed local or the headers and libraries could not be found in the standard directories, the options \verb?--with-mpi-includedir=PATH? and \verb?--with-mpi-libdir=PATH? should be used. At the end of the configuration it is stated whether parallel computation can be used or not.
     3722\begin{center}
     3723   \begin{tabular}{l l}
     3724      \verb=Configuration:= & \ \\
     3725      \verb=  ....=  & \ \\
     3726      \verb=  Source code location:= & \verb=/PATH-TO-ADOL-C/adol-c=\\
     3727      \verb=  Install path:= & \verb=$HOME/adolc_base=\\
     3728      \verb=  ....=  & \ \\
     3729      \verb=  Build sparse drivers:= & \verb= yes=\\
     3730      \verb=  Build with ColPack:= & \verb= yes=\\
     3731      {\bf \verb=  Build with MPI:= }& {\bf\verb= yes= }\\
     3732      \verb=  ....=
     3733   \end{tabular}
     3734\end{center}
     3735%
     3736\subsection{Header files and definitions}
     3737\label{HeadDefPar}
     3738%
     3739For the parallel computation one has to define which version of MPI is installed. If MPI is located by configuration, the output shows where to find the MPI headers.
     3740\begin{center}
     3741By configuring ADOL-C you will see which version is found.\\
     3742   \begin{tabular}{l l}
     3743Example: & $\vdots$\\
     3744 & \verb=checking mpi/mpi.h usability... yes=\\
     3745 & \verb=checking mpi/mpi.h presence... yes=\\
     3746 & \verb=checking for mpi/mpi.h... yes=\\
     3747 & \verb=checking for MPI_Init in -lmpich... yes=\\
     3748 & $\vdots$
     3749   \end{tabular}
     3750\end{center}
     3751In this case the MPI header file is found at \verb=mpi/mpi.h=, so that \verb=HAVE_MPI_MPI_H 1= has to be included. The other option is \verb=mpi.h=, so \verb=#define HAVE_MPI_H 1=.\\
     3752If a local installation of MPI is used, the path to the header file \verb=mpi.h= must be  given. In this case use \verb=#define HAVE_MPI_H 1=. The header file \verb=<adolc/adolc_mpi.h>= is needed for parallel computing as well as \verb=<adolc/sparsedrivers_mpi.h>= to use Colpack.
     3753
     3754\subsubsection{Compiling and Linking}
     3755Only \verb=C++= programs may use the ADOL-C MPI interface, therefore programs in \verb=C= must be compiled with the \verb=C++= compiler. For compiling and linking the \verb=ladolc_mpi= library is required. A possible Makefile could be the following one
     3756\begin{center}
     3757\begin{verbatim}
     3758  # MPI C++ Compiler
     3759  CXX = mpicxx
     3760
     3761  # flags for compiling
     3762  CFLAGS = -g -O0
     3763
     3764  # Paths and libraries for ADOL-C with MPI - example
     3765  ADPATH = $(HOME)/adolc_base/include
     3766  ADLIBDIR = $(HOME)/adolc_base/lib
     3767  ADCFLAGS = -I$(ADPATH)
     3768  ADLIBS = -Wl,--rpath -Wl,$(ADLIBDIR) -L$(ADLIBDIR) -ladolc_mpi
     3769
     3770  all: example
     3771  example: example.o
     3772           $(CXX) $(CFLAGS) $(ADCFLAGS) -o example example.o -lm $(ADLIBS)
     3773  example.o: example.cpp
     3774           $(CXX) $(CFLAGS) $(ADCFLAGS) -c -o example.o example.cpp
     3775
     3776  clean:
     3777           rm -f *.o example
     3778\end{verbatim}
     3779\end{center}
     3780%
     3781\subsection{MPI communicator in ADOL-C}
     3782\label{CommPar}
     3783%
     3784Communicator objects connect groups of processes in the MPI session. Each communicator gives each contained process an independent identifier (id) and arranges its contained processes in an ordered topology.\\
     3785The header file \verb=<adolc/adolc_mpi.h>= assumes, that the main/root process has id 0. All other processes have an id $> 0$. The main process must declare the independent and dependent variables.
     3786%
     3787\subsubsection{Initialisation calls}
     3788\label{InitCallsPar}
     3789\begin{itemize}
     3790\item \verb=int ADOLC_MPI_Init(= // Parameter is given from \verb=main(argc,argv)= program\\
     3791\begin{tabular}{l l}
     3792\ \ & \verb=int* argc,=\\
     3793 & \verb=char*** argv)=
     3794\end{tabular}\\
     3795This function initialises the use of MPI and has to be called before any other \verb=ADOLC_MPI= function.
     3796\item \verb=int ADOLC_MPI_Comm_size(=\\
     3797\begin{tabular}{l l l}
     3798\ \ & \verb=ADOLC_MPI_Comm comm,= & communicator of process group\\
     3799 & \verb=int* size)= & pointer to count of processes
     3800\end{tabular}\\
     3801 The used number of processes is returned by the parameter \verb=size=. This function should be called directly after the initialisation.
     3802\item \verb=int ADOLC_MPI_Comm_rank(=\\
     3803\begin{tabular}{l l l}
     3804\ \ & \verb=ADOLC_MPI_Comm comm,= & communicator of process group\\
     3805 & \verb=int* id)= & pointer to the identity number of process
     3806\end{tabular}\\
     3807 This function returns the rank or id of the process, which has called this function. This function should be also called directly  after the initialisation.
     3808\item \verb=int ADOLC_MPI_Get_processor_name(=\\
     3809\begin{tabular}{l l l}
     3810\ \ & \verb=char* name,= & pointer to process' name\\
     3811 & \verb=int* id)= & pointer to identity of process
     3812\end{tabular}\\
     3813The name of the process with identity \verb=id= is saved temporary in \verb=name=.
     3814\item \verb=int ADOLC_MPI_Barrier(=\\
     3815\begin{tabular}{l l l}
     3816\ \ & \verb=ADOLC_MPI_Comm comm)= & communicator of process group\\
     3817\end{tabular}\\
     3818This functions synchronises all processes.
     3819\item \verb=int ADOLC_MPI_Finalize()=\\
     3820At the end of the \verb=main= program this function has to be called for the finalisation of all processes.
     3821\item \verb=int trace_on(=\\
     3822\begin{tabular}{l l l}
     3823\ \ & \verb=int id,= & identity of process\\
     3824 & \verb=int size,= & count of processes \\
     3825 & \verb=short tag)= & tag of tape
     3826\end{tabular}\\
     3827 This is the parallel version of \verb=trace_on(short tag)=. The function needs two more parameters in order to generate a tape for each process of the process group.
     3828\item \verb=void tape_doc(=\\
     3829\begin{tabular}{l l l}
     3830\ \ & \verb=int id,= & identity of process\\
     3831 & \verb=int size,= & count of processes \\
     3832 & \verb=short tag,= & tag of tape \\
     3833 & \verb=int depen,= & count of dependend variables \\
     3834 & \verb=int indep,= & count of independent variables\\
     3835 & \verb=double* argument,= & pointer of buffer of the arguments\\
     3836 & \verb=double* result)= & pointer of the buffer of results
     3837\end{tabular}\\
     3838 This is the parallel version of \verb=tape_doc=. The function needs two more parameters in order to transform the tapes into  \LaTeX source documents.
     3839\end{itemize}
     3840%
     3841\subsubsection{Communication calls}
     3842\label{CommParCalls}
     3843The most basic type of communication takes place between two processes: a sending process transmits information  to a receiving process. In MPI, this information is packed into messages with the describing parameters \verb=buf=, \verb=count=, and \verb=datatype=. For each sending operation there must be a matching receive operation.\\
     3844Since in parallel applications, the execution order of operations is not always deterministic, MPI provides \verb=tag= parameters - only where the value of \verb=tag= for the send and the receive operation is identical, then these operations fit together.
     3845\begin{itemize}
     3846\item \verb=int ADOLC_MPI_Send(=\\
     3847\begin{tabular}{l l l}
     3848\ \ & \verb=adouble *buf,=& // pointer to sending buffer\\
     3849& \verb=int count,= & // number of elements to send\\
     3850& \verb=ADOLC_MPI_Datatype datatype,= & // datatype of the elements of sending buffer\\
     3851& \verb=int dest,= & // id of the destination process\\
     3852& \verb=int tag,= &  // mark of the information\\
     3853& \verb=ADOLC_MPI_Comm comm)=  & // communicator of the process group
     3854\end{tabular} \\
     3855This call is the standard point-to-point function to send \verb=adoubles= from one process to another. Each sending call needs an receiving call by the other process.\\
     3856\item \verb=int ADOLC_MPI_Recv(=\\
     3857\begin{tabular}{l l l}
     3858\ \ & \verb=adouble *buf,=& // pointer to receiving buffer\\
     3859& \verb=int count,= & // number of elements to receive\\
     3860& \verb=ADOLC_MPI_Datatype datatype,= & // datatype of the elements of sending buffer\\
     3861& \verb=int source,= & // id of the sending process\\
     3862& \verb=int tag,= &  // mark of the information\\
     3863& \verb=ADOLC_MPI_Comm comm)=  & // communicator of the process group
     3864\end{tabular} \\
     3865This is the standard point-to-point function to receive \verb=adoubles= from another process. It is the opposite of the sending call.\\
     3866\item \verb=int ADOLC_MPI_Bcast(=\\
     3867\begin{tabular}{l l l}
     3868\ \ & \verb=adouble *buf,=& // pointer to sending/receiving buffer\\
     3869& \verb=int count,= & // number of elements of buffer\\
     3870& \verb=ADOLC_MPI_Datatype datatype,= & // datatype of the elements of sending buffer\\
     3871& \verb=int root,= & // id of the process who have to send\\
     3872& \verb=ADOLC_MPI_Comm comm)=  & // communicator of the process group
     3873\end{tabular} \\
     3874 This function takes data from one node and sends it to all processes in the process group.
     3875\item \verb=int ADOLC_MPI_Reduce(=\\
     3876\begin{tabular}{l l l}
     3877\ \ & \verb=adouble *sendbuf,=& // pointer to sending buffer\\
     3878& \verb=adouble *rec_buf,=& // pointer to receiving buffer\\
     3879& \verb=int count,= & // number of elements of buffer\\
     3880& \verb=ADOLC_MPI_Datatype datatype,= & // datatype of the elements of both buffers\\
     3881& \verb=ADOLC_MPI_Op op,= & // operation for all received data (buffers)\\
     3882& \verb=int root,= & // id of the process who have to receive\\
     3883& \verb=ADOLC_MPI_Comm comm)=  & // communicator of the process group
     3884\end{tabular} \\
     3885 The function takes data from all processes in a group, performs an operation \verb=op= (such as summing), and stores the results on one node. Reduce is often useful at the beginning or end of a large distributed calculation, where each processor operates on a part of the data and then combines it into a result.
     3886\end{itemize}
     3887%
     3888%
     3889\subsection{Drivers and Interfaces}
     3890\label{DrAndIntPar}
     3891\subsubsection{Basic Drivers for parallel computing}
     3892\label{BasicDrPar}
     3893%
     3894After the tape is generated the appropriate ADOL-C drivers can be called. The only thing to do is to fit in the process' id and the count of all processes of the process group as first and second parameters. The same holds for the parallel version for the sparse drivers, if \verb=ColPack= is used.\\
     3895Examples with \verb=m= for the number of dependent and \verb=n= for the number of independent variables:
     3896\begin{itemize}
     3897\item \verb=int function( int id, int size,= // new parameters \\
     3898      \verb=              short tag,int m,int n,double* argument ,double* result)=
     3899\item \verb=int gradient( int id, int size,=\\
     3900      \verb=              short tag ,int n, const double* x,double* result)=
     3901\item \verb=int vec_jac(  int id, int size,=\\
     3902      \verb=              short tag, int m, int n, int repeat, double *argument,=\\
     3903      \verb=              double *lagrange, double *row)=
     3904\item \verb=int hess_mat( int id,int size,=\\
     3905      \verb=              short tag, int n, int q, double *argument,=\\
     3906      \verb=              double **tangent, double **result)=
     3907\item \verb=int hessian(  int id, int size,=\\
     3908      \verb=              short tag ,int n, double* argument, double** hess)=
     3909\item \verb=int jacobian( int id, int size,=\\
     3910      \verb=              short tag, int m, int n, const double* argument,=\\
     3911      \verb=              double** jacobian)=
     3912\item \verb=int jac_pat(  int id, int size,=\\
     3913      \verb=              short tag, int depen, int indep, const double *basepoint,=\\
     3914      \verb=              unsigned int **crs, int *options)=
     3915\item \verb=int sparse_jac( int id, int size,=\\
     3916      \verb=              short tag, int depen, int indep, int repeat,=\\
     3917      \verb=              const double *basepoint, int *nnz, unsigned int **rind,=\\
     3918      \verb=              unsigned int **cind, double **values,int *options )=
     3919\item \verb=int sparse_hess( int id, int size,=\\
     3920      \verb=              short tag, int indep, int repeat, const double *basepoint,=\\
     3921      \verb=              int *nnz, unsigned int **rind, unsigned int **cind,=\\
     3922      \verb=              double **values, int *options)=
     3923\end{itemize}
     3924%
     3925%
     3926\subsubsection{Basic Interfaces for parallel computing}
     3927\label{BasicIntPar}
     3928Also all interface functions can be called by adding \verb=id= and \verb=size= to the committed parameters. For example
     3929\begin{itemize}
     3930\item \verb=int zos_forward( int id, int size,=\\
     3931      \verb=              short tag, int m, int n, int keep,=\\
     3932      \verb=              const double *basepoints, double *valuepoints)=
     3933\item \verb=int fos_forward( int id, int size,=\\
     3934      \verb=              short tag, int m, int n, int keep,=\\
     3935      \verb=              const double *basepoints, double *argument=\\
     3936      \verb=              double *valuepoints, double *taylors)=
     3937\item \verb=int hos_reverse( int id, int size,=\\
     3938      \verb=              short tag, int m, int n, int degre,=\\
     3939      \verb=              double *lagrange, double **results)=
     3940\item \verb=int int_forward_tight( int id, int size,=\\
     3941      \verb=              short tag, int m, int n, int p,=\\
     3942      \verb=              const double *basepoints,=\\
     3943      \verb=              unsigned long int **arguments, double *valuepoints,=\\
     3944      \verb=              unsigned long int **taylors)=
     3945\item \verb=int nonl_ind_forward_tight( int id, int size,=\\
     3946      \verb=              short tag, int m, int n, double *basepoints,=\\
     3947      \verb=              unsigned int **crs )=
     3948\item \verb=int indopro_forward_safe( int id, int size,=\\
     3949      \verb=              short tag, int m, int n, double *basepoints,=\\
     3950      \verb=              unsigned int **crs )=
     3951\end{itemize}
     3952%
     3953
    37143954\section{Example Codes}
    37153955\label{example}
     
    37734013cout << errh <<" consistency check \n";
    37744014}                                  // end main
     4015\end{verbatim}
     4016%
     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...
     4026using namespace std;
     4027#define CMMCTR ADOLC_MPI_COMM_WORLD
     4028#define tag 1
     4029
     4030int 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}
    37754099\end{verbatim}
    37764100%
  • branches/MPI/ADOL-C/examples/additional_examples/openmp_exam/liborser.cpp

    r42 r273  
    112112  Nmat = 40;
    113113  N = Nmat+40;
    114   npath = 100;
     114  npath = 30;
    115115
    116116  lambda   = new double[N];
     
    140140      for (i=0; i<Nmat; i++)
    141141        {
    142           z[j][i] = 0.2+j*0.00001;
    143           xp[j][N+i]=  0.2+j*0.00001;
     142          z[j][i] = 0.3;
     143          xp[j][N+i]=  0.3;
    144144        }
    145145    }
     
    171171       
    172172      va >>= v[i];
    173     trace_off();
     173    trace_off(1);
    174174
    175175    for(i=0;i<npath;i++)
  • branches/MPI/ADOL-C/src/adolc_mpi.cpp

    r252 r273  
    3131int mpi_initialized = 0;
    3232int process_count = 1;
     33int all_root = 0;
    3334
    3435int trace_on( int id,
     
    4647){
    4748    mpi_initialized = 1;
     49    all_root = 0;
    4850    return MPI_Init(a,b);
    4951}
     
    114116
    115117    put_op(send_data);
    116     ADOLC_PUT_LOCINT(buf[0].loc());
     118    ADOLC_PUT_LOCINT(count);
     119    for(i=0; i < count; i++)
     120       ADOLC_PUT_LOCINT(buf[i].loc());
    117121    ADOLC_PUT_LOCINT(count);
    118122    ADOLC_PUT_LOCINT(dest);
     
    145149
    146150    put_op(receive_data);
    147     ADOLC_PUT_LOCINT(buf[0].loc());
     151    ADOLC_PUT_LOCINT(count);
     152    for (i=0; i< count;i++)
     153       ADOLC_PUT_LOCINT(buf[i].loc());
    148154    ADOLC_PUT_LOCINT(count);
    149155    ADOLC_PUT_LOCINT(source);
     
    159165
    160166{
    161     int i,id,size, ierr=0;
     167    int i,id, ierr=0;
    162168    double *trade;
    163169
    164     MPI_Comm_size(MPI_COMM_WORLD, &size);
    165170    MPI_Comm_rank(MPI_COMM_WORLD, &id);
    166171
     
    183188
    184189    put_op(broadcast);
    185     ADOLC_PUT_LOCINT(buf[0].loc()); // send
    186     ADOLC_PUT_LOCINT(buf[0].loc()); // recv
     190    ADOLC_PUT_LOCINT(count);
     191    for (i=0; i< count;i++)
     192       ADOLC_PUT_LOCINT(buf[i].loc());
    187193    ADOLC_PUT_LOCINT(count);
    188194    ADOLC_PUT_LOCINT(root);
     
    193199
    194200int ADOLC_MPI_Reduce(
    195     adouble *send_buf, adouble *rec_buf, int count, ADOLC_MPI_Datatype datatype,
     201    adouble *send_buf, adouble *rec_buf, int count, ADOLC_MPI_Datatype type,
    196202    ADOLC_MPI_Op op, int root, ADOLC_MPI_Comm comm)
    197203{
    198     int i,id,size, ierr=0;
     204    int i,j,id, ierr=0;
     205    adouble tmp, *tmp_adoubles = NULL;
    199206    double *trade_s, *trade_r;
    200207
    201     MPI_Comm_size(MPI_COMM_WORLD, &size);
     208    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      ADOLC_PUT_LOCINT(count*process_count);
     239    }
     240    ADOLC_PUT_LOCINT(op);
     241
     242    if ( id == root){
     243       if( rec_buf == NULL)
     244           rec_buf = (adouble*) calloc(count, sizeof(adouble));
     245          switch (op) {
     246               case ADOLC_MPI_MAX: for(i=0; i < count; i++ ) {
     247                                       tmp = tmp_adoubles[i];
     248                                       for(j=1; j< process_count ; j++)
     249                                          if ( tmp <= tmp_adoubles[j*count+i] )
     250                                             tmp = tmp_adoubles[j*count+i];
     251                                       rec_buf[i] = tmp;
     252                                   }
     253                                   break;
     254               case ADOLC_MPI_MIN: for(i=0; i < count; i++ ) {
     255                                      tmp = tmp_adoubles[i];
     256                                      for(j=1; j< process_count ; j++)
     257                                         if ( tmp >= tmp_adoubles[j*count+i] )
     258                                            tmp = tmp_adoubles[j*count+i];
     259                                      rec_buf[i] = tmp;
     260                                   }
     261                                   break;
     262               case ADOLC_MPI_SUM: for(i=0; i < count; i++ ) {
     263                                      tmp = 0;
     264                                      for(j=0; j< process_count ; j++)
     265                                         tmp += tmp_adoubles[j*count+i];
     266                                       rec_buf[i] = tmp;
     267                                   }
     268                                   break;
     269               case ADOLC_MPI_PROD:for(i=0; i < count; i++ ) {
     270                                      tmp = 1;
     271                                      for(j=0; j< process_count ; j++)
     272                                         tmp *= tmp_adoubles[j*count+i];
     273                                      rec_buf[i] = tmp;
     274                                    }
     275                                    break;
     276               default:             printf("Operation %d not yet implemented!\n",op);
     277                                    break;
     278          }
     279
     280    delete[] tmp_adoubles;
     281    }
     282
     283    free(trade_s);
     284    free(trade_r);
     285
     286    return ierr;
     287}
     288
     289int ADOLC_MPI_Gather(
     290    adouble *sendbuf, adouble *recvbuf, int count, ADOLC_MPI_Datatype type, int root, MPI_Comm comm)
     291{
     292    int i,id, ierr=0;
     293    double *trade_s, *trade_r;
     294
    202295    MPI_Comm_rank(MPI_COMM_WORLD, &id);
    203296
    204297    trade_s = (double*) myalloc1(count);
    205298    if (id == root)
    206       trade_r = (double*) myalloc1(count);
     299      trade_r = (double*) myalloc1(count*process_count);
    207300    else trade_r = NULL;
    208301
    209302    for(i= 0; i < count; i++) {
    210        trade_s[i] = send_buf[i].getValue();
    211      }
    212     ierr = MPI_Reduce(trade_s,trade_r ,count,datatype,adolc_to_mpi_op(op),root, comm);
     303       trade_s[i] = sendbuf[i].getValue();
     304    }
     305    ierr = MPI_Gather(trade_s,count,type,trade_r,count,type, root, comm);
    213306
    214307    if ( id == root){
    215        if( rec_buf == NULL)
    216            rec_buf = new adouble[count];
    217        for(i=0; i< count;i++){
    218           rec_buf[i].setValue(trade_r[i]);
     308       if( recvbuf == NULL)
     309           recvbuf = new adouble[count*process_count];
     310       for(i=0; i< count*process_count;i++){
     311          recvbuf[i].setValue(trade_r[i]);
    219312          }
    220313    }
     
    222315    free(trade_r);
    223316
    224     put_op(reduce);
    225     ADOLC_PUT_LOCINT(send_buf[0].loc());
    226     ADOLC_PUT_LOCINT(rec_buf[0].loc());
     317    put_op(gather);
     318    ADOLC_PUT_LOCINT(count);
     319    for(i= 0; i < count; i++)
     320        ADOLC_PUT_LOCINT(sendbuf[i].loc());
    227321    ADOLC_PUT_LOCINT(count);
    228322    ADOLC_PUT_LOCINT(root);
    229323    ADOLC_PUT_LOCINT(id);
    230     ADOLC_PUT_LOCINT(op);
     324    ADOLC_PUT_LOCINT(count*process_count);
     325    if( id==root) for(i=0; i < count*process_count;i++)
     326        ADOLC_PUT_LOCINT(recvbuf[i].loc());
     327    ADOLC_PUT_LOCINT(count*process_count);
     328
     329    return ierr;
     330}
     331
     332int ADOLC_MPI_Scatter(
     333    adouble *sendbuf, int sendcount, adouble *recvbuf,
     334    int recvcount, ADOLC_MPI_Datatype type, int root, MPI_Comm comm)
     335{
     336    int i,id, ierr=0;
     337    double *trade_s, *trade_r;
     338
     339    MPI_Comm_rank(MPI_COMM_WORLD, &id);
     340
     341    trade_r = (double*) myalloc1(recvcount);
     342    if (id == root)
     343      trade_s = (double*) myalloc1(sendcount*process_count);
     344    else trade_s = NULL;
     345
     346    if ( id == root){
     347       for(i= 0; i < sendcount*process_count; i++)
     348          trade_s[i] = sendbuf[i].getValue();
     349    }
     350
     351    ierr = MPI_Scatter(trade_s,sendcount,type,trade_r,recvcount,type, root, comm);
     352
     353    if( recvbuf == NULL)
     354       recvbuf = new adouble[recvcount];
     355
     356    for(i=0; i< recvcount;i++)
     357         recvbuf[i].setValue(trade_r[i]);
     358
     359    free(trade_s);
     360    free(trade_r);
     361
     362    put_op(scatter);
     363    ADOLC_PUT_LOCINT(sendcount*process_count);
     364    ADOLC_PUT_LOCINT(root);
     365    ADOLC_PUT_LOCINT(id);
     366    if( id == root ) {
     367      for(i=0; i< sendcount*process_count ;i++)
     368        ADOLC_PUT_LOCINT(sendbuf[i].loc());
     369      ADOLC_PUT_LOCINT(sendcount*process_count);
     370    }
     371    ADOLC_PUT_LOCINT(root);
     372    ADOLC_PUT_LOCINT(id);
     373    ADOLC_PUT_LOCINT(recvcount);
     374    for(i=0; i< recvcount;i++)
     375      ADOLC_PUT_LOCINT(recvbuf[i].loc());
     376    ADOLC_PUT_LOCINT(recvcount);
    231377
    232378    return ierr;
     
    300446          rc = zos_forward_mpi(id,size,tag,1,n,1,x,result);
    301447          if(rc <0){
    302                printf("Failure by computing parallel hessian, process id %d!\n",id);
     448               printf("Failure by computing parallel gradient, process id %d!\n",id);
    303449               return rc;
    304450          }
     
    307453          rc = zos_forward_mpi(id,size,tag,0,0,1,NULL,NULL);
    308454          if(rc <0){
    309                printf("Failure by computing parallel hessian, process id %d!\n",id);
     455               printf("Failure by computing parallel gradient, process id %d!\n",id);
    310456               return rc;
    311457          }
     
    359505        for(i=0;i<n;i++) {
    360506           v[i] = 1;
    361            MINDEC(rc, hess_vec_mpi(id,size,tag, n, x, v, w));
    362         if(rc <0){
    363            printf("Failure by computing parallel hessian, process id %d!\n",id);
    364            free((char *)v);
    365            free((char *) w);
    366            return rc;
     507           rc = hess_vec_mpi(id,size,tag, n, x, v, w);
     508           if(rc <0){
     509             printf("Failure by computing parallel hessian, process id %d!\n",id);
     510             free(v);
     511             free(w);
     512             return rc;
     513           }
     514           for(j=0;j<=i;j++)
     515            result[i][j] = w[j];
     516           v[i] = 0;
    367517        }
    368         for(j=0;j<=i;j++)
    369             result[i][j] = w[j];
    370         v[i] = 0;
    371         }
    372         free((char *)v);
    373         free((char *) w);
     518        free(v);
     519        free(w);
    374520     } else {
    375521        for (i=0; i<n; i++){
     
    462608        rc = fos_forward_mpi(id,size,tag, 0, 0, keep, NULL, lagrange , NULL, NULL);
    463609        if (rc <0){
    464            printf("Failure by computing parallel vec_jac, process id %d!\n",id);
     610           printf("Failure by computing parallel lagra_hess_vec, process id %d!\n",id);
    465611           return rc;
    466612        }
    467613        rc = hos_reverse_mpi(id,size,tag, 0, 0, degree, lagrange, NULL );
    468      }
     614    }
    469615     return rc;
    470616}
  • branches/MPI/ADOL-C/src/adolc_mpi.h

    r252 r273  
    6262extern int mpi_initialized;
    6363extern int process_count;
     64extern int all_root;
    6465
    6566#ifdef __cplusplus
     
    7980    adouble *sendbuf, adouble* rec_buf, int count, ADOLC_MPI_Datatype type,
    8081    ADOLC_MPI_Op op, int root, ADOLC_MPI_Comm comm);
     82
     83ADOLC_DLL_EXPORT int ADOLC_MPI_Gather(
     84    adouble *sendbuf, adouble *recvbuf, int count, ADOLC_MPI_Datatype type,
     85    int root, MPI_Comm comm);
     86
     87ADOLC_DLL_EXPORT int ADOLC_MPI_Scatter(
     88    adouble *sendbuf, int sendcount, adouble *recvbuf,
     89    int recvcount, ADOLC_MPI_Datatype type, int root, MPI_Comm comm);
    8190
    8291ADOLC_DLL_EXPORT int trace_on(int, int, short, int keep = 0);
  • branches/MPI/ADOL-C/src/drivers/taylor.c

    r191 r273  
    397397
    398398/****************************************************************************/
    399 int jac_solv( unsigned short tag, int n, double* x, double* b, unsigned short mode ) {
     399int jac_solv( unsigned short tag, int n, const double* x, double* b, unsigned short mode ) {
    400400    double *y;
    401401    int i, newX = 0;
  • branches/MPI/ADOL-C/src/drivers/taylor.h

    r106 r273  
    7272/* jac_solv(tag,n,x,b,mode) */
    7373ADOLC_DLL_EXPORT int jac_solv
    74 (unsigned short tag, int n, double* x, double* b,
     74(unsigned short tag, int n, const double* x, double* b,
    7575 unsigned short mode);
    7676
  • branches/MPI/ADOL-C/src/fo_rev.c

    r252 r273  
    412412
    413413#if defined(_MPI_)
    414         double *trade, *rec_buf;
    415414        MPI_Status status_MPI;
    416         int mpi_i, id, root, count, loc_recv, loc_send;
     415        int mpi_i,mpi_ii, myid, root, count, count2, *loc_recv, *loc_send;
     416     double *trade, *rec_buf;
     417     int *trade_ulong, *rec_ulong, target, tag,mpi_op,use_reduce=0;
    417418#endif
    418419
     
    520521    if (taycheck < 0) {
    521522        fprintf(DIAG_OUT,"\n ADOL-C error: reverse fails because it was not"
    522                 " preceeded\nby a forward sweep with degree>0, keep=1!\n");
     523                " preceded\nby a forward sweep with degree>0, keep=1!\n");
    523524        exit(-2);
    524525    };
     
    18371838#if defined(_MPI_)
    18381839            case receive_data:  // MPI-Send
    1839                 res = get_locint_r(); // tag
    1840                 arg2 = get_locint_r(); // dest
    1841                 arg1 = get_locint_r(); // count
    1842                 arg = get_locint_r(); // first Buffer
     1840                tag = get_locint_r(); // tag
     1841                target = get_locint_r(); // dest
     1842                count = get_locint_r(); // count
     1843                loc_recv = (int*) malloc(count*sizeof(int));
     1844                for(mpi_i=0;mpi_i<count;mpi_i++)
     1845                    loc_recv[mpi_i] = get_locint_r();
     1846                count2 = get_locint_r(); // count
     1847#if !defined(_NTIGHT_)
     1848                trade = myalloc1(count);
     1849                for(mpi_i=0; mpi_i<count; mpi_i++){
     1850                   trade[mpi_i] = rp_T[loc_recv[mpi_i]];
     1851                   ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
     1852                }
     1853                MPI_Send( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     1854                myfree1(trade);
     1855#endif
     1856#if defined(_INT_REV_)
     1857                trade_ulong = (int*) malloc(count*p* sizeof(int));
     1858                for(mpi_i=0; mpi_i<count; mpi_i++){
     1859                   for(l=0; l<p;l++){
     1860                      trade_ulong[mpi_i*p+l] = upp_A[loc_recv[mpi_i]][l];
     1861                      upp_A[loc_recv[mpi_i]][l]=0;
     1862                   }
     1863                }
     1864                MPI_Send( trade_ulong , count*p, MPI_INT , target, tag , MPI_COMM_WORLD);
     1865                free(trade_ulong);
     1866#endif
    18431867#if defined(_FOS_)
    1844                 trade = (double*) myalloc1(2*arg1);
    1845 
    1846                 for (mpi_i=0; mpi_i< arg1; mpi_i++) {
    1847                     trade[2*mpi_i] = rp_T[arg + mpi_i];
    1848                     trade[2*mpi_i + 1]=rp_A[arg + mpi_i];
    1849                     rp_A[arg + mpi_i]=0;
    1850                     ADOLC_GET_TAYLOR(arg+mpi_i);
     1868                trade = myalloc1(count);
     1869
     1870                for (mpi_i=0; mpi_i< count; mpi_i++) {
     1871                    trade[mpi_i]=rp_A[loc_recv[mpi_i]];
     1872                    rp_A[loc_recv[mpi_i]]=0;
    18511873                   }
    1852                 MPI_Send( trade , arg1*2, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
     1874                MPI_Send( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
    18531875                myfree1(trade);
    18541876#endif /* ALL_TOGETHER_AGAIN */
    18551877#if defined(_FOV_)
    1856                 trade = (double*) myalloc1((1+p)*arg1);
    1857 
    1858                 for (mpi_i=0; mpi_i< arg1; mpi_i++)
    1859                     trade[mpi_i] = rp_T[arg +mpi_i];
    1860 
    1861                 n = arg1;
    1862                 for (mpi_i=0; mpi_i < arg1; mpi_i++){
     1878                trade =  myalloc1(p*count);
     1879
     1880                n = 0;
     1881                for (mpi_i=0; mpi_i < count; mpi_i++){
    18631882                    FOR_0_LE_l_LT_p
    18641883                    {
    1865                         trade[n]=rpp_A[arg+mpi_i][l];
    1866                         rpp_A[arg+mpi_i][l]=0;
     1884                        trade[n]=rpp_A[loc_recv[mpi_i]][l];
     1885                        rpp_A[loc_recv[mpi_i]][l]=0;
    18671886                        n++;
    18681887                    }
    1869                     ADOLC_GET_TAYLOR(arg+mpi_i);
    1870                 }
    1871                 MPI_Send( trade , arg1*(p+1), MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
     1888//                     ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
     1889                }
     1890                MPI_Send( trade , count*p, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
    18721891                myfree1(trade);
    18731892#endif /* ALL_TOGETHER_AGAIN */
     1893                free(loc_recv);
    18741894                break;
    18751895                /*--------------------------------------------------------------------------*/
    18761896            case send_data:     // MPI-Send-Befehl
    1877                 res = get_locint_r(); // tag
    1878                 arg2 = get_locint_r(); // source
    1879                 arg1 = get_locint_r(); // count
    1880                 arg = get_locint_r(); // first Buffer
     1897                tag = get_locint_r(); // tag
     1898                target = get_locint_r(); // source
     1899                count = get_locint_r(); // count
     1900                loc_recv = (int*) malloc(count*sizeof(int));
     1901                for(mpi_i=0;mpi_i<count;mpi_i++)
     1902                     loc_recv[mpi_i] = get_locint_r();
     1903                count2 = get_locint_r();
     1904#if !defined(_NTIGHT_)
     1905                trade = myalloc1(count);
     1906                MPI_Recv( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     1907                for(mpi_i=0; mpi_i<count; mpi_i++){
     1908                   rp_T[loc_recv[mpi_i]] = trade[mpi_i];
     1909                }
     1910                myfree1(trade);
     1911#endif
     1912#if defined(_INT_REV_)
     1913                trade_ulong = (int*) malloc(count*p*sizeof(int));
     1914                MPI_Recv( trade_ulong , count*p, MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
     1915                for(mpi_i=0; mpi_i<count; mpi_i++){
     1916                   for(l=0; l<p;l++){
     1917                      upp_A[loc_recv[mpi_i]][l]+=trade_ulong[mpi_i*p+l];
     1918                   }
     1919                }
     1920                free(trade_ulong);
     1921#endif
    18811922#if defined(_FOS_)
    1882                 trade = (double*) myalloc1(arg1*2);
    1883                 MPI_Recv( trade , 2*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    1884 
    1885                 for (mpi_i=0; mpi_i < arg1; mpi_i++) {
    1886                     rp_T[arg + mpi_i] = trade[2*mpi_i];
    1887                     rp_A[arg + mpi_i] += trade[2*mpi_i + 1];
     1923                trade = myalloc1(count);
     1924                MPI_Recv( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     1925
     1926                for (mpi_i=0; mpi_i < count; mpi_i++) {
     1927                    rp_A[loc_recv[mpi_i]] += trade[mpi_i ];
    18881928                }
    18891929                myfree1(trade);
    18901930#endif
    18911931#if defined(_FOV_)
    1892                 trade = (double*) myalloc1(arg1*(1+p));
    1893                 MPI_Recv( trade , (1+p)*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    1894 
    1895                 for ( mpi_i=0; mpi_i < arg1 ; mpi_i++ )
    1896                     rp_T[arg+mpi_i] = trade[mpi_i];
    1897 
    1898                 n = arg1;
    1899                 for ( mpi_i=0; mpi_i < arg1 ; mpi_i++ )
     1932                trade = myalloc1(count*p);
     1933                MPI_Recv( trade ,p*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     1934
     1935                n = 0;
     1936                for ( mpi_i=0; mpi_i < count ; mpi_i++ )
    19001937                    FOR_0_LE_l_LT_p
    19011938                    {
    1902                         rpp_A[arg+mpi_i][l] += trade[n];
     1939                        rpp_A[loc_recv[mpi_i]][l] += trade[n];
    19031940                        n++;
    19041941                    }
     
    19061943                myfree1(trade);
    19071944#endif
     1945                free(loc_recv);
    19081946                   break;
    19091947                /*--------------------------------------------------------------------------*/
     
    19131951                /*--------------------------------------------------------------------------*/
    19141952            case broadcast:
    1915                 id = get_locint_r(); // process id
     1953                myid = get_locint_r(); // process id
    19161954                root = get_locint_r(); // root
    19171955                count = get_locint_r(); // count
    1918                 loc_recv = get_locint_r(); // Recv Buffer
    1919                 loc_send = get_locint_r(); // Send Buffer
    1920 #if defined(_FOS_)
    1921                 trade = (double*) myalloc1(count*2);
    1922                 if (id == root)
    1923                    rec_buf = (double*) myalloc1(2*count);
     1956                loc_recv = (int*) malloc(count*sizeof(int));
     1957                for(mpi_i=0;mpi_i<count;mpi_i++)
     1958                   loc_recv[mpi_i] = get_locint_r(); // Recv Buffer
     1959                count2 = get_locint_r(); // count
     1960#if !defined(_NTIGHT_)
     1961                trade = myalloc1(count);
     1962                if (myid == root)
     1963                   rec_buf = myalloc1(count*process_count);
    19241964                else
    19251965                   rec_buf = NULL;
    19261966                for (mpi_i=0; mpi_i < count; mpi_i++) {
    1927                     trade[2*mpi_i] = rp_T[loc_send + mpi_i] ;
    1928                     trade[2*mpi_i+1] = rp_A[loc_send + mpi_i];
    1929                     rp_A[loc_send + mpi_i]=0;
    1930                     if (id != root)
    1931                        ADOLC_GET_TAYLOR(loc_send+mpi_i);
    1932                 }
    1933                 MPI_Reduce( trade , rec_buf ,2*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
    1934                 if (id == root){
     1967                    trade[mpi_i] = rp_T[loc_recv[mpi_i]] ;
     1968                       ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
     1969                }
     1970                MPI_Gather( trade, count, MPI_DOUBLE, rec_buf ,count, MPI_DOUBLE, root, MPI_COMM_WORLD);
     1971                if (myid == root){
    19351972                   for (mpi_i=0; mpi_i < count; mpi_i++) {
    1936                        rp_T[loc_send + mpi_i] = rec_buf[2*mpi_i];
    1937                        rp_A[loc_send + mpi_i] += rec_buf[2*mpi_i + 1];
     1973                       rp_T[loc_recv[mpi_i]] = rec_buf[(process_count-1)*count+mpi_i];
    19381974                   }
    19391975                   myfree1(rec_buf);
     
    19411977                myfree1(trade);
    19421978#endif
    1943 #if defined(_FOV_)
    1944                 trade = (double*) myalloc1(count*(1+p));
    1945                 if (id==root)
    1946                    rec_buf = (double*) myalloc1((1+p)*count);
     1979#if defined(_INT_REV_)
     1980                trade_ulong = (int*) malloc(count*p*sizeof(int));
     1981                if (myid == root)
     1982                   rec_ulong = (int*) malloc(count*p*process_count*sizeof(int));
     1983                else
     1984                   rec_ulong = NULL;
     1985                for (mpi_i=0; mpi_i < count; mpi_i++) {
     1986                    FOR_0_LE_l_LT_p{
     1987                       trade_ulong[p*mpi_i+l] = upp_A[loc_recv[mpi_i]][l];
     1988                       upp_A[loc_recv[mpi_i]][l]=0;
     1989                    }
     1990                }
     1991                MPI_Reduce( trade_ulong , rec_ulong ,p*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
     1992                if (myid == root){
     1993                   for (mpi_i=0; mpi_i < count; mpi_i++) {
     1994                        FOR_0_LE_l_LT_p
     1995                          upp_A[loc_recv[mpi_i]][l] += rec_ulong[p*mpi_i +l];
     1996                   }
     1997                   free(rec_ulong);
     1998                }
     1999                free(trade_ulong);
     2000#endif
     2001#if defined(_FOS_)
     2002                trade = myalloc1(count);
     2003                if (myid == root)
     2004                   rec_buf = myalloc1(count);
    19472005                else
    19482006                   rec_buf = NULL;
    19492007                for (mpi_i=0; mpi_i < count; mpi_i++) {
    1950                     trade[(p+1)*mpi_i] = rp_T[loc_send + mpi_i];
    1951                     FOR_0_LE_l_LT_p{
    1952                        trade[(p+1)*mpi_i+1+l] = rpp_A[loc_send + mpi_i][l];
    1953                        rpp_A[loc_send + mpi_i][l] = 0;
    1954                     }
    1955                     if(id != root)
    1956                         ADOLC_GET_TAYLOR(loc_send+mpi_i);
    1957                 }
    1958                 MPI_Reduce( trade , rec_buf ,(1+p)*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
    1959                 if (id == root){
     2008                    trade[mpi_i] = rp_A[loc_recv[mpi_i]];
     2009                    rp_A[loc_recv[mpi_i]]=0;
     2010                }
     2011                MPI_Reduce( trade , rec_buf ,count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
     2012                if (myid == root){
    19602013                   for (mpi_i=0; mpi_i < count; mpi_i++) {
    1961                        rp_T[loc_send + mpi_i] = rec_buf[(p+1)*mpi_i];
    1962                        FOR_0_LE_l_LT_p
    1963                           rpp_A[loc_send + mpi_i][l] = rec_buf[(p+1)*mpi_i + 1+l];
     2014                       rp_A[loc_recv[mpi_i]] += rec_buf[mpi_i];
    19642015                   }
    19652016                   myfree1(rec_buf);
     
    19672018                myfree1(trade);
    19682019#endif
     2020#if defined(_FOV_)
     2021                trade = myalloc1(count*p);
     2022                if (myid==root)
     2023                   rec_buf = myalloc1(p*count);
     2024                else
     2025                   rec_buf = NULL;
     2026                n=0;
     2027                for (mpi_i=0; mpi_i < count; mpi_i++){
     2028                    FOR_0_LE_l_LT_p{
     2029                       trade[n] = rpp_A[loc_recv[mpi_i]][l];
     2030                       rpp_A[loc_recv[mpi_i]][l] = 0;
     2031                       n++;
     2032                    }
     2033                }
     2034                MPI_Reduce( trade , rec_buf ,p*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
     2035                if (myid == root){
     2036                  for(mpi_i=0;mpi_i<count;mpi_i++)
     2037                    rp_T[loc_recv[mpi_i]] = rec_buf[mpi_i];
     2038                  n=0;
     2039                  for (mpi_i=0; mpi_i < count; mpi_i++){
     2040                       FOR_0_LE_l_LT_p{
     2041                          rpp_A[loc_recv[mpi_i]][l] += rec_buf[n];
     2042                          n++;
     2043                       }
     2044                   }
     2045                   myfree1(rec_buf);
     2046                }
     2047                myfree1(trade);
     2048#endif
     2049                free(loc_recv);
    19692050                break;
    19702051            case reduce:
    1971                 arg = get_locint_r(); // Operation
    1972                 id = get_locint_r(); // process id
     2052                 use_reduce=1;
     2053            case gather:
     2054                if(use_reduce==1) mpi_op = get_locint_r();
     2055                if(all_root == mpi_id){
     2056                   count2 = get_locint_r(); // count*process_count
     2057                   loc_recv = (int*) malloc (count2*sizeof(int));
     2058                   /* Must use an additional value to send the right locints back */
     2059                   if (use_reduce==1){
     2060                         if (mpi_op == ADOLC_MPI_SUM){
     2061                            for(mpi_i=0;mpi_i<count2;mpi_i++)
     2062                               loc_recv[mpi_i] = get_locint_r(); // Receive Buffer
     2063                         } else {
     2064                            for(mpi_i=0;mpi_i<count2;mpi_i++)
     2065                               loc_recv[count2-1-mpi_i] = get_locint_r(); // Receive Buffer
     2066                         }
     2067                    }
     2068                }
     2069                count2 = get_locint_r(); // count*process_count
     2070                myid = get_locint_r(); // process id
    19732071                root = get_locint_r(); // root
    19742072                count = get_locint_r(); // count
    1975                 loc_recv = get_locint_r(); // Receive Buffer
    1976                 loc_send = get_locint_r(); // Send Buffer
     2073                loc_send = (int*) calloc(count,sizeof(int));
     2074                if (use_reduce==1){
     2075                   if (mpi_op == ADOLC_MPI_SUM){
     2076                      for(mpi_i=0;mpi_i<count;mpi_i++)
     2077                         loc_send[mpi_i] = get_locint_r(); // Send Buffer
     2078                   } else {
     2079                      for(mpi_i=0;mpi_i<count;mpi_i++)
     2080                         loc_send[count-1-mpi_i] = get_locint_r(); // Send Buffer
     2081                   }
     2082                }
     2083                for(mpi_i=0;mpi_i<count;mpi_i++)
     2084                   loc_send[mpi_i] = get_locint_r(); // Send Buffer
     2085                arg = get_locint_r(); // count
     2086#if !defined(_NTIGHT_)
     2087               trade = myalloc1(count);
     2088               rec_buf = NULL;
     2089               if(myid == root){
     2090                   rec_buf = myalloc1(count2);
     2091                   for (mpi_i=0; mpi_i < count2; mpi_i++)
     2092                       rec_buf[mpi_i] = rp_T[loc_recv[mpi_i]];
     2093                   for (mpi_i=0; mpi_i < count2; mpi_i++)
     2094                       ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
     2095               }
     2096               MPI_Scatter(rec_buf,count,MPI_DOUBLE,trade,count,MPI_DOUBLE, root,MPI_COMM_WORLD);
     2097
     2098               for (mpi_i=0; mpi_i < count; mpi_i++) {
     2099                 rp_T[loc_send[mpi_i]] = trade[mpi_i];
     2100               }
     2101               if(myid == root) myfree1(rec_buf);
     2102               myfree1(trade);
     2103#endif
     2104#if defined(_INT_REV_)
     2105               trade_ulong = (int*) malloc(count*p*sizeof(int));
     2106               rec_ulong = NULL;
     2107               if(myid == root){
     2108                  rec_ulong = (int*) malloc(count2*p*sizeof(int));
     2109                  for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2110                     FOR_0_LE_l_LT_p{
     2111                       rec_ulong[p*mpi_i+l] = upp_A[loc_recv[mpi_i]][l];
     2112                       upp_A[loc_recv[mpi_i]][l]=0;
     2113                     }
     2114                  }
     2115               }
     2116               MPI_Scatter(rec_ulong,count*p,MPI_DOUBLE,trade_ulong,count*p,MPI_DOUBLE, root,MPI_COMM_WORLD);
     2117
     2118               for (mpi_i=0; mpi_i < count; mpi_i++) {
     2119                  FOR_0_LE_l_LT_p
     2120                    upp_A[loc_send[mpi_i]][l] += trade_ulong[p*mpi_i+l];
     2121                }
     2122                if(myid == root) free(rec_ulong);
     2123                free(trade_ulong);
     2124#endif
    19772125#if defined(_FOS_)
    1978                 trade = (double*) myalloc1(count*2);
    1979 
    1980                if(id == root)
     2126                trade = myalloc1(count);
     2127                rec_buf = NULL;
     2128                if(myid == root){
     2129                    rec_buf = myalloc1(count2);
     2130                    for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2131                       rec_buf[mpi_i] = rp_A[loc_recv[mpi_i]];
     2132                       rp_A[loc_recv[mpi_i]]=0;
     2133                    }
     2134                }
     2135                MPI_Scatter(rec_buf,count,MPI_DOUBLE,trade,count,MPI_DOUBLE, root,MPI_COMM_WORLD);
     2136
    19812137                for (mpi_i=0; mpi_i < count; mpi_i++) {
    1982                     trade[2*mpi_i] = rp_T[loc_send + mpi_i] ;
    1983                     trade[2*mpi_i+1] = rp_A[loc_send + mpi_i];
    1984                     rp_A[loc_send + mpi_i]=0;
    1985                     ADOLC_GET_TAYLOR(loc_send+mpi_i);
    1986                 }
    1987                 MPI_Bcast( trade ,2*count, MPI_DOUBLE , root, MPI_COMM_WORLD);
    1988                 for (mpi_i=0; mpi_i < count; mpi_i++) {
    1989                     rp_T[loc_recv + mpi_i] = trade[2*mpi_i];
    1990                     rp_A[loc_recv + mpi_i] += trade[2*mpi_i + 1];
    1991                 }
     2138                    rp_A[loc_send[mpi_i]] += trade[mpi_i];
     2139                }
     2140                if(myid == root) myfree1(rec_buf);
    19922141                myfree1(trade);
    19932142#endif
    19942143#if defined(_FOV_)
    1995                 trade = (double*) myalloc1(count*(1+p));
    1996                 if (id == root){
     2144                trade = myalloc1(count*p);
     2145                rec_buf = NULL;
     2146                if(myid == root){
     2147                    rec_buf = myalloc1(count2*p);
     2148                    n= 0;
     2149                    for (mpi_i=0; mpi_i < count2; mpi_i++){
     2150                       FOR_0_LE_l_LT_p {
     2151                         rec_buf[n] = rpp_A[loc_recv[mpi_i]][l];
     2152                         rpp_A[loc_recv[mpi_i]][l]=0;
     2153                         n++;
     2154                       }
     2155                    }
     2156                }
     2157                MPI_Scatter(rec_buf,count*p,MPI_DOUBLE,trade,count*p,MPI_DOUBLE, root,MPI_COMM_WORLD);
     2158
     2159                n=0;
     2160                for (mpi_i=0; mpi_i < count; mpi_i++){
     2161                    FOR_0_LE_l_LT_p{
     2162                       rpp_A[loc_send[mpi_i]][l] += trade[n];
     2163                       n++;
     2164                    }
     2165                }
     2166                if(myid == root) myfree1(rec_buf);
     2167                myfree1(trade);
     2168#endif
     2169                if(myid == root ) free(loc_recv);
     2170                free(loc_send);
     2171                use_reduce=0;
     2172                break;
     2173                /*--------------------------------------------------------------------------*/
     2174            case scatter:
     2175               count2 = get_locint_r(); // recvcount (count)
     2176               loc_recv = (int*) malloc(count2*sizeof(int));
     2177               for(mpi_i=0;mpi_i<count2;mpi_i++)
     2178                 loc_recv[count2-1-mpi_i] = get_locint_r(); // recv Buffer
     2179               arg = get_locint_r(); // recvcount (count)
     2180               myid = get_locint_r(); // process id
     2181               root = get_locint_r(); // root
     2182               if(myid==root){
     2183                  count = get_locint_r(); // sendcount (count*process_count)
     2184                  loc_send = (int*) malloc(count*sizeof(int));
     2185                  for(mpi_i=0;mpi_i<count;mpi_i++)
     2186                     loc_send[count-1-mpi_i]= get_locint_r();
     2187               }
     2188               res = get_locint_r(); // id
     2189               res = get_locint_r(); // root
     2190               res = get_locint_r(); // sendcount (count*process_count)
     2191#if !defined(_NTIGHT_)
     2192               rec_buf = myalloc1(count2);
     2193               trade = NULL;
     2194               if(myid == root)
     2195                   trade = myalloc1(count);
     2196               for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2197                   rec_buf[mpi_i] = rp_T[loc_recv[mpi_i]];
     2198                   ADOLC_GET_TAYLOR(loc_recv[mpi_i]);
     2199                }
     2200
     2201                MPI_Gather(rec_buf , count2, MPI_DOUBLE,trade,count2, MPI_DOUBLE, root, MPI_COMM_WORLD);
     2202
     2203                if(myid == root){
     2204                  for (mpi_i=0; mpi_i < count; mpi_i++) {
     2205                    rp_T[loc_send[mpi_i]] = trade[mpi_i];
     2206                  }
     2207                  myfree1(trade);
     2208                }
     2209                myfree1(rec_buf);
     2210#endif
     2211#if defined(_INT_REV_)
     2212               rec_ulong = (int*) malloc(count2*p*sizeof(int));
     2213               trade_ulong = NULL;
     2214               if(myid == root)
     2215                   trade_ulong = (int*) malloc(count*p*sizeof(int));
     2216
     2217               for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2218                  FOR_0_LE_l_LT_p{
     2219                     rec_ulong[p*mpi_i+l] = upp_A[loc_recv[mpi_i]][l];
     2220                     upp_A[loc_recv[mpi_i]][l]=0;
     2221                     }
     2222                }
     2223
     2224                MPI_Gather(rec_ulong , count2*p, MPI_DOUBLE,trade_ulong,count2*p, MPI_DOUBLE, root, MPI_COMM_WORLD);
     2225
     2226                if(myid == root){
     2227                  for (mpi_i=0; mpi_i < count; mpi_i++) {
     2228                    FOR_0_LE_l_LT_p
     2229                       upp_A[loc_send[mpi_i]][l] += trade_ulong[p*mpi_i+l];
     2230                  }
     2231                  free(trade_ulong);
     2232                }
     2233                free(rec_ulong);
     2234#endif
     2235#if defined(_FOS_)
     2236                rec_buf = myalloc1(count2);
     2237                trade = NULL;
     2238                if(myid == root)
     2239                   trade = myalloc1(count);
     2240
     2241                for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2242                   rec_buf[mpi_i] = rp_A[loc_recv[ mpi_i]];
     2243                   rp_A[loc_recv[mpi_i]]=0;
     2244                }
     2245
     2246                MPI_Gather( rec_buf ,count2, MPI_DOUBLE,trade,count2,MPI_DOUBLE, root, MPI_COMM_WORLD);
     2247                if(myid == root){
    19972248                   for (mpi_i=0; mpi_i < count; mpi_i++) {
    1998                        trade[(p+1)*mpi_i] = rp_T[loc_send + mpi_i];
    1999                        FOR_0_LE_l_LT_p {
    2000                           trade[(p+1)*mpi_i+1+l] = rpp_A[loc_send + mpi_i][l];
    2001                           rpp_A[loc_send + mpi_i][l] = 0;
    2002                        }
    2003                        ADOLC_GET_TAYLOR(loc_send+mpi_i);
     2249                      rp_A[loc_send[mpi_i]] += trade[mpi_i];
    20042250                   }
    2005                 }
    2006                 MPI_Bcast( trade, (1+p)*count, MPI_DOUBLE, root, MPI_COMM_WORLD);
    2007                 for (mpi_i=0; mpi_i < count; mpi_i++) {
    2008                     rp_T[loc_recv + mpi_i] = trade[(p+1)*mpi_i];
    2009                     FOR_0_LE_l_LT_p
    2010                        rpp_A[loc_recv + mpi_i][l] += trade[(p+1)*mpi_i + 1+l];
    2011                     }
    2012                 myfree1(trade);
    2013 #endif
    2014                 break;
    2015                 /*--------------------------------------------------------------------------*/
     2251                   myfree1(trade);
     2252                }
     2253                myfree1(rec_buf);
     2254#endif
     2255#if defined(_FOV_)
     2256               rec_buf = myalloc1(count2*p);
     2257                trade = NULL;
     2258                if(myid == root)
     2259                   trade = myalloc1(count*p);
     2260
     2261                n=0;
     2262                for (mpi_i=0; mpi_i < count2; mpi_i++) {
     2263                   FOR_0_LE_l_LT_p{
     2264                      rec_buf[n] = rpp_A[loc_recv[mpi_i]][l];
     2265                      rpp_A[loc_recv[mpi_i]][l]=0;
     2266                      n++;
     2267                   }
     2268                }
     2269
     2270                MPI_Gather( rec_buf ,p*count2, MPI_DOUBLE,trade,p*count2,MPI_DOUBLE, root, MPI_COMM_WORLD);
     2271                if(myid == root){
     2272                      n=0;
     2273                   for (mpi_i=0; mpi_i < count; mpi_i++)
     2274                      FOR_0_LE_l_LT_p{
     2275                         rpp_A[loc_send[mpi_i]][l] += trade[n];
     2276                         n++;
     2277                      }
     2278                   myfree1(trade);
     2279                }
     2280                myfree1(rec_buf);
     2281#endif
     2282                if(myid == root) free(loc_send);
     2283                free(loc_recv);
     2284                break;
    20162285#endif
    20172286                /*--------------------------------------------------------------------------*/
     
    20312300
    20322301    /* clean up */
    2033 #if !defined(_INT_REV_)
     2302#if !defined(_NTIGHT_)
    20342303    free(rp_T);
    20352304#endif
  • branches/MPI/ADOL-C/src/ho_rev.c

    r252 r273  
    310310                double  **results)   /* matrix of coefficient vectors */
    311311{ int i, j, rc;
     312#if defined(_MPI_)
    312313        double** L = NULL;
    313314        /* if depen==indep==0 then tnum is not main process */
     
    318319            L[i][j] = 0.0;
    319320    }
    320 #if defined(_MPI_)
    321     rc = hos_ti_reverse(mpi_id+mpi_size*tnum,depen,indep,degre,L,results);
     321    rc = hos_ti_reverse_mpi(mpi_id,mpi_size,tnum,depen,indep,degre,L,results);
     322    if((depen!=0) && (indep != 0)) myfree2(L);
    322323#else
     324    double** L = myalloc2(depen,degre+1);
     325    for ( i = 0; i < depen; ++i ) {
     326        L[i][0] = lagrange[i];
     327        for ( j = 1; j <= degre; ++j )
     328            L[i][j] = 0.0;
     329    }
    323330    rc = hos_ti_reverse(tnum,depen,indep,degre,L,results);
    324 #endif
    325         if((depen!=0) && (indep != 0)) myfree2(L);
     331    myfree2(L);
     332#endif
    326333    return rc;
    327334}
    328 
     335#if defined(_MPI_)
     336int hos_ti_reverse_mpi( int mpi_id, int mpi_size,
     337#else
    329338int hos_ti_reverse(
     339#endif
    330340    short   tnum,        /* tape id */
    331341    int     depen,       /* consistency chk on # of deps */
     
    366376                short   **nonzero )  /* structural sparsity  pattern  */
    367377{ int i, j, k, rc;
     378#if defined(_MPI_)
     379    double*** L = NULL;
     380    if(depen>0 && indep>0 ){
     381      L = myalloc3(nrows,depen,degre+1);
     382      for ( k = 0; k < nrows; ++k )
     383        for ( i = 0; i < depen; ++i ) {
     384          L[k][i][0] = lagrange[k][i];
     385            for ( j = 1; j <= degre; ++j )
     386              L[k][i][j] = 0.0;
     387        }
     388    }
     389    rc = hov_ti_reverse_mpi(mpi_id,mpi_size,tnum ,depen,indep,degre,nrows,L,results,nonzero);
     390    if(depen>0 && indep>0 ) myfree3(L);
     391#else
    368392    double*** L = myalloc3(nrows,depen,degre+1);
    369     for ( k = 0; k < nrows; ++k )
     393      for ( k = 0; k < nrows; ++k )
    370394        for ( i = 0; i < depen; ++i ) {
    371             L[k][i][0] = lagrange[k][i];
     395          L[k][i][0] = lagrange[k][i];
    372396            for ( j = 1; j <= degre; ++j )
    373                 L[k][i][j] = 0.0;
     397              L[k][i][j] = 0.0;
    374398        }
    375 #if defined(_MPI_)
    376     rc = hov_ti_reverse(mpi_size*tnum + mpi_id,depen,indep,degre,nrows,L,results,nonzero);
    377 #else
    378399    rc = hov_ti_reverse(tnum,depen,indep,degre,nrows,L,results,nonzero);
    379 #endif
    380400    myfree3(L);
     401#endif
    381402    return rc;
    382403}
    383404
     405#if defined(_MPI_)
     406int hov_ti_reverse_mpi( int mpi_id, int mpi_size,
     407#else
    384408int hov_ti_reverse(
     409#endif
    385410    short   tnum,        /* tape id */
    386411    int     depen,       /* consistency chk on # of deps */
     
    400425    int dc, ret_c=3;
    401426
     427#if defined(_MPI_)
     428     tnum = mpi_id + mpi_size*tnum;
     429#endif
    402430    locint size = 0;
    403431    locint res  = 0;
     
    585613    if(taycheck != degre) {
    586614        fprintf(DIAG_OUT,"\n ADOL-C error: reverse fails because it was not"
    587                 " preceeded\nby a forward sweep with degree>%i,"
     615                " preceded\nby a forward sweep with degree>%i,"
    588616                " keep=%i!\n",degre,degre+1);
    589617        exit(-2);
     
    620648        MPI_Status status_MPI;
    621649        double *trade, *rec_buf;
    622         int mpi_i, id, root, count, loc_recv, loc_send;
     650        int mpi_i, myid, root, count,count2, *loc_recv, *loc_send;
     651     int target, tag, use_reduce=0;
    623652     ADOLC_MPI_Op mpi_op;
    624653#endif /* is used by Parallelisation */
     
    21212150#if defined(_MPI_)
    21222151               case receive_data:       // MPI-Send
    2123                    res  = get_locint_r(); // tag
    2124                    arg2 = get_locint_r(); // dest
    2125                 arg1 = get_locint_r(); // count
    2126                       arg  = get_locint_r(); // first Buffer
     2152                   tag  = get_locint_r(); // tag
     2153                   target = get_locint_r(); // dest
     2154                count = get_locint_r(); // count
     2155                loc_recv = (int*) malloc(count*sizeof(int));
     2156                for(mpi_i=0;mpi_i<count;mpi_i++)
     2157                 loc_recv[mpi_i]  = get_locint_r(); // first Buffer
     2158                count2 = get_locint_r(); // count
     2159
     2160                trade = myalloc1(k*count);
     2161                /* writing Taylor- and Adjointbuffer in one double array */
     2162                for (mpi_i=0; mpi_i< count ;mpi_i++){
     2163                    FOR_0_LE_l_LT_pk
     2164                         trade[mpi_i*k + l] = rpp_T[loc_recv[mpi_i]][l];
     2165                   GET_TAYL(loc_recv[mpi_i],k,p);
     2166                }
     2167
     2168               MPI_Send(trade,k*count,MPI_DOUBLE,target,tag,MPI_COMM_WORLD);
     2169               myfree1(trade);
    21272170
    21282171#if defined(_HOS_)
    2129                 trade = (double*) myalloc1((k+k1)*arg1);
     2172               count2 = k1;
     2173#endif
     2174#if defined(_HOV_)
     2175               count2 = pk1;
     2176#endif
     2177               trade = myalloc1(count2*count);
     2178               for (mpi_i=0; mpi_i< count ;mpi_i++)
     2179                 for (l=0; l< count2 ;l++){
     2180                   trade[mpi_i*count2 + l] = rpp_A[loc_recv[mpi_i]][l];
     2181                   rpp_A[mpi_i][l] = 0;
     2182                   }
     2183         /* loading saved Values of Adjoint- and Taylorbuffer */
     2184               MPI_Send(trade,count2*count,MPI_DOUBLE,target,tag,MPI_COMM_WORLD);
     2185               myfree1(trade);
     2186
     2187               free(loc_recv);
     2188                break;
     2189
     2190                /*--------------------------------------------------------------------------*/
     2191            case send_data:     // MPI-Send-Befehl
     2192               tag = get_locint_r(); // tag
     2193                target = get_locint_r(); // source
     2194                count = get_locint_r(); // count
     2195                loc_recv = (int*) malloc(count*sizeof(int));
     2196                for(mpi_i=0;mpi_i<count;mpi_i++)
     2197                     loc_recv[mpi_i] = get_locint_r();
     2198                count2 = get_locint_r();
     2199
     2200                trade = myalloc1(k*count);
    21302201                /* writing Taylor- and Adjointbuffer in one double array */
    2131 
    2132                 for (mpi_i=0 , i = arg; mpi_i< arg1 ;mpi_i++, i++){
     2202                MPI_Recv( trade , k*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     2203
     2204                for (mpi_i=0; mpi_i< count ;mpi_i++)
    21332205                    FOR_0_LE_l_LT_pk
    2134                          trade[mpi_i*(k+k1) + l] = rpp_T[i][l];
    2135 
    2136                     FOR_0_LE_l_LT_pk1 {
    2137                          trade[mpi_i*(k+k1) + k + l] = rpp_A[i][l];
    2138                          rpp_A[i][l] = 0;
    2139                     }
    2140                 }
    2141 
    2142                MPI_Send(trade,(k+k1)*arg1,MPI_DOUBLE,arg2,res,MPI_COMM_WORLD);
     2206                         rpp_T[loc_recv[mpi_i]][l] = trade[mpi_i*k + l];
     2207
    21432208               myfree1(trade);
    2144 
    2145          /* loading saved Values of Adjoint- and Taylorbuffer */
    2146                 for (mpi_i=0; mpi_i<arg1; mpi_i++)
    2147                     GET_TAYL(arg+mpi_i,k,p);
     2209#if defined(_HOS_)
     2210               count2 = k1;
    21482211#endif
    21492212#if defined(_HOV_)
    2150                 trade = (double*) myalloc1((k+pk1)*arg1);
    2151                 /* writing Taylor- and Adjointbuffer in one double array */
    2152                 l= 0;
    2153                 for (mpi_i=0; mpi_i< arg1;mpi_i++)
    2154                     for (i=0; i < k ; i++ )
    2155                         trade[mpi_i*k+i] = rpp_T[arg+mpi_i][i];
    2156 
    2157                 l =  arg1*k;
    2158                 for (mpi_i=0; mpi_i< arg1;mpi_i++){
    2159                     for (i=0; i < pk1 ; i++){
    2160                         trade[l + i] = rpp_A[arg+mpi_i][i];
    2161                         rpp_A[arg+mpi_i][i] =0;
    2162                     }
    2163                     l += pk1;
    2164                 }
    2165 
    2166                /* loading saved Values of Adjoint- and Taylorbuffer */
    2167                for (mpi_i=0; mpi_i<arg1; mpi_i++)
    2168                    GET_TAYL(arg+mpi_i,k,p)
    2169 
    2170                 MPI_Send(trade,(k+pk1)*arg1,MPI_DOUBLE,arg2,res,MPI_COMM_WORLD);
    2171                 myfree1(trade);
    2172 #endif
    2173                 break;
    2174 
    2175                 /*--------------------------------------------------------------------------*/
    2176             case send_data:     // MPI-Send-Befehl
    2177                    res = get_locint_r(); // tag
    2178                       arg2 = get_locint_r(); // source
    2179                       arg1 = get_locint_r(); // count
    2180                       arg = get_locint_r(); // first Buffer
    2181 #if defined(_HOS_)
    2182                 trade = (double*) myalloc1(arg1*(k+k1));
    2183                 MPI_Recv( trade , (k+k1)*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    2184 
    2185                 for (mpi_i=0 , i = arg; mpi_i< arg1 ;mpi_i++, i++){
    2186                     FOR_0_LE_l_LT_pk
    2187                          rpp_T[i][l] = trade[mpi_i*(k+k1) + l];
    2188 
    2189                     FOR_0_LE_l_LT_pk1 {
    2190                          rpp_A[i][l] += trade[mpi_i*(k+k1) + k + l] ;
    2191                     }
    2192                 }
    2193 
    2194                    myfree1(trade);
    2195 #endif
    2196 #if defined(_HOV_)
    2197                 trade = (double*) myalloc1(arg1*(k+pk1));
    2198                 MPI_Recv( trade , (k+pk1)*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    2199 
    2200                 for (mpi_i=0; mpi_i<arg1; mpi_i++)
    2201                     for (i=0; i < k ; i++ )
    2202                         rpp_T[arg+mpi_i][i] = trade[mpi_i*k +i];
    2203 
    2204                 l= arg1*k;
    2205                 for (mpi_i=0; mpi_i<arg1; mpi_i++ )
    2206                     for (i=0; i < pk1 ; i++){
    2207                         rpp_A[arg+mpi_i][i] += trade[l];
     2213               count2 = pk1;
     2214#endif
     2215               trade = myalloc1(count2*count);
     2216
     2217               MPI_Recv( trade , count2*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     2218               l=0;
     2219                for (mpi_i=0; mpi_i<count; mpi_i++)
     2220                    for (i=0; i < count2 ; i++){
     2221                        rpp_A[loc_recv[mpi_i]][i] += trade[l];
    22082222                        l++;
    22092223                    }
    2210 
    22112224                myfree1(trade);
    2212 #endif
     2225
     2226                free(loc_recv);
    22132227                   break;
    22142228
     
    22182232                break;
    22192233            case broadcast:
    2220                 id = get_locint_r(); // process id
     2234                myid = get_locint_r(); // process id
    22212235                root = get_locint_r(); // root
    22222236                count = get_locint_r(); // count
    2223                 loc_recv = get_locint_r();
    2224                 loc_send = get_locint_r(); // first Buffer
    2225 #if defined(_HOS_)
    2226                 trade = (double*) myalloc1(count*(k+k1));
    2227                 for (mpi_i=0, i = loc_send; mpi_i< count; mpi_i++, i++){
    2228                     for( l=0; l < k ; l++)
    2229                         trade[mpi_i*(k+k1) +l] = rpp_T[i][l];
    2230                     for( l=0; l < k1 ; l++) {
    2231                       trade[mpi_i*(k+k1) + k + l] = rpp_A[i][l];
    2232                         rpp_A[i][l] = 0;
    2233                     }
    2234                 }
    2235             /* loading saved Values of Adjoint- and Taylorbuffer */
    2236                 if (id == root) {
    2237                    rec_buf = myalloc1(count*(k+k1));
     2237                loc_recv = (int*) malloc(count*sizeof(int));
     2238                for(mpi_i=0;mpi_i<count;mpi_i++)
     2239                   loc_recv[count-1-mpi_i] = get_locint_r();
     2240                count2 = get_locint_r();
     2241
     2242                trade = myalloc1(count*k);
     2243                if (myid == root) {
     2244                   rec_buf = myalloc1(count*k*process_count);
    22382245                }else{
    22392246                   rec_buf = NULL;
    22402247                }
    2241                 for(mpi_i=0; mpi_i<count; mpi_i++)
    2242                    GET_TAYL(loc_send+mpi_i,k,p);
    2243 
    2244 //                 MPI_Gather(trade,count*(k+k1),MPI_DOUBLE,rec_buf, count*(k+k1), MPI_DOUBLE, root, MPI_COMM_WORLD);
    2245                 MPI_Reduce( trade , rec_buf ,(k+k1)*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
     2248                for (mpi_i=0; mpi_i< count; mpi_i++){
     2249                    for( l=0; l < k ; l++)
     2250                        trade[mpi_i*k +l] = rpp_T[loc_recv[mpi_i]][l];
     2251                }
     2252            /* loading saved Values of Adjoint- and Taylorbuffer */
     2253                for(mpi_i=0; mpi_i<count; mpi_i++){
     2254                   GET_TAYL(loc_recv[mpi_i],k,p);
     2255                }
     2256                MPI_Gather(trade,k*count, MPI_DOUBLE, rec_buf, k*count, MPI_DOUBLE, root, MPI_COMM_WORLD);
    22462257                myfree1(trade);
    2247                 if (id == root){
    2248                    for(j=1; j < process_count ; j++){
    2249                       for(mpi_i=0 ; mpi_i< count ;mpi_i++){
    2250                          for( l=0; l < k ; l++){
    2251                             rpp_T[loc_send+mpi_i][l] = rec_buf[i];
     2258                if (myid == root){
     2259                   i = 0;
     2260                   for(count2=0; count2 < process_count; count2++ )
     2261                   for(mpi_i=0 ; mpi_i< count ;mpi_i++){
     2262                       for( l=0; l < k ; l++){
     2263                            rpp_T[loc_recv[mpi_i]][l] = rec_buf[i];
    22522264                            i++;
    22532265                         }
    2254                          for( l=0; l < k1 ; l++){
    2255                             rpp_A[loc_send+mpi_i][l] = rec_buf[i];
    2256                             i++;
    2257                          }
     2266                   }
     2267                   myfree1(rec_buf);
     2268                }
     2269#if defined(_HOS_)
     2270               count2 = k1;
     2271#endif
     2272#if defined(_HOV_)
     2273               count2 = pk1;
     2274#endif
     2275                trade = myalloc1(count*count2);
     2276
     2277                for (mpi_i=0 ; mpi_i< count ;mpi_i++)
     2278                    for( l=0; l < count2 ; l++){
     2279                         trade[mpi_i*count2 +l] = rpp_A[loc_recv[mpi_i]][l];
     2280                          rpp_A[loc_recv[mpi_i]][l] = 0;
     2281                    }
     2282                if (myid == root)
     2283                   rec_buf = myalloc1(count*count2);
     2284                else rec_buf = NULL;
     2285
     2286                MPI_Reduce( trade , rec_buf ,count2*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
     2287                myfree1(trade);
     2288                if (myid == root){
     2289                   for (mpi_i=0; mpi_i< count ;mpi_i++){
     2290                       for( l=0; l < count2 ; l++)
     2291                            rpp_A[loc_recv[mpi_i]][l] += rec_buf[mpi_i*count2 + l];
     2292                   }
     2293                   myfree1(rec_buf);
     2294                }
     2295                free(loc_recv);
     2296                break;
     2297                /*--------------------------------------------------------------------------*/
     2298
     2299            case reduce:
     2300                use_reduce=1;
     2301            case gather:
     2302               if(use_reduce==1) mpi_op=get_locint_r();
     2303               if(all_root == mpi_id){
     2304                   count2 = get_locint_r(); // count*process_count
     2305                   loc_recv = (int*) malloc (count2*sizeof(int));
     2306                   if (use_reduce==1){
     2307                      if (mpi_op == ADOLC_MPI_SUM){
     2308                         for(mpi_i=0;mpi_i<count2;mpi_i++)
     2309                            loc_recv[mpi_i] = get_locint_r(); // Send Buffer
     2310                      } else {
     2311                         for(mpi_i=0;mpi_i<count2;mpi_i++)
     2312                            loc_recv[count2-1-mpi_i] = get_locint_r(); // Send Buffer
    22582313                      }
    22592314                   }
    2260                    myfree1(rec_buf);
    2261                 }
    2262 #endif
    2263 #if defined(_HOV_)
    2264                 trade = (double*) myalloc1(count*(k+pk1));
    2265 
    2266                 for (mpi_i=0 , i = loc_send; mpi_i< count ;mpi_i++, i++){
    2267                     for( l=0; l < k ; l++)
    2268                          trade[mpi_i*(k+pk1) +l] = rpp_T[i][l];
    2269 
    2270                     for( l=0; l < pk1 ; l++) {
    2271                          trade[mpi_i*(k+pk1) + k + l] = rpp_A[i][l];
    2272 //                          rpp_A[i][l] = 0;
    2273                     }
    2274                 }
    2275          /* loading saved Values of Adjoint- and Taylorbuffer */
    2276 //                 for (mpi_i=0; mpi_i<count; mpi_i++)
    2277 //                     GET_TAYL(loc_recv+mpi_i,k,p);
    2278 
    2279                 if (id == root)
    2280                    rec_buf = myalloc1(count*(k+pk1));
    2281                 else rec_buf = NULL;
    2282 
    2283                 MPI_Reduce( trade , rec_buf ,(k+pk1)*count, MPI_DOUBLE , MPI_SUM , root, MPI_COMM_WORLD);
    2284                 myfree1(trade);
    2285                 if (id == root){
    2286                    for (mpi_i=0 , i = loc_send; mpi_i< count ;mpi_i++, i++){
    2287                        for( l=0; l < k ; l++)
    2288                             rpp_T[i+mpi_i][l] = rec_buf[mpi_i*(k+pk1) +l];
    2289                        for( l=0; l < pk1 ; l++)
    2290                             rpp_A[i+mpi_i][l] = rec_buf[mpi_i*(k+pk1) + k + l];
    2291                    }
    2292                    myfree1(rec_buf);
    2293                 }
    2294 #endif
    2295                 break;
    2296 
    2297             case reduce:
    2298                 mpi_op = get_locint_r(); // Operation
    2299                 id = get_locint_r(); // process id
     2315                }
     2316                res = get_locint_r(); // count*process_count
     2317                myid = get_locint_r(); // process id
    23002318                root = get_locint_r(); // root
    23012319                count = get_locint_r(); // count
    2302                 loc_recv = get_locint_r(); // first Buffer
    2303 #if defined(_HOS_)
    2304 
    2305                 trade = (double*) myalloc1(count*(k+k1));
    2306                 if (id == root){
     2320                loc_send = (int*) malloc(count*sizeof(int));
     2321                   /* Must use an additional value to send the right locints back */
     2322                if (use_reduce==1){
     2323                   if (mpi_op == ADOLC_MPI_SUM){
     2324                      for(mpi_i=0;mpi_i<count;mpi_i++)
     2325                         loc_send[mpi_i] = get_locint_r(); // Send Buffer
     2326                   } else {
     2327                      for(mpi_i=0;mpi_i<count;mpi_i++)
     2328                         loc_send[count-1-mpi_i] = get_locint_r(); // Send Buffer
     2329                   }
     2330                }
     2331                arg = get_locint_r(); // count
     2332                trade = myalloc1(count*k);
     2333                rec_buf = NULL;
     2334                if(myid == root ){
     2335                   rec_buf = myalloc1(count2*k);
    23072336                   i=0;
    2308                    for (mpi_i=0 ; mpi_i< count ;mpi_i++ ){
     2337                   for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ ){
    23092338                      for( l=0; l < k ; l++){
    2310                          trade[i] = rpp_T[mpi_i+loc_recv][l];
     2339                         rec_buf[i] = rpp_T[loc_recv[mpi_i]][l];
    23112340                         i++;
    23122341                      }
    2313                       for( l=0; l < k1 ;l++) {
    2314                          trade[i] = rpp_A[mpi_i+loc_recv][l];
    2315                          rpp_A[mpi_i+loc_recv][l] = 0;
     2342                      GET_TAYL(loc_recv[mpi_i],k,p);
     2343                   }
     2344                }
     2345                MPI_Scatter(rec_buf,k*count, MPI_DOUBLE , trade, count*k,MPI_DOUBLE, root, MPI_COMM_WORLD);
     2346                i=0;
     2347                for (mpi_i=0; mpi_i< count ;mpi_i++)
     2348                    for( l=0; l < k ; l++,i++)
     2349                       rpp_T[loc_send[mpi_i]][l] = trade[i];
     2350                if(myid==root) myfree1(rec_buf);
     2351                myfree1(trade);
     2352#if defined(_HOS_)
     2353               arg = k1;
     2354#endif
     2355#if defined(_HOV_)
     2356               arg = pk1;
     2357#endif
     2358              trade = myalloc1(count*arg);
     2359                rec_buf = NULL;
     2360                if(myid == root ){
     2361                   rec_buf = myalloc1(count2*arg);
     2362                   i=0;
     2363                   for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ ){
     2364                      for( l=0; l < arg ; l++){
     2365                         rec_buf[i] = rpp_A[loc_recv[mpi_i]][l];
     2366                         rpp_A[loc_recv[mpi_i]][l] = 0;
    23162367                         i++;
    23172368                      }
    2318                       GET_TAYL(loc_recv+mpi_i,k,p);
    23192369                   }
    23202370                }
    2321                 MPI_Bcast( trade ,(k+k1)*count, MPI_DOUBLE , root, MPI_COMM_WORLD);
    2322 
    2323                 if ( !(id == root )){
     2371                MPI_Scatter(rec_buf,arg*count, MPI_DOUBLE , trade, count*arg,MPI_DOUBLE, root, MPI_COMM_WORLD);
     2372                i=0;
     2373                for (mpi_i=0; mpi_i< count ;mpi_i++)
     2374                    for( l=0; l < arg ; l++,i++)
     2375                       rpp_A[loc_send[mpi_i]][l] += trade[i];
     2376
     2377                if(myid==root) myfree1(rec_buf);
     2378                myfree1(trade);
     2379
     2380                use_reduce=0;
     2381                if(myid==root) free(loc_recv);
     2382                free(loc_send);
     2383                break;
     2384           /*--------------------------------------------------------------------------*/
     2385           case scatter:
     2386                count2 = get_locint_r(); // recvcount (count)
     2387                loc_recv = (int*) malloc(count2*sizeof(int));
     2388                for(mpi_i=0; mpi_i < count2 ; mpi_i++)
     2389                  loc_recv[count2-1-mpi_i] = get_locint_r(); // recv Buffer
     2390                res = get_locint_r(); // recvcount (count)
     2391                myid = get_locint_r(); // process id
     2392                root = get_locint_r(); // root
     2393                if(myid==root){
     2394                   count = get_locint_r(); // sendcount (count*process_count)
     2395                   loc_send = (int*) malloc(count*sizeof(int));
     2396                   for(mpi_i=0;mpi_i<count;mpi_i++)
     2397                     loc_send[count-1-mpi_i] = get_locint_r();
     2398                }
     2399                res = get_locint_r(); // id
     2400                res = get_locint_r(); // root
     2401                res = get_locint_r(); // sendcount (count*process_count)
     2402
     2403                rec_buf = (double*) myalloc1(count2*k);
     2404                trade = NULL;
     2405                if(myid == root)
     2406                   trade = myalloc1(count*k);
     2407
     2408                i=0;
     2409                for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ ){
     2410                   for( l=0; l < k ; l++,i++)
     2411                      rec_buf[i] = rpp_T[loc_recv[mpi_i]][l];
     2412                   GET_TAYL(loc_recv[mpi_i],k,p);
     2413                }
     2414
     2415                MPI_Gather(rec_buf,k*count2, MPI_DOUBLE, trade, k*count2, MPI_DOUBLE, root, MPI_COMM_WORLD);
     2416
     2417                if (myid == root ){
    23242418                   i=0;
    23252419                   for (mpi_i=0; mpi_i< count ;mpi_i++){
    2326                        for( l=0; l < k ; l++){
    2327                           rpp_T[loc_recv+mpi_i][l] = trade[i];
    2328                           i++;
    2329                        }
    2330                        for( l=0; l < k1 ; l++){
    2331                           rpp_A[loc_recv+mpi_i][l] += trade[i];
    2332                           i++;
    2333                        }
     2420                       for( l=0; l < k ; l++,i++)
     2421                          rpp_T[loc_send[mpi_i]][l] = trade[i];
    23342422                   }
    2335                 }
    2336                 myfree1(trade);
     2423                   myfree1(trade);
     2424                }
     2425                myfree1(rec_buf);
     2426#if defined(_HOS_)
     2427               arg = k1;
    23372428#endif
    23382429#if defined(_HOV_)
    2339                 trade = (double*) myalloc1(count*(k+pk1));
    2340 
    2341                 if (id == root){
     2430               arg = pk1;
     2431#endif
     2432                rec_buf = (double*) myalloc1(count2*arg);
     2433                trade = NULL;
     2434                if(myid == root )
     2435                   trade = myalloc1(count*arg);
     2436
     2437                i=0;
     2438                for (mpi_i=0 ; mpi_i< count2 ;mpi_i++ ){
     2439                   for( l=0; l < arg ; l++,i++){
     2440                         rec_buf[i] = rpp_A[loc_recv[mpi_i]][l];
     2441                         rpp_A[loc_recv[mpi_i]][l] = 0;
     2442                      }
     2443                }
     2444
     2445                MPI_Gather(rec_buf,arg*count2, MPI_DOUBLE, trade,arg*count2, MPI_DOUBLE, root, MPI_COMM_WORLD);
     2446
     2447                if (myid == root ){
    23422448                   i=0;
    2343                    for (mpi_i=0 ; mpi_i< count ;mpi_i++){
    2344                       for( l=0; l < k ; l++){
    2345                          trade[i] = rpp_T[mpi_i+loc_recv][l];
    2346                          i++;
    2347                       }
    2348                       for( l=0; l < pk1 ; l++) {
    2349                          trade[i] = rpp_A[loc_recv+mpi_i][l];
    2350                          rpp_A[i][l] = 0;
    2351                          i++;
    2352                       }
    2353                       GET_TAYL(loc_recv+mpi_i,k,p);
     2449                   for (mpi_i=0; mpi_i< count ;mpi_i++){
     2450                       for( l=0; l < arg ; l++,i++)
     2451                          rpp_A[loc_send[mpi_i]][l] += trade[i];
     2452
    23542453                   }
    2355                 }
    2356 
    2357                 MPI_Bcast( trade,(k+pk1)*count, MPI_DOUBLE , root, MPI_COMM_WORLD);
    2358 
    2359                 if (id != root){
    2360                    i=0;
    2361                    for (mpi_i=0 ; mpi_i< count ; mpi_i++){
    2362                        for( l=0; l < k ; l++){
    2363                           rpp_T[mpi_i+loc_recv][l] = trade[i];
    2364                           i++;
    2365                        }
    2366                        for( l=0; l < pk1 ; l++) {
    2367                           rpp_A[mpi_i+loc_recv][l] += trade[i];
    2368                           i++;
    2369                        }
    2370                    }
    2371                 }
    2372                 myfree1(trade);
    2373 #endif
     2454                   myfree1(trade);
     2455                }
     2456                myfree1(rec_buf);
     2457
     2458                if( myid == root) free(loc_send);
     2459                free(loc_recv);
    23742460                break;
    23752461#endif
  • branches/MPI/ADOL-C/src/interfaces_mpi.cpp

    r252 r273  
    160160       rc = hov_reverse_mpi(id,size,tag,m,n,degre,nrows, lagrange,results,nonzero);
    161161    else
    162        rc = hov_reverse_mpi(id,size,tag,0,0,degre,0, NULL,NULL,NULL);
     162       rc = hov_reverse_mpi(id,size,tag,0,0,degre,nrows, NULL,NULL,NULL);
    163163    return rc;
    164164}
     
    203203}
    204204
     205int int_reverse_tight(
     206    int id,int size,short tag, int m, int n, int p, unsigned long int **seed, unsigned long int **bit_pat){
     207
     208    int rc=-3;
     209    if (id==0)
     210       rc = int_reverse_tight_mpi(id,size,tag,m,n,p,seed,bit_pat);
     211    else
     212       rc = int_reverse_tight_mpi(id,size,tag,0,0,p,NULL,NULL);
     213    return rc;
     214}
     215int int_reverse_safe(
     216    int id,int size,short tag, int m, int n, int p, unsigned long int **seed, unsigned long int **bit_pat){
     217
     218    int rc=-3;
     219    if (id==0)
     220       rc = int_reverse_safe_mpi(id,size,tag,m,n,p,seed,bit_pat);
     221    else
     222       rc = int_reverse_safe_mpi(id,size,tag,0,0,p,NULL,NULL);
     223    return rc;
     224}
     225
     226
    205227/* indopro_forward_tight(rank,size, tag, m, n, x[n], *crs[m])                         */
    206228int indopro_forward_tight(
  • branches/MPI/ADOL-C/src/interfaces_mpi.h

    r252 r273  
    6262
    6363ADOLC_DLL_EXPORT int hov_reverse(
    64     int, int, short,int,int,int,int, double**,double***,short*);
     64    int, int, short,int,int,int,int, double**,double***,short**);
    6565
    6666/* int_forward_tight(rank,size,tag, m, n, p, x[n], X[n][p], y[m], Y[m][p])            */
     
    7171ADOLC_DLL_EXPORT int int_forward_safe(
    7272    int,int,short,int,int,int,unsigned long int**,unsigned long int**);
     73
     74/* int_reverse_tight(tag, m, n, q, U[q][m], Z[q][n])                        */
     75ADOLC_DLL_EXPORT int int_reverse_tight
     76(int,int,short, int, int, int, unsigned long int**, unsigned long int**);
     77/* int_reverse_safe(tag, m, n, q, U[q][m], Z[q][n])                         */
     78ADOLC_DLL_EXPORT int int_reverse_safe
     79(int,int,short, int, int, int, unsigned long int**, unsigned long int**);
    7380
    7481/* indopro_forward_tight(rank,size, tag, m, n, x[n], *crs[m])                         */
     
    131138    int,int,short,int,int,int,unsigned long int**,unsigned long int**);
    132139
     140/* int_reverse_tight(rank, size,tag, m, n, q, U[q][m], Z[q][n])                        */
     141ADOLC_DLL_EXPORT int int_reverse_tight_mpi
     142(int,int,short, int, int, int, unsigned long int**, unsigned long int**);
     143/* int_reverse_safe(rank, size,tag, m, n, q, U[q][m], Z[q][n])                         */
     144ADOLC_DLL_EXPORT int int_reverse_safe_mpi
     145(int,int,short, int, int, int, unsigned long int**, unsigned long int**);
    133146/* indopro_forward_tight(rank,size, tag, m, n, x[n], *crs[m])                         */
    134147ADOLC_DLL_EXPORT int indopro_forward_tight_mpi(
     
    147160    int, int, short, int, int,const double*, unsigned int**);
    148161
     162ADOLC_DLL_EXPORT int hos_ti_reverse_mpi( int mpi_id, int mpi_size,
     163    short   tnum,        /* tape id */
     164    int     depen,       /* consistency chk on # of deps */
     165    int     indep,       /* consistency chk on # of indeps */
     166    int     degre,       /* highest derivative degre  */
     167    double  **lagrange,  /* range weight vectors       */
     168    double  **results);   /* matrix of coefficient vectors */
     169
     170ADOLC_DLL_EXPORT int hov_ti_reverse_mpi( int mpi_id, int mpi_size,
     171    short   tnum,        /* tape id */
     172    int     depen,       /* consistency chk on # of deps */
     173    int     indep,       /* consistency chk on # of indeps */
     174    int     degre,       /* highest derivative degre */
     175    int     nrows,       /* # of Jacobian rows calculated */
     176    double  ***lagrange, /* domain weight vectors */
     177    double  ***results,  /* matrix of coefficient vectors */
     178    short   **nonzero );  /* structural sparsity  pattern  */
    149179END_C_DECLS
    150180
  • branches/MPI/ADOL-C/src/oplate.h

    r240 r273  
    8989  barrier_op,
    9090  broadcast,
    91   reduce
     91  reduce,
     92  gather,
     93  scatter
    9294};
    9395
  • branches/MPI/ADOL-C/src/sparse/sparsedrivers.cpp

    r252 r273  
    650650    TapeInfos *tapeInfos;
    651651
     652    ADOLC_OPENMP_THREAD_NUMBER;
     653    ADOLC_OPENMP_GET_THREAD_NUMBER;
     654
    652655    tapeInfos=getTapeInfos(tag);
    653656    memcpy(&ADOLC_CURRENT_TAPE_INFOS, tapeInfos, sizeof(TapeInfos));
     
    680683    SparseHessInfos sHinfos;
    681684    TapeInfos *tapeInfos;
     685
     686    ADOLC_OPENMP_THREAD_NUMBER;
     687    ADOLC_OPENMP_GET_THREAD_NUMBER;
    682688
    683689    tapeInfos=getTapeInfos(tag);
  • branches/MPI/ADOL-C/src/storemanager.h

    r199 r273  
    9292
    9393  StoreManagerLocint(double * &storePtr, size_t &size, size_t &numlives);
     94  StoreManagerLocint(const StoreManagerLocint *const stm, double * &storePtr, size_t &size, size_t &numLives);
    9495
    9596  virtual ~StoreManagerLocint();
  • branches/MPI/ADOL-C/src/tape_handling.cpp

    r228 r273  
    5353}
    5454
     55const GlobalTapeVarsCL& GlobalTapeVarsCL::operator=(const GlobalTapeVarsCL& gtv) {
     56    storeSize = gtv.storeSize;
     57    numLives = gtv.numLives;
     58    maxLoc = gtv.maxLoc;
     59    operationBufferSize = gtv.operationBufferSize;
     60    locationBufferSize = gtv.locationBufferSize;
     61    valueBufferSize = gtv.valueBufferSize;
     62    taylorBufferSize = gtv.taylorBufferSize;
     63    maxNumberTaylorBuffers = gtv.maxNumberTaylorBuffers;
     64    inParallelRegion = gtv.inParallelRegion;
     65    newTape = gtv.newTape;
     66    branchSwitchWarning = gtv.branchSwitchWarning;
     67    currentTapeInfosPtr = gtv.currentTapeInfosPtr;
     68    store = new double[storeSize];
     69    memcpy(store, gtv.store, storeSize*sizeof(double));
     70    storeManagerPtr = new
     71        StoreManagerLocint(
     72            dynamic_cast<StoreManagerLocint*>(gtv.storeManagerPtr),
     73            store, storeSize, numLives);
     74    return *this;
     75}
     76
    5577StoreManagerLocint::StoreManagerLocint(double * &storePtr, size_t &size, size_t &numlives) :
    5678    storePtr(storePtr),
     
    80102    anzahl = 0;
    81103    head = 0;
     104}
     105
     106StoreManagerLocint::StoreManagerLocint(const StoreManagerLocint *const stm,
     107                                       double * &storePtr, size_t &size, size_t &numlives) :
     108    storePtr(storePtr),
     109    groesse(size), anzahl(numlives)
     110{
     111#ifdef ADOLC_DEBUG
     112    std::cerr << "StoreManagerInteger::StoreManagerInteger()\n";
     113#endif
     114    head = stm->head;
     115    indexFeld = new locint[groesse];
     116    for (int i = 0; i < groesse; i++)
     117        indexFeld[i] = stm->indexFeld[i];
    82118}
    83119
     
    10401076    if (firstParallel) {
    10411077        ADOLC_EXT_DIFF_FCTS_BUFFER.init(init_CpInfos);
    1042         memcpy(&ADOLC_GLOBAL_TAPE_VARS, globalTapeVars_s, sizeof(GlobalTapeVars));
    1043         ADOLC_GLOBAL_TAPE_VARS.store = (double *)
    1044             malloc(sizeof(double) * ADOLC_GLOBAL_TAPE_VARS.storeSize);
    1045         memcpy(ADOLC_GLOBAL_TAPE_VARS.store, globalTapeVars_s->store,
    1046                 ADOLC_GLOBAL_TAPE_VARS.locMinUnused * sizeof(double));
     1078
     1079        /* Use assignment operator instead of open coding
     1080         * this copies the store and the storemanager too
     1081         */
     1082        ADOLC_GLOBAL_TAPE_VARS = *globalTapeVars_s;
     1083
    10471084        ADOLC_GLOBAL_TAPE_VARS.newTape = 0;
    10481085        ADOLC_CURRENT_TAPE_INFOS.tapingComplete = 1;
     
    10501087    } else {
    10511088        if (ADOLC_parallel_doCopy) {
    1052             ADOLC_GLOBAL_TAPE_VARS.locMinUnused = globalTapeVars_s->locMinUnused;
    1053             ADOLC_GLOBAL_TAPE_VARS.numMaxAlive = globalTapeVars_s->numMaxAlive;
    10541089            ADOLC_GLOBAL_TAPE_VARS.storeSize = globalTapeVars_s->storeSize;
    1055             ADOLC_GLOBAL_TAPE_VARS.numToFree = globalTapeVars_s->numToFree;
    1056             ADOLC_GLOBAL_TAPE_VARS.minLocToFree = globalTapeVars_s->minLocToFree;
     1090            ADOLC_GLOBAL_TAPE_VARS.numLives = globalTapeVars_s->numLives;
     1091           
    10571092            ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning = globalTapeVars_s->branchSwitchWarning;
    1058             free(ADOLC_GLOBAL_TAPE_VARS.store);
    1059             ADOLC_GLOBAL_TAPE_VARS.store = (double *)
    1060                 malloc(sizeof(double) * ADOLC_GLOBAL_TAPE_VARS.storeSize);
     1093
     1094            /* deleting the storemanager deletes the store too */
     1095            delete ADOLC_GLOBAL_TAPE_VARS.storeManagerPtr;
     1096
     1097            ADOLC_GLOBAL_TAPE_VARS.store = new
     1098                double[ADOLC_GLOBAL_TAPE_VARS.storeSize];
    10611099            memcpy(ADOLC_GLOBAL_TAPE_VARS.store, globalTapeVars_s->store,
    1062                     ADOLC_GLOBAL_TAPE_VARS.locMinUnused * sizeof(double));
     1100                    ADOLC_GLOBAL_TAPE_VARS.storeSize * sizeof(double));
     1101            ADOLC_GLOBAL_TAPE_VARS.storeManagerPtr = new
     1102                StoreManagerLocint(
     1103                    dynamic_cast<StoreManagerLocint*>(globalTapeVars_s->storeManagerPtr),
     1104                    ADOLC_GLOBAL_TAPE_VARS.store,
     1105                    ADOLC_GLOBAL_TAPE_VARS.storeSize,
     1106                    ADOLC_GLOBAL_TAPE_VARS.numLives);
    10631107        }
    10641108    }
  • branches/MPI/ADOL-C/src/tapedoc/tapedoc.c

    r240 r273  
    110110                       "send data",
    111111                       "receive data",
    112                        "barrier Op"
     112                             "barrier Op",
     113                       "broadcast Op",
     114                       "reduce Op",
     115                       "gather Op",
     116                       "scatter Op"
    113117                    };
    114118
     
    300304        fprintf(DIAG_OUT,"ADOL-C error: Tape_doc on tape %d  aborted!\n",tag);
    301305        fprintf(DIAG_OUT,"Number of dependent (%d) and/or independent (%d) "
    302                 "variables passed to Tape_doc is\ninconsistant with "
     306                "variables passed to Tape_doc is\ninconsistent with "
    303307                "number recorded on tape %d (%d:%d)\n", depcheck,
    304308                indcheck, tag, ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS],
     
    313317    dp_T0 = myalloc1(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
    314318
     319#if defined(HAVE_MPI)
     320    int mpi_i,mpi_ii,count,count2,dest,tag,buf,use_reduce=0;
     321#endif
    315322    operation=get_op_f();
    316323    while (operation !=end_of_tape) {
     
    11901197#if defined(HAVE_MPI)       
    11911198        case send_data:
    1192                 arg1 = get_locint_f();
    1193                 arg2 = get_locint_f();
    1194                 res  = get_locint_f();
    1195                 loc_a[0]=get_locint_f();
    1196                 loc_a[0]=arg1;
    1197                 loc_a[1]=arg2;
    1198                 loc_a[2]=res;
    1199 #ifdef computenumbers
    1200                 val_a[0]=dp_T0[arg1];
    1201                 dp_T0[res] = erf(dp_T0[arg1]);
    1202                 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
    1203                 val_a[1]=dp_T0[arg2];
    1204                 val_a[2]=dp_T0[res];
    1205 #endif
    1206                 filewrite(operation,3,loc_a,val_a,0,cst_d);
     1199                count  = get_locint_f(); // count
     1200             buf    = get_locint_f(); // first buffer
     1201             for(mpi_i=1; mpi_i<count;mpi_i++)
     1202                mpi_ii = get_locint_f(); // rest buffer
     1203                count2 = get_locint_f();
     1204                dest   = get_locint_f();
     1205             tag    = get_locint_f();
     1206                loc_a[0] = buf;
     1207                loc_a[1] = count;
     1208                loc_a[2] = dest;
     1209#ifdef computenumbers
     1210              val_a[0] = dp_T0[buf];
     1211              val_a[1] = dp_T0[buf];
     1212#endif
     1213                filewrite(operation,3,loc_a,val_a,1,cst_d);
    12071214                break;
    12081215        case receive_data:
    1209                 loc_a[0]=get_locint_f(); // adouble location
    1210                 loc_a[1]=get_locint_f(); // target
    1211                 loc_a[2]=get_locint_f(); // destination
    1212                 res = get_locint_f();
    1213                 filewrite(operation, 3, loc_a, val_a, 0, cst_d);
    1214                 break;
     1216             count  = get_locint_f(); // count
     1217             buf    = get_locint_f(); // first buffer
     1218             for(mpi_i=1; mpi_i<count;mpi_i++)
     1219                mpi_ii = get_locint_f(); // rest buffer
     1220             count2 = get_locint_f();
     1221             dest   = get_locint_f();
     1222             tag    = get_locint_f();
     1223             loc_a[0] = buf;
     1224             loc_a[1] = count;
     1225             loc_a[2] = dest;
     1226             filewrite(operation, 3, loc_a, val_a, 0, cst_d);
     1227                break;
    12151228        case barrier_op:
    12161229                ++op_cnt;
    12171230                --rev_op_cnt;
    12181231                fprintf(fp,"%i & %i & %i & ",op_cnt, rev_op_cnt, barrier_op);
    1219                
     1232
    12201233    /* write opcode name if available */
    12211234                res=0;
     
    12241237                        res++;
    12251238                }
    1226                
     1239
    12271240    /* write locations (max 4) right-justified */
    12281241                fprintf(fp," & & & & & ");
    1229                
     1242
    12301243#ifdef computenumbers
    12311244                fprintf(fp," & & & & & \\\\ \\hline \n");
     
    12341247#endif
    12351248                break;
    1236 #endif
     1249        case broadcast:
     1250             count  = get_locint_f(); // count
     1251             buf    = get_locint_f(); // first buffer
     1252             for(mpi_i=1; mpi_i<count;mpi_i++)
     1253                mpi_ii = get_locint_f(); // rest buffer
     1254             count2 = get_locint_f();
     1255             dest   = get_locint_f(); // root
     1256             tag    = get_locint_f(); // id
     1257             loc_a[0] = buf;
     1258             loc_a[1] = count;
     1259             loc_a[2] = dest;
     1260             filewrite(operation, 3, loc_a, val_a, 0, cst_d);
     1261             break;
     1262       case reduce:
     1263             use_reduce=1;
     1264       case gather:
     1265             count  = get_locint_f(); // count
     1266             buf    = get_locint_f(); // first buffer
     1267             for(mpi_i=1; mpi_i<count;mpi_i++)
     1268                mpi_ii = get_locint_f(); // rest buffer
     1269             count2 = get_locint_f();
     1270             dest   = get_locint_f(); // root
     1271             tag    = get_locint_f(); // id
     1272             count2 = get_locint_f(); // 2nd count
     1273             if(dest == tag){
     1274               for(mpi_i=0; mpi_i<count2;mpi_i++)
     1275                  mpi_ii = get_locint_f(); // rest buffer
     1276               mpi_ii = get_locint_f();
     1277             }
     1278             if(use_reduce==1) mpi_ii=get_locint_f();
     1279
     1280             loc_a[0] = buf;
     1281             loc_a[1] = count;
     1282             loc_a[2] = dest;
     1283             filewrite(operation, 3, loc_a, val_a, 0, cst_d);
     1284             break;
     1285       case scatter:
     1286             count  = get_locint_f(); // sendcount*process_count
     1287             dest   = get_locint_f(); // root
     1288             tag    = get_locint_f(); // id
     1289             if(dest == tag){
     1290               for(mpi_i=0; mpi_i<count;mpi_i++)
     1291                 mpi_ii = get_locint_f(); // rest buffer
     1292               count = get_locint_f();
     1293             }
     1294             dest   = get_locint_f(); // root
     1295             tag    = get_locint_f(); // id
     1296             count2 = get_locint_f(); // recvcount
     1297             buf    = get_locint_f(); // first buffer
     1298             for(mpi_i=1; mpi_i<count2;mpi_i++)
     1299                mpi_ii = get_locint_f(); // rest buffer
     1300             mpi_ii = get_locint_f();
     1301
     1302             loc_a[0] = buf;
     1303             loc_a[1] = count2;
     1304             loc_a[2] = dest;
     1305             filewrite(operation, 3, loc_a, val_a, 0, cst_d);
     1306             break;
     1307#endif // end of HAVE_MPI
    12371308                /*--------------------------------------------------------------------------*/
    12381309        default:                                                   /* default */
  • branches/MPI/ADOL-C/src/taping.c

    r229 r273  
    213213            fprintf(DIAG_OUT,
    214214                    "ADOL-C error: Number of independents/dependents recorded on"
    215                     " tape differ from number suplied by user!\n");
     215                    " tape differ from number supplied by user!\n");
    216216            break;
    217217        case ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION:
  • branches/MPI/ADOL-C/src/taping_p.h

    r199 r273  
    288288    GlobalTapeVarsCL();
    289289    ~GlobalTapeVarsCL();
     290    const GlobalTapeVarsCL& operator=(const GlobalTapeVarsCL&);
    290291#else
    291292    void *storeManagerPtr;
     
    295296
    296297#if defined(_OPENMP)
    297 #error nicht hier
     298
    298299extern int isParallel();
    299300
  • branches/MPI/ADOL-C/src/uni5_for.c

    r252 r273  
    10381038    }
    10391039#if defined(_MPI_)
    1040      double *trade, *rec_buf;
     1040     double *trade, *rec_buf, *mpi_tmp;
    10411041     MPI_Status status_MPI;
    1042      int mpi_i , loc_send,loc_recv;
     1042     int mpi_i,mpi_ii, *loc_send, *loc_recv, s_r_c=1,use_reduce=0;
    10431043     ADOLC_MPI_Op mpi_op;
    1044      int myid,root, count, id=mpi_id;
     1044     int myid,root, count, id=mpi_id,count2, target,tag;
    10451045#if defined(_NONLIND_)
    10461046     locint *tmp_element;
    10471047#endif
    1048 #if defined(_INDO_)
     1048#if (defined(_INDO_) | defined(_INT_FOR_))
    10491049     int *trade_loc, *rec_buf_loc;
    10501050     int *counts, *tmp_counts;
    10511051     int anz;
    1052 #endif
    1053 #if defined(_INT_FOR_)
    1054      unsigned long int *up_mpi;
    10551052#endif
    10561053#endif
     
    38073804#if defined(_MPI_)
    38083805      case send_data:   // MPI-Send-Befehl
    3809               arg = get_locint_f(); // first Buffer
    3810               arg1 = get_locint_f(); // count
    3811               arg2 = get_locint_f(); // dest
    3812               res = get_locint_f(); // tag
     3806              count = get_locint_f(); // first Buffer
     3807           loc_send = (int*) malloc(count*sizeof(int));
     3808           for(mpi_i=0; mpi_i < count; mpi_i++)
     3809               loc_send[mpi_i] = get_locint_f();
     3810           count2 = get_locint_f();
     3811              target = get_locint_f(); // dest
     3812              tag = get_locint_f(); // tag
    38133813#if !defined(_NTIGHT_)
    38143814          // sending dp_t0
    3815           trade = (double*) myalloc1( arg1 );
    3816           for (mpi_i=0; mpi_i< arg1; mpi_i++)
    3817                     trade[mpi_i] = dp_T0[arg+mpi_i];
    3818           MPI_Send( trade , arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
    3819           myfree1(trade);
     3815          trade = (double*) myalloc1( count );
     3816          for (mpi_i=0; mpi_i< count; mpi_i++)
     3817                    trade[mpi_i] = dp_T0[ loc_send[mpi_i]];
     3818          MPI_Send( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     3819          free(trade);
    38203820#endif    /* END NOT _NTIGHT_ */
     3821#if defined(_INT_FOR_)
     3822           trade_loc = (int*) myalloc1(arg1*p);
     3823           for (mpi_i=0; mpi_i< arg1; mpi_i++) {
     3824               FOR_0_LE_l_LT_pk
     3825                trade_loc[mpi_i*p+l]=up_T[loc_send[mpi_i]][l];
     3826           }
     3827           MPI_Send( trade_loc , count*p, MPI_INT , target, tag , MPI_COMM_WORLD);
     3828           free(trade_loc);
     3829#endif /* END INT_FOR */
    38213830#if defined(_FOS_)
    38223831           trade = (double*) myalloc1(arg1);
    38233832           for (mpi_i=0; mpi_i< arg1; mpi_i++) {
    3824                 trade[mpi_i]=dp_T[arg+mpi_i];
    3825            }
    3826            MPI_Send( trade , arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
    3827            myfree1(trade);
     3833                trade[mpi_i]=dp_T[loc_send[mpi_i]];
     3834           }
     3835           MPI_Send( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     3836           free(trade);
    38283837#endif /* END FOS */
    38293838#if defined(_FOV_)
    3830            trade = (double*) myalloc1(p*arg1);
    3831            for (mpi_i=0; mpi_i< arg1; mpi_i++) {
     3839           trade = (double*) myalloc1(p*count);
     3840           for (mpi_i=0; mpi_i< count; mpi_i++) {
    38323841                for(i=0;i<p;i++)
    3833                      trade[p*mpi_i+i] = dpp_T[arg+mpi_i][i];
    3834            }
    3835            MPI_Send( trade , arg1*p, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
    3836            myfree1(trade);
     3842                     trade[p*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     3843           }
     3844           MPI_Send( trade , arg1*p, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     3845           free(trade);
    38373846#endif /* END FOV */
    38383847#if defined(_HOS_)
    3839            trade = (double*) myalloc1(arg1 * k);
     3848           trade = (double*) myalloc1(count * k);
    38403849           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3841            for (mpi_i=0; mpi_i< arg1; mpi_i++)
     3850           for (mpi_i=0; mpi_i< count; mpi_i++)
    38423851               for (i=0; i<k; i++)
    3843                    trade[k*mpi_i + i] = dpp_T[arg+mpi_i][i];
    3844            MPI_Send( trade , arg1*k, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
    3845            myfree1(trade);
     3852                   trade[k*mpi_i + i] = dpp_T[loc_send[mpi_i]][i];
     3853           MPI_Send( trade , count*k, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     3854           free(trade);
    38463855#endif /* END HOS */
    38473856#if defined(_HOV_)
    3848            trade = (double*) myalloc1(arg1 * p*k);
     3857           trade = (double*) myalloc1(count*p*k);
    38493858           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3850            for (mpi_i=0; mpi_i< arg1; mpi_i++)
     3859           for (mpi_i=0; mpi_i< count; mpi_i++)
    38513860               for (i=0; i<p*k; i++)
    3852                    trade[p*k*mpi_i + i] = dpp_T[arg+mpi_i][i];
    3853            MPI_Send( trade , arg1*p*k, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD);
    3854            myfree1(trade);
     3861                   trade[p*k*mpi_i + i] = dpp_T[loc_send[mpi_i]][i];
     3862           MPI_Send( trade , count*p*k, MPI_DOUBLE , target, tag , MPI_COMM_WORLD);
     3863           free(trade);
    38553864#endif /* END HOV */
    38563865#if defined(_INDO_)
    38573866           // getting information about count of entries
    3858            counts = (int*) malloc( arg1*sizeof(int) );
     3867           counts = (int*) malloc( count*sizeof(int) );
    38593868           anz=0;
    3860            for (mpi_i=0; mpi_i< arg1; mpi_i++){
    3861                counts[mpi_i] = (int) ind_dom[arg+mpi_i][0];
     3869           for (mpi_i=0; mpi_i< count; mpi_i++){
     3870               counts[mpi_i] = (int) ind_dom[loc_send[mpi_i]][0];
    38623871               anz += counts[mpi_i];
    38633872           }
    3864            MPI_Send( counts , arg1 , MPI_INT , arg2, res , MPI_COMM_WORLD);
     3873           MPI_Send( counts , count , MPI_INT , target, tag , MPI_COMM_WORLD);
    38653874
    38663875           // sending index domains
     
    38683877              trade_loc = (int*) malloc( anz*sizeof(int) );
    38693878              l =0;
    3870               for (mpi_i=0; mpi_i< arg1; mpi_i++){
    3871                   for(i=2;i < ind_dom[arg+mpi_i][0]+2 ;i++ ){
    3872                        trade_loc[l] = (int) ind_dom[arg+mpi_i][i];
     3879              for (mpi_i=0; mpi_i< count; mpi_i++){
     3880                  for(i=2;i < ind_dom[loc_send[mpi_i]][0]+2 ;i++ ){
     3881                       trade_loc[l] = (int) ind_dom[loc_send[mpi_i]][i];
    38733882                       l++;
    38743883                  }
    38753884              }
    3876               MPI_Send( trade_loc , anz , MPI_INT , arg2, res , MPI_COMM_WORLD);
     3885              MPI_Send( trade_loc , anz , MPI_INT , target, tag , MPI_COMM_WORLD);
    38773886              free(trade_loc);
    38783887           }
     
    38883897               }
    38893898
    3890            MPI_Send( counts , s_r_indep , MPI_INT , arg2, res , MPI_COMM_WORLD);
     3899           MPI_Send( counts , s_r_indep , MPI_INT , target, tag , MPI_COMM_WORLD);
    38913900
    38923901           // sending index domains
     
    38993908                      l++;
    39003909                  }
    3901               MPI_Send( trade_loc , anz , MPI_INT , arg2, res , MPI_COMM_WORLD);
     3910              MPI_Send( trade_loc , anz , MPI_INT , target, tag , MPI_COMM_WORLD);
    39023911              free( trade_loc);
    39033912           }
    39043913           free( counts);
    39053914#endif    // end _NONLIND_
     3915           free(loc_send);
    39063916              break;
    39073917                /*--------------------------------------------------------------------------*/
    39083918      case receive_data: // MPI-Receive
    3909            arg =get_locint_f(); // Location
    3910            arg1 = get_locint_f(); // count
    3911            arg2 = get_locint_f(); // source
    3912            res = get_locint_f(); // tag
     3919           count =get_locint_f(); // Location
     3920           loc_recv = (int*) malloc(count*sizeof(int));
     3921           for(mpi_i=0; mpi_i<count;mpi_i++)
     3922               loc_recv[mpi_i] = get_locint_f();
     3923           count2 =get_locint_f(); // Location
     3924           target = get_locint_f(); // source
     3925           tag = get_locint_f(); // tag
    39133926#if !defined(_NTIGHT_)
    39143927          // receiving values for dp_T0
    3915           trade = (double*) myalloc1( arg1 );
    3916           MPI_Recv( trade , arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    3917           for (mpi_i =0; mpi_i < arg1; mpi_i++){
    3918               IF_KEEP_WRITE_TAYLOR(arg+mpi_i,keep,k,p)
    3919               dp_T0[arg+mpi_i] = trade[mpi_i];
     3928          trade = (double*) myalloc1( count );
     3929          MPI_Recv( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     3930          for (mpi_i =0; mpi_i < count; mpi_i++){
     3931              IF_KEEP_WRITE_TAYLOR(loc_recv[mpi_i],keep,k,p)
     3932              dp_T0[loc_recv[mpi_i]] = trade[mpi_i];
    39203933          }
    3921           myfree1(trade);
     3934          free(trade);
    39223935#endif /* END NOT _NTIGHT_ */
     3936#if defined(_INT_FOR_)
     3937           trade_loc = (int*) malloc(count*p*sizeof(int));
     3938           MPI_Recv( trade_loc , count*p, MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
     3939           for (mpi_i=0; mpi_i< count; mpi_i++) {
     3940               FOR_0_LE_l_LT_pk
     3941                up_T[loc_recv[mpi_i]][l]=trade_loc[mpi_i*p+l];
     3942           }
     3943           free(trade_loc);
     3944#endif /* END INT_FOR */
    39233945#if defined(_FOS_)
    3924            trade = (double*) myalloc1(arg1);
    3925            MPI_Recv( trade , arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
     3946           trade = (double*) myalloc1(count);
     3947           MPI_Recv( trade , count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
    39263948           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3927            for (mpi_i=0; mpi_i< arg1; mpi_i++){
    3928                 dp_T[arg+mpi_i] = trade[mpi_i];
     3949           for (mpi_i=0; mpi_i< count; mpi_i++){
     3950                dp_T[loc_recv[mpi_i]] = trade[mpi_i];
    39293951                }
     3952           free(trade);
     3953#endif
     3954#if defined(_FOV_)
     3955           trade = (double*) myalloc1(count*p);
     3956           MPI_Recv( trade , p*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     3957           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
     3958           for (mpi_i=0; mpi_i< count; mpi_i++) {
     3959                for(i=0;i<p;i++)
     3960                     dpp_T[loc_recv[mpi_i]][i] = trade[p*mpi_i+i];
     3961           }
     3962           free(trade);
     3963#endif
     3964#if defined(_HOS_)
     3965           trade = (double*) myalloc1(count * k);
     3966           MPI_Recv( trade , k*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
     3967           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
     3968           for (mpi_i=0; mpi_i< count; mpi_i++) {
     3969               for(i=0; i < k ; i++ )
     3970                dpp_T[loc_recv[mpi_i]][i] = trade[k*mpi_i+i];
     3971           }
    39303972           myfree1(trade);
    39313973#endif
    3932 #if defined(_FOV_)
    3933            trade = (double*) myalloc1(arg1*p);
    3934            MPI_Recv( trade , p*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
     3974#if defined(_HOV_)
     3975           trade = (double*) myalloc1(count * p*k);
     3976           MPI_Recv( trade , p*k*count, MPI_DOUBLE , target, tag , MPI_COMM_WORLD, &status_MPI);
    39353977           /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3936            for (mpi_i=0; mpi_i< arg1; mpi_i++) {
    3937                 for(i=0;i<p;i++)
    3938                      dpp_T[arg+mpi_i][i] = trade[p*mpi_i+i];
    3939            }
    3940            myfree1(trade);
    3941 #endif
    3942 #if defined(_HOS_)
    3943            trade = (double*) myalloc1(arg1 * k);
    3944            MPI_Recv( trade , k*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    3945            /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3946            for (mpi_i=0; mpi_i< arg1; mpi_i++) {
    3947                for(i=0; i < k ; i++ )
    3948                 dpp_T[arg+mpi_i][i] = trade[k*mpi_i+i];
    3949            }
    3950            myfree1(trade);
    3951 #endif
    3952 #if defined(_HOV_)
    3953            trade = (double*) myalloc1(arg1 * p*k);
    3954            MPI_Recv( trade , p*k*arg1, MPI_DOUBLE , arg2, res , MPI_COMM_WORLD, &status_MPI);
    3955            /*  Receiving double Values by MPI and try to save Taylorbuffer before overwriting */
    3956            for (mpi_i=0; mpi_i< arg1; mpi_i++) {
     3978           for (mpi_i=0; mpi_i< count; mpi_i++) {
    39573979               for(i=0; i < p*k ; i++ )
    3958                 dpp_T[arg+mpi_i][i] = trade[p*k*mpi_i+i];
    3959            }
    3960            myfree1(trade);
     3980                dpp_T[loc_recv[mpi_i]][i] = trade[p*k*mpi_i+i];
     3981           }
     3982           free(trade);
    39613983#endif
    39623984#if defined(_INDO_)
    39633985           // getting information about count of entries
    3964            counts = ( int*) malloc( arg1*sizeof(int) );
    3965            MPI_Recv( counts , arg1, MPI_INT , arg2, res , MPI_COMM_WORLD, &status_MPI);
     3986           counts = ( int*) malloc( count*sizeof(int) );
     3987           MPI_Recv( counts , count, MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
    39663988
    39673989           anz =0;
    3968            for (mpi_i=0; mpi_i< arg1; mpi_i++) {
     3990           for (mpi_i=0; mpi_i< count; mpi_i++) {
    39693991               anz += counts[mpi_i];
    39703992           }
    39713993           if ( anz > 0){
    39723994              trade_loc = (int*) malloc( anz*sizeof(int) );
    3973               MPI_Recv( trade_loc , anz , MPI_INT , arg2, res , MPI_COMM_WORLD, &status_MPI);
     3995              MPI_Recv( trade_loc , anz , MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
    39743996
    39753997              // combine each index domain ...
    39763998              l = 0;
    3977               for(mpi_i=0; mpi_i < arg1; mpi_i++){
    3978                    combine_index_domain_received_data(arg+mpi_i, counts[mpi_i], ind_dom, &trade_loc[l] );
     3999              for(mpi_i=0; mpi_i < count; mpi_i++){
     4000                   combine_index_domain_received_data(loc_recv[mpi_i], counts[mpi_i], ind_dom, &trade_loc[l] );
    39794001                   l += counts[mpi_i];
    39804002              }
     
    39854007#if defined(_NONLIND_)
    39864008           counts = ( int*) malloc( s_r_indep*sizeof(int) );
    3987            MPI_Recv( counts , s_r_indep, MPI_INT , arg2, res , MPI_COMM_WORLD, &status_MPI);
     4009           MPI_Recv( counts , s_r_indep, MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
    39884010           anz =0;
    39894011           for (mpi_i=0; mpi_i< s_r_indep; mpi_i++){
     
    39924014           if (anz > 0) {
    39934015              trade_loc = (int*) calloc( anz,sizeof(int) );
    3994               MPI_Recv( trade_loc , anz , MPI_INT , arg2, res , MPI_COMM_WORLD, &status_MPI);
     4016              MPI_Recv( trade_loc , anz , MPI_INT , target, tag , MPI_COMM_WORLD, &status_MPI);
    39954017
    39964018              // combine each index domain ...
     
    40064028           free( counts);
    40074029#endif    // end _NONLIND_
     4030           free(loc_recv);
    40084031              break;
    40094032      case barrier_op:
     
    40114034              break;
    40124035      case broadcast:
    4013            loc_send = get_locint_f(); // Send Location
    4014            loc_recv = get_locint_f(); // Receive Location
    40154036           count = get_locint_f(); // count
     4037           loc_send = (int*) malloc(count*sizeof(int));
     4038           for(mpi_i=0;mpi_i<count;mpi_i++)
     4039              loc_send[mpi_i] = get_locint_f(); // Send Location
     4040           count2 = get_locint_f(); // count
    40164041           root = get_locint_f(); // root
    40174042           myid = get_locint_f(); // process id
     
    40214046           if (myid == root){
    40224047              for(mpi_i =0; mpi_i < count ; mpi_i++)
    4023                  trade[mpi_i] = dp_T0[loc_send+mpi_i];
     4048                 trade[mpi_i] = dp_T0[loc_send[mpi_i]];
    40244049            }
    40254050           MPI_Bcast(trade,count, MPI_DOUBLE, root, MPI_COMM_WORLD);
    40264051           for( mpi_i =0; mpi_i < count; mpi_i++){
    4027                IF_KEEP_WRITE_TAYLOR(loc_recv+mpi_i,keep,k,p)
    4028                dp_T0[loc_recv+mpi_i] = trade[mpi_i];
    4029            }
    4030            myfree1(trade);
     4052               IF_KEEP_WRITE_TAYLOR(loc_send[mpi_i],keep,k,p)
     4053               dp_T0[loc_send[mpi_i]] = trade[mpi_i];
     4054           }
     4055           free(trade);
    40314056#endif /* END NOT _NTIGHT_ */
     4057#if defined(_INT_FOR_)
     4058           trade_loc = (int*) myalloc1(count*p);
     4059           for (mpi_i=0; mpi_i< count; mpi_i++) {
     4060               FOR_0_LE_l_LT_pk
     4061                trade_loc[mpi_i*p+l]=up_T[loc_send[mpi_i]][l];
     4062           }
     4063           MPI_Bcast(trade_loc,count*p, MPI_INT, root, MPI_COMM_WORLD);
     4064           for( mpi_i =0; mpi_i < count; mpi_i++){
     4065              FOR_0_LE_l_LT_pk
     4066               up_T[loc_send[mpi_i]][l] = trade_loc[mpi_i*p+l];
     4067           }
     4068           free(trade_loc);
     4069#endif /* END INT_FOR */
    40324070#if defined(_FOS_)
    40334071           trade = (double*) myalloc1( count );
    40344072           if (myid ==root){
    40354073               for(mpi_i =0; mpi_i < count; mpi_i++){
    4036                  trade[mpi_i] = dp_T[loc_send+mpi_i];
     4074                 trade[mpi_i] = dp_T[loc_send[mpi_i]];
    40374075              }
    40384076           }
     
    40404078           if ( myid != root){
    40414079              for( mpi_i =0; mpi_i < count; mpi_i++)
    4042                  dp_T[loc_recv+mpi_i] = trade[mpi_i];
    4043            }
    4044            myfree1(trade);
     4080                 dp_T[loc_send[mpi_i]] = trade[mpi_i];
     4081           }
     4082           free(trade);
    40454083#endif
    40464084#if defined(_FOV_)
     
    40494087              for(mpi_i =0; mpi_i < count; mpi_i++)
    40504088                 for(i=0; i<p; i++)
    4051                     trade[p*mpi_i+i] = dpp_T[loc_recv+mpi_i][i];
     4089                    trade[p*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
    40524090           }
    40534091           MPI_Bcast(trade,count*p, MPI_DOUBLE, root, MPI_COMM_WORLD);
     
    40554093              for(mpi_i =0; mpi_i < count; mpi_i++)
    40564094                 for(i=0; i<p; i++)
    4057                     dpp_T[loc_recv+mpi_i][i] = trade[p*mpi_i+i];
    4058            }
    4059            myfree1(trade);
     4095                    dpp_T[loc_send[mpi_i]][i] = trade[p*mpi_i+i];
     4096           }
     4097           free(trade);
    40604098#endif
    40614099#if defined(_HOS_)
     
    40644102             for(mpi_i =0; mpi_i < count; mpi_i++)
    40654103                for(i=0; i<k; i++)
    4066                    trade[k*mpi_i+i] = dpp_T[loc_recv+mpi_i][i];
     4104                   trade[k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
    40674105           }
    40684106           MPI_Bcast(trade,count*k, MPI_DOUBLE, root, MPI_COMM_WORLD);
     
    40704108              for(mpi_i =0; mpi_i < count; mpi_i++)
    40714109                 for(i=0; i<k; i++)
    4072                     dpp_T[loc_recv+mpi_i][i] = trade[k*mpi_i+i];
    4073            }
    4074            myfree1(trade);
     4110                    dpp_T[loc_send[mpi_i]][i] = trade[k*mpi_i+i];
     4111           }
     4112           free(trade);
    40754113#endif
    40764114#if defined(_HOV_)
     
    40794117              for(mpi_i =0; mpi_i < count; mpi_i++)
    40804118                 for(i=0; i<p*k; i++)
    4081                     trade[p*k*mpi_i+i] = dpp_T[loc_recv+mpi_i][i];
     4119                    trade[p*k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
    40824120           }
    40834121           MPI_Bcast(trade,count*p*k, MPI_DOUBLE, root, MPI_COMM_WORLD);
     
    40854123              for(mpi_i =0; mpi_i < count; mpi_i++)
    40864124                 for(i=0; i<p*k; i++)
    4087                     dpp_T[loc_recv+mpi_i][i] = trade[p*k*mpi_i+i];
    4088            }
    4089            myfree1(trade);
     4125                    dpp_T[loc_send[mpi_i]][i] = trade[p*k*mpi_i+i];
     4126           }
     4127           free(trade);
    40904128#endif
    40914129#if defined(_INDO_)
     
    40944132           if (myid ==root){
    40954133              for(mpi_i =0; mpi_i < count; mpi_i++)
    4096                  counts[mpi_i] = ind_dom[loc_recv+mpi_i][0];
     4134                 counts[mpi_i] = ind_dom[loc_send[mpi_i]][0];
    40974135           }
    40984136           MPI_Bcast(counts,count, MPI_INT, root, MPI_COMM_WORLD);
     
    41074145                 l=0;
    41084146                 for(mpi_i =0; mpi_i < anz; mpi_i++)
    4109                     for(i=2; i < ind_dom[loc_recv+mpi_i][0]+2; i++){
    4110                        trade_loc[l] = ind_dom[loc_recv+mpi_i][i];
     4147                    for(i=2; i < ind_dom[loc_send[mpi_i]][0]+2; i++){
     4148                       trade_loc[l] = ind_dom[loc_send[mpi_i]][i];
    41114149                       l++;
    41124150                    }
     
    41174155                 l = 0;
    41184156                 for(mpi_i=0; mpi_i < count; mpi_i++){
    4119                     combine_index_domain_received_data(loc_recv+mpi_i, counts[mpi_i], ind_dom, &trade_loc[l] );
     4157                    combine_index_domain_received_data(loc_send[mpi_i], counts[mpi_i], ind_dom, &trade_loc[l] );
    41204158                    l += counts[mpi_i];
    41214159                 }
     
    41574195                 }
    41584196              }
    4159               free((char*) trade_loc);
    4160            }
    4161            free((char*) counts);
     4197              free(trade_loc);
     4198           }
     4199           free(counts);
    41624200#endif    // end _NONLIND_
     4201           free(loc_send);
    41634202           break;
    41644203      case reduce:
    4165            loc_send = get_locint_f(); // Send Location
    4166            loc_recv = get_locint_f(); // Receive Location
     4204           use_reduce=1;
     4205      case gather:
     4206           count = get_locint_f(); // count
     4207           loc_send = (int*) malloc(count*sizeof(int));
     4208           for(mpi_i=0; mpi_i < count ; mpi_i++)
     4209               loc_send[mpi_i] = get_locint_f(); // Send Location
    41674210           count = get_locint_f(); // count
    41684211           root = get_locint_f(); // root
    41694212           myid = get_locint_f(); // process id
    4170            mpi_op = get_locint_f(); // MPI_Operation
     4213           count2 = get_locint_f(); // count*process_count
     4214           if(myid==root){
     4215             loc_recv = (int*) malloc(count2*sizeof(int));
     4216             for(mpi_i=0; mpi_i < count2 ; mpi_i++)
     4217                loc_recv[mpi_i] = get_locint_f(); // Receive Location
     4218           arg = get_locint_f(); // count*process_count
     4219           }
     4220           if (use_reduce == 1)
     4221              mpi_op = get_locint_f();
    41714222#if !defined(_NTIGHT_)
    41724223           // receiving values for dp_T0
    41734224           trade = (double*) myalloc1( count );
    41744225           if (myid == root)
    4175               rec_buf = (double*) myalloc1(count);
     4226              rec_buf = (double*) myalloc1(count2);
    41764227           else
    41774228              rec_buf =NULL;
    41784229           for(mpi_i =0; mpi_i < count; mpi_i++)
    4179               trade[mpi_i] = dp_T0[loc_send+mpi_i];
    4180 
    4181            MPI_Reduce(trade,rec_buf,count, MPI_DOUBLE, adolc_to_mpi_op(mpi_op), root, MPI_COMM_WORLD);
     4230              trade[mpi_i] = dp_T0[loc_send[mpi_i]];
     4231
     4232           MPI_Gather(trade,count, MPI_DOUBLE,rec_buf, count,MPI_DOUBLE, root, MPI_COMM_WORLD);
     4233           if (myid == root){
     4234              for( mpi_i =0; mpi_i < count2; mpi_i++){
     4235                 IF_KEEP_WRITE_TAYLOR(loc_recv[mpi_i],keep,k,p)
     4236                 dp_T0[loc_recv[mpi_i]] = rec_buf[mpi_i];
     4237              }
     4238              free(rec_buf);
     4239           }
     4240           free(trade);
     4241#endif /* END NOT _NTIGHT_ */
     4242#if defined(_INT_FOR_)
     4243           trade_loc = (int*) malloc(count*p*sizeof(int));
     4244           if (myid == root)
     4245             rec_buf_loc = (int*) malloc(count2*p*sizeof(int));
     4246           else
     4247              rec_buf =NULL;
     4248           for (mpi_i=0; mpi_i< count; mpi_i++) {
     4249               FOR_0_LE_l_LT_pk
     4250                trade_loc[mpi_i*p+l]=up_T[loc_send[mpi_i]][l];
     4251           }
     4252           MPI_Gather(trade_loc,count*p, MPI_INT,rec_buf_loc, count*p,MPI_INT, root, MPI_COMM_WORLD);
    41824253           if (myid == root){
    41834254              for( mpi_i =0; mpi_i < count; mpi_i++){
    4184                  IF_KEEP_WRITE_TAYLOR(loc_recv+mpi_i,keep,k,p)
    4185                  dp_T0[loc_recv+mpi_i] = rec_buf[mpi_i];
     4255                 FOR_0_LE_l_LT_pk
     4256                  up_T[loc_recv[mpi_i]][l] = rec_buf_loc[mpi_i*p+l];
    41864257              }
    4187               myfree1(rec_buf);
    4188            }
    4189            myfree1(trade);
    4190 #endif /* END NOT _NTIGHT_ */
     4258              free(rec_buf_loc);
     4259           }
     4260           free(trade_loc);
     4261#endif /* END INT_FOR */
    41914262#if defined(_FOS_)
    41924263           trade = (double*) myalloc1( count );
    41934264           if (myid ==root)
    4194                rec_buf = (double*) myalloc1(count);
     4265               rec_buf = (double*) myalloc1(count2);
    41954266           else
    41964267               rec_buf = NULL;
    41974268           for(mpi_i =0; mpi_i < count; mpi_i++) {
    4198               trade[mpi_i] = dp_T[loc_recv + mpi_i];
    4199            }
    4200            MPI_Reduce(trade,rec_buf,count, MPI_DOUBLE, adolc_to_mpi_op(mpi_op), root, MPI_COMM_WORLD);
     4269              trade[mpi_i] = dp_T[loc_send[mpi_i]];
     4270           }
     4271           MPI_Gather(trade,count, MPI_DOUBLE,rec_buf, count,MPI_DOUBLE, root, MPI_COMM_WORLD);
    42014272           if ( myid == root){
    4202               for( mpi_i =0; mpi_i < count; mpi_i++){
    4203                  dp_T[loc_send+mpi_i] = rec_buf[mpi_i];
     4273              for( mpi_i =0; mpi_i < count2; mpi_i++){
     4274                 dp_T[loc_recv[mpi_i]] = rec_buf[mpi_i];
    42044275               }
    4205               myfree1(rec_buf);
    4206            }
    4207            myfree1(trade);
     4276               free(rec_buf);
     4277           }
     4278           free(trade);
    42084279#endif
    42094280#if defined(_FOV_)
    42104281           trade = (double*) myalloc1( count*p);
    42114282           if (myid == root)
    4212               rec_buf = (double*) myalloc1(count*p);
     4283              rec_buf = (double*) myalloc1(count2*p);
    42134284           else
    42144285              rec_buf=NULL;
    42154286           for(mpi_i =0; mpi_i < count; mpi_i++)
    42164287              for(i=0; i<p; i++)
    4217                  trade[p*mpi_i+i] = dpp_T[loc_recv+mpi_i][i];
    4218 
    4219            MPI_Reduce(trade,rec_buf,count*p, MPI_DOUBLE,adolc_to_mpi_op(mpi_op), root, MPI_COMM_WORLD);
     4288                 trade[p*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4289
     4290           MPI_Gather(trade,count*p, MPI_DOUBLE,rec_buf, count*p,MPI_DOUBLE, root, MPI_COMM_WORLD);
    42204291           if ( myid == root){
    4221               for(mpi_i =0; mpi_i < count; mpi_i++)
     4292              for(mpi_i =0; mpi_i < count2; mpi_i++)
    42224293                 for(i=0; i<p; i++)
    4223                     dpp_T[loc_send+mpi_i][i] = rec_buf[p*mpi_i+i];
    4224               myfree1(rec_buf);
    4225            }
    4226            myfree1(trade);
     4294                    dpp_T[loc_recv[mpi_i]][i] = rec_buf[p*mpi_i+i];
     4295              free(rec_buf);
     4296           }
     4297           free(trade);
    42274298#endif
    42284299#if defined(_HOS_)
    42294300           trade = (double*) myalloc1(count * k);
    42304301           if (myid ==root)
    4231               rec_buf = (double*) myalloc1(count*k);
     4302              rec_buf = (double*) myalloc1(count2*k);
    42324303           else
    42334304              rec_buf=NULL;
    42344305           for(mpi_i =0; mpi_i < count; mpi_i++)
    42354306              for(i=0; i<k; i++)
    4236                  trade[k*mpi_i+i] = dpp_T[loc_recv + mpi_i][i];
    4237 
    4238            MPI_Reduce(trade,rec_buf,count*k, MPI_DOUBLE,adolc_to_mpi_op(mpi_op), root, MPI_COMM_WORLD);
     4307                 trade[k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4308
     4309           MPI_Gather(trade,count*k, MPI_DOUBLE,rec_buf, count*k,MPI_DOUBLE, root, MPI_COMM_WORLD);
    42394310           if ( myid == root){
    4240               for(mpi_i =0; mpi_i < count; mpi_i++)
     4311              for(mpi_i =0; mpi_i < count2; mpi_i++)
    42414312                 for(i=0; i<k; i++)
    4242                     dpp_T[loc_send+mpi_i][i] = rec_buf[k*mpi_i+i];
    4243               myfree1(rec_buf);
    4244            }
    4245            myfree1(trade);
     4313                    dpp_T[loc_recv[mpi_i]][i] = rec_buf[k*mpi_i+i];
     4314              free(rec_buf);
     4315           }
     4316           free(trade);
    42464317#endif
    42474318#if defined(_HOV_)
    42484319           trade = (double*) myalloc1(count * p*k);
    42494320           if (myid == root)
    4250               rec_buf = (double*) myalloc1(count*p*k);
     4321              rec_buf = (double*) myalloc1(count2*p*k);
    42514322           else
    42524323              rec_buf=NULL;
    42534324           for(mpi_i =0; mpi_i < count; mpi_i++)
    42544325              for(i=0; i<p*k; i++)
    4255                  trade[p*k*mpi_i+i] = dpp_T[loc_recv+mpi_i][i];
    4256 
    4257            MPI_Reduce(trade,rec_buf,count*p*k, MPI_DOUBLE,adolc_to_mpi_op(mpi_op), root, MPI_COMM_WORLD);
     4326                 trade[p*k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4327
     4328           MPI_Gather(trade,count*p*k, MPI_DOUBLE,rec_buf, count*p*k,MPI_DOUBLE, root, MPI_COMM_WORLD);
    42584329           if ( myid == root){
    4259               for(mpi_i =0; mpi_i < count; mpi_i++)
     4330              for(mpi_i =0; mpi_i < count2; mpi_i++)
    42604331                 for(i=0; i<p*k; i++)
    4261                     dpp_T[loc_send+mpi_i][i] = rec_buf[p*k*mpi_i+i];
    4262               myfree1(rec_buf);
    4263            }
    4264            myfree1(trade);
     4332                    dpp_T[loc_recv[mpi_i]][i] = rec_buf[p*k*mpi_i+i];
     4333              free(rec_buf);
     4334           }
     4335           free(trade);
    42654336#endif
    42664337#if defined(_INDO_)
     
    42684339           counts = ( int*) malloc( count*sizeof(int) );
    42694340           if( myid == root)
    4270               tmp_counts = ( int*) malloc( count*sizeof(int)* process_count );
    4271 
    4272            for(mpi_i =0; mpi_i < count; mpi_i++){
    4273               counts[mpi_i] = ind_dom[loc_recv+mpi_i][0];
    4274                }
     4341              tmp_counts = ( int*) malloc( count2*sizeof(int) );
     4342           else
     4343              tmp_counts = NULL;
     4344
     4345           for(mpi_i =0; mpi_i < count; mpi_i++)
     4346                counts[mpi_i] = ind_dom[loc_send[mpi_i]][0];
    42754347
    42764348           MPI_Gather(counts,count, MPI_INT, tmp_counts, count, MPI_INT, root, MPI_COMM_WORLD);
    4277 
    4278            if ( myid == root){
    4279               for(i=0; i < count ; i++){
    4280                  for(mpi_i = 1 ; mpi_i < process_count ; mpi_i++)
    4281                      if ( tmp_counts[i] < tmp_counts[i+ mpi_i*count] )
    4282                         tmp_counts[i] = tmp_counts[i+ mpi_i*count];
     4349           if (myid == root){
     4350              for(mpi_i =0; mpi_i < count; mpi_i++ ){
     4351                 for(i=1; i < process_count; i++ )
     4352                   if( counts[mpi_i] < tmp_counts[count*i + mpi_i])
     4353                         counts[mpi_i] = tmp_counts[count*i + mpi_i];
     4354              }
     4355           }
     4356           MPI_Bcast(counts,count,MPI_INT, root, MPI_COMM_WORLD);
     4357           anz=0;
     4358           for(mpi_i =0; mpi_i < count; mpi_i++ )
     4359                anz += counts[mpi_i];
     4360
     4361           // every process has same counts
     4362           if ( anz > 0){
     4363              trade_loc = (int*) malloc( anz*sizeof(int) );
     4364              l=0;
     4365              for(mpi_i =0; mpi_i < count; mpi_i++){
     4366                 for (i=2; i < ind_dom[loc_send[mpi_i]][0]+2; i++){
     4367                    trade_loc[l] = ind_dom[loc_send[mpi_i]][i];
     4368                    l++;
    42834369                 }
    4284               for(i=0; i < count ; i++){
    4285                  counts[i] = tmp_counts[i];
     4370                 for(i=ind_dom[loc_send[mpi_i]][0]; i < counts[mpi_i] ; i++  ){
     4371                    trade_loc[l] = -10;
     4372                    l++;
     4373                 }
    42864374              }
     4375              if (myid == root) rec_buf_loc = (int*) malloc(process_count * anz * sizeof(int) );
     4376              else  rec_buf_loc = NULL ;
     4377
     4378              MPI_Gather(trade_loc, anz, MPI_INT, rec_buf_loc, anz, MPI_INT, root, MPI_COMM_WORLD);
     4379              free( trade_loc );
     4380
     4381              if(myid == root){
     4382                l = 0;
     4383                for(i=0;i<process_count; i++) {
     4384                   for(mpi_i=0; mpi_i < count; mpi_i++){
     4385                      combine_index_domain_received_data(loc_recv[mpi_i], tmp_counts[i*count+mpi_i], ind_dom, &rec_buf_loc[l] );
     4386                      l += counts[mpi_i];
     4387                   }
     4388                }
     4389              free(rec_buf_loc);
    42874390              free(tmp_counts);
    4288           }
    4289            MPI_Bcast(counts ,count, MPI_INT, root, MPI_COMM_WORLD);
    4290 
    4291            anz =0;
    4292            for (mpi_i=0; mpi_i< count; mpi_i++) {
    4293                anz += counts[mpi_i];
    4294            }
     4391              }
     4392           }
     4393           free(counts);
     4394#endif
     4395#if defined(_NONLIND_)
     4396           // getting information about count of entries
     4397           counts = ( int*) malloc( count*sizeof(int) );
     4398           if( myid == root)
     4399              tmp_counts = ( int*) malloc( count2*sizeof(int) );
     4400           else
     4401              tmp_counts = NULL;
     4402
     4403           for(mpi_i =0; mpi_i < count; mpi_i++)
     4404                counts[mpi_i] = nonl_dom[mpi_i][0];
     4405
     4406           MPI_Gather(counts,count, MPI_INT, tmp_counts, count, MPI_INT, root, MPI_COMM_WORLD);
     4407           if (id == root){
     4408              for(mpi_i =0; mpi_i < count; mpi_i++ ){
     4409                 for(i=1; i < process_count; i++ )
     4410                   if( counts[mpi_i] < tmp_counts[count*i + mpi_i])
     4411                         counts[mpi_i] = tmp_counts[count*i + mpi_i];
     4412              }
     4413           }
     4414           MPI_Bcast(counts,count,MPI_INT, root, MPI_COMM_WORLD);
     4415           anz=0;
     4416           for(mpi_i =0; mpi_i < count; mpi_i++ )
     4417                anz += counts[mpi_i];
     4418
    42954419           // every process has same counts
    42964420           if ( anz > 0){
     
    43024426              l=0;
    43034427              for(mpi_i =0; mpi_i < count; mpi_i++){
    4304                  for (i=2; i < ind_dom[loc_recv+mpi_i][0]+2; i++){
    4305                     trade_loc[l] = ind_dom[loc_recv+mpi_i][i];
     4428                 for (i=2; i < nonl_dom[mpi_i][0]+2; i++){
     4429                    trade_loc[l] = nonl_dom[mpi_i][i];
    43064430                    l++;
    43074431                 }
    4308                  for(i=ind_dom[loc_recv+mpi_i][0]; i < counts[mpi_i] ; i++  ){
     4432                 for(i=nonl_dom[mpi_i][0]; i < counts[0] ; i++  ){
    43094433                    trade_loc[l] = -10;
    43104434                    l++;
     
    43144438              free( trade_loc );
    43154439              if(myid == root){
    4316                  // combine each index domain ...
    4317                  l = anz;
    4318                  for(mpi_id=1; mpi_id < process_count; mpi_id++ ){
    4319 
    4320                     for(mpi_i=0; mpi_i < count; mpi_i++){
    4321                        i = 0;
    4322                        while ((rec_buf_loc[l+i] > -1 ) && ( i < counts[mpi_i]) ) {
    4323                               i++;
    4324                             }
    4325                        combine_index_domain_received_data(loc_send+mpi_i, i, ind_dom, &rec_buf_loc[l] );
    4326                        l += counts[mpi_i];
     4440                 // rewrite each index domain  rec_buf_loc[pc*process_count*anz + count]
     4441                 l = 0;
     4442                 for(mpi_i=0; mpi_i < count2; mpi_i++){
     4443                    i = 0;
     4444                    free(nonl_dom[mpi_i]);
     4445                    nonl_dom[mpi_i] = (locint*) calloc(2*tmp_counts[mpi_i]+2,sizeof(locint));
     4446                    nonl_dom[mpi_i][1] = 2*tmp_counts[mpi_i];
     4447                    while ((rec_buf_loc[l+i] > -1 ) && ( i < tmp_counts[mpi_i]) ) {
     4448                       nonl_dom[mpi_i][i+2]= rec_buf_loc[l+i];
     4449                       i++;
    43274450                    }
     4451                    nonl_dom[mpi_i][0]= i;
     4452                    l += counts[mpi_i];
    43284453                 }
    4329                  free(rec_buf_loc);
    43304454              }
    4331            }
    4332          free(counts);
    4333 #endif
    4334 #if defined(_NONLIND_)
    4335            tmp_element = (locint*) malloc( sizeof(locint) );
     4455              free(rec_buf_loc);
     4456           }
     4457           if( myid == root) free(tmp_counts);
     4458           free(counts);
     4459#endif    // end _NONLIND_
     4460           if( myid == root) free(loc_recv);
     4461           free(loc_send);
     4462           use_reduce=0;
     4463           break;
     4464      case scatter:
     4465           count = get_locint_f(); // count*procsize
     4466           if(myid == root){
     4467             loc_send = (int*) malloc(count*sizeof(int));
     4468             for(mpi_i=0; mpi_i < count ; mpi_i++)
     4469               loc_send[mpi_i] = get_locint_f(); // Send Location
     4470             count = get_locint_f(); // count*procsize
     4471           }
     4472           root = get_locint_f(); // root
     4473           myid = get_locint_f(); // process id
     4474           count2 = get_locint_f(); // count
     4475           loc_recv = (int*) malloc(count2*sizeof(int));
     4476           for(mpi_i=0;mpi_i< count2; mpi_i++)
     4477             loc_recv[mpi_i] = get_locint_f(); // Receive Location
     4478           count2 = get_locint_f(); // count
     4479
     4480#if !defined(_NTIGHT_)
     4481           // receiving values for dp_T0
     4482           if (myid == root)
     4483               trade = (double*) myalloc1( count );
     4484           else
     4485              trade = NULL;
     4486
     4487           rec_buf = (double*) myalloc1(count2);
     4488
     4489           if(myid == root)
     4490             for(mpi_i =0; mpi_i < count; mpi_i++)
     4491                trade[mpi_i] = dp_T0[loc_send[mpi_i]];
     4492
     4493           MPI_Scatter(trade,count2, MPI_DOUBLE,rec_buf, count2 ,MPI_DOUBLE, root, MPI_COMM_WORLD);
     4494
     4495           for( mpi_i =0; mpi_i < count2; mpi_i++){
     4496               IF_KEEP_WRITE_TAYLOR(loc_recv[mpi_i],keep,k,p)
     4497               dp_T0[loc_recv[mpi_i]] = rec_buf[mpi_i];
     4498           }
     4499           free(rec_buf);
     4500           if(myid==root) free(trade);
     4501#endif /* END NOT _NTIGHT_ */
     4502#if defined(_INT_FOR_)
     4503           if (myid == root)
     4504             trade_loc = (int*) malloc(count*p*sizeof(int));
     4505           else
     4506             trade_loc =NULL;
     4507           rec_buf_loc = (int*) malloc(count2*p*sizeof(int));
     4508           for (mpi_i=0; mpi_i< count; mpi_i++) {
     4509               FOR_0_LE_l_LT_pk
     4510                trade_loc[mpi_i*p+l]=up_T[loc_send[mpi_i]][l];
     4511           }
     4512           MPI_Scatter(trade_loc,count2*p, MPI_INT,rec_buf_loc, count2*p ,MPI_INT, root, MPI_COMM_WORLD);
     4513
     4514           for( mpi_i =0; mpi_i < count; mpi_i++){
     4515              FOR_0_LE_l_LT_pk
     4516                up_T[loc_recv[mpi_i]][l] = rec_buf_loc[mpi_i*p+l];
     4517           }
     4518           free(rec_buf_loc);
     4519           if(myid==root) free(trade_loc);
     4520#endif /* END INT_FOR */
     4521#if defined(_FOS_)
     4522           rec_buf = (double*) myalloc1( count2 );
     4523           if (myid ==root)
     4524               trade = (double*) myalloc1(count);
     4525           else
     4526               trade = NULL;
     4527
     4528           if ( myid == root){
     4529              for(mpi_i =0; mpi_i < count; mpi_i++)
     4530                 trade[mpi_i] = dp_T[loc_send[mpi_i]];
     4531           }
     4532           MPI_Scatter(trade,count2, MPI_DOUBLE,rec_buf, count2, MPI_DOUBLE, root, MPI_COMM_WORLD);
     4533
     4534           for( mpi_i =0; mpi_i < count2; mpi_i++){
     4535              dp_T[loc_recv[mpi_i]] = rec_buf[mpi_i];
     4536           }
     4537           free(rec_buf);
     4538           if(myid==root) free(trade);
     4539#endif
     4540#if defined(_FOV_)
     4541          rec_buf = (double*) myalloc1( count2*p);
     4542           if (myid == root)
     4543              trade = (double*) myalloc1(count*p);
     4544           else
     4545              trade = NULL;
     4546
     4547           if( myid == root){
     4548              for(mpi_i =0; mpi_i < count; mpi_i++)
     4549                 for(i=0; i<p; i++)
     4550                    trade[p*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4551           }
     4552
     4553           MPI_Scatter(trade,count2*p, MPI_DOUBLE,rec_buf, count2*p,MPI_DOUBLE, root, MPI_COMM_WORLD);
     4554
     4555           for(mpi_i =0; mpi_i < count2; mpi_i++)
     4556              for(i=0; i<p; i++)
     4557                 dpp_T[loc_recv[mpi_i]][i] = rec_buf[p*mpi_i+i];
     4558
     4559           free(rec_buf);
     4560           if(myid==root) free(trade);
     4561#endif
     4562#if defined(_HOS_)
     4563           if (myid ==root)
     4564              trade = (double*) myalloc1(count * k);
     4565           else
     4566              trade=NULL;
     4567           rec_buf = (double*) myalloc1(count2*k);
     4568
     4569           if(myid== root){
     4570              for(mpi_i =0; mpi_i < count; mpi_i++)
     4571                 for(i=0; i<k; i++)
     4572                    trade[k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4573           }
     4574
     4575           MPI_Scatter(trade,count2*k, MPI_DOUBLE,rec_buf, count2*k,MPI_DOUBLE, root, MPI_COMM_WORLD);
     4576
     4577           for(mpi_i =0; mpi_i < count2; mpi_i++)
     4578              for(i=0; i<k; i++)
     4579                 dpp_T[loc_recv[mpi_i]][i] = rec_buf[k*mpi_i+i];
     4580
     4581           free(rec_buf);
     4582           if(myid==root) free(trade);
     4583#endif
     4584#if defined(_HOV_)
     4585           rec_buf = (double*) myalloc1(count2*p*k);
     4586           if (myid == root)
     4587              trade = (double*) myalloc1(count * p*k);
     4588           else
     4589              trade = NULL;
     4590
     4591           if(myid == root){
     4592              for(mpi_i =0; mpi_i < count; mpi_i++)
     4593                 for(i=0; i<p*k; i++)
     4594                    trade[p*k*mpi_i+i] = dpp_T[loc_send[mpi_i]][i];
     4595           }
     4596
     4597           MPI_Gather(trade,count2*p*k, MPI_DOUBLE,rec_buf, count2*p*k,MPI_DOUBLE, root, MPI_COMM_WORLD);
     4598
     4599           for(mpi_i =0; mpi_i < count2; mpi_i++)
     4600              for(i=0; i<p*k; i++)
     4601                 dpp_T[loc_recv[mpi_i]][i] = rec_buf[p*k*mpi_i+i];
     4602
     4603           free(rec_buf);
     4604           if(myid==root) free(trade);
     4605#endif
     4606#if defined(_INDO_)
     4607           // getting information about count of entries
    43364608           counts = ( int*) malloc( sizeof(int) );
    4337            tmp_element[0] = 0;
    4338            for(mpi_i =0; mpi_i < s_r_indep; mpi_i++)
    4339                if( tmp_element[0] < nonl_dom[mpi_i][0] )
    4340                      tmp_element[0] = nonl_dom[mpi_i][0];
    4341            MPI_Allreduce(tmp_element,counts, 1, MPI_INT, MPI_MAX , MPI_COMM_WORLD);
    4342            free(tmp_element);
    4343 
    4344            anz = counts[0] * s_r_indep;
    4345 
    4346            if (anz > 0) {
    4347               trade_loc = (int*) malloc( anz*sizeof(int) );
    4348               if (myid == root)
    4349                  rec_buf_loc = (int*) malloc(anz*process_count*sizeof(int) );
    4350               else
    4351                  rec_buf_loc = NULL;
    4352               l=0;
    4353               for(mpi_i=0; mpi_i < s_r_indep ; mpi_i++){
    4354                  for(i=0; i < nonl_dom[mpi_i][0] ; i++){
    4355                     trade_loc[l] = nonl_dom[mpi_i][i+2];
     4609           if(myid== root){
     4610              counts[0] = ind_dom[loc_send[0]][0];
     4611              for(mpi_i =1; mpi_i < count; mpi_i++)
     4612                 if(counts[0] < ind_dom[loc_send[mpi_i]][0])
     4613                     counts[0] = ind_dom[loc_send[mpi_i]][0];
     4614           }
     4615           MPI_Bcast(counts,1,MPI_INT, root, MPI_COMM_WORLD);
     4616           l=0;
     4617           if(myid == root){
     4618              trade_loc = (int*) calloc(count*counts[0],sizeof(int));
     4619              for(mpi_i =0; mpi_i < count; mpi_i++ )
     4620                 for (i=2; i < ind_dom[loc_send[mpi_i]][0]+2; i++){
     4621                    trade_loc[l] = ind_dom[loc_send[mpi_i]][i];
     4622                    l++;
     4623                    }
     4624              for(i=ind_dom[loc_send[mpi_i]][0]; i < counts[0] ; i++  ){
     4625                    trade_loc[l] = -10;
    43564626                    l++;
    43574627                 }
    4358                  for(i= nonl_dom[mpi_i][0]; i < counts[0] ; i++){
    4359                     trade_loc[l] = -10 ;
     4628           }
     4629           rec_buf_loc = ( int*) malloc(counts[0]*count2*sizeof(int) );
     4630           MPI_Scatter(trade_loc,counts[0]*count2, MPI_INT, rec_buf_loc, counts[0]*count2, MPI_INT, root, MPI_COMM_WORLD);
     4631
     4632           if(myid == root) free( trade_loc );
     4633           l = 0;
     4634           for(mpi_i=0; mpi_i < count2; mpi_i++){
     4635               i = 0;
     4636               free(ind_dom[loc_recv[mpi_i]]);
     4637               ind_dom[loc_recv[mpi_i]] = (locint*) calloc(2*tmp_counts[0]+2,sizeof(locint));
     4638               ind_dom[loc_recv[mpi_i]][1] = 2*counts[0];
     4639
     4640               while ((rec_buf_loc[l+i] > -1 ) && ( i < counts[0]) ) {
     4641                       ind_dom[loc_recv[mpi_i]][i+2]= rec_buf_loc[l+i];
     4642                       i++;
     4643               }
     4644               ind_dom[loc_recv[mpi_i]][0]= i;
     4645               l += counts[0];
     4646           }
     4647
     4648           free(rec_buf_loc);
     4649           free(counts);
     4650#endif
     4651#if defined(_NONLIND_)
     4652           // getting information about count of entries
     4653           counts = ( int*) malloc( sizeof(int) );
     4654           if(myid== root){
     4655              counts[0] = nonl_dom[0][0];
     4656              for(mpi_i =1; mpi_i < count; mpi_i++)
     4657                 if(counts[0] < nonl_dom[mpi_i][0])
     4658                     counts[0] = nonl_dom[mpi_i][0];
     4659           }
     4660           MPI_Bcast(counts,1,MPI_INT, root, MPI_COMM_WORLD);
     4661           l=0;
     4662           if(myid == root){
     4663              trade_loc = (int*) calloc(count*counts[0],sizeof(int));
     4664              for(mpi_i =0; mpi_i < count; mpi_i++ )
     4665                 for (i=2; i < nonl_dom[mpi_i][0]+2; i++){
     4666                    trade_loc[l] = nonl_dom[mpi_i][i];
     4667                    l++;
     4668                    }
     4669              for(i=nonl_dom[mpi_i][0]; i < counts[0] ; i++  ){
     4670                    trade_loc[l] = -10;
    43604671                    l++;
    43614672                 }
    4362               }
    4363 
    4364               MPI_Gather(trade_loc,anz, MPI_INT,rec_buf_loc, anz, MPI_INT, root, MPI_COMM_WORLD);
    4365               if( myid == root){
    4366                // combine each index domain ...
    4367                  l = 0;
    4368                  for (i=0; i < process_count ; i++){
    4369                     for (mpi_i=0; mpi_i < s_r_indep; mpi_i++){
    4370                      // nonl_dom settings
    4371                         mpi_id=0;
    4372                         while ((rec_buf_loc[l + mpi_id] > -1) && (mpi_id < counts[0]) ) {
    4373                               mpi_id++;
    4374                         }
    4375                         extend_nonlinearity_domain_combine_received_trade(mpi_i, mpi_id, nonl_dom, &rec_buf_loc[l]);
    4376                         l +=counts[0];
    4377                     }
    4378                  }
    4379                  free(rec_buf_loc);
    4380               }
    4381               free(trade_loc);
    4382            }
     4673           }
     4674           rec_buf_loc = ( int*) malloc(counts[0]*count2*sizeof(int) );
     4675           MPI_Scatter(trade_loc,counts[0]*count2, MPI_INT, rec_buf_loc, counts[0]*count2, MPI_INT, root, MPI_COMM_WORLD);
     4676
     4677           if(myid == root) free( trade_loc );
     4678           l = 0;
     4679           for(mpi_i=0; mpi_i < count2; mpi_i++){
     4680               i = 0;
     4681               free(nonl_dom[mpi_i]);
     4682               nonl_dom[mpi_i] = (locint*) calloc(2*tmp_counts[0]+2,sizeof(locint));
     4683               nonl_dom[mpi_i][1] = 2*counts[0];
     4684
     4685               while ((rec_buf_loc[l+i] > -1 ) && ( i < counts[0]) ) {
     4686                       nonl_dom[mpi_i][i+2]= rec_buf_loc[l+i];
     4687                       i++;
     4688               }
     4689               nonl_dom[mpi_i][0]= i;
     4690               l += counts[0];
     4691           }
     4692
     4693           free(rec_buf_loc);
    43834694           free(counts);
    43844695#endif    // end _NONLIND_
     4696           if( myid == root) free(loc_send);
     4697           free(loc_recv);
    43854698           break;
    43864699#endif
  • branches/MPI/ADOL-C/src/usrparms.h

    r175 r273  
    2222/*--------------------------------------------------------------------------*/
    2323/* Buffer sizes */
    24 #define OBUFSIZE  65536 /* 16384 or  524288  */
    25 #define LBUFSIZE  65536 /* 16384 or  524288  */
    26 #define VBUFSIZE  65536 /* 16384 or  524288  */
     24#define OBUFSIZE  524288 /* 16384 or  65536  */
     25#define LBUFSIZE  524288 /* 16384 or  65536  */
     26#define VBUFSIZE  524288 /* 16384 or  65536  */
    2727
    2828/*--------------------------------------------------------------------------*/
    2929/* Buffer size for temporary Taylor store */
    30 #define TBUFSIZE  65536 /* 16384 or  524288  */
     30#define TBUFSIZE  524288 /* 16384 or  65536  */
    3131
    3232/*--------------------------------------------------------------------------*/
  • branches/MPI/ADOL-C/test/Makefile.am

    r171 r273  
    2525fminmax_LDADD           = ../src/libadolc.la
    2626
     27AM_CFLAGS               = @ac_adolc_cflags@
     28AM_CXXFLAGS             = @ac_adolc_cxxflags@
    2729
    2830# Here list all include flags, relative to this "srcdir" directory.  This
  • branches/MPI/ADOL-C/test/Makefile.in

    r253 r273  
    227227speelpenning_LDADD = ../src/libadolc.la
    228228fminmax_LDADD = ../src/libadolc.la
     229AM_CFLAGS = @ac_adolc_cflags@
     230AM_CXXFLAGS = @ac_adolc_cxxflags@
    229231
    230232# Here list all include flags, relative to this "srcdir" directory.  This
Note: See TracChangeset for help on using the changeset viewer.