Utilities.h

Go to the documentation of this file.

#ifndef included_AMP_Utilities
#define included_AMP_Utilities
 
 
#include "AMP/AMP_TPLs.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Backend.h"
#include "AMP/utils/Memory.h"
#include "AMP/utils/UtilityMacros.h"
 
#include "StackTrace/Utilities.h"
 
#include <algorithm>
#include <cctype>
#include <chrono>
#include <cstdarg>
#include <limits>
#include <math.h>
#include <sstream>
#include <stdio.h>
#include <string>
#include <string_view>
#include <vector>
 
 
namespace AMP {
 
 
class Database;
 
 
// \cond HIDDEN_SYMBOLS
template<class T>
inline T type_default_tol()
{
    if constexpr ( std::is_integral_v<T> )
        return 0;
    else if constexpr ( std::is_same_v<T, double> )
        return 1e-12;
    else if constexpr ( std::is_floating_point_v<T> )
        return std::pow( std::numeric_limits<T>::epsilon(), (T) 0.77 );
    else
        return T();
}
// \endcond
 
 
namespace Utilities {
 
 
// Include functions from StackTrace
using StackTrace::Utilities::abort;
using StackTrace::Utilities::exec;
using StackTrace::Utilities::getMemoryUsage;
using StackTrace::Utilities::getOS;
using StackTrace::Utilities::getSystemMemory;
using StackTrace::Utilities::OS;
using StackTrace::Utilities::tick;
using StackTrace::Utilities::time;
 
 
std::string getLastErrnoString();
 
 
bool running_valgrind();
 
 
template<class TYPE>
bool isInf( TYPE x );
 
 
template<class TYPE>
bool isNaN( TYPE x );
 
 
void setenv( const char *name, const char *value );
 
std::string getenv( const char *name );
 
 
std::string intToString( int num, int min_width = 1 );
 
 
std::string strrep( const std::string &str, const std::string &s, const std::string &r );
 
 
std::string nodeToString( int num );
std::string processorToString( int num );
std::string patchToString( int num );
std::string levelToString( int num );
std::string blockToString( int num );
 
 
template<class T>
inline bool approx_equal( const T &v1, const T &v2, const T tol = type_default_tol<T>() )
{
    // Compute the absolute tolerance
    T tol2 = static_cast<T>( tol * std::max( fabs( (double) ( v1 ) ), fabs( (double) ( v2 ) ) ) );
    // Check if the two value are less than tolerance
    return fabs( (double) ( v1 - v2 ) ) <= tol2;
}
 
template<class T>
inline bool approx_equal_abs( const T &v1, const T &v2, const T tol = type_default_tol<T>() )
{
    return fabs( (double) ( v1 - v2 ) ) <= tol; // Check if the two value are less than tolerance
}
 
 
template<typename T1, typename T2, Backend, class Allocator>
void copyCast( const size_t len, const T1 *vec_in, T2 *vec_out );
 
template<typename T1, typename T2, Backend>
void copyCast( const size_t len, const T1 *vec_in, T2 *vec_out );
 
 
template<class T>
void quicksort( size_t N, T *x );
 
template<class T>
inline void quicksort( std::vector<T> &x )
{
    quicksort( x.size(), x.data() );
}
 
template<class T1, class T2>
void quicksort( size_t N, T1 *x, T2 *y );
 
template<class T1, class T2>
inline void quicksort( std::vector<T1> &x, std::vector<T2> &y )
{
    AMP_INSIST( x.size() == y.size(), "x and y must be the same size" );
    quicksort( x.size(), x.data(), y.data() );
}
 
template<class T1, class T2, class T3>
void quicksort( size_t N, T1 *x, T2 *y, T3 *z );
 
 
template<class T>
void unique( std::vector<T> &x );
 
template<class T>
void unique( std::vector<T> &X, std::vector<size_t> &I );
 
 
template<class T>
size_t findfirst( size_t N, const T *x, const T &value );
 
template<class T>
inline size_t findfirst( const std::vector<T> &x, const T &value )
{
    return findfirst( x.size(), x.data(), value );
}
 
 
double linear( const std::vector<double> &x, const std::vector<double> &f, double xi );
 
double bilinear( const std::vector<double> &x,
                 const std::vector<double> &y,
                 const std::vector<double> &f,
                 double xi,
                 double yi );
 
double trilinear( const std::vector<double> &x,
                  const std::vector<double> &y,
                  const std::vector<double> &z,
                  const std::vector<double> &f,
                  double xi,
                  double yi,
                  double zi );
 
 
constexpr unsigned int hash_char( const std::string_view &str )
{
    uint32_t hash = 5381;
    for ( unsigned char c : str ) {
        // hash = hash * 33 ^ c
        hash = ( ( hash << 5 ) + hash ) ^ c;
    }
    return hash;
}
 
 
// Function to demangle a string (e.g. from typeid)
std::string demangle( const std::string &name );
 
 
std::vector<int> factor( uint64_t );
 
 
bool isPrime( uint64_t );
 
 
std::vector<uint64_t> primes( uint64_t );
 
 
inline void sleep_ms( int N ) { std::this_thread::sleep_for( std::chrono::milliseconds( N ) ); }
 
inline void sleep_s( int N ) { std::this_thread::sleep_for( std::chrono::seconds( N ) ); }
 
void busy_ms( int N );
 
inline void busy_s( int N ) { busy_ms( 1000 * N ); }
 
 
void printBanner();
 
 
void nullUse( const void * );
 
 
std::string randomString( const AMP::AMP_MPI &comm = AMP_COMM_NULL );
 
 
void fillRandom( std::vector<double> & );
 
 
template<size_t N>
void fillRandom( std::vector<std::array<double, N>> & );
 
 
inline std::string stringf( const char *format, ... )
{
    va_list ap;
    va_start( ap, format );
    char tmp[4096];
    int n = vsnprintf( tmp, sizeof tmp, format, ap );
    va_end( ap );
    AMP_INSIST( n >= 0, "Error using stringf: encoding error" );
    AMP_INSIST( n < (int) sizeof tmp, "Error using stringf: internal buffer size" );
    return std::string( tmp );
}
 
 
template<class TYPE>
std::string to_string( const std::vector<TYPE> &x );
 
 
[[deprecated( "This function will be removed soon, use Database::print" )]] void
printDatabase( const Database &, std::ostream &, const std::string &indent = "" );
 
 
template<class TYPE, std::size_t CAPACITY>
class stackVector final
{
public:
    stackVector() : d_size( 0 ) {}
    stackVector( std::initializer_list<TYPE> x ) : d_size( 0 )
    {
        if ( x.size() > CAPACITY )
            throw std::bad_alloc();
        for ( const auto &y : x )
            d_data[d_size++] = y;
    }
    size_t size() const { return d_size; }
    bool empty() const { return d_size == 0; }
    void push_back( const TYPE &v )
    {
        if ( d_size == CAPACITY )
            throw std::bad_alloc();
        d_data[d_size++] = v;
    }
    void clear()
    {
        for ( size_t i = 0; i < d_size; i++ )
            d_data[i] = TYPE();
        d_size = 0;
    }
    TYPE &operator[]( size_t i ) { return d_data[i]; }
    TYPE *begin() { return d_data; }
    TYPE *end() { return d_data + d_size; }
    TYPE &back() { return d_data[d_size - 1]; }
    TYPE *data() { return d_size == 0 ? nullptr : d_data; }
    void pop_back() { d_size = std::max<size_t>( d_size, 1 ) - 1; }
    const TYPE &operator[]( size_t i ) const { return d_data[i]; }
    const TYPE *begin() const { return d_data; }
    const TYPE *end() const { return d_data + d_size; }
    const TYPE &back() const { return d_data[d_size - 1]; }
    template<class... Args>
    void emplace_back( Args &&...args )
    {
        if ( d_size == CAPACITY )
            throw std::bad_alloc();
        d_data[d_size++] = TYPE( args... );
    }
 
private:
    uint32_t d_size;
    TYPE d_data[CAPACITY];
};
 
 
void setNestedOperatorMemoryLocations( std::shared_ptr<AMP::Database> input_db,
                                       std::string outerOperatorName,
                                       std::vector<std::string> nestedOperatorNames );
 
} // namespace Utilities
} // namespace AMP
 
 
#endif