platform.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#ifndef __ASE_PLATFORM_HH__
#define __ASE_PLATFORM_HH__
 
#include <ase/defs.hh>
#include <condition_variable>
#include <thread>
#include <list>
 
namespace Ase {
 
// == Build Constants ==
extern const int         ase_major_version;
extern const int         ase_minor_version;
extern const int         ase_micro_version;
extern const char *const ase_version_long;
extern const char *const ase_version_short;
extern const char *const ase_gettext_domain;
 
// == Translate i18n strings ==
const char* (_) (const char *string) __attribute__ ((__format_arg__ (1)));
std::string (_) (const std::string &string);
const char* (_) (const char *string, const char *plural, int64_t n) __attribute__ ((__format_arg__ (1), __format_arg__ (2)));
std::string (_) (const std::string &string, const std::string &plural, int64_t n);
 
// == INSTALLPATH ==
enum class RPath {
  PREFIXDIR = 1,
  INSTALLDIR,
  LOCALEDIR,
  LIBDIR,
  ELECTRONDIR,
  LADSPADIRS,
  SAMPLEDIR,
  DEMODIR,
};
std::string anklang_runpath  (RPath rpath, const String &segment = "");
String      anklang_home_dir (const String &subdir = "");
 
// == AnsiColors ==
namespace AnsiColors {
enum Colors {
  NONE,
  RESET,                
  BOLD, BOLD_OFF,
  ITALICS, ITALICS_OFF,
  UNDERLINE, UNDERLINE_OFF,
  INVERSE, INVERSE_OFF,
  STRIKETHROUGH, STRIKETHROUGH_OFF,
  FG_BLACK, FG_RED, FG_GREEN, FG_YELLOW, FG_BLUE, FG_MAGENTA, FG_CYAN, FG_WHITE,
  FG_DEFAULT,
  BG_BLACK, BG_RED, BG_GREEN, BG_YELLOW, BG_BLUE, BG_MAGENTA, BG_CYAN, BG_WHITE,
  BG_DEFAULT,
};
enum class Colorize : int8 { NEVER = 0, ALWAYS = 1, AUTO = 2 };
const char*     color_code      (Colors acolor);
std::string     color           (Colors acolor, Colors c1 = Colors::NONE, Colors c2 = Colors::NONE, Colors c3 = Colors::NONE,
                                 Colors c4 = Colors::NONE, Colors c5 = Colors::NONE, Colors c6 = Colors::NONE);
void            configure       (Colorize colorize);
bool            colorize_tty    (int fd = -1);
} // AnsiColors
 
// == Timestamp Handling ==
uint64  timestamp_startup    ();        // µseconds
uint64  timestamp_realtime   ();        // µseconds
uint64  timestamp_benchmark  ();        // nseconds
uint64  timestamp_resolution ();        // nseconds
String  timestamp_format     (uint64 stamp, uint maxlength = 8);
uint64  monotonic_counter    ();
 
// == Stopwatch ==
class Stopwatch {
  uint64 start_ = 0, end_ = 0;   String msg_;
public:
  explicit Stopwatch    (const String &msg = "");
  void     start        (const String &msg = "");
  void     stop         (const String &msg = "");
  double   seconds      () const;
  double   milliseconds () const;
  /*dtor*/ ~Stopwatch   ();
};
 
// == process names ==
String      program_alias         ();                   
void        program_alias_init    (String customname);  
String      application_name      ();                   
void        application_name_init (String desktopname); 
String      program_cwd           ();                   
std::string executable_name       () ASE_PURE;          
std::string executable_path       () ASE_PURE;          
std::string cpu_info              ();                   
std::string cpu_arch              ();                   
const char* ase_version           ();                   
const char* ase_build_id          ();                   
 
// == user ==
int     user_id         ();
String  user_name       ();
String  user_real_name  ();
 
// == ScopedSemaphore ==
class ScopedSemaphore {
  unsigned long mem_[4];
  /*copy*/         ScopedSemaphore (const ScopedSemaphore&) = delete;
  ScopedSemaphore& operator=       (const ScopedSemaphore&) = delete;
public:
  explicit  ScopedSemaphore () noexcept;  
  int       post            () noexcept;  
  int       wait            () noexcept;  
  int       wait_for        (uint64_t useconds) noexcept;  
  /*dtor*/ ~ScopedSemaphore () noexcept;
};
 
// == AsyncBlockingQueue ==
template<class Value>
class AsyncBlockingQueue {
  std::mutex              mutex_;
  std::condition_variable cond_;
  std::list<Value>        list_;
public:
  void  push    (const Value &v);
  Value pop     ();
  bool  pending ();
  void  swap    (std::list<Value> &list);
};
 
// == Scheduling ==
int  sched_get_priority  (int tid);
bool sched_set_priority  (int tid, int nicelevel);
bool sched_fast_priority (int tid);
 
// == Thread Status ==
struct TaskStatus {
  enum State { UNKNOWN = '?', RUNNING = 'R', SLEEPING = 'S', DISKWAIT = 'D', STOPPED = 'T', PAGING = 'W', ZOMBIE = 'Z', DEBUG = 'X', };
  int           process_id;     
  int           task_id;        
  String        name;           
  State         state;          
  int           processor;      
  int           priority;       
  uint64        utime;          
  uint64        stime;          
  uint64        cutime;         
  uint64        cstime;         
  uint64        ac_stamp;       
  uint64        ac_utime, ac_stime, ac_cutime, ac_cstime;
  explicit      TaskStatus (int pid, int tid = -1); 
  bool          update     ();  
  String        string     ();  
};
 
class TaskRegistry {
  static std::thread::id ase_thread_id, main_thread_id;
public:
  typedef std::vector<Ase::TaskStatus> List;
  static void add       (const std::string &name, int pid,
                         int tid = -1);  
  static bool remove    (int tid);       
  static void update    ();              
  static List list      ();              
  static void setup_ase (const String &name16chars);
  static bool is_ase    () { return std::this_thread::get_id() == ase_thread_id; }
  static bool is_main   () { return std::this_thread::get_id() == main_thread_id; }
};
 
// == Thread Info ==
using ThreadId = std::thread::id;
ThreadId    this_thread_self        ();
void        this_thread_set_name    (const String &name16chars);
String      this_thread_get_name    ();
int         this_thread_getpid      ();
int         this_thread_gettid      ();
int         this_thread_online_cpus ();
inline bool this_thread_is_ase      () { return TaskRegistry::is_ase(); }
inline bool this_thread_is_main     () { return TaskRegistry::is_ase(); }
 
// == Debugging Aids ==
extern inline void breakpoint               () ASE_ALWAYS_INLINE;       
 
// == Memory Barriers ==
#if defined __x86_64__ || defined __amd64__
#define  ASE_MFENCE __sync_synchronize()
#define  ASE_SFENCE __asm__ __volatile__ ("sfence" ::: "memory")
#define  ASE_LFENCE __asm__ __volatile__ ("lfence" ::: "memory")
#else // !x86/64
#define  ASE_SFENCE __sync_synchronize() 
#define  ASE_LFENCE __sync_synchronize() 
#define  ASE_MFENCE __sync_synchronize()
#endif
#define  ASE_CFENCE __asm__ __volatile__ ("" ::: "memory")
 
// == Implementation Details ==
#if (defined __i386__ || defined __x86_64__)
inline void breakpoint() { __asm__ __volatile__ ("int $03"); }
#elif defined __alpha__ && !defined __osf__
inline void breakpoint() { __asm__ __volatile__ ("bpt"); }
#else   // !__i386__ && !__alpha__
inline void breakpoint() { __builtin_trap(); }
#endif
 
template<class Value> void
AsyncBlockingQueue<Value>::push (const Value &v)
{
  std::lock_guard<std::mutex> locker (mutex_);
  const bool notify = list_.empty();
  list_.push_back (v);
  if (ASE_UNLIKELY (notify))
    cond_.notify_all();
}
 
template<class Value> Value
AsyncBlockingQueue<Value>::pop ()
{
  std::unique_lock<std::mutex> locker (mutex_);
  while (list_.empty())
    cond_.wait (locker);
  Value v = list_.front();
  list_.pop_front();
  return v;
}
 
template<class Value> bool
AsyncBlockingQueue<Value>::pending()
{
  std::lock_guard<std::mutex> locker (mutex_);
  return !list_.empty();
}
 
template<class Value> void
AsyncBlockingQueue<Value>::swap (std::list<Value> &list)
{
  std::lock_guard<std::mutex> locker (mutex_);
  const bool notify = list_.empty();
  list_.swap (list);
  if (notify && !list_.empty())
    cond_.notify_all();
}
 
} // Ase
 
#endif // __ASE_PLATFORM_HH__