Util.h

Go to the documentation of this file.

/*-------------------------------------------------------------------
Copyright 2011 Ravishankar Sundararaman

This file is part of JDFTx.

JDFTx is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

JDFTx is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with JDFTx.  If not, see <http://www.gnu.org/licenses/>.
-------------------------------------------------------------------*/

#ifndef JDFTX_CORE_UTIL_H
#define JDFTX_CORE_UTIL_H

#include <core/MPIUtil.h>
#include <map>
#include <array>
#include <cstring>
#include <cstdio>
#include <cstdint>
#include <sys/time.h>
#include <sys/wait.h>
#include <unistd.h>
#include <execinfo.h>

//------------- Common Initialization -----------------

extern bool killFlag; 
extern MPIUtil* mpiUtil;
extern bool mpiDebugLog; 
void printVersionBanner(); 
void initSystem(int argc, char** argv); 
void initSystemCmdline(int argc, char** argv, const char* description, string& inputFilename, bool& dryRun, bool& printDefaults); 
void finalizeSystem(bool successful=true); 

//----------------- Profiling --------------------------

double clock_us(); 
double clock_sec(); 

#define TIME(title,fp,code) \
{       double runTime = clock_us(); \
        { code } \
        runTime = clock_us() - runTime; \
        fprintf(fp, "%s took %.2le s.\n", title, runTime*1e-6); \
}

#ifdef ENABLE_PROFILING
class StopWatch
{
public:
        StopWatch(string name);
        void start();
        void stop();
        void print() const;
private:
        double tPrev, Ttot, TsqTot; int nT;
        string name;
};
#else //ENABLE_PROFILING
//Version which does no profiling for release versions
class StopWatch
{
public:
        StopWatch(string name) {}
        void start() {}
        void stop() {}
};
#endif //ENABLE_PROFILING



// -----------  Debugging ---------------
void printStack(bool detailedStackScript=false); 
void stackTraceExit(int code); 
int assertStackTraceExit(const char* expr, const char* function, const char* file, long line); 
#define assert(expr) \
        (void)((expr) ? 0 : assertStackTraceExit(#expr, __func__, __FILE__, __LINE__))


// -----------  Logging ---------------
extern FILE* globalLog;
extern FILE* nullLog; 
void logSuspend(); 
void logResume(); 

#define logPrintf(...) fprintf(globalLog, __VA_ARGS__) 
#define logFlush() fflush(globalLog) 

#define die(...) \
        {       fprintf(globalLog, __VA_ARGS__); \
                if(mpiUtil->isHead() && globalLog != stdout) \
                        fprintf(stderr, __VA_ARGS__); \
                finalizeSystem(false); \
                exit(1); \
        }

#define die_alone(...) \
        {       fprintf(globalLog, __VA_ARGS__); \
                fflush(globalLog); \
                if(mpiUtil->isHead() && globalLog != stdout) \
                        fprintf(stderr, __VA_ARGS__); \
                if(mpiUtil->nProcesses() == 1) finalizeSystem(false); /* Safe to call only if no other process */ \
                mpiUtil->exit(1); \
        }

//--------------- Citations --------------------
namespace Citations
{       
        void add(string reason, string paper);
        
        void print(FILE* fp=globalLog);
}


//--------------- Miscellaneous ------------------


#include <sys/stat.h>
off_t fileSize(const char *filename);

inline uint16_t positiveRemainder(int16_t x, uint16_t y)
{       int16_t xMody = x % y;
        if(xMody < 0) return uint16_t(y + xMody);
        else return xMody;
}

inline bool fftSuitable(int N)
{       static std::array<int,4> primes = {{2,3,5,7}};
        int tmpN = N;
        for(int p: primes) while(tmpN % p == 0) tmpN /= p;
        //All suitable prime factors taken out, we should be left with 1 for a suitable N:
        return (tmpN==1);
}

template<typename Enum>
class EnumStringMap
{
        std::map<string,Enum> stringToEnum;
        std::map<Enum,string> enumToString;
        void addEntry() {}
        template<typename...Args> void addEntry(Enum e, const string& s, Args...args)
        {       stringToEnum[s]=e; enumToString[e]=s;
                addEntry(args...);
        }
public:
        //Initialize using the convenient syntax:
        // EnumStringMap mapname(enum1, string1, enum2, string2, ... as many as needed!)
        template<typename...Args> EnumStringMap(Args...args) { addEntry(args...); }

        //Match a key string to an enum, return false if not found
        bool getEnum(const char* key, Enum& e) const
        {       typename std::map<string,Enum>::const_iterator i = stringToEnum.find(key);
                if(i==stringToEnum.end()) return false;
                else
                {       e = i->second;
                        return true;
                }
        }

        //Return the string representation of the enum:
        const char* getString(Enum e) const
        {       typename std::map<Enum,string>::const_iterator i = enumToString.find(e);
                return i->second.c_str();
        }

        string optionList() const
        {       typename std::map<string,Enum>::const_iterator i=stringToEnum.begin();
                string ret = i->first; i++;
                for(; i!=stringToEnum.end(); i++) ret += ("|"+i->first);
                return ret;
        }
};

#endif //JDFTX_CORE_UTIL_H