Utility.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_UTILITY_H
#define BL_UTILITY_H
//
// $Id: Utility.H,v 1.52 2002/02/06 18:14:46 car Exp $
//
#include <winstd.H>

#include <iostream>
#include <string>

#ifndef WIN32
#include <sys/types.h>
#include <sys/wait.h>
#endif

#include <BLassert.H>
#include <REAL.H>

//
// :

namespace BoxLib
{
    double second (double* t = 0);

    double wsecond (double* t = 0);
    //
    //
    void ResetWallClockTime ();
    //
    //
    bool is_integer (const char* str);
    //
    //
    std::string Concatenate (const std::string& root,
                             int                num);

    bool UtilCreateDirectory (const std::string& path,
                              mode_t             mode);
    //
    //
    void CreateDirectoryFailed (const std::string& dir);
    //
    //
    void FileOpenFailed (const std::string& dir);
    //
    //
    void UnlinkFile (const std::string& file);

    void OutOfMemory ();

    double Random ();

    void InitRandom (unsigned long seed);

    pid_t Execute (const char* cmd);
    //
    // Helper class for Times, used in Threads, Profiling, and Timers.
    //
    class Time
    {
    public:
    Time();
    Time(long s, long n = 0);
    Time(double d);
    double as_double() const;
    long as_long() const;
    Time& operator+=(const Time&);
    Time operator+(const Time&) const;
    static Time get_time();
    private:
    long tv_sec;
    long tv_nsec;
    void normalize();
    };
    //
    // Implements a simple in place Timer:
    //
    template <double (*FCN)(double*)> class base_Timer;
    template <double (*FCN)(double*)> std::ostream& operator<<(std::ostream&, const base_Timer<FCN>&);

    typedef base_Timer<BoxLib::wsecond> WallTimer;
    typedef base_Timer<BoxLib::second>  CPUTimer;

    template <double (*FCN)(double*)>
    class base_Timer
    {
    public:
    class bad_timer;
    base_Timer();
    ~base_Timer();
    void start();
    void stop();
    void reset();
    double time() const;
    double accum_time() const;
    int count() const;
    bool is_running() const;
    static double tick();
    private:
    bool running;
    double val;
    double held;
    double accum_val;
    int cnt;
    };
    //
    // The Mersenne twistor :
    //
    class mt19937
    {
    public:
    typedef unsigned long seed_type;
    explicit mt19937 (seed_type seed = 4357UL);
    mt19937 (seed_type array[], int array_len);
    void rewind();
    
    double d1_value (); // [0,1] random numbers
    double d_value ();  // [0,1) random numbers
    long l_value ();    // [0,2^31-1] random numbers
    unsigned long u_value (); // [0,2^32-1] random numbers
    private:
    void sgenrand (unsigned long seed);
    void sgenrand (seed_type seed_array[], int len);
    unsigned long igenrand ();
    void reload ();
    private:
    enum { N = 624 };
    unsigned long init_seed;
    unsigned long mt[N];    // the array for the state vector
    int mti;        // mti==N+1 means mt[N] is not initialized
    };

    class expect;
    std::istream& operator>>(std::istream&, const expect& exp);
    
    class expect
    {
    friend std::istream& operator>>(std::istream&, const expect& exp);
    public:
    explicit expect(const std::string& str_);
    explicit expect(const char* istr_);
    explicit expect(char c);
    const std::string& the_string() const;
    private:
    std::string istr;
    };
}

//
// I'm going to document right here all the BL macros that aren't documented
// anywhere else.  Note that all these #ifdef ... #endif blocks are necessary
// to get doc++ to properly document the macros.
//

#ifdef BL_ARCH_CRAY
#undef BL_ARCH_CRAY

#define BL_ARCH_CRAY 1
#endif /*BL_ARCH_CRAY*/

#ifdef BL_LANG_FORT
#undef BL_LANG_FORT

#define BL_LANG_FORT 1
#endif /*BL_LANG_FORT*/

#ifdef BL_LANG_CC
#undef BL_LANG_CC

#define BL_LANG_CC 1
#endif /*BL_LANG_CC*/

#ifdef BL_FORT_USE_UNDERSCORE
#undef BL_FORT_USE_UNDERSCORE

#define BL_FORT_USE_UNDERSCORE 1
#endif /*BL_FORT_USE_UNDERSCORE*/

#ifdef BL_FORT_USE_UPPERCASE
#undef BL_FORT_USE_UPPERCASE

#define BL_FORT_USE_UPPERCASE 1
#endif /*BL_FORT_USE_UPPERCASE*/

#ifdef BL_FORT_USE_LOWERCASE
#undef BL_FORT_USE_LOWERCASE

#define BL_FORT_USE_LOWERCASE 1
#endif /*BL_FORT_USE_LOWERCASE*/

#define BL_IGNORE_MAX 100000

// Implementation of the Timer

template <double (*FCN)(double*)>
BoxLib::base_Timer<FCN>::base_Timer()
    : running(false), val(0.0), accum_val(0.0), cnt(0)
{
}

template <double (*FCN)(double*)>
BoxLib::base_Timer<FCN>::~base_Timer()
{
    BL_ASSERT( !running );
}

template <double (*FCN)(double*)>
bool
BoxLib::base_Timer<FCN>::is_running() const
{
    return running;
}

template <double (*FCN)(double*)>
inline
void
BoxLib::base_Timer<FCN>::start()
{
    BL_ASSERT( !running );
    held = FCN(0);
    running = true;
}

template <double (*FCN)(double*)>
inline
void
BoxLib::base_Timer<FCN>::stop()
{
    BL_ASSERT( running );
    val = (FCN(0) - held);
#ifndef NDEBUG
    if ( val < 0 )
    {
    std::cout << "Got a negative time " << val << "!" << std::endl;
    }
#endif
    accum_val += val;
    cnt += 1;
    running = false;
}

template <double (*FCN)(double*)>
void
BoxLib::base_Timer<FCN>::reset()
{
    BL_ASSERT( !running );
    accum_val = 0;
    cnt = 0;
}

template <double (*FCN)(double*)>
double
BoxLib::base_Timer<FCN>::accum_time() const
{
    BL_ASSERT( !running );
    return accum_val;
}

template <double (*FCN)(double*)>
double
BoxLib::base_Timer<FCN>::time() const
{
    BL_ASSERT( !running );
    return val;
}

template <double (*FCN)(double*)>
int
BoxLib::base_Timer<FCN>::count() const
{
    BL_ASSERT( !running );
    return cnt;
}

// I stole this code from someplace, but I don't know where.
template <double (*FCN)(double*)>
double
BoxLib::base_Timer<FCN>::tick()
{
    const int M = 100;
    double timesfound[M];

    //  Collect a sequence of M unique time values from the system.

    for ( int i = 0; i < M; ++i )
    {
    double t2;
    double t1 = FCN(0);
    while( ((t2 = FCN(0)) - t1) == 0 )
    {
    }
    timesfound[i] = t2;
    }

    double minDelta = timesfound[1] - timesfound[0];
    for ( int i = 2; i < M; i++ )
    {
    minDelta = std::min(minDelta, std::max(timesfound[i]-timesfound[i-1], 0.0));
    }
    return minDelta;
}

template <double (*FCN)(double*)>
std::ostream& operator<<(std::ostream& os, const BoxLib::base_Timer<FCN>& bt)
{
    return os << "["
          << bt.accum_time() << "/"
          << bt.count()
          << "]";
}

#endif /*BL_UTILITY_H*/

---