YAKL_InitConfig.h

Go to the documentation of this file.

 
#pragma once
 
#include <unistd.h>
 
__YAKL_NAMESPACE_WRAPPER_BEGIN__
namespace yakl {
  
  class InitConfig {
  protected:
    std::function<void *( size_t , char const *)> alloc_device_func;
    std::function<void ( void * , char const *)>  free_device_func;  
    std::function<void ()>                        timer_init;
    std::function<void ()>                        timer_finalize;
    std::function<void (char const *)>            timer_start;
    std::function<void (char const *)>            timer_stop;
    bool pool_enabled;
    size_t pool_initial_mb;
    size_t pool_grow_mb;
    size_t pool_block_bytes;
  
  public:
    InitConfig() {
      size_t mem_total, mem_free;
      #if   defined(YAKL_ARCH_CUDA)
        cudaMemGetInfo(&mem_free, &mem_total);
        mem_free  /= 1024*1024;
        mem_total /= 1024*1024;
      #elif defined(YAKL_ARCH_HIP)
        hipMemGetInfo(&mem_free, &mem_total);
        mem_free  /= 1024*1024;
        mem_total /= 1024*1024;
      #elif defined(YAKL_ARCH_SYCL)
        mem_total = sycl_default_stream().get_device().get_info<sycl::info::device::global_mem_size>();
        mem_free  = sycl_default_stream().get_device().get_info<sycl::ext::intel::info::device::free_memory>();
        mem_free  /= 1024*1024;
        mem_total /= 1024*1024;
      #else
        long pages = sysconf(_SC_PHYS_PAGES);
        long page_size = sysconf(_SC_PAGE_SIZE);
        mem_total = (size_t)pages*(size_t)page_size;
        mem_free  = mem_total;
        mem_free  /= 1024*1024;
        mem_total /= 1024*1024;
      #endif
      pool_enabled     = true;
      pool_initial_mb  = mem_total / 8;
      if (mem_free < pool_initial_mb) pool_initial_mb = 0.5*mem_free;
      pool_grow_mb     = pool_initial_mb;
      pool_block_bytes = 16*sizeof(size_t);
 
      char * env = std::getenv("GATOR_DISABLE");
      if ( env != nullptr ) {
        std::string resp(env);
        if (resp == "yes" || resp == "YES" || resp == "1" || resp == "true" || resp == "TRUE" || resp == "T") {
          pool_enabled = false;
        }
      }
 
      // Check for GATOR_INITIAL_MB environment variable
      env = std::getenv("GATOR_INITIAL_MB");
      if ( env != nullptr ) {
        long int initial_mb = atol(env);
        if (initial_mb != 0) {
          pool_initial_mb = initial_mb;
          pool_grow_mb = pool_initial_mb;
        } else {
          if (yakl_mainproc()) std::cout << "WARNING: Invalid GATOR_INITIAL_MB. Defaulting to 1GB\n";
        }
      }
      // Check for GATOR_GROW_MB environment variable
      env = std::getenv("GATOR_GROW_MB");
      if ( env != nullptr ) {
        long int grow_mb = atol(env);
        if (grow_mb != 0) {
          pool_grow_mb = grow_mb;
        } else {
          if (yakl_mainproc()) std::cout << "WARNING: Invalid GATOR_GROW_MB. Defaulting to 1GB\n";
        }
      }
 
      // Check for GATOR_BLOCK_BYTES environment variable
      env = std::getenv("GATOR_BLOCK_BYTES");
      if ( env != nullptr ) {
        long int block_bytes = atol(env);
        if (block_bytes != 0 && block_bytes%(2*sizeof(size_t)) == 0) {
          pool_block_bytes = block_bytes;
        } else {
          if (yakl_mainproc()) std::cout << "WARNING: Invalid GATOR_BLOCK_BYTES. Defaulting to 16*sizeof(size_t)\n";
          if (yakl_mainproc()) std::cout << "         GATOR_BLOCK_BYTES must be > 0 and a multiple of 2*sizeof(size_t)\n";
        }
      }
    }
    InitConfig set_device_allocator( std::function<void *( size_t )> func ) {
      alloc_device_func = [=] (size_t bytes , char const *label) -> void * { return func(bytes); };
      return *this;
    }
    InitConfig set_device_deallocator( std::function<void ( void * )> func ) {
      free_device_func  = [=] (void *ptr , char const *label) { func(ptr); };
      return *this;
    }
    InitConfig set_device_allocator  ( std::function<void *( size_t , char const *)> func ) { alloc_device_func = func; return *this; }
    InitConfig set_device_deallocator( std::function<void ( void * , char const *)>  func ) { free_device_func  = func; return *this; }
    InitConfig set_timer_init        ( std::function<void (            )>            func ) { timer_init      = func; return *this; }
    InitConfig set_timer_finalize    ( std::function<void (            )>            func ) { timer_finalize  = func; return *this; }
    InitConfig set_timer_start       ( std::function<void (char const *)>            func ) { timer_start     = func; return *this; }
    InitConfig set_timer_stop        ( std::function<void (char const *)>            func ) { timer_stop      = func; return *this; }
    InitConfig set_pool_enabled    ( bool enabled      ) { this->pool_enabled     = enabled    ; return *this; }
    InitConfig set_pool_initial_mb ( size_t initial_mb ) { this->pool_initial_mb  = initial_mb ; return *this; }
    InitConfig set_pool_grow_mb    ( size_t grow_mb    ) { this->pool_grow_mb     = grow_mb    ; return *this; }
    InitConfig set_pool_block_bytes( size_t block_bytes) { this->pool_block_bytes = block_bytes; return *this; }
    std::function<void *( size_t , char const *)> get_device_allocator  () const { return alloc_device_func; }
    std::function<void ( void * , char const *)>  get_device_deallocator() const { return free_device_func ; }
    std::function<void ()>                        get_timer_init        () const { return timer_init     ; }
    std::function<void ()>                        get_timer_finalize    () const { return timer_finalize ; }
    std::function<void (char const *)>            get_timer_start       () const { return timer_start    ; }
    std::function<void (char const *)>            get_timer_stop        () const { return timer_stop     ; }
    bool   get_pool_enabled    () const { return pool_enabled    ; }
    size_t get_pool_initial_mb () const { return pool_initial_mb ; }
    size_t get_pool_grow_mb    () const { return pool_grow_mb    ; }
    size_t get_pool_block_bytes() const { return pool_block_bytes; }
  };
 
}
__YAKL_NAMESPACE_WRAPPER_END__