songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into cvm

Browse Source
This commit is contained in:
graham 2010-11-17 17:25:43 +00:00
commit d132a6bacf
87 changed files with 1015 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
applications/solvers/compressible/rhoSimplecFoam/UEqn.H
View File

@ -1,11 +0,0 @@
// Solve the Momentum equation
tmp<fvVectorMatrix> UEqn
(
fvm::div(phi, U)
+ turbulence->divDevRhoReff(U)
);
UEqn().relax();
solve(UEqn() == -fvc::grad(p));

28
applications/solvers/compressible/rhoSimplecFoam/hEqn.H
View File

@ -1,28 +0,0 @@
{
fvScalarMatrix hEqn
(
fvm::div(phi, h)
- fvm::Sp(fvc::div(phi), h)
- fvm::laplacian(turbulence->alphaEff(), h)
==
fvc::div(phi/fvc::interpolate(rho)*fvc::interpolate(p, "div(U,p)"))
- p*fvc::div(phi/fvc::interpolate(rho))
);
hEqn.relax();
hEqn.solve();
thermo.correct();
rho = thermo.rho();
if (!transonic)
{
rho.relax();
}
Info<< "rho max/min : "
<< max(rho).value() << " "
<< min(rho).value() << endl;
}

10
applications/solvers/compressible/rhoSimplecFoam/pEqn.H
View File

@ -1,3 +1,8 @@
rho = thermo.rho();
rho = max(rho, rhoMin);
rho = min(rho, rhoMax);
rho.relax();
volScalarField p0 = p;
volScalarField AU = UEqn().A();
@ -24,8 +29,8 @@ if (transonic)
+ phid*(fvc::interpolate(p) - fvc::interpolate(p, "UD"))
);
refCast<mixedFvPatchScalarField>(p.boundaryField()[1]).refValue()
= p.boundaryField()[1];
//refCast<mixedFvPatchScalarField>(p.boundaryField()[1]).refValue()
// = p.boundaryField()[1];
fvScalarMatrix pEqn
(
@ -35,6 +40,7 @@ if (transonic)
+ fvc::div(phid)*p
- fvm::laplacian(rho/AtU, p)
);
//pEqn.relax();
pEqn.setReference(pRefCell, pRefValue);

1
applications/solvers/compressible/rhoSimplecFoam/rhoSimplecFoam.C
View File

@ -57,6 +57,7 @@ int main(int argc, char *argv[])
#include "readSIMPLEControls.H"
p.storePrevIter();
rho.storePrevIter();
if (!transonic)
{

4
bin/foamJob
View File

@ -188,12 +188,12 @@ then
fi
mpiopts="-np $NPROCS"
#
#
# is the machine ready to run parallel?
#
echo "Parallel processing using $WM_MPLIB with $NPROCS processors"
case "$WM_MPLIB" in
OPENMPI)
*OPENMPI)
# add hostfile info
for hostfile in \
hostfile \

2
bin/mpirunDebug
View File

@ -221,7 +221,7 @@ done
unset cmd
case "$WM_MPLIB" in
OPENMPI)
*OPENMPI)
cmd="mpirun -app $PWD/mpirun.schema </dev/null"
;;
MPICH)

25
bin/tools/pre-commit-hook
View File

@ -146,13 +146,20 @@ checkIllegalCode()
badFiles=$(
for f in $fileList
do
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -E -hn -e "$reBad" $scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
)
[ -n "$lines" ] && echo "$Indent$f -- lines: $lines"
case "$f" in
# exclude potential makefiles
(wmake/[Mm]akefile* | wmake/rules/*)
;;
(*)
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -E -hn -e "$reBad" $scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
)
[ -n "$lines" ] && echo "$Indent$f -- lines: $lines"
;;
esac
done
)
@ -243,7 +250,7 @@ checkLineLengthNonComments()
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -hn -e '^.\{81,\}' \
--and --not -e "^ *//" \
--and --not -e '^ *//' \
$scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
@ -276,7 +283,7 @@ checkLineLengthNonDirective()
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -hn -e '^.\{81,\}' \
--and --not -e "^ *#" \
--and --not -e '^ *#' \
$scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '

25
bin/tools/pre-receive-hook
View File

@ -109,13 +109,20 @@ checkIllegalCode()
badFiles=$(
for f in $fileList
do
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -E -hn -e "$reBad" $scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
)
[ -n "$lines" ] && echo "$Indent$f -- lines: $lines"
case "$f" in
# exclude potential makefiles
(wmake/[Mm]akefile* | wmake/rules/*)
;;
(*)
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -E -hn -e "$reBad" $scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
)
[ -n "$lines" ] && echo "$Indent$f -- lines: $lines"
;;
esac
done
)
@ -206,7 +213,7 @@ checkLineLengthNonComments()
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -hn -e '^.\{81,\}' \
--and --not -e "^ *//" \
--and --not -e '^ *//' \
$scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '
@ -239,7 +246,7 @@ checkLineLengthNonDirective()
# parse line numbers from grep output:
# <lineNr>: contents
lines=$(git grep -hn -e '^.\{81,\}' \
--and --not -e "^ *#" \
--and --not -e '^ *#' \
$scope"$f" |
sed -e 's@:.*@@' |
tr '\n' ' '

59
doc/changes/inotify.txt
View File

@ -24,21 +24,63 @@ be quite a gain on large numbers of processors.
- all file monitoring is done by an instance of 'fileMonitor' in the Time
class. The fileMonitor class can be found in OSspecific. Default is
to use the (linux-specific) 'inotify' system calls.
If compiled with -DFOAM_USE_STAT it will revert to the current 'stat' system
calls.
class. The fileMonitor class can be found in OSspecific. It uses either
timestamps as before or the (linux-specific) 'inotify' system framework
(available only if compiled with -DFOAM_USE_INOTIFY).
- inotify does not need timestamps. There is no need for fileModificationSkew
- the monitoring can be done in one of four modes as set by
OptimisationSwitches::fileModificationChecking
- timeStamp : old behaviour : all nodes check the timestamp
- inotify : using inotify instead of timestamps
- timeStampMaster,inotifyMaster : only the master node checks the file
and only the master node reads it and distribute it to the
slaves. This makes runTimeModifiable possible on distributed
running (see below).
- distributed running:
- set fileModificationChecking to e.g. timeStampMaster
- decompose a case, e.g. cavity
- copy system and constant to processor0/
- put the all the processor* directories on the wanted nodes inside
the case directory. E.g.
- on master have /tmp/cavity/processor0
- on slaveN have /tmp/cavity/processorN
- so to reiterate:
- there is no need for cavity/constant or cavity/system, all the
dictionaries are only in processor0/constant or processor0/system
- the slave processor directories have no system directory and the
constant directory only contains the mesh.
- start the job in distributed mode by specifying the slave roots
(so one less than the number of processors) with
the -roots command line option:
mpirun -np 2 icoFoam -roots '("/tmp")' -parallel
- the alternative to the -roots option is to have a
cavity/system/decomposeParDict on the master with
distributed yes;
roots ("/tmp");
Details:
- timeStampMaster, inotifyMaster : this works only for IOdictionaries that
are READ_IF_MODIFIED. It means that slaves read exactly the same dictionary
as the master so cannot be used for dictionaries that contain e.g. mesh
specific information.
- inotify is a monitoring framework used to monitor changes in
lots of files (e.g. used in desktop searched like beagle). You specify
files to monitor and then get warned for any changes to these files.
It does not need timestamps. There is no need for fileModificationSkew
to allow for time differences. (there can still temporarily be a difference
in modified status between different processors due to nfs lagging)
in modified status between different processors due to nfs lagging). The big
problem is that it does not work over nfs3 (not sure about nfs4).
- fileMonitor stores two hashtables per file so there is a small overhead
adding and removing files from monitoring.
- if runTimeModifiable is false at start of run no files will get monitored,
however if runTimeModified gets set to false during the run the files
will still get monitored (though never reloaded). This is only a hypothetical
@ -46,7 +88,6 @@ problem in that the kernel still stores events for the monitored files. However
inotify is very efficient - e.g. it gets used to track changes on file systems
for desktop search engines.
- in the old system one could call modified() on any object and get
and uptodate state. In the new system it will return the state from
the last runTime++ (which if it triggered any re-reads will have reset the

8
etc/controlDict
View File

@ -874,6 +874,14 @@ InfoSwitches
OptimisationSwitches
{
fileModificationSkew 10;
//- Modification checking:
// - timeStamp : use modification time on file
// - inotify : use inotify framework
// - timeStampMaster : do time stamp (and file reading) only on master.
// - inotifyMaster : do inotify (and file reading) only on master.
fileModificationChecking timeStampMaster;//inotify;timeStamp;inotifyMaster;
commsType nonBlocking; //scheduled; //blocking;
floatTransfer 0;
nProcsSimpleSum 0;

19
etc/settings.csh
View File

@ -90,17 +90,20 @@ switch ("$compilerInstall")
case OpenFOAM:
switch ("$WM_COMPILER")
case Gcc:
case Gcc++0x:
set gcc_version=gcc-4.4.3
set gmp_version=gmp-5.0.1
set mpfr_version=mpfr-2.4.2
breaksw
case Gcc45:
case Gcc45++0x:
set gcc_version=gcc-4.5.0
set gmp_version=gmp-5.0.1
set mpfr_version=mpfr-2.4.2
set mpc_version=mpc-0.8.1
breaksw
case Gcc44:
case Gcc44++0x:
set gcc_version=gcc-4.4.3
set gmp_version=gmp-5.0.1
set mpfr_version=mpfr-2.4.2
@ -190,6 +193,18 @@ case OpenFOAM:
endsw
#
# add c++0x flags for external programs
#
if ( $?WM_CXXFLAGS ) then
switch ("$WM_COMPILER")
case Gcc*++0x:
setenv WM_CXXFLAGS "$WM_CXXFLAGS -std=c++0x"
breaksw
endsw
endif
# boost and CGAL
# ~~~~~~~~~~~~~~
@ -236,9 +251,7 @@ case OPENMPI:
breaksw
case SYSTEMOPENMPI:
# This uses the installed openmpi. It needs mpicc installed!
# Use the system installed openmpi, get library directory via mpicc
set mpi_version=openmpi-system
# Set compilation flags here instead of in wmake/rules/../mplibSYSTEMOPENMPI

21
etc/settings.sh
View File

@ -111,18 +111,18 @@ unset MPFR_ARCH_PATH
case "${compilerInstall:-OpenFOAM}" in
OpenFOAM)
case "$WM_COMPILER" in
Gcc)
Gcc | Gcc++0x)
gcc_version=gcc-4.4.3
gmp_version=gmp-5.0.1
mpfr_version=mpfr-2.4.2
;;
Gcc45)
Gcc45 | Gcc45++0x)
gcc_version=gcc-4.5.0
gmp_version=gmp-5.0.1
mpfr_version=mpfr-2.4.2
mpc_version=mpc-0.8.1
;;
Gcc44)
Gcc44 | Gcc44++0x)
gcc_version=gcc-4.4.3
gmp_version=gmp-5.0.1
mpfr_version=mpfr-2.4.2
@ -213,6 +213,19 @@ OpenFOAM)
esac
#
# add c++0x flags for external programs
#
if [ -n "$WM_CXXFLAGS" ]
then
case "$WM_COMPILER" in
Gcc*++0x)
WM_CXXFLAGS="$WM_CXXFLAGS -std=c++0x"
;;
esac
fi
# boost and CGAL
# ~~~~~~~~~~~~~~
@ -261,7 +274,7 @@ OPENMPI)
;;
SYSTEMOPENMPI)
# use the system installed openmpi, get library directory via mpicc
# Use the system installed openmpi, get library directory via mpicc
mpi_version=openmpi-system
# Set compilation flags here instead of in wmake/rules/../mplibSYSTEMOPENMPI

4
src/OSspecific/POSIX/Allwmake
View File

@ -12,9 +12,9 @@ unset COMP_FLAGS LINK_FLAGS
if [ -f /usr/include/sys/inotify.h -a "${1%USE_STAT}" = "$1" ]
then
echo "Found <sys/inotify.h> -- using inotify for file monitoring."
unset COMP_FLAGS
export COMP_FLAGS="-DFOAM_USE_INOTIFY"
else
export COMP_FLAGS="-DFOAM_USE_STAT"
unset COMP_FLAGS
fi

31
src/OSspecific/POSIX/clockTime/clockTime.C
View File

@ -24,38 +24,25 @@ License
\*---------------------------------------------------------------------------*/
#include "clockTime.H"
#include "scalar.H"
#include <sys/time.h>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Static Members * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void clockTime::getTime(struct timeval& t)
void Foam::clockTime::getTime(timeType& t)
{
gettimeofday(&t, NULL);
gettimeofday(&t, 0);
}
double clockTime::timeDifference
(
const struct timeval& start,
const struct timeval& end
)
double Foam::clockTime::timeDifference(const timeType& beg, const timeType& end)
{
return end.tv_sec - start.tv_sec + 1E-6*(end.tv_usec - start.tv_usec);
return end.tv_sec - beg.tv_sec + 1E-6*(end.tv_usec - beg.tv_usec);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
clockTime::clockTime()
Foam::clockTime::clockTime()
{
getTime(startTime_);
lastTime_ = startTime_;
@ -65,14 +52,14 @@ clockTime::clockTime()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
double clockTime::elapsedTime() const
double Foam::clockTime::elapsedTime() const
{
getTime(newTime_);
return timeDifference(startTime_, newTime_);
}
double clockTime::timeIncrement() const
double Foam::clockTime::timeIncrement() const
{
lastTime_ = newTime_;
getTime(newTime_);
@ -80,8 +67,4 @@ double clockTime::timeIncrement() const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

36
src/OSspecific/POSIX/clockTime/clockTime.H
View File

@ -44,43 +44,45 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class clockTime Declaration
Class clockTime Declaration
\*---------------------------------------------------------------------------*/
class clockTime
{
// Private data
struct timeval startTime_;
mutable struct timeval lastTime_;
mutable struct timeval newTime_;
//- Time structure used
typedef struct timeval timeType;
static void getTime(struct timeval& t);
timeType startTime_;
static double timeDifference
(
const struct timeval& start,
const struct timeval& end
);
mutable timeType lastTime_;
mutable timeType newTime_;
// Private Member Functions
//- Retrieve the current time values from the system
static void getTime(timeType&);
//- Difference between two times
static double timeDifference(const timeType& beg, const timeType& end);
public:
// Constructors
//- Construct from components
//- Construct with the current clock time
clockTime();
// Member Functions
// Access
//- Return time (in seconds) from the start
double elapsedTime() const;
//- Returns CPU time from start of run
double elapsedTime() const;
//- Returns CPU time from last call of clockTimeIncrement()
double timeIncrement() const;
//- Return time (in seconds) since last call to timeIncrement()
double timeIncrement() const;
};

31
src/OSspecific/POSIX/cpuTime/cpuTime.C
View File

@ -21,45 +21,32 @@ License
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
Starts timing CPU usage and return elapsed time from start.
\*---------------------------------------------------------------------------*/
#include "cpuTime.H"
#include <unistd.h>
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Static Members * * * * * * * * * * * * * * //
long cpuTime::Hz_(sysconf(_SC_CLK_TCK));
const long Foam::cpuTime::Hz_(sysconf(_SC_CLK_TCK));
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void cpuTime::getTime(struct tms& t)
void Foam::cpuTime::getTime(timeType& t)
{
times(&t);
}
double cpuTime::timeDifference
(
const struct tms& start,
const struct tms& end
)
double Foam::cpuTime::timeDifference(const timeType& beg, const timeType& end)
{
return
(
double
(
(end.tms_utime + end.tms_stime)
- (start.tms_utime + start.tms_stime)
- (beg.tms_utime + beg.tms_stime)
)/Hz_
);
}
@ -67,7 +54,7 @@ double cpuTime::timeDifference
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
cpuTime::cpuTime()
Foam::cpuTime::cpuTime()
{
getTime(startTime_);
lastTime_ = startTime_;
@ -77,14 +64,14 @@ cpuTime::cpuTime()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
double cpuTime::elapsedCpuTime() const
double Foam::cpuTime::elapsedCpuTime() const
{
getTime(newTime_);
return timeDifference(startTime_, newTime_);
}
double cpuTime::cpuTimeIncrement() const
double Foam::cpuTime::cpuTimeIncrement() const
{
lastTime_ = newTime_;
getTime(newTime_);
@ -92,8 +79,4 @@ double cpuTime::cpuTimeIncrement() const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

37
src/OSspecific/POSIX/cpuTime/cpuTime.H
View File

@ -54,38 +54,41 @@ class cpuTime
{
// Private data
static long Hz_;
//- Time structure used
typedef struct tms timeType;
struct tms startTime_;
mutable struct tms lastTime_;
mutable struct tms newTime_;
//- Clock-ticks per second
static const long Hz_;
static void getTime(struct tms& t);
//- The start time
timeType startTime_;
mutable timeType lastTime_;
mutable timeType newTime_;
static double timeDifference
(
const struct tms& start,
const struct tms& end
);
// Private Member Functions
//- Retrieve the current time values from the system
static void getTime(timeType&);
//- Difference between two times
static double timeDifference(const timeType& beg, const timeType& end);
public:
// Constructors
//- Construct from components
//- Construct with the current clock time
cpuTime();
// Member Functions
// Access
//- Return CPU time (in seconds) from the start
double elapsedCpuTime() const;
//- Returns CPU time from start of run
double elapsedCpuTime() const;
//- Returns CPU time from last call of cpuTimeIncrement()
double cpuTimeIncrement() const;
//- Return CPU time (in seconds) since last call to cpuTimeIncrement()
double cpuTimeIncrement() const;
};

540
src/OSspecific/POSIX/fileMonitor.C
View File

@ -32,17 +32,17 @@ Class
#include "PackedList.H"
#include "PstreamReduceOps.H"
#include "OSspecific.H"
#include "regIOobject.H" // for fileModificationSkew symbol
#ifdef FOAM_USE_STAT
# include "OSspecific.H"
# include "regIOobject.H" // for fileModificationSkew symbol
#else
#ifdef FOAM_USE_INOTIFY
# include <sys/inotify.h>
# include <sys/ioctl.h>
# include <errno.h>
# define EVENT_SIZE ( sizeof (struct inotify_event) )
# define EVENT_LEN (EVENT_SIZE + 16)
# define EVENT_BUF_LEN ( 1024 * EVENT_LEN )
#else
# include "OSspecific.H"
#endif
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -111,78 +111,77 @@ namespace Foam
{
public:
#ifdef FOAM_USE_STAT
//- From watch descriptor to modified time
DynamicList<time_t> lastMod_;
const bool useInotify_;
//- initialize HashTable size
inline fileMonitorWatcher(const label sz = 20)
:
lastMod_(sz)
{}
// For inotify
inline bool addWatch(const label watchFd, const fileName& fName)
{
if (watchFd < lastMod_.size() && lastMod_[watchFd] != 0)
{
// Reuse of watchFd : should have lastMod set to 0.
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Problem adding watch " << watchFd
<< " to file " << fName
<< abort(FatalError);
}
//- File descriptor for the inotify instance
int inotifyFd_;
lastMod_(watchFd) = lastModified(fName);
return true;
}
//- Current watchIDs and corresponding directory id
DynamicList<label> dirWatches_;
DynamicList<fileName> dirFiles_;
inline bool removeWatch(const label watchFd)
{
lastMod_[watchFd] = 0;
return true;
}
// For stat
//- From watch descriptor to modified time
DynamicList<time_t> lastMod_;
#else
//- File descriptor for the inotify instance
int inotifyFd_;
//- Current watchIDs and corresponding directory id
DynamicList<label> dirWatches_;
DynamicList<fileName> dirFiles_;
//- initialise inotify
inline fileMonitorWatcher(const label sz = 20)
inline fileMonitorWatcher(const bool useInotify, const label sz = 20)
:
inotifyFd_(inotify_init()),
dirWatches_(sz),
dirFiles_(sz)
useInotify_(useInotify)
{
if (inotifyFd_ < 0)
if (useInotify_)
{
static bool hasWarned = false;
if (!hasWarned)
#ifdef FOAM_USE_INOTIFY
inotifyFd_ = inotify_init();
dirWatches_.setCapacity(sz);
dirFiles_.setCapacity(sz);
if (inotifyFd_ < 0)
{
hasWarned = true;
WarningIn("fileMonitorWatcher(const label)")
<< "Failed allocating an inotify descriptor : "
<< string(strerror(errno)) << endl
<< " Please increase the number of allowable "
<< "inotify instances" << endl
<< " (/proc/sys/fs/inotify/max_user_instances"
<< " on Linux)" << endl
<< " , switch off runTimeModifiable." << endl
<< " or compile this file with FOAM_USE_STAT to use"
<< " time stamps instead of inotify." << endl
<< " Continuing without additional file monitoring."
<< endl;
static bool hasWarned = false;
if (!hasWarned)
{
hasWarned = true;
WarningIn("fileMonitorWatcher(const bool, const label)")
<< "Failed allocating an inotify descriptor : "
<< string(strerror(errno)) << endl
<< " Please increase the number of allowable "
<< "inotify instances" << endl
<< " (/proc/sys/fs/inotify/max_user_instances"
<< " on Linux)" << endl
<< " , switch off runTimeModifiable." << endl
<< " or compile this file without "
<< "FOAM_USE_INOTIFY"
<< " to use time stamps instead of inotify." << endl
<< " Continuing without additional file"
<< " monitoring."
<< endl;
}
}
#else
FatalErrorIn("fileMonitorWatcher(const bool, const label)")
<< "You selected inotify but this file was compiled"
<< " without FOAM_USE_INOTIFY"
<< "Please select another fileModification test method"
<< exit(FatalError);
#endif
}
else
{
lastMod_.setCapacity(sz);
}
}
//- remove all watches
inline ~fileMonitorWatcher()
{
if (inotifyFd_ >= 0)
#ifdef FOAM_USE_INOTIFY
if (useInotify_ && inotifyFd_ >= 0)
{
forAll(dirWatches_, i)
{
@ -197,57 +196,92 @@ namespace Foam
}
}
}
#endif
}
inline bool addWatch(const label watchFd, const fileName& fName)
{
if (inotifyFd_ < 0)
if (useInotify_)
{
return false;
if (inotifyFd_ < 0)
{
return false;
}
#ifdef FOAM_USE_INOTIFY
// Add/retrieve watch on directory containing file.
// Note that fName might be non-existing in special situations
// (master-only reading for IODictionaries)
const fileName dir = fName.path();
label dirWatchID = -1;
if (isDir(dir))
{
dirWatchID = inotify_add_watch
(
inotifyFd_,
dir.c_str(),
IN_CLOSE_WRITE
);
if (dirWatchID < 0)
{
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Failed adding watch " << watchFd
<< " to directory " << fName << " due to "
<< string(strerror(errno))
<< exit(FatalError);
}
}
if (watchFd < dirWatches_.size() && dirWatches_[watchFd] != -1)
{
// Reuse of watchFd : should have dir watchID set to -1.
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Problem adding watch " << watchFd
<< " to file " << fName
<< abort(FatalError);
}
dirWatches_(watchFd) = dirWatchID;
dirFiles_(watchFd) = fName.name();
#endif
}
else
{
if (watchFd < lastMod_.size() && lastMod_[watchFd] != 0)
{
// Reuse of watchFd : should have lastMod set to 0.
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Problem adding watch " << watchFd
<< " to file " << fName
<< abort(FatalError);
}
lastMod_(watchFd) = lastModified(fName);
}
// Add/retrieve watch on directory containing file
label dirWatchID = inotify_add_watch
(
inotifyFd_,
fName.path().c_str(),
IN_CLOSE_WRITE
);
if (dirWatchID < 0)
{
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Failed adding watch " << watchFd
<< " to directory " << fName << " due to "
<< string(strerror(errno))
<< exit(FatalError);
}
if (watchFd < dirWatches_.size() && dirWatches_[watchFd] != -1)
{
// Reuse of watchFd : should have dir watchID set to -1.
FatalErrorIn("addWatch(const label, const fileName&)")
<< "Problem adding watch " << watchFd
<< " to file " << fName
<< abort(FatalError);
}
dirWatches_(watchFd) = dirWatchID;
dirFiles_(watchFd) = fName.name();
return true;
}
inline bool removeWatch(const label watchFd)
{
if (inotifyFd_ < 0)
if (useInotify_)
{
return false;
}
if (inotifyFd_ < 0)
{
return false;
}
dirWatches_[watchFd] = -1;
dirWatches_[watchFd] = -1;
}
else
{
lastMod_[watchFd] = 0;
}
return true;
}
#endif
};
//! @endcond
@ -258,131 +292,146 @@ namespace Foam
void Foam::fileMonitor::checkFiles() const
{
#ifdef FOAM_USE_STAT
forAll(watcher_->lastMod_, watchFd)
if (useInotify_)
{
time_t oldTime = watcher_->lastMod_[watchFd];
#ifdef FOAM_USE_INOTIFY
// Large buffer for lots of events
char buffer[EVENT_BUF_LEN];
if (oldTime != 0)
while (true)
{
const fileName& fName = watchFile_[watchFd];
time_t newTime = lastModified(fName);
struct timeval zeroTimeout = {0, 0};
if (newTime == 0)
//- Pre-allocated structure containing file descriptors
fd_set fdSet;
// Add notify descriptor to select fd_set
FD_ZERO(&fdSet);
FD_SET(watcher_->inotifyFd_, &fdSet);
int ready = select
(
watcher_->inotifyFd_+1, // num filedescriptors in fdSet
&fdSet, // fdSet with only inotifyFd
NULL, // No writefds
NULL, // No errorfds
&zeroTimeout // eNo timeout
);
if (ready < 0)
{
state_[watchFd] = DELETED;
FatalErrorIn("fileMonitor::updateStates()")
<< "Problem in issuing select."
<< abort(FatalError);
}
else if (FD_ISSET(watcher_->inotifyFd_, &fdSet))
{
// Read events
ssize_t nBytes = read
(
watcher_->inotifyFd_,
buffer,
EVENT_BUF_LEN
);
if (nBytes < 0)
{
FatalErrorIn("fileMonitor::updateStates(const fileName&)")
<< "read of " << watcher_->inotifyFd_
<< " failed with " << label(nBytes)
<< abort(FatalError);
}
// Go through buffer, consuming events
int i = 0;
while (i < nBytes)
{
const struct inotify_event* inotifyEvent =
reinterpret_cast<const struct inotify_event*>
(
&buffer[i]
);
//Pout<< "watchFd:" << inotifyEvent->wd << nl
// << "mask:" << inotifyEvent->mask << nl
// << endl;
//Pout<< "file:" << fileName(inotifyEvent->name) << endl;
//Pout<< "len:" << inotifyEvent->len << endl;
if
(
(inotifyEvent->mask & IN_CLOSE_WRITE)
&& inotifyEvent->len
)
{
// Search for file
forAll(watcher_->dirWatches_, i)
{
label id = watcher_->dirWatches_[i];
if
(
id == inotifyEvent->wd
&& inotifyEvent->name == watcher_->dirFiles_[i]
)
{
// Correct directory and name
state_[i] = MODIFIED;
}
}
}
i += EVENT_SIZE + inotifyEvent->len;
}
}
else
{
if (newTime > (oldTime + regIOobject::fileModificationSkew))
// No data
return;
}
}
#endif
}
else
{
forAll(watcher_->lastMod_, watchFd)
{
time_t oldTime = watcher_->lastMod_[watchFd];
if (oldTime != 0)
{
const fileName& fName = watchFile_[watchFd];
time_t newTime = lastModified(fName);
if (newTime == 0)
{
watcher_->lastMod_[watchFd] = newTime;
state_[watchFd] = MODIFIED;
state_[watchFd] = DELETED;
}
else
{
state_[watchFd] = UNMODIFIED;
}
}
}
}
#else
// Large buffer for lots of events
char buffer[EVENT_BUF_LEN];
while (true)
{
struct timeval zeroTimeout = {0, 0};
//- Pre-allocated structure containing file descriptors
fd_set fdSet;
// Add notify descriptor to select fd_set
FD_ZERO(&fdSet);
FD_SET(watcher_->inotifyFd_, &fdSet);
int ready = select
(
watcher_->inotifyFd_+1, // num filedescriptors in fdSet
&fdSet, // fdSet with only inotifyFd
NULL, // No writefds
NULL, // No errorfds
&zeroTimeout // eNo timeout
);
if (ready < 0)
{
FatalErrorIn("fileMonitor::updateStates()")
<< "Problem in issuing select."
<< abort(FatalError);
}
else if (FD_ISSET(watcher_->inotifyFd_, &fdSet))
{
// Read events
ssize_t nBytes = read(watcher_->inotifyFd_, buffer, EVENT_BUF_LEN);
if (nBytes < 0)
{
FatalErrorIn("fileMonitor::updateStates(const fileName&)")
<< "read of " << watcher_->inotifyFd_
<< " failed with " << label(nBytes)
<< abort(FatalError);
}
// Go through buffer, consuming events
int i = 0;
while (i < nBytes)
{
const struct inotify_event* inotifyEvent =
reinterpret_cast<const struct inotify_event*>
(
&buffer[i]
);
//Pout<< "watchFd:" << inotifyEvent->wd << nl
// << "mask:" << inotifyEvent->mask << nl
// << endl;
//Pout<< "file:" << fileName(inotifyEvent->name) << endl;
//Pout<< "len:" << inotifyEvent->len << endl;
if ((inotifyEvent->mask & IN_CLOSE_WRITE) && inotifyEvent->len)
{
// Search for file
forAll(watcher_->dirWatches_, i)
if (newTime > (oldTime + regIOobject::fileModificationSkew))
{
label id = watcher_->dirWatches_[i];
if
(
id == inotifyEvent->wd
&& inotifyEvent->name == watcher_->dirFiles_[i]
)
{
// Correct directory and name
state_[i] = MODIFIED;
}
watcher_->lastMod_[watchFd] = newTime;
state_[watchFd] = MODIFIED;
}
else
{
state_[watchFd] = UNMODIFIED;
}
}
i += EVENT_SIZE + inotifyEvent->len;
}
}
else
{
// No data
return;
}
}
#endif
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fileMonitor::fileMonitor()
Foam::fileMonitor::fileMonitor(const bool useInotify)
:
useInotify_(useInotify),
state_(20),
watchFile_(20),
freeWatchFds_(2),
watcher_(new fileMonitorWatcher(20))
watcher_(new fileMonitorWatcher(useInotify_, 20))
{}
@ -394,6 +443,8 @@ Foam::fileMonitor::~fileMonitor()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// Note: fName might not exist (on slaves if in master-only mode for
// regIOobject)
Foam::label Foam::fileMonitor::addWatch(const fileName& fName)
{
label watchFd;
@ -458,50 +509,97 @@ const
}
void Foam::fileMonitor::updateStates(const bool syncPar) const
void Foam::fileMonitor::updateStates
(
const bool masterOnly,
const bool syncPar
) const
{
checkFiles();
if (Pstream::master() || !masterOnly)
{
checkFiles();
}
if (syncPar)
{
PackedList<2> stats(state_.size());
forAll(state_, watchFd)
// Pack current state (might be on master only)
PackedList<2> stats(state_.size(), MODIFIED);
if (Pstream::master() || !masterOnly)
{
stats[watchFd] = static_cast<unsigned int>(state_[watchFd]);
forAll(state_, watchFd)
{
stats[watchFd] = static_cast<unsigned int>(state_[watchFd]);
}
}
// Save local state for warning message below
PackedList<2> thisProcStats(stats);
if (stats.storage().size() == 1)
// Save local state for warning message below
PackedList<2> thisProcStats;
if (!masterOnly)
{
// Optimisation valid for most cases.
reduce(stats.storage()[0], reduceFileStates());
thisProcStats = stats;
}
// Scatter or reduce to synchronise state
if (masterOnly)
{
// Scatter
if (stats.storage().size() == 1)
{
Pstream::scatter(stats.storage()[0]);
}
else
{
Pstream::listCombineScatter(stats.storage());
}
}
else
{
Pstream::listCombineGather
(
stats.storage(),
combineReduceFileStates()
);
// Reduce
if (stats.storage().size() == 1)
{
// Optimisation valid for most cases.
reduce(stats.storage()[0], reduceFileStates());
}
else
{
Pstream::listCombineGather
(
stats.storage(),
combineReduceFileStates()
);
}
}
// Update local state
forAll(state_, watchFd)
{
if (thisProcStats[watchFd] != UNMODIFIED)
if (masterOnly)
{
if (stats[watchFd] == UNMODIFIED)
// No need to check for inconsistent state. Just assign.
unsigned int stat = stats[watchFd];
state_[watchFd] = fileState(stat);
}
else
{
// Check for inconsistent state before assigning.
if (thisProcStats[watchFd] != UNMODIFIED)
{
WarningIn("fileMonitor::updateStates(const bool) const")
<< "Delaying reading " << watchFile_[watchFd]
<< " due to inconsistent "
"file time-stamps between processors"
<< endl;
}
else
{
unsigned int stat = stats[watchFd];
state_[watchFd] = fileState(stat);
if (stats[watchFd] == UNMODIFIED)
{
WarningIn("fileMonitor::updateStates(const bool) const")
<< "Delaying reading " << watchFile_[watchFd]
<< " due to inconsistent "
"file time-stamps between processors"
<< endl;
}
else
{
unsigned int stat = stats[watchFd];
state_[watchFd] = fileState(stat);
}
}
}
}
@ -511,10 +609,12 @@ void Foam::fileMonitor::updateStates(const bool syncPar) const
void Foam::fileMonitor::setUnmodified(const label watchFd)
{
#ifdef FOAM_USE_STAT
watcher_->lastMod_[watchFd] = lastModified(watchFile_[watchFd]);
#endif
state_[watchFd] = UNMODIFIED;
if (!useInotify_)
{
watcher_->lastMod_[watchFd] = lastModified(watchFile_[watchFd]);
}
}

18
src/OSspecific/POSIX/fileMonitor.H
View File

@ -28,10 +28,11 @@ Description
Checking for changes to files.
Note
The default is to use inotify (Linux specific, since 2.6.13)
The default is to use stat to get the timestamp.
Compiling with FOAM_USE_STAT (or if /usr/include/sys/inotify.h
does not exist) uses the stat function call.
Compile with FOAM_USE_INOTIFY to use the inotify
(Linux specific, since 2.6.13) framework. The problem is that inotify does
not work on nfs3 mounted directories!!
SourceFiles
fileMonitor.C
@ -78,6 +79,9 @@ public:
private:
// Private data
//- Whether to use inotify (requires -DFOAM_USE_INOTIFY, see above)
const bool useInotify_;
//- State for all watchFds
mutable DynamicList<fileState> state_;
@ -111,7 +115,7 @@ public:
// Constructors
//- Construct null
fileMonitor();
fileMonitor(const bool useInotify);
//- Destructor
@ -133,7 +137,11 @@ public:
fileState getState(const label watchFd) const;
//- Check state of all files. Updates state_.
void updateStates(const bool syncPar) const;
void updateStates
(
const bool masterOnly,
const bool syncPar
) const;
//- Reset state (e.g. after having read it) using handle
void setUnmodified(const label watchFd);

39
src/OpenFOAM/containers/NamedEnum/NamedEnum.C
View File

@ -24,7 +24,6 @@ License
\*---------------------------------------------------------------------------*/
#include "NamedEnum.H"
#include "stringList.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -85,4 +84,42 @@ void Foam::NamedEnum<Enum, nEnum>::write(const Enum e, Ostream& os) const
}
template<class Enum, int nEnum>
Foam::stringList Foam::NamedEnum<Enum, nEnum>::strings()
{
stringList lst(nEnum);
label nElem = 0;
for (int enumI = 0; enumI < nEnum; ++enumI)
{
if (names[enumI] && names[enumI][0])
{
lst[nElem++] = names[enumI];
}
}
lst.setSize(nElem);
return lst;
}
template<class Enum, int nEnum>
Foam::wordList Foam::NamedEnum<Enum, nEnum>::words()
{
wordList lst(nEnum);
label nElem = 0;
for (int enumI = 0; enumI < nEnum; ++enumI)
{
if (names[enumI] && names[enumI][0])
{
lst[nElem++] = names[enumI];
}
}
lst.setSize(nElem);
return lst;
}
// ************************************************************************* //

8
src/OpenFOAM/containers/NamedEnum/NamedEnum.H
View File

@ -37,6 +37,8 @@ SourceFiles
#include "HashTable.H"
#include "StaticAssert.H"
#include "stringList.H"
#include "wordList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -87,6 +89,12 @@ public:
//- Write the name representation of the enumeration to an Ostream
void write(const Enum e, Ostream&) const;
//- The set of names as a list of strings
static stringList strings();
//- The set of names as a list of words
static wordList words();
// Member Operators

109
src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.C
View File

@ -31,12 +31,61 @@ Description
#include "IOdictionary.H"
#include "objectRegistry.H"
#include "Pstream.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(Foam::IOdictionary, 0);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// Parallel aware reading, using non-virtual type information (typeName instead
// of type()) because of use in constructor.
void Foam::IOdictionary::readFile(const bool masterOnly)
{
if (Pstream::master() || !masterOnly)
{
if (debug)
{
Pout<< "IOdictionary : Reading " << objectPath()
<< " from file " << endl;
}
readStream(typeName) >> *this;
close();
}
if (masterOnly)
{
// Scatter master data
if (Pstream::master())
{
for
(
int slave=Pstream::firstSlave();
slave<=Pstream::lastSlave();
slave++
)
{
OPstream toSlave(Pstream::scheduled, slave);
IOdictionary::writeData(toSlave);
}
}
else
{
if (debug)
{
Pout<< "IOdictionary : Reading " << objectPath()
<< " from master processor " << Pstream::masterNo() << endl;
}
IPstream fromMaster(Pstream::scheduled, Pstream::masterNo());
IOdictionary::readData(fromMaster);
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::IOdictionary::IOdictionary(const IOobject& io)
@ -56,17 +105,41 @@ Foam::IOdictionary::IOdictionary(const IOobject& io)
//<< abort(FatalError);
}
// Everyone check or just master
bool masterOnly =
regIOobject::fileModificationChecking == timeStampMaster
|| regIOobject::fileModificationChecking == inotifyMaster;
// Check if header is ok for READ_IF_PRESENT
bool isHeaderOk = false;
if (io.readOpt() == IOobject::READ_IF_PRESENT)
{
if (masterOnly)
{
if (Pstream::master())
{
isHeaderOk = headerOk();
}
Pstream::scatter(isHeaderOk);
}
else
{
isHeaderOk = headerOk();
}
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
|| isHeaderOk
)
{
readStream(typeName) >> *this;
close();
readFile(masterOnly);
}
dictionary::name() = IOobject::objectPath();
@ -90,17 +163,41 @@ Foam::IOdictionary::IOdictionary(const IOobject& io, const dictionary& dict)
<< endl;
}
// Everyone check or just master
bool masterOnly =
regIOobject::fileModificationChecking == timeStampMaster
|| regIOobject::fileModificationChecking == inotifyMaster;
// Check if header is ok for READ_IF_PRESENT
bool isHeaderOk = false;
if (io.readOpt() == IOobject::READ_IF_PRESENT)
{
if (masterOnly)
{
if (Pstream::master())
{
isHeaderOk = headerOk();
}
Pstream::scatter(isHeaderOk);
}
else
{
isHeaderOk = headerOk();
}
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
|| isHeaderOk
)
{
readStream(typeName) >> *this;
close();
readFile(masterOnly);
}
else
{

5
src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionary.H
View File

@ -57,6 +57,11 @@ class IOdictionary
public dictionary
{
// Private Member Functions
//- read dictionary from file
void readFile(const bool);
public:
TypeName("dictionary");

46
src/OpenFOAM/db/Time/Time.C
View File

@ -250,8 +250,27 @@ Foam::Time::Time
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset(new fileMonitor());
controlDict_.watchIndex() = addWatch(controlDict_.filePath());
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// File might not exist yet.
fileName f(controlDict_.filePath());
if (!f.size())
{
// We don't have this file but would like to re-read it.
// Possibly if in master-only reading mode. Use a non-existing
// file to keep fileMonitor synced.
f = controlDict_.objectPath();
}
controlDict_.watchIndex() = addWatch(f);
}
}
@ -308,19 +327,36 @@ Foam::Time::Time
readLibs_(controlDict_, "libs"),
functionObjects_(*this)
{
// Since could not construct regIOobject with setting:
controlDict_.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
setControls();
// Time objects not registered so do like objectRegistry::checkIn ourselves.
if (runTimeModifiable_)
{
monitorPtr_.reset(new fileMonitor());
monitorPtr_.reset
(
new fileMonitor
(
regIOobject::fileModificationChecking == inotify
|| regIOobject::fileModificationChecking == inotifyMaster
)
);
// File might not exist yet.
fileName f(controlDict_.filePath());
if (f != fileName::null)
if (!f.size())
{
controlDict_.watchIndex() = addWatch(f);
// We don't have this file but would like to re-read it.
// Possibly if in master-only reading mode. Use a non-existing
// file to keep fileMonitor synced.
f = controlDict_.objectPath();
}
controlDict_.watchIndex() = addWatch(f);
}
}

9
src/OpenFOAM/db/Time/TimeIO.C
View File

@ -211,7 +211,14 @@ void Foam::Time::readModifiedObjects()
// valid filePath).
// Note: requires same ordering in objectRegistries on different
// processors!
monitorPtr_().updateStates(Pstream::parRun());
monitorPtr_().updateStates
(
(
regIOobject::fileModificationChecking == inotifyMaster
|| regIOobject::fileModificationChecking == timeStampMaster
),
Pstream::parRun()
);
// Time handling is special since controlDict_ is the one dictionary
// that is not registered to any database.

8
src/OpenFOAM/db/functionObjects/functionObjectList/functionObjectList.C
View File

@ -198,7 +198,13 @@ bool Foam::functionObjectList::read()
}
// Update existing and add new functionObjects
const entry* entryPtr = parentDict_.lookupEntryPtr("functions",false,false);
const entry* entryPtr = parentDict_.lookupEntryPtr
(
"functions",
false,
false
);
if (entryPtr)
{
PtrList<functionObject> newPtrs;

36
src/OpenFOAM/db/regIOobject/regIOobject.C
View File

@ -36,6 +36,35 @@ int Foam::regIOobject::fileModificationSkew
Foam::debug::optimisationSwitch("fileModificationSkew", 30)
);
namespace Foam
{
template<>
const char* Foam::NamedEnum<Foam::regIOobject::fileCheckTypes, 4>::names[] =
{
"timeStamp",
"timeStampMaster",
"inotify",
"inotifyMaster"
};
}
const Foam::NamedEnum<Foam::regIOobject::fileCheckTypes, 4>
Foam::regIOobject::fileCheckTypesNames;
// Default fileCheck type
Foam::regIOobject::fileCheckTypes Foam::regIOobject::fileModificationChecking
(
fileCheckTypesNames.read
(
debug::optimisationSwitches().lookup
(
"fileModificationChecking"
//Foam::regIOobject::timeStamp
)
)
);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -149,10 +178,13 @@ bool Foam::regIOobject::checkIn()
}
fileName f = filePath();
if (f != fileName::null)
if (!f.size())
{
watchIndex_ = time().addWatch(f);
// We don't have this file but would like to re-read it.
// Possibly if master-only reading mode.
f = objectPath();
}
watchIndex_ = time().addWatch(f);
}
// check-in on defaultRegion is allowed to fail, since subsetted meshes

17
src/OpenFOAM/db/regIOobject/regIOobject.H
View File

@ -41,6 +41,7 @@ SourceFiles
#include "IOobject.H"
#include "typeInfo.H"
#include "OSspecific.H"
#include "NamedEnum.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -57,6 +58,20 @@ class regIOobject
public IOobject
{
public:
//- Types of communications
enum fileCheckTypes
{
timeStamp,
timeStampMaster,
inotify,
inotifyMaster
};
static const NamedEnum<fileCheckTypes, 4> fileCheckTypesNames;
private:
// Private data
@ -95,6 +110,8 @@ public:
static int fileModificationSkew;
static fileCheckTypes fileModificationChecking;
// Constructors

48
src/OpenFOAM/db/regIOobject/regIOobjectRead.C
View File

@ -26,7 +26,7 @@ License
#include "regIOobject.H"
#include "IFstream.H"
#include "Time.H"
//#include "PstreamReduceOps.H"
#include "Pstream.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
@ -170,8 +170,50 @@ bool Foam::regIOobject::readData(Istream&)
bool Foam::regIOobject::read()
{
bool ok = readData(readStream(type()));
close();
// Note: cannot do anything in readStream itself since this is used by
// e.g. GeometricField.
bool masterOnly =
regIOobject::fileModificationChecking == timeStampMaster
|| regIOobject::fileModificationChecking == inotifyMaster;
bool ok;
if (Pstream::master() || !masterOnly)
{
ok = readData(readStream(type()));
close();
}
if (masterOnly)
{
// Scatter master data
if (Pstream::master())
{
for
(
int slave=Pstream::firstSlave();
slave<=Pstream::lastSlave();
slave++
)
{
OPstream toSlave(Pstream::scheduled, slave);
writeData(toSlave);
}
}
else
{
if (IFstream::debug)
{
Pout<< "regIOobject::read() : "
<< "reading object " << name()
<< " from master processor " << Pstream::masterNo()
<< endl;
}
IPstream fromMaster(Pstream::scheduled, Pstream::masterNo());
ok = readData(fromMaster);
}
}
return ok;
}

80
src/OpenFOAM/global/argList/argList.C
View File

@ -55,6 +55,12 @@ Foam::argList::initValidTables::initValidTables()
);
argList::addBoolOption("parallel", "run in parallel");
validParOptions.set("parallel", "");
argList::addOption
(
"roots", "(dir1 .. dirn)",
"slave root directories for distributed running"
);
validParOptions.set("roots", "(dir1 .. dirn)");
Pstream::addValidParOptions(validParOptions);
}
@ -511,6 +517,10 @@ Foam::argList::argList
// Case is a single processor run unless it is running parallel
int nProcs = 1;
// Roots if running distributed
fileNameList roots;
// If this actually is a parallel run
if (parRunControl_.parRun())
{
@ -520,28 +530,42 @@ Foam::argList::argList
// establish rootPath_/globalCase_/case_ for master
getRootCase();
IFstream decompDictStream
(
rootPath_/globalCase_/"system/decomposeParDict"
);
// See if running distributed (different roots for different procs)
label dictNProcs = -1;
fileName source;
if (!decompDictStream.good())
if (options_.found("roots"))
{
FatalError
<< "Cannot read "
<< decompDictStream.name()
<< exit(FatalError);
IStringStream str(options_["roots"]);
str >> roots;
dictNProcs = roots.size()+1;
source = "roots-command-line";
}
else
{
source = rootPath_/globalCase_/"system/decomposeParDict";
IFstream decompDictStream(source);
dictionary decompDict(decompDictStream);
if (!decompDictStream.good())
{
FatalError
<< "Cannot read "
<< decompDictStream.name()
<< exit(FatalError);
}
label dictNProcs
(
readLabel
dictionary decompDict(decompDictStream);
dictNProcs = readLabel
(
decompDict.lookup("numberOfSubdomains")
)
);
);
if (decompDict.lookupOrDefault("distributed", false))
{
decompDict.lookup("roots") >> roots;
}
}
// Check number of processors.
// nProcs => number of actual procs
@ -555,23 +579,27 @@ Foam::argList::argList
if (dictNProcs > Pstream::nProcs())
{
FatalError
<< decompDictStream.name()
<< source
<< " specifies " << dictNProcs
<< " processors but job was started with "
<< Pstream::nProcs() << " processors."
<< exit(FatalError);
}
// distributed data
if (decompDict.lookupOrDefault("distributed", false))
if (roots.size())
{
fileNameList roots;
decompDict.lookup("roots") >> roots;
forAll(roots, i)
{
roots[i] = roots[i].expand();
}
if (roots.size() != Pstream::nProcs()-1)
{
FatalError
<< "number of entries in decompositionDict::roots"
<< "number of entries in roots "
<< roots.size()
<< " is not equal to the number of slaves "
<< Pstream::nProcs()-1
<< exit(FatalError);
@ -705,8 +733,12 @@ Foam::argList::argList
if (parRunControl_.parRun())
{
Info<< "Slaves : " << slaveProcs << nl
<< "Pstream initialized with:" << nl
Info<< "Slaves : " << slaveProcs << nl;
if (roots.size())
{
Info<< "Roots : " << roots << nl;
}
Info<< "Pstream initialized with:" << nl
<< " floatTransfer : " << Pstream::floatTransfer << nl
<< " nProcsSimpleSum : " << Pstream::nProcsSimpleSum << nl
<< " commsType : "
@ -722,6 +754,10 @@ Foam::argList::argList
{
jobInfo.add("slaves", slaveProcs);
}
if (roots.size())
{
jobInfo.add("roots", roots);
}
jobInfo.write();
// Switch on signal trapping. We have to wait until after Pstream::init

17
src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C
View File

@ -620,24 +620,23 @@ Foam::dynamicRefineFvMesh::cellToPoint(const scalarField& vFld) const
}
// Calculate error. Is < 0 or distance from inbetween levels
Foam::scalarField
Foam::dynamicRefineFvMesh::error
// Calculate error. Is < 0 or distance to minLevel, maxLevel
Foam::scalarField Foam::dynamicRefineFvMesh::error
(
const scalarField& fld,
const scalar minLevel,
const scalar maxLevel
) const
{
const scalar halfLevel = 0.5*(minLevel + maxLevel);
scalarField c(fld.size(), -1);
forAll(fld, i)
{
if (fld[i] >= minLevel && fld[i] < maxLevel)
scalar err = min(fld[i]-minLevel, maxLevel-fld[i]);
if (err >= 0)
{
c[i] = mag(fld[i] - halfLevel);
c[i] = err;
}
}
return c;
@ -877,6 +876,10 @@ Foam::dynamicRefineFvMesh::dynamicRefineFvMesh(const IOobject& io)
nRefinementIterations_(0),
protectedCell_(nCells(), 0)
{
// Read static part of dictionary
readDict();
const labelList& cellLevel = meshCutter_.cellLevel();
const labelList& pointLevel = meshCutter_.pointLevel();

1
src/finiteVolume/fields/fvPatchFields/derived/directMappedVelocityFluxFixedValue/directMappedVelocityFluxFixedValueFvPatchField.H
View File

@ -27,7 +27,6 @@ Class
Description
Recycles the velocity and flux at a patch to this patch
mode = NEARESTCELL : sample nearest cell
mode = NEARESTPATCHFACE : sample nearest face on selected patch
mode = NEARESTFACE : sample nearest face on any patch. Note: does not
warn if nearest actually is on internal face!

11
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C
View File

@ -261,17 +261,16 @@ void timeVaryingMappedFixedValueFvPatchField<Type>::readSamplePoints()
for (label i = 1; i < samplePoints.size(); i++)
{
e1 = samplePoints[i] - p0;
scalar magE1 = mag(e1);
const vector d = samplePoints[i] - p0;
scalar magD = mag(d);
if (magE1 > maxDist)
if (magD > maxDist)
{
e1 /= magE1;
e1 = d/magD;
index1 = i;
maxDist = magE1;
maxDist = magD;
}
}
// Find point that is furthest away from line p0-p1
const point& p1 = samplePoints[index1];

3
src/finiteVolume/fvMesh/singleCellFvMesh/singleCellFvMesh.C
View File

@ -211,7 +211,8 @@ void Foam::singleCellFvMesh::agglomerateMesh
"singleCellFvMesh::agglomerateMesh(..)"
) << "agglomeration does not create a"
<< " single, non-manifold"
<< " face for agglomeration " << coarseI
<< " face for agglomeration " << myAgglom
<< " on patch " << patchI
<< exit(FatalError);
}

3
src/finiteVolume/fvMesh/wallDist/wallPointYPlus/wallPointYPlusI.H
View File

@ -21,8 +21,6 @@ License
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -32,7 +30,6 @@ namespace Foam
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// Update this with w2 if w2 nearer to pt.
inline bool wallPointYPlus::update
(

4
src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
View File

@ -333,7 +333,7 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
trackedParticle::trackData td(cloud, maxFeatureLevel);
// Track all particles to their end position (= starting feature point)
cloud.move(td, mesh_.time().deltaTValue());
cloud.move(td, GREAT);
// Reset level
maxFeatureLevel = -1;
@ -406,7 +406,7 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
}
// Track all particles to their end position.
cloud.move(td, mesh_.time().deltaTValue());
cloud.move(td, GREAT);
}

8
src/postProcessing/functionObjects/field/surfaceInterpolateFields/surfaceInterpolateFields.H
View File

@ -25,8 +25,11 @@ Class
Foam::surfaceInterpolateFields
Description
Reads fields from the time folders and adds them to the mesh database
for further post-processing.
Linear interpolates volFields to surfaceFields
Note: gets executed every time step. Could move it to write() but then
you'd have problems if you have different write frequencies for different
function objects.
SourceFiles
surfaceInterpolateFields.C
@ -38,7 +41,6 @@ SourceFiles
#define surfaceInterpolateFields_H
#include "OFstream.H"
//#include "pointFieldFwd.H"
#include "surfaceFields.H"
#include "Tuple2.H"

2
wmake/MakefileApps
View File

@ -1,4 +1,4 @@
#------------------------------------------------------------------------------
#-------------------------------*- makefile -*---------------------------------
# ========= |
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
# \\ / O peration |

2
wmake/MakefileFiles
View File

@ -1,4 +1,4 @@
#------------------------------------------------------------------------------
#-------------------------------*- makefile -*---------------------------------
# ========= |
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
# \\ / O peration |

2
wmake/MakefileOptions
View File

@ -1,4 +1,4 @@
#------------------------------------------------------------------------------
#-------------------------------*- makefile -*---------------------------------
# ========= |
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
# \\ / O peration |

4
wmake/rules/General/bison
View File

@ -1,8 +1,8 @@
.SUFFIXES: .y .Y
ytoo = bison -v -d -y $$SOURCE ; mv y.tab.c $*.c ; mv y.tab.h $*.h ; $(cc) $(cFLAGS) -c $*.c -o $@
ytoo = bison -v -d -y $$SOURCE ; mv y.tab.c $*.c ; mv y.tab.h $*.h ; $(cc) $(cFLAGS) -c $*.c -o $@
Ytoo = bison -v -d -y $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
Ytoo = bison -v -d -y $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
.y.dep:
$(MAKE_DEP)

2
wmake/rules/General/btyacc
View File

@ -1,6 +1,6 @@
.SUFFIXES: .y
ytoo = btyacc -v -d $(SKELETON) $$SOURCE ; mv y_tab.c $*.C ; mv y_tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
ytoo = btyacc -v -d $(SKELETON) $$SOURCE ; mv y_tab.c $*.C ; mv y_tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
.y.dep:
$(MAKE_DEP)

2
wmake/rules/General/btyacc++
View File

@ -1,6 +1,6 @@
.SUFFIXES: .Y
Ytoo = btyacc++ -v -d $(SKELETON) $$SOURCE ; mv y_tab.c $*.C ; mv y_tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
Ytoo = btyacc++ -v -d $(SKELETON) $$SOURCE ; mv y_tab.c $*.C ; mv y_tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
.Y.dep:
$(MAKE_DEP)

2
wmake/rules/General/byacc
View File

@ -1,6 +1,6 @@
.SUFFIXES: .y
ytoo = byacc -v $(YYPREFIX) -d $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
ytoo = byacc -v $(YYPREFIX) -d $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $*.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
.y.dep:
$(MAKE_DEP)

2
wmake/rules/General/moc
View File

@ -1,6 +1,6 @@
.SUFFIXES: .qt
qttoo = $(QTDIR)/bin/moc -f $$SOURCE -o $*.C ; $(CC) $(c++FLAGS) -c $*.C -o $@
qttoo = $(QTDIR)/bin/moc -f $$SOURCE -o $*.C ; $(CC) $(c++FLAGS) -c $*.C -o $@
.qt.dep:
$(MAKE_DEP)

4
wmake/rules/General/yacc
View File

@ -1,8 +1,8 @@
.SUFFIXES: .y .Y
ytoo = yacc -v -d $$SOURCE ; mv y.tab.c $*.c ; mv y.tab.h $(@D)/parser.h ; $(CC) $(c++FLAGS) -c $*.c -o $@
ytoo = yacc -v -d $$SOURCE ; mv y.tab.c $*.c ; mv y.tab.h $(@D)/parser.h ; $(CC) $(c++FLAGS) -c $*.c -o $@
Ytoo = yacc -v -d $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $(@D)/parser.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
Ytoo = yacc -v -d $$SOURCE ; mv y.tab.c $*.C ; mv y.tab.h $(@D)/parser.H ; $(CC) $(c++FLAGS) -c $*.C -o $@
.y.dep:
$(MAKE_DEP)

2
wmake/rules/SiCortex64Gcc/c++Opt
View File

@ -1,4 +1,4 @@
c++DBUG =
c++DBUG =
c++OPT = -O3
#c++OPT = -O3
# -ftree-vectorize -ftree-vectorizer-verbose=3

2
wmake/rules/SiCortex64Gcc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3

2
wmake/rules/SunOS64Gcc/c++Opt
View File

@ -1,2 +1,2 @@
c++DBUG =
c++DBUG =
c++OPT = -O3

2
wmake/rules/SunOS64Gcc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3

16
wmake/rules/linux64Gcc++0x/c Normal file
View File

@ -0,0 +1,16 @@
.SUFFIXES: .c .h
cWARN = -Wall
cc = gcc -m64
include $(RULES)/c$(WM_COMPILE_OPTION)
cFLAGS = $(GFLAGS) $(cWARN) $(cOPT) $(cDBUG) $(LIB_HEADER_DIRS) -fPIC
ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $$SOURCE -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

21
wmake/rules/linux64Gcc++0x/c++ Normal file
View File

@ -0,0 +1,21 @@
.SUFFIXES: .C .cxx .cc .cpp
c++WARN = -Wall -Wextra -Wno-unused-parameter -Wold-style-cast -Wnon-virtual-dtor
CC = g++ -m64 -std=c++0x
include $(RULES)/c++$(WM_COMPILE_OPTION)
ptFLAGS = -DNoRepository -ftemplate-depth-60
c++FLAGS = $(GFLAGS) $(c++WARN) $(c++OPT) $(c++DBUG) $(ptFLAGS) $(LIB_HEADER_DIRS) -fPIC
Ctoo = $(WM_SCHEDULER) $(CC) $(c++FLAGS) -c $$SOURCE -o $@
cxxtoo = $(Ctoo)
cctoo = $(Ctoo)
cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed

2
wmake/rules/linux64Gcc++0x/c++Debug Normal file
View File

@ -0,0 +1,2 @@
c++DBUG = -ggdb3 -DFULLDEBUG
c++OPT = -O0 -fdefault-inline

3
wmake/rules/linux64Gcc++0x/c++Opt Normal file
View File

@ -0,0 +1,3 @@
#c++DBUG = -O0 -DFULLDEBUG -g
c++DBUG =
c++OPT = -O3

2
wmake/rules/linux64Gcc++0x/c++Prof Normal file
View File

@ -0,0 +1,2 @@
c++DBUG = -pg
c++OPT = -O2

2
wmake/rules/linux64Gcc++0x/cDebug Normal file
View File

@ -0,0 +1,2 @@
cDBUG = -ggdb -DFULLDEBUG
cOPT = -O1 -fdefault-inline -finline-functions

2
wmake/rules/linux64Gcc++0x/cOpt Normal file
View File

@ -0,0 +1,2 @@
cDBUG =
cOPT = -O3

2
wmake/rules/linux64Gcc++0x/cProf Normal file
View File

@ -0,0 +1,2 @@
cDBUG = -pg
cOPT = -O2

8
wmake/rules/linux64Gcc++0x/general Normal file
View File

@ -0,0 +1,8 @@
CPP = cpp -traditional-cpp $(GFLAGS)
PROJECT_LIBS = -l$(WM_PROJECT) -liberty -ldl
include $(GENERAL_RULES)/standard
include $(RULES)/c
include $(RULES)/c++

3
wmake/rules/linux64Gcc++0x/mplibHPMPI Normal file
View File

@ -0,0 +1,3 @@
PFLAGS =
PINC = -I$(MPI_ARCH_PATH)/include -D_MPICC_H
PLIBS = -L$(MPI_ARCH_PATH)/lib/linux_amd64 -lmpi

2
wmake/rules/linux64Gcc/c++Opt
View File

@ -1,3 +1,3 @@
#c++DBUG = -O0 -DFULLDEBUG -g
c++DBUG =
c++DBUG =
c++OPT = -O3

2
wmake/rules/linux64Icc/c
View File

@ -1,6 +1,6 @@
.SUFFIXES: .c .h
cWARN =
cWARN =
cc = icc

2
wmake/rules/linux64Icc/c++Debug
View File

@ -1,2 +1,2 @@
c++DBUG = -g -DFULLDEBUG -O0
c++OPT =
c++OPT =

2
wmake/rules/linux64Icc/c++Opt
View File

@ -1,2 +1,2 @@
c++DBUG =
c++DBUG =
c++OPT = -xT -O3 -no-prec-div

2
wmake/rules/linux64Icc/cDebug
View File

@ -1,2 +1,2 @@
cDBUG = -g -DFULLDEBUG -O0
cOPT =
cOPT =

2
wmake/rules/linux64Icc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3 -no-prec-div

2
wmake/rules/linuxIA64Gcc/c++Opt
View File

@ -1,2 +1,2 @@
c++DBUG =
c++DBUG =
c++OPT = -O3

2
wmake/rules/linuxIA64Gcc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3

2
wmake/rules/linuxIA64Gcc/mplibMPI
View File

@ -1,3 +1,3 @@
PFLAGS = -DSGIMPI -DMPI_NO_CPPBIND
PINC =
PINC =
PLIBS = -lmpi

2
wmake/rules/linuxIA64Icc/c
View File

@ -1,6 +1,6 @@
.SUFFIXES: .c .h
cWARN =
cWARN =
cc = icc

2
wmake/rules/linuxIA64Icc/c++Debug
View File

@ -1,2 +1,2 @@
c++DBUG = -g -DFULLDEBUG -O0
c++OPT =
c++OPT =

2
wmake/rules/linuxIA64Icc/c++Opt
View File

@ -1,4 +1,4 @@
c++DBUG =
c++DBUG =
c++OPT = \
-DICC_IA64_PREFETCH \

2
wmake/rules/linuxIA64Icc/cDebug
View File

@ -1,2 +1,2 @@
cDBUG = -g -DFULLDEBUG -O0
cOPT =
cOPT =

2
wmake/rules/linuxIA64Icc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3

2
wmake/rules/linuxIA64Icc/mplibIMPI
View File

@ -1,3 +1,3 @@
PFLAGS = -DSGIMPI -DMPI_NO_CPPBIND
PINC =
PINC =
PLIBS = -lmpi

2
wmake/rules/linuxIA64Icc/mplibMPI
View File

@ -1,3 +1,3 @@
PFLAGS = -DSGIMPI -DMPI_NO_CPPBIND
PINC =
PINC =
PLIBS = -lmpi

2
wmake/rules/linuxIcc/c
View File

@ -1,6 +1,6 @@
.SUFFIXES: .c .h
cWARN =
cWARN =
cc = icc -gcc-version=400

2
wmake/rules/linuxIcc/c++Debug
View File

@ -1,2 +1,2 @@
c++DBUG = -g -DFULLDEBUG -O0
c++OPT =
c++OPT =

2
wmake/rules/linuxIcc/c++Opt
View File

@ -1,4 +1,4 @@
c++DBUG =
c++DBUG =
#c++OPT = -O3 -xP -no-prec-div
c++OPT = -ansi-alias -O3 -ftz -fno-alias \
-fargument-noalias-global \

2
wmake/rules/linuxIcc/cDebug
View File

@ -1,2 +1,2 @@
cDBUG = -g -DFULLDEBUG -O0
cOPT =
cOPT =

2
wmake/rules/linuxIcc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3 -no-prec-div

2
wmake/rules/linuxmingw32/X
View File

@ -1,3 +1,3 @@
XFLAGS =
XINC =
XINC =
XLIBS =

2
wmake/rules/linuxmingw32/c++Opt
View File

@ -1,2 +1,2 @@
c++DBUG =
c++DBUG =
c++OPT = -O3 -DNDEBUG

2
wmake/rules/linuxmingw32/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O3 -DNDEBUG

2
wmake/rules/solarisGcc/c++Opt
View File

@ -1,2 +1,2 @@
c++DBUG =
c++DBUG =
c++OPT = -O3 -fno-schedule-insns

2
wmake/rules/solarisGcc/cOpt
View File

@ -1,2 +1,2 @@
cDBUG =
cDBUG =
cOPT = -O2 -fno-schedule-insns

4
wmake/rules/solarisGcc/mplibMPI
View File

@ -1,3 +1,3 @@
PFLAGS =
PINC = -I$(MPI_ROOT)/include
PFLAGS =
PINC = -I$(MPI_ROOT)/include
PLIBS = -L$(MPI_ROOT)/lib/$(MPI_ARCH) -lmpi