heavyai Namespace Reference

Classes
class	MutexInterface
class	SharedMutexInterface
class	DistributedSharedMutex
struct	DeviceIdentifier
class	JSON
class	InSituFlagsOwnerInterface
class	UUID
class	RequestInfo

Typedefs
using	DeviceGroup = std::vector< DeviceIdentifier >
using	shared_mutex = std::shared_timed_mutex
template<typename T >
using	lock_guard = std::lock_guard< T >
template<typename T >
using	unique_lock = std::unique_lock< T >
template<typename T >
using	shared_lock = std::shared_lock< T >

Enumerations
enum	InSituFlags { InSituFlags::kInSitu = 1u << 0, InSituFlags::kNonInSitu = 1u << 1, InSituFlags::kForcedNonInSitu = (kInSitu | kNonInSitu) }

Functions
size_t	file_size (const int fd)
void *	checked_mmap (const int fd, const size_t sz)
void	checked_munmap (void *addr, size_t length)
int	msync (void *addr, size_t length, bool async)
int	fsync (int fd)
int	open (const char *path, int flags, int mode)
void	close (const int fd)
::FILE *	fopen (const char *filename, const char *mode)
::FILE *	popen (const char *command, const char *type)
int32_t	pclose (::FILE *fh)
int	get_page_size ()
int32_t	ftruncate (const int32_t fd, int64_t length)
int	safe_open (const char *path, int flags, mode_t mode) noexcept
int	safe_close (int fd) noexcept
int	safe_fcntl (int fd, int cmd, struct flock *fl) noexcept
ssize_t	safe_read (const int fd, void *buffer, const size_t buffer_size) noexcept
ssize_t	safe_write (const int fd, const void *buffer, const size_t buffer_size) noexcept
int32_t	safe_ftruncate (const int32_t fd, int64_t length) noexcept
std::vector< std::string >	glob (const std::string &pattern)
std::string	get_hostname ()
std::string	get_root_abs_path ()
bool	operator== (const JSON &json1, const JSON &json2)
bool	operator!= (const JSON &json1, const JSON &json2)
template<typename T >
bool	operator== (const JSON &json, const T &value)
template<typename T >
bool	operator== (const T &value, const JSON &json)
template<typename T >
bool	operator!= (const JSON &json, const T &value)
template<typename T >
bool	operator!= (const T &value, const JSON &json)
bool	operator== (const UUID &lhs, const UUID &rhs) noexcept
bool	operator!= (const UUID &lhs, const UUID &rhs) noexcept
bool	operator< (const UUID &lhs, const UUID &rhs) noexcept
std::string	to_string (const UUID &uuid)

Variables
constexpr UUID	empty_uuid {}

Typedef Documentation

using heavyai::DeviceGroup = typedef std::vector<DeviceIdentifier>

Definition at line 31 of file DeviceGroup.h.

template<typename T >

using heavyai::lock_guard = typedef std::lock_guard<T>

Definition at line 37 of file heavyai_shared_mutex.h.

template<typename T >

using heavyai::shared_lock = typedef std::shared_lock<T>

Definition at line 41 of file heavyai_shared_mutex.h.

using heavyai::shared_mutex = typedef std::shared_timed_mutex

Definition at line 31 of file heavyai_shared_mutex.h.

template<typename T >

using heavyai::unique_lock = typedef std::unique_lock<T>

Definition at line 39 of file heavyai_shared_mutex.h.

Enumeration Type Documentation

enum heavyai::InSituFlags

strong

Enumerator
kInSitu
kNonInSitu
kForcedNonInSitu

Definition at line 23 of file InSituFlags.h.

                       {
  kInSitu = 1u << 0,
  kNonInSitu = 1u << 1,
  kForcedNonInSitu = (kInSitu | kNonInSitu)
};

Function Documentation

void * heavyai::checked_mmap	(	const int	fd,
		const size_t	sz
	)

Definition at line 40 of file heavyai_fs.cpp.

References CHECK.

Referenced by StringDictionary::checkAndConditionallyIncreaseOffsetCapacity(), StringDictionary::checkAndConditionallyIncreasePayloadCapacity(), and StringDictionary::StringDictionary().

                                                  {
  auto ptr = mmap(nullptr, sz, PROT_WRITE | PROT_READ, MAP_SHARED, fd, 0);
  CHECK(ptr != reinterpret_cast<void*>(-1));
#ifdef __linux__
#ifdef MADV_HUGEPAGE
  madvise(ptr, sz, MADV_RANDOM | MADV_WILLNEED | MADV_HUGEPAGE);
#else
  madvise(ptr, sz, MADV_RANDOM | MADV_WILLNEED);
#endif
#endif
  return ptr;
}

Here is the caller graph for this function:

void heavyai::checked_munmap	(	void *	addr,
		size_t	length
	)

Definition at line 53 of file heavyai_fs.cpp.

References CHECK_EQ.

Referenced by StringDictionary::checkAndConditionallyIncreaseOffsetCapacity(), StringDictionary::checkAndConditionallyIncreasePayloadCapacity(), and StringDictionary::~StringDictionary().

                                               {
  CHECK_EQ(0, munmap(addr, length));
}

Here is the caller graph for this function:

void heavyai::close

(

const int

fd

)

Definition at line 70 of file heavyai_fs.cpp.

Referenced by import_export::DataStreamSink::import_compressed(), safe_close(), and StringDictionary::~StringDictionary().

                         {
  ::close(fd);
}

Here is the caller graph for this function:

size_t heavyai::file_size

(

const int

fd

)

Definition at line 33 of file heavyai_fs.cpp.

References CHECK_EQ.

Referenced by get_filesize(), File_Namespace::FileMgr::getMetadataForFile(), File_Namespace::TableFileMgr::getReservedSpace(), File_Namespace::FileMgr::openAndReadEpochFile(), File_Namespace::FileMgr::openAndReadLegacyEpochFile(), File_Namespace::FileMgr::readPageMappingsFromStatusFile(), File_Namespace::FileMgr::readVersionFromDisk(), anonymous_namespace{TableArchiver.cpp}::rewrite_column_ids_in_page_headers(), anonymous_namespace{CachingFileMgr.cpp}::size_of_dir(), StringDictionary::StringDictionary(), and File_Namespace::TableFileMgr::TableFileMgr().

                               {
  struct stat buf;
  int err = fstat(fd, &buf);
  CHECK_EQ(0, err);
  return buf.st_size;
}

Here is the caller graph for this function:

FILE * heavyai::fopen	(	const char *	filename,
		const char *	mode
	)

Definition at line 74 of file heavyai_fs.cpp.

Referenced by foreign_storage::SingleTextFileReader::checkForMoreRows(), File_Namespace::create(), TableArchiver::dumpTable(), import_export::Detector::importDelimited(), import_export::Importer::importDelimited(), PosixFileArchive::init_for_read(), File_Namespace::open(), anonymous_namespace{TableArchiver.cpp}::rewrite_column_ids_in_page_headers(), and foreign_storage::SingleTextFileReader::SingleTextFileReader().

                                                    {
  return ::fopen(filename, mode);
}

Here is the caller graph for this function:

int heavyai::fsync

(

int

fd

)

Definition at line 62 of file heavyai_fs.cpp.

Referenced by StringDictionary::checkpoint(), File_Namespace::FileInfo::syncToDisk(), File_Namespace::TableFileMgr::writeAndSyncEpochToDisk(), File_Namespace::FileMgr::writeAndSyncEpochToDisk(), and File_Namespace::FileMgr::writeAndSyncVersionToDisk().

                  {
  return ::fsync(fd);
}

Here is the caller graph for this function:

int32_t heavyai::ftruncate	(	const int32_t	fd,
		int64_t	length
	)

Definition at line 86 of file heavyai_fs.cpp.

Referenced by safe_ftruncate(), and CommandLineOptions::validate().

                                                    {
  return ::ftruncate(fd, length);
}

Here is the caller graph for this function:

std::string heavyai::get_hostname

(

)

Definition at line 23 of file heavyai_hostname.cpp.

Referenced by DBHandler::get_server_status(), and DBHandler::get_status().

                         {
  char hostname[_POSIX_HOST_NAME_MAX];
  gethostname(hostname, _POSIX_HOST_NAME_MAX);
  return {hostname};
}

Here is the caller graph for this function:

int heavyai::get_page_size

(

)

Definition at line 29 of file heavyai_fs.cpp.

                    {
  return getpagesize();
}

std::string heavyai::get_root_abs_path

(

)

Definition at line 40 of file heavyai_path.cpp.

References CHECK, CHECK_EQ, CHECK_GT, and CHECK_LT.

