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{CachingFileMgr.cpp}::size_of_dir(), StringDictionary::StringDictionary(), File_Namespace::TableFileMgr::TableFileMgr(), and anonymous_namespace{TableArchiver.cpp}::update_or_drop_column_ids_in_page_headers().

                                {
   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(), foreign_storage::SingleTextFileReader::SingleTextFileReader(), and anonymous_namespace{TableArchiver.cpp}::update_or_drop_column_ids_in_page_headers().

                                                     {
   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 get_runtime_test_lib_path(), get_runtime_test_lib_tfs_path(), get_torch_table_functions_path(), 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 TableFunctionsFactory_linker.BaseGenerateFiles::_generate_files(), anonymous_namespace{StringDictionary.cpp}::checked_open(), generate_TableFunctionsFactory_init::find_signatures(), create_table.SyntheticTable::generateData(), TableFunctionsFactory_linker::get_existing_file_content(), 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.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation