SearchUtils.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File SearchUtils.h ---------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*------------------------------ DEFINITIONS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __PBeFS_SearchUtils
 #define __PBeFS_SearchUtils
                      /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*-------------------------------- INCLUDES --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include <algorithm>
 
#include <chrono>
 
#include <cstddef>
 
#include <cstdint>
 
#include <cstdlib>
 
#include <vector>
 
#include "ADS/concurrent/Backoff.h"
 
#include "ADS/dictionary/RandomHashing.h"
 
#include "ADS/memory/HugePageAllocator.h"
 
#include "ADS/parallel/Affinity.h"
 
#include "ADS/parallel/Executor.h"
 
#include "ADS/parallel/ThreadPool.h"
 
/*--------------------------------------------------------------------------*/
/*------------------------------- NAMESPACE --------------------------------*/
/*--------------------------------------------------------------------------*/

namespace PBeFS_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*------------------------ CONSTANTS AND FUNCTIONS -------------------------*/
/*--------------------------------------------------------------------------*/

inline constexpr std::size_t cache_line = 64;
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

 
inline void pin_worker( unsigned i ) noexcept
{
 static const bool pin = [] {
  const char * v = std::getenv( "PBEFS_PIN" );
  return( v && *v && ( v[ 0 ] != '0' ) );
  }();
 if( pin )
  static_cast< void >( ADS::pinThread( i ) );
 }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

 
struct ParallelParams {
 
 unsigned threads = 1;          
 std::size_t batch = 64;        
 unsigned flush_period = 64;    
 std::uint64_t seed = 1;        

 void normalize( void ) noexcept {
  if( threads == 0 )
   threads = 1;
  if( batch == 0 )
   batch = 1;
  if( flush_period == 0 )
   flush_period = 1;
  }
 
 };  // end( struct( ParallelParams ) )
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

 
template< ADS::WorkerExecutor Executor , class F >
void run_workers( Executor * ex , unsigned p , F && f )
{
 const auto body = [ & f ]( std::size_t i ) {
  if( ! ADS::isRunCaller() )
   pin_worker( unsigned( i ) );
  f( unsigned( i ) );
  };
 if( ex )
  ex->run( p , body );
 else {
  Executor own( p );
  own.run( p , body );
  }
 }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
inline void prefetch( const void * p ) noexcept
{
 #if defined( __GNUC__ ) || defined( __clang__ )
  __builtin_prefetch( p , 0 , 1 );
 #else
  ( void ) p;
 #endif
 }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

 
template< class Gen >
[[nodiscard]] double random_unit( Gen & gen )
{
 return( double( std::uint64_t( gen() ) >> 11 ) * 0x1.0p-53 );
 }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
template< class Gen >
[[nodiscard]] std::uint64_t random_below( Gen & gen , std::uint64_t n )
{
 return( std::uint64_t( gen() ) % n );
 }
 
/*--------------------------------------------------------------------------*/
/*---------------------------- CLASS Stopwatch -----------------------------*/
/*--------------------------------------------------------------------------*/
 
class Stopwatch {
 
 public:
 
 Stopwatch( void ) : f_start( std::chrono::steady_clock::now() ) {}

 [[nodiscard]] double seconds( void ) const {
  return( std::chrono::duration< double >(
                       std::chrono::steady_clock::now() - f_start ).count() );
  }
 
 private:
 
 std::chrono::steady_clock::time_point f_start;     
 
 };  // end( class( Stopwatch ) )
 
/*--------------------------------------------------------------------------*/
 
}  // end( namespace PBeFS_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
 
#endif  /* __PBeFS_SearchUtils */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File SearchUtils.h -------------------------*/
/*--------------------------------------------------------------------------*/