Referenced by Geospatial::GDAL::init(), Executor::initialize_extension_module_sources(), loadGeo(), and start_calcite_server_as_daemon().

                              {
#ifdef ENABLE_EMBEDDED_DATABASE
  void* const handle = dlopen(DBEngine_LIBNAME, RTLD_LAZY | RTLD_NOLOAD);
  if (handle) {
    /* Non-zero handle means that libDBEngine.so has been loaded and
       the omnisci root path will be determined with respect to the
       location of the shared library rather than the appliction
       `/proc/self/exe` path. */
    const struct link_map* link_map = 0;
    const int ret = dlinfo(handle, RTLD_DI_LINKMAP, &link_map);
    CHECK_EQ(ret, 0);
    CHECK(link_map);
    /* Despite the dlinfo man page claim that l_name is absolute path,
       it is so only when the location path to the library is absolute,
       say, as specified in LD_LIBRARY_PATH. */
    boost::filesystem::path abs_exe_dir(boost::filesystem::absolute(
        boost::filesystem::canonical(std::string(link_map->l_name))));
    abs_exe_dir.remove_filename();
#ifdef XCODE
    const auto mapd_root = abs_exe_dir.parent_path().parent_path();
#else
    const auto mapd_root = abs_exe_dir.parent_path();
#endif
    return mapd_root.string();
  }
#endif
#ifdef __APPLE__
  char abs_exe_path[PROC_PIDPATHINFO_MAXSIZE] = {0};
  auto path_len = proc_pidpath(getpid(), abs_exe_path, sizeof(abs_exe_path));
#else
  char abs_exe_path[PATH_MAX] = {0};
  auto path_len = readlink("/proc/self/exe", abs_exe_path, sizeof(abs_exe_path));
#endif
  CHECK_GT(path_len, 0);
  CHECK_LT(static_cast<size_t>(path_len), sizeof(abs_exe_path));
  boost::filesystem::path abs_exe_dir(std::string(abs_exe_path, path_len));
  abs_exe_dir.remove_filename();
#ifdef XCODE
  const auto mapd_root = abs_exe_dir.parent_path().parent_path();
#else
  const auto mapd_root = abs_exe_dir.parent_path();
#endif
  return mapd_root.string();
}

Here is the caller graph for this function:

std::vector< std::string > heavyai::glob

(

const std::string &

pattern

)

Definition at line 24 of file heavyai_glob.cpp.

Referenced by shared::file_or_glob_path_exists(), anonymous_namespace{heavyai_glob.cpp}::glob(), and shared::anonymous_namespace{file_path_util.cpp}::glob_local_recursive_files().

                                                    {
  std::vector<std::string> results;
  glob_t glob_result;
  ::glob(pattern.c_str(), GLOB_BRACE | GLOB_TILDE, nullptr, &glob_result);
  for (size_t i = 0; i < glob_result.gl_pathc; i++) {
    results.emplace_back(glob_result.gl_pathv[i]);
  }
  globfree(&glob_result);
  return results;
}

Here is the caller graph for this function:

int heavyai::msync	(	void *	addr,
		size_t	length,
		bool	async
	)

Definition at line 57 of file heavyai_fs.cpp.

Referenced by StringDictionary::checkpoint().

                                                 {
  // TODO: support MS_INVALIDATE?
  return ::msync(addr, length, async ? MS_ASYNC : MS_SYNC);
}

Here is the caller graph for this function:

int heavyai::open	(	const char *	path,
		int	flags,
		int	mode
	)

Definition at line 66 of file heavyai_fs.cpp.

Referenced by anonymous_namespace{StringDictionary.cpp}::checked_open(), generate_TableFunctionsFactory_init::find_signatures(), create_table.SyntheticTable::generateData(), heavydb.version::get_source_version(), analyze_benchmark.BenchmarkLoader::load(), make-m2-proxy::main(), run_benchmark::read_query_files(), benchmarks.GoogleBenchmark::run(), benchmarks.TPC_DS_10GB::run(), safe_open(), run_benchmark::send_results_db(), run_benchmark::send_results_file_json(), and run_benchmark::send_results_jenkins_bench().

                                                {
  return ::open(path, flags, mode);
}

Here is the caller graph for this function:

bool heavyai::operator!= ( const UUID &  lhs, const UUID &  rhs  )

inlinenoexcept

Definition at line 102 of file uuid.h.

                                                                  {
  return !(lhs == rhs);
}

bool heavyai::operator!= ( const JSON &  json1, const JSON &  json2  )

inline

Definition at line 408 of file json.h.

References heavyai::JSON::vptr_.

                                                             {
  return (*json1.vptr_ != *json2.vptr_);
}

template<typename T >

bool heavyai::operator!= ( const JSON &  json, const T &  value  )

inline

Definition at line 424 of file json.h.

References heavyai::JSON::vptr_.

                                                         {
  return (*json.vptr_ != value);
}

template<typename T >

bool heavyai::operator!= ( const T &  value, const JSON &  json  )

inline

Definition at line 428 of file json.h.

                                                         {
  return (json != value);
}

bool heavyai::operator< ( const UUID &  lhs, const UUID &  rhs  )

inlinenoexcept

Definition at line 106 of file uuid.h.

                                                                 {
  return lhs.data_ < rhs.data_;
}

bool heavyai::operator== ( const UUID &  lhs, const UUID &  rhs  )

inlinenoexcept

Definition at line 98 of file uuid.h.

                                                                  {
  return lhs.data_ == rhs.data_;
}

bool heavyai::operator== ( const JSON &  json1, const JSON &  json2  )

inline

Definition at line 404 of file json.h.

References heavyai::JSON::vptr_.

                                                             {
  return (*json1.vptr_ == *json2.vptr_);
}

template<typename T >

bool heavyai::operator== ( const JSON &  json, const T &  value  )

inline

Definition at line 415 of file json.h.

References heavyai::JSON::vptr_.

                                                         {
  return (*json.vptr_ == value);
}

template<typename T >

bool heavyai::operator== ( const T &  value, const JSON &  json  )

inline

Definition at line 419 of file json.h.

                                                         {
  return (json == value);
}

int32_t heavyai::pclose

(

::FILE *

fh

)

Definition at line 82 of file heavyai_fs.cpp.

Referenced by anonymous_namespace{UdfCompiler.cpp}::exec_output().

                         {
  return ::pclose(fh);
}

Here is the caller graph for this function:

FILE * heavyai::popen	(	const char *	command,
		const char *	type
	)

Definition at line 78 of file heavyai_fs.cpp.

Referenced by anonymous_namespace{UdfCompiler.cpp}::exec_output().

                                                   {
  return ::popen(command, type);
}

Here is the caller graph for this function:

int heavyai::safe_close ( int  fd )

noexcept

Definition at line 101 of file heavyai_fs.cpp.

References close(), and UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                {
  for (int ret;;) {
    ret = ::close(fd);
    if (ret == -1 && errno == EINTR) {  // interrupted by signal
      continue;
    }
    return ret;
  }
  UNREACHABLE();
}

Here is the call graph for this function:

Here is the caller graph for this function:

int heavyai::safe_fcntl ( int  fd, int  cmd, struct flock *  fl  )

noexcept

Definition at line 112 of file heavyai_fs.cpp.

References UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                                           {
  for (int ret;;) {
    ret = ::fcntl(fd, cmd, fl);
    if (ret == -1 && errno == EINTR) {  // interrupted by signal
      continue;
    }
    return ret;
  }
  UNREACHABLE();
}

Here is the caller graph for this function:

int32_t heavyai::safe_ftruncate ( const int32_t  fd, int64_t  length  )

noexcept

Definition at line 162 of file heavyai_fs.cpp.

References ftruncate(), and UNREACHABLE.

                                                                  {
  for (int ret;;) {
    ret = ::ftruncate(fd, length);
    if (ret == -1 && errno == EINTR) {  // interrupted by signal
      continue;
    }
    return ret;
  }
  UNREACHABLE();
}

Here is the call graph for this function:

int heavyai::safe_open ( const char *  path, int  flags, mode_t  mode  )

noexcept

Definition at line 90 of file heavyai_fs.cpp.

References open(), and UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                                                 {
  for (int ret;;) {
    ret = ::open(path, flags, mode);
    if (ret == -1 && errno == EINTR) {  // interrupted by signal
      continue;
    }
    return ret;
  }
  UNREACHABLE();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ssize_t heavyai::safe_read ( const int  fd, void *  buffer, const size_t  buffer_size  )

noexcept

Definition at line 123 of file heavyai_fs.cpp.

References File_Namespace::read(), and UNREACHABLE.

                                                                                 {
  for (ssize_t ret, sz = 0;;) {
    ret = ::read(fd, &static_cast<char*>(buffer)[sz], buffer_size - sz);
    if (ret == -1) {
      if (errno == EINTR) {  // interrupted by signal
        continue;
      }
      return -1;
    }
    if (ret == 0) {  // EOF
      return sz;
    }
    sz += ret;
    if (sz == static_cast<ssize_t>(buffer_size)) {
      return sz;
    }
    // either an EOF is coming or interrupted by signal
  }
  UNREACHABLE();
}

Here is the call graph for this function:

ssize_t heavyai::safe_write ( const int  fd, const void *  buffer, const size_t  buffer_size  )

noexcept

Definition at line 144 of file heavyai_fs.cpp.

References UNREACHABLE, and File_Namespace::write().

Referenced by CommandLineOptions::validate().

                                                                                        {
  for (ssize_t ret, sz = 0;;) {
    ret = ::write(fd, &static_cast<char const*>(buffer)[sz], buffer_size - sz);
    if (ret == -1) {
      if (errno == EINTR) {  // interrupted by signal
        continue;
      }
      return -1;
    }
    sz += ret;
    if (sz == static_cast<ssize_t>(buffer_size)) {
      return sz;
    }
    // either an error is coming (such as disk full) or interrupted by signal
  }
  UNREACHABLE();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string heavyai::to_string ( const UUID &  uuid )

inline

Definition at line 110 of file uuid.h.

                                             {
  std::stringstream ss;
  ss << uuid;
  return ss.str();
}

Variable Documentation

constexpr UUID heavyai::empty_uuid {}

Definition at line 116 of file uuid.h.