Updating threadpool / StackTrace
This commit is contained in:
Mark Berrill
@@ -1117,9 +1117,8 @@ Array<TYPE, FUN, Allocator> Array<TYPE, FUN, Allocator>::cat( const std::vector<
|
||||
* Interpolate *
|
||||
********************************************************/
|
||||
template<class T>
|
||||
struct is_compatible_double : std::integral_constant<bool,
|
||||
std::is_floating_point<typename std::remove_cv<T>::type>::value ||
|
||||
std::is_integral<typename std::remove_cv<T>::type>::value> {
|
||||
struct is_compatible_double
|
||||
: std::integral_constant<bool, std::is_floating_point<T>::value || std::is_integral<T>::value> {
|
||||
};
|
||||
template<class TYPE>
|
||||
inline typename std::enable_if<is_compatible_double<TYPE>::value, TYPE>::type Array_interp_1D(
|
||||
|
||||
@@ -36,7 +36,7 @@ template<> MPI_Datatype getMPItype<double>() {
|
||||
********************************************************/
|
||||
// unsigned char
|
||||
template<>
|
||||
size_t packsize<unsigned char>( const unsigned char& rhs )
|
||||
size_t packsize<unsigned char>( const unsigned char& )
|
||||
{
|
||||
return sizeof(unsigned char);
|
||||
}
|
||||
@@ -52,7 +52,7 @@ void unpack<unsigned char>( unsigned char& data, const char *buffer )
|
||||
}
|
||||
// char
|
||||
template<>
|
||||
size_t packsize<char>( const char& rhs )
|
||||
size_t packsize<char>( const char& )
|
||||
{
|
||||
return sizeof(char);
|
||||
}
|
||||
@@ -68,7 +68,7 @@ void unpack<char>( char& data, const char *buffer )
|
||||
}
|
||||
// int
|
||||
template<>
|
||||
size_t packsize<int>( const int& rhs )
|
||||
size_t packsize<int>( const int& )
|
||||
{
|
||||
return sizeof(int);
|
||||
}
|
||||
@@ -84,7 +84,7 @@ void unpack<int>( int& data, const char *buffer )
|
||||
}
|
||||
// unsigned int
|
||||
template<>
|
||||
size_t packsize<unsigned int>( const unsigned int& rhs )
|
||||
size_t packsize<unsigned int>( const unsigned int& )
|
||||
{
|
||||
return sizeof(unsigned int);
|
||||
}
|
||||
@@ -100,7 +100,7 @@ void unpack<unsigned int>( unsigned int& data, const char *buffer )
|
||||
}
|
||||
// size_t
|
||||
template<>
|
||||
size_t packsize<size_t>( const size_t& rhs )
|
||||
size_t packsize<size_t>( const size_t& )
|
||||
{
|
||||
return sizeof(size_t);
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,242 +0,0 @@
|
||||
#ifndef included_StackTrace
|
||||
#define included_StackTrace
|
||||
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <set>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
|
||||
// Check for and include MPI
|
||||
// clang-format off
|
||||
#if defined(USE_MPI) || defined(USE_EXT_MPI)
|
||||
#include "mpi.h"
|
||||
#elif defined(__has_include)
|
||||
#if __has_include("mpi.h")
|
||||
#include "mpi.h"
|
||||
#else
|
||||
typedef int MPI_Comm;
|
||||
#endif
|
||||
#else
|
||||
typedef int MPI_Comm;
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
|
||||
namespace StackTrace {
|
||||
|
||||
|
||||
struct stack_info {
|
||||
void *address;
|
||||
void *address2;
|
||||
std::string object;
|
||||
std::string function;
|
||||
std::string filename;
|
||||
int line;
|
||||
//! Default constructor
|
||||
stack_info() : address( nullptr ), address2( nullptr ), line( 0 ) {}
|
||||
//! Reset the stack
|
||||
void clear();
|
||||
//! Operator==
|
||||
bool operator==( const stack_info &rhs ) const;
|
||||
//! Operator!=
|
||||
bool operator!=( const stack_info &rhs ) const;
|
||||
//! Get the minimum width to print the addresses
|
||||
int getAddressWidth() const;
|
||||
//! Print the stack info
|
||||
std::string print( int widthAddress = 16, int widthObject = 20, int widthFunction = 32 ) const;
|
||||
//! Compute the number of bytes needed to store the object
|
||||
size_t size() const;
|
||||
//! Pack the data to a byte array, returning a pointer to the end of the data
|
||||
char *pack( char *ptr ) const;
|
||||
//! Unpack the data from a byte array, returning a pointer to the end of the data
|
||||
const char *unpack( const char *ptr );
|
||||
//! Pack a vector of data to a memory block
|
||||
static std::vector<char> packArray( const std::vector<stack_info> &data );
|
||||
//! Unpack a vector of data from a memory block
|
||||
static std::vector<stack_info> unpackArray( const char *data );
|
||||
};
|
||||
|
||||
|
||||
struct multi_stack_info {
|
||||
int N; // Number of threads/processes
|
||||
stack_info stack; // Current stack item
|
||||
std::vector<multi_stack_info> children; // Children
|
||||
//! Default constructor
|
||||
multi_stack_info() : N( 0 ) {}
|
||||
//! Construct from a simple call stack
|
||||
explicit multi_stack_info( const std::vector<stack_info> & );
|
||||
//! Copy constructor from a simple call stack
|
||||
multi_stack_info &operator=( const std::vector<stack_info> & );
|
||||
//! Reset the stack
|
||||
void clear();
|
||||
//! Add the given stack to the multistack
|
||||
void add( size_t len, const stack_info *stack );
|
||||
//! Print the stack info
|
||||
std::vector<std::string> print( const std::string &prefix = std::string() ) const;
|
||||
|
||||
private:
|
||||
void print2( const std::string &prefix, int w[3], std::vector<std::string> &text ) const;
|
||||
int getAddressWidth() const;
|
||||
int getObjectWidth() const;
|
||||
int getFunctionWidth() const;
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Get the current call stack
|
||||
* @details This function returns the current call stack for the current thread
|
||||
* @return Returns vector containing the stack
|
||||
*/
|
||||
std::vector<stack_info> getCallStack();
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Get the current call stack for a thread
|
||||
* @details This function returns the current call stack for the given thread
|
||||
* @param[in] id The thread id of the stack we want to return
|
||||
* @return Returns vector containing the stack
|
||||
*/
|
||||
std::vector<stack_info> getCallStack( std::thread::native_handle_type id );
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Get the current call stack for all threads
|
||||
* @details This function returns the current call stack for all threads
|
||||
* in the current process.
|
||||
* Note: This functionality may not be availible on all platforms
|
||||
* @return Returns vector containing the stack
|
||||
*/
|
||||
multi_stack_info getAllCallStacks();
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Get the current call stack for all threads/processes
|
||||
* @details This function returns the current call stack for all threads
|
||||
* for all processes in the current process. This function requires
|
||||
* the user to call globalCallStackInitialize() before calling this
|
||||
* routine, and globalCallStackFinalize() before exiting.
|
||||
* Note: This functionality may not be availible on all platforms
|
||||
* @return Returns vector containing the stack
|
||||
*/
|
||||
multi_stack_info getGlobalCallStacks();
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Clean up the stack trace
|
||||
* @details This function modifies the stack trace to remove entries
|
||||
* related to acquiring the stack trace in an attempt to make it
|
||||
* more useful for display/users.
|
||||
* @param[in,out] stack The stack trace to modify
|
||||
*/
|
||||
void cleanupStackTrace( multi_stack_info &stack );
|
||||
|
||||
|
||||
//! Function to return the current call stack for the current thread
|
||||
std::vector<void *> backtrace();
|
||||
|
||||
//! Function to return the current call stack for the given thread
|
||||
std::vector<void *> backtrace( std::thread::native_handle_type id );
|
||||
|
||||
//! Function to return the current call stack for all threads
|
||||
std::vector<std::vector<void *>> backtraceAll();
|
||||
|
||||
|
||||
//! Function to return the stack info for a given address
|
||||
stack_info getStackInfo( void *address );
|
||||
|
||||
|
||||
//! Function to return the stack info for a given address
|
||||
std::vector<stack_info> getStackInfo( const std::vector<void *> &address );
|
||||
|
||||
|
||||
//! Function to return the signal name
|
||||
std::string signalName( int signal );
|
||||
|
||||
|
||||
/*!
|
||||
* Return the symbols from the current executable (not availible for all platforms)
|
||||
* @return Returns 0 if sucessful
|
||||
*/
|
||||
int getSymbols( std::vector<void *> &address,
|
||||
std::vector<char> &type,
|
||||
std::vector<std::string> &obj );
|
||||
|
||||
|
||||
/*!
|
||||
* Return the name of the executable
|
||||
* @return Returns the name of the executable (usually the full path)
|
||||
*/
|
||||
std::string getExecutable();
|
||||
|
||||
|
||||
/*!
|
||||
* Return the search path for the symbols
|
||||
* @return Returns the search path for the symbols
|
||||
*/
|
||||
std::string getSymPaths();
|
||||
|
||||
|
||||
//!< Terminate type
|
||||
enum class terminateType { signal, exception };
|
||||
|
||||
/*!
|
||||
* Set the error handlers
|
||||
* @param[in] abort Function to terminate the program: abort(msg,type)
|
||||
*/
|
||||
void setErrorHandlers( std::function<void( std::string, terminateType )> abort );
|
||||
|
||||
|
||||
/*!
|
||||
* Set the given signals to the handler
|
||||
* @param[in] signals Signals to handle
|
||||
* @param[in] handler Function to terminate the program: abort(msg,type)
|
||||
*/
|
||||
void setSignals( const std::vector<int> &signals, void ( *handler )( int ) );
|
||||
|
||||
|
||||
//! Clear a signal set by setSignals
|
||||
void clearSignal( int signal );
|
||||
|
||||
|
||||
//! Clear all signals set by setSignals
|
||||
void clearSignals();
|
||||
|
||||
|
||||
//! Return a list of all signals that can be caught
|
||||
std::vector<int> allSignalsToCatch();
|
||||
|
||||
//! Return a default list of signals to catch
|
||||
std::vector<int> defaultSignalsToCatch();
|
||||
|
||||
|
||||
//! Get a list of the active threads
|
||||
std::set<std::thread::native_handle_type> activeThreads();
|
||||
|
||||
//! Get a handle to this thread
|
||||
std::thread::native_handle_type thisThread();
|
||||
|
||||
|
||||
//! Initialize globalCallStack functionallity
|
||||
void globalCallStackInitialize( MPI_Comm comm );
|
||||
|
||||
//! Clean up globalCallStack functionallity
|
||||
void globalCallStackFinalize();
|
||||
|
||||
|
||||
/*!
|
||||
* @brief Call system command
|
||||
* @details This function calls a system command, waits for the program
|
||||
* to execute, captures and returns the output and exit code.
|
||||
* @param[in] cmd Command to execute
|
||||
* @param[out] exit_code Exit code returned from child process
|
||||
* @return Returns string containing the output
|
||||
*/
|
||||
std::string exec( const std::string &cmd, int &exit_code );
|
||||
|
||||
|
||||
} // namespace StackTrace
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,303 +1,8 @@
|
||||
#include "common/Utilities.h"
|
||||
#include "common/StackTrace.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <fstream>
|
||||
#include <string.h>
|
||||
#include <signal.h>
|
||||
#include <math.h>
|
||||
#include <algorithm>
|
||||
|
||||
#ifdef USE_MPI
|
||||
#include "mpi.h"
|
||||
#endif
|
||||
|
||||
// Detect the OS and include system dependent headers
|
||||
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) || defined(_MSC_VER)
|
||||
// Note: windows has not been testeds
|
||||
#define USE_WINDOWS
|
||||
#include <windows.h>
|
||||
#include <process.h>
|
||||
#include <stdio.h>
|
||||
#include <tchar.h>
|
||||
#include <psapi.h>
|
||||
#include <DbgHelp.h>
|
||||
#define mkdir(path, mode) _mkdir(path)
|
||||
//#pragma comment(lib, psapi.lib) //added
|
||||
//#pragma comment(linker, /DEFAULTLIB:psapi.lib)
|
||||
#elif defined(__APPLE__)
|
||||
#define USE_MAC
|
||||
#include <sys/time.h>
|
||||
#include <signal.h>
|
||||
#include <execinfo.h>
|
||||
#include <dlfcn.h>
|
||||
#include <mach/mach.h>
|
||||
#include <unistd.h>
|
||||
#elif defined( __linux ) || defined( __linux__ ) || defined( __unix ) || defined( __posix )
|
||||
#define USE_LINUX
|
||||
#include <sys/time.h>
|
||||
#include <execinfo.h>
|
||||
#include <dlfcn.h>
|
||||
#include <malloc.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#error Unknown OS
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define USE_ABI
|
||||
#include <cxxabi.h>
|
||||
#endif
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function to terminate the program *
|
||||
****************************************************************************/
|
||||
static bool abort_printMemory = true;
|
||||
static bool abort_printStack = true;
|
||||
static bool abort_throwException = false;
|
||||
static int force_exit = 0;
|
||||
void Utilities::setAbortBehavior( bool printMemory, bool printStack, bool throwException )
|
||||
{
|
||||
abort_printMemory = printMemory;
|
||||
abort_printStack = printStack;
|
||||
abort_throwException = throwException;
|
||||
}
|
||||
void Utilities::abort(const std::string &message, const std::string &filename, const int line)
|
||||
{
|
||||
std::stringstream msg;
|
||||
msg << "Program abort called in file `" << filename << "' at line " << line << std::endl;
|
||||
// Add the memory usage and call stack to the error message
|
||||
if ( abort_printMemory ) {
|
||||
size_t N_bytes = Utilities::getMemoryUsage();
|
||||
msg << "Bytes used = " << N_bytes << std::endl;
|
||||
}
|
||||
if ( abort_printStack ) {
|
||||
std::vector<StackTrace::stack_info> stack = StackTrace::getCallStack();
|
||||
msg << std::endl;
|
||||
msg << "Stack Trace:\n";
|
||||
for (size_t i=0; i<stack.size(); i++)
|
||||
msg << " " << stack[i].print() << std::endl;
|
||||
}
|
||||
msg << std::endl << message << std::endl;
|
||||
// Print the message and abort
|
||||
if ( force_exit>1 ) {
|
||||
exit(-1);
|
||||
} else if ( !abort_throwException ) {
|
||||
// Use MPI_abort (will terminate all processes)
|
||||
force_exit = 2;
|
||||
std::cerr << msg.str();
|
||||
#if defined(USE_MPI) || defined(HAVE_MPI)
|
||||
int initialized=0, finalized=0;
|
||||
MPI_Initialized(&initialized);
|
||||
MPI_Finalized(&finalized);
|
||||
if ( initialized!=0 && finalized==0 )
|
||||
MPI_Abort(MPI_COMM_WORLD,-1);
|
||||
#endif
|
||||
exit(-1);
|
||||
} else if ( force_exit>0 ) {
|
||||
exit(-1);
|
||||
} else {
|
||||
// Throw and standard exception (allows the use of try, catch)
|
||||
throw std::logic_error(msg.str());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function to handle MPI errors *
|
||||
****************************************************************************/
|
||||
/*#if defined(USE_MPI) || defined(HAVE_MPI)
|
||||
MPI_Errhandler mpierr;
|
||||
void MPI_error_handler_fun( MPI_Comm *comm, int *err, ... )
|
||||
{
|
||||
if ( *err==MPI_ERR_COMM && *comm==MPI_COMM_WORLD ) {
|
||||
// Special error handling for an invalid MPI_COMM_WORLD
|
||||
std::cerr << "Error invalid MPI_COMM_WORLD";
|
||||
exit(-1);
|
||||
}
|
||||
int msg_len=0;
|
||||
char message[1000];
|
||||
MPI_Error_string( *err, message, &msg_len );
|
||||
if ( msg_len <= 0 )
|
||||
abort("Unkown error in MPI");
|
||||
abort( "Error calling MPI routine:\n" + std::string(message) );
|
||||
}
|
||||
#endif*/
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function to handle unhandled exceptions *
|
||||
****************************************************************************/
|
||||
bool tried_MPI_Abort=false;
|
||||
void term_func_abort(int err)
|
||||
{
|
||||
printf("Exiting due to abort (%i)\n",err);
|
||||
std::vector<StackTrace::stack_info> stack = StackTrace::getCallStack();
|
||||
std::string message = "Stack Trace:\n";
|
||||
for (size_t i=0; i<stack.size(); i++)
|
||||
message += " " + stack[i].print() += "\n";
|
||||
message += "\nExiting\n";
|
||||
// Print the message and abort
|
||||
std::cerr << message;
|
||||
#ifdef USE_MPI
|
||||
if ( !abort_throwException && !tried_MPI_Abort ) {
|
||||
tried_MPI_Abort = true;
|
||||
MPI_Abort(MPI_COMM_WORLD,-1);
|
||||
}
|
||||
#endif
|
||||
exit(-1);
|
||||
}
|
||||
#if defined(USE_LINUX) || defined(USE_MAC)
|
||||
static int tried_throw = 0;
|
||||
#endif
|
||||
void term_func()
|
||||
{
|
||||
// Try to re-throw the last error to get the last message
|
||||
std::string last_message;
|
||||
#if defined(USE_LINUX) || defined(USE_MAC)
|
||||
try {
|
||||
if ( tried_throw==0 ) {
|
||||
tried_throw = 1;
|
||||
throw;
|
||||
}
|
||||
// No active exception
|
||||
} catch (const std::exception &err) {
|
||||
// Caught a std::runtime_error
|
||||
last_message = err.what();
|
||||
} catch (...) {
|
||||
// Caught an unknown exception
|
||||
last_message = "unknown exception occurred.";
|
||||
}
|
||||
#endif
|
||||
std::stringstream msg;
|
||||
msg << "Unhandled exception:" << std::endl;
|
||||
msg << " " << last_message << std::endl;
|
||||
Utilities::abort( msg.str(), __FILE__, __LINE__ );
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Functions to set the error handler *
|
||||
****************************************************************************/
|
||||
static void setTerminateErrorHandler()
|
||||
{
|
||||
std::set_terminate( term_func );
|
||||
signal(SIGABRT,&term_func_abort);
|
||||
signal(SIGFPE,&term_func_abort);
|
||||
signal(SIGILL,&term_func_abort);
|
||||
signal(SIGINT,&term_func_abort);
|
||||
signal(SIGSEGV,&term_func_abort);
|
||||
signal(SIGTERM,&term_func_abort);
|
||||
}
|
||||
void Utilities::setErrorHandlers()
|
||||
{
|
||||
//d_use_MPI_Abort = use_MPI_Abort;
|
||||
//setMPIErrorHandler( SAMRAI::tbox::SAMRAI_MPI::getSAMRAIWorld() );
|
||||
setTerminateErrorHandler();
|
||||
}
|
||||
/*void Utilities::setMPIErrorHandler( const SAMRAI::tbox::SAMRAI_MPI& mpi )
|
||||
{
|
||||
#if defined(USE_MPI) || defined(HAVE_MPI)
|
||||
if ( mpierr.get()==NULL ) {
|
||||
mpierr = boost::shared_ptr<MPI_Errhandler>( new MPI_Errhandler );
|
||||
MPI_Comm_create_errhandler( MPI_error_handler_fun, mpierr.get() );
|
||||
}
|
||||
MPI_Comm_set_errhandler( mpi.getCommunicator(), *mpierr );
|
||||
MPI_Comm_set_errhandler( MPI_COMM_WORLD, *mpierr );
|
||||
#endif
|
||||
}
|
||||
void Utilities::clearMPIErrorHandler( )
|
||||
{
|
||||
#if defined(USE_MPI) || defined(HAVE_MPI)
|
||||
if ( mpierr.get()!=NULL )
|
||||
MPI_Errhandler_free( mpierr.get() ); // Delete the error handler
|
||||
mpierr.reset();
|
||||
MPI_Comm_set_errhandler( MPI_COMM_SELF, MPI_ERRORS_ARE_FATAL );
|
||||
MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL );
|
||||
#endif
|
||||
}*/
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Function to get the memory usage *
|
||||
* Note: this function should be thread-safe *
|
||||
****************************************************************************/
|
||||
#if defined(USE_MAC)
|
||||
// Get the page size on mac
|
||||
static size_t page_size = static_cast<size_t>(sysconf(_SC_PAGESIZE));
|
||||
#endif
|
||||
static size_t N_bytes_initialization = Utilities::getMemoryUsage();
|
||||
size_t Utilities::getMemoryUsage()
|
||||
{
|
||||
size_t N_bytes = 0;
|
||||
#if defined(USE_LINUX)
|
||||
struct mallinfo meminfo = mallinfo();
|
||||
size_t size_hblkhd = static_cast<unsigned int>( meminfo.hblkhd );
|
||||
size_t size_uordblks = static_cast<unsigned int>( meminfo.uordblks );
|
||||
N_bytes = size_hblkhd + size_uordblks;
|
||||
#elif defined(USE_MAC)
|
||||
struct task_basic_info t_info;
|
||||
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
|
||||
if (KERN_SUCCESS != task_info(mach_task_self(),
|
||||
TASK_BASIC_INFO, (task_info_t)&t_info,
|
||||
&t_info_count)) {
|
||||
return 0;
|
||||
}
|
||||
N_bytes = t_info.virtual_size;
|
||||
#elif defined(USE_WINDOWS)
|
||||
PROCESS_MEMORY_COUNTERS memCounter;
|
||||
GetProcessMemoryInfo( GetCurrentProcess(), &memCounter, sizeof(memCounter) );
|
||||
N_bytes = memCounter.WorkingSetSize;
|
||||
#endif
|
||||
return N_bytes;
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Functions to get the time and timer resolution *
|
||||
****************************************************************************/
|
||||
#if defined(USE_WINDOWS)
|
||||
double Utilities::time()
|
||||
{
|
||||
LARGE_INTEGER end, f;
|
||||
QueryPerformanceFrequency(&f);
|
||||
QueryPerformanceCounter(&end);
|
||||
double time = ((double)end.QuadPart)/((double)f.QuadPart);
|
||||
return time;
|
||||
}
|
||||
double Utilities::tick()
|
||||
{
|
||||
LARGE_INTEGER f;
|
||||
QueryPerformanceFrequency(&f);
|
||||
double resolution = ((double)1.0)/((double)f.QuadPart);
|
||||
return resolution;
|
||||
}
|
||||
#elif defined(USE_LINUX) || defined(USE_MAC)
|
||||
double Utilities::time()
|
||||
{
|
||||
timeval current_time;
|
||||
gettimeofday(¤t_time,NULL);
|
||||
double time = ((double)current_time.tv_sec)+1e-6*((double)current_time.tv_usec);
|
||||
return time;
|
||||
}
|
||||
double Utilities::tick()
|
||||
{
|
||||
timeval start, end;
|
||||
gettimeofday(&start,NULL);
|
||||
gettimeofday(&end,NULL);
|
||||
while ( end.tv_sec==start.tv_sec && end.tv_usec==start.tv_usec )
|
||||
gettimeofday(&end,NULL);
|
||||
double resolution = ((double)(end.tv_sec-start.tv_sec))+1e-6*((double)(end.tv_usec-start.tv_usec));
|
||||
return resolution;
|
||||
}
|
||||
#else
|
||||
#error Unknown OS
|
||||
#endif
|
||||
|
||||
|
||||
// Factor a number into it's prime factors
|
||||
std::vector<int> Utilities::factor(size_t number)
|
||||
|
||||
@@ -1,91 +1,42 @@
|
||||
#ifndef included_Utilities
|
||||
#define included_Utilities
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdarg>
|
||||
#include <iostream>
|
||||
#include <mutex>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
#include "StackTrace/Utilities.h"
|
||||
|
||||
|
||||
namespace Utilities {
|
||||
|
||||
|
||||
/*!
|
||||
* Aborts the run after printing an error message with file and
|
||||
* linenumber information.
|
||||
*/
|
||||
void abort( const std::string &message, const std::string &filename, const int line );
|
||||
|
||||
|
||||
/*!
|
||||
* Set the behavior of abort
|
||||
* @param printMemory Print the current memory usage (default is true)
|
||||
* @param printStack Print the current call stack (default is true)
|
||||
* @param throwException Throw an exception instead of MPI_Abort (default is false)
|
||||
*/
|
||||
void setAbortBehavior( bool printMemory, bool printStack, bool throwException );
|
||||
|
||||
//! Function to set the error handlers
|
||||
void setErrorHandlers();
|
||||
|
||||
|
||||
/*!
|
||||
* Function to get the memory availible.
|
||||
* This function will return the total memory availible
|
||||
* Note: depending on the implimentation, this number may be rounded to
|
||||
* to a multiple of the page size.
|
||||
* If this function fails, it will return 0.
|
||||
*/
|
||||
size_t getSystemMemory();
|
||||
|
||||
|
||||
/*!
|
||||
* Function to get the memory usage.
|
||||
* This function will return the total memory used by the application.
|
||||
* Note: depending on the implimentation, this number may be rounded to
|
||||
* to a multiple of the page size.
|
||||
* If this function fails, it will return 0.
|
||||
*/
|
||||
size_t getMemoryUsage();
|
||||
|
||||
|
||||
//! Function to get an arbitrary point in time
|
||||
double time();
|
||||
|
||||
|
||||
//! Function to get the resolution of time
|
||||
double tick();
|
||||
// Functions inherited from StackTrace::Utilities
|
||||
using StackTrace::Utilities::abort;
|
||||
using StackTrace::Utilities::cause_segfault;
|
||||
using StackTrace::Utilities::clearErrorHandlers;
|
||||
using StackTrace::Utilities::exec;
|
||||
using StackTrace::Utilities::getMemoryUsage;
|
||||
using StackTrace::Utilities::getSystemMemory;
|
||||
using StackTrace::Utilities::setAbortBehavior;
|
||||
using StackTrace::Utilities::setErrorHandlers;
|
||||
using StackTrace::Utilities::tick;
|
||||
using StackTrace::Utilities::time;
|
||||
using StackTrace::Utilities::sleep_ms;
|
||||
using StackTrace::Utilities::sleep_s;
|
||||
|
||||
|
||||
//! std::string version of sprintf
|
||||
inline std::string stringf( const char *format, ... );
|
||||
|
||||
|
||||
/*!
|
||||
* Sleep for X ms
|
||||
* @param N Time to sleep (ms)
|
||||
*/
|
||||
inline void sleep_ms( int N ) { std::this_thread::sleep_for( std::chrono::milliseconds( N ) ); }
|
||||
|
||||
|
||||
/*!
|
||||
* Sleep for X s
|
||||
* @param N Time to sleep (s)
|
||||
*/
|
||||
inline void sleep_s( int N ) { std::this_thread::sleep_for( std::chrono::seconds( N ) ); }
|
||||
|
||||
|
||||
//! Factor a number into it's prime factors
|
||||
std::vector<int> factor(size_t number);
|
||||
|
||||
//! Print AMP Banner
|
||||
|
||||
//! Null use function
|
||||
void nullUse( void* );
|
||||
|
||||
|
||||
} // namespace Utilities
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user