OmniSciDB  e465130ba1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
File_Namespace::GlobalFileMgr Class Reference

#include <GlobalFileMgr.h>

+ Inheritance diagram for File_Namespace::GlobalFileMgr:
+ Collaboration diagram for File_Namespace::GlobalFileMgr:

Public Member Functions

 GlobalFileMgr (const int deviceId, std::string basePath=".", const size_t num_reader_threads=0, const size_t defaultPageSize=2097152)
 Constructor. More...
 
 ~GlobalFileMgr () override
 Destructor. More...
 
AbstractBuffercreateBuffer (const ChunkKey &key, size_t pageSize=0, const size_t numBytes=0) override
 Creates a chunk with the specified key and page size. More...
 
bool isBufferOnDevice (const ChunkKey &key) override
 
void deleteBuffer (const ChunkKey &key, const bool purge=true) override
 Deletes the chunk with the specified key. More...
 
void deleteBuffersWithPrefix (const ChunkKey &keyPrefix, const bool purge=true) override
 
AbstractBuffergetBuffer (const ChunkKey &key, const size_t numBytes=0) override
 Returns the a pointer to the chunk with the specified key. More...
 
void fetchBuffer (const ChunkKey &key, AbstractBuffer *destBuffer, const size_t numBytes) override
 
AbstractBufferputBuffer (const ChunkKey &key, AbstractBuffer *d, const size_t numBytes=0) override
 Puts the contents of d into the Chunk with the given key. More...
 
AbstractBufferalloc (const size_t numBytes) override
 
void free (AbstractBuffer *buffer) override
 
MgrType getMgrType () override
 
std::string getStringMgrType () override
 
std::string printSlabs () override
 
void clearSlabs () override
 
size_t getMaxSize () override
 
size_t getInUseSize () override
 
size_t getAllocated () override
 
bool isAllocationCapped () override
 
void init ()
 
void getChunkMetadataVec (std::vector< std::pair< ChunkKey, ChunkMetadata >> &chunkMetadataVec) override
 
void getChunkMetadataVecForKeyPrefix (std::vector< std::pair< ChunkKey, ChunkMetadata >> &chunkMetadataVec, const ChunkKey &keyPrefix) override
 
void checkpoint () override
 Fsyncs data files, writes out epoch and fsyncs that. More...
 
void checkpoint (const int db_id, const int tb_id) override
 
size_t getNumReaderThreads ()
 Returns number of threads defined by parameter num-reader-threads which should be used during initial load and consequent read of data. More...
 
size_t getNumChunks () override
 
AbstractBufferMgrfindFileMgr (const int db_id, const int tb_id, const bool remove_from_map=false)
 
AbstractBufferMgrgetFileMgr (const int db_id, const int tb_id)
 
AbstractBufferMgrgetFileMgr (const ChunkKey &key)
 
std::string getBasePath () const
 
size_t getDefaultPageSize () const
 
void writeFileMgrData (FileMgr *fileMgr=0)
 
int getDBVersion () const
 
bool getDBConvert () const
 
void setDBConvert (bool val)
 
void removeTableRelatedDS (const int db_id, const int tb_id)
 
void setTableEpoch (const int db_id, const int tb_id, const int start_epoch)
 
size_t getTableEpoch (const int db_id, const int tb_id)
 

Private Attributes

std::string basePath_
 
size_t num_reader_threads_
 The OS file system path containing the files. More...
 
int epoch_
 number of threads used when loading data More...
 
size_t defaultPageSize_
 
int mapd_db_version_
 default page size, used to set FileMgr defaultPageSize_ More...
 
bool dbConvert_
 
std::map< std::pair< int, int >
, AbstractBufferMgr * > 
fileMgrs_
 
mapd_shared_mutex fileMgrs_mutex_
 

Detailed Description

Definition at line 47 of file GlobalFileMgr.h.

Constructor & Destructor Documentation

File_Namespace::GlobalFileMgr::GlobalFileMgr ( const int  deviceId,
std::string  basePath = ".",
const size_t  num_reader_threads = 0,
const size_t  defaultPageSize = 2097152 
)

Constructor.

Definition at line 42 of file GlobalFileMgr.cpp.

References dbConvert_, init(), and mapd_db_version_.

46  : AbstractBufferMgr(deviceId)
47  , basePath_(basePath)
48  , num_reader_threads_(num_reader_threads)
49  , epoch_(-1)
50  , // set the default epoch for all tables corresponding to the time of
51  // last checkpoint
52  defaultPageSize_(defaultPageSize) {
54  1; // DS changes triggered by individual FileMgr per table project (release 2.1.0)
55  dbConvert_ = false;
56  init();
57 }
int epoch_
number of threads used when loading data
int mapd_db_version_
default page size, used to set FileMgr defaultPageSize_
size_t num_reader_threads_
The OS file system path containing the files.

+ Here is the call graph for this function:

File_Namespace::GlobalFileMgr::~GlobalFileMgr ( )
override

Destructor.

Definition at line 59 of file GlobalFileMgr.cpp.

References fileMgrs_, and fileMgrs_mutex_.

59  {
60  mapd_lock_guard<mapd_shared_mutex> fileMgrsMutex(fileMgrs_mutex_);
61  for (auto fileMgrsIt = fileMgrs_.begin(); fileMgrsIt != fileMgrs_.end(); ++fileMgrsIt) {
62  delete fileMgrsIt->second;
63  }
64 }
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_

Member Function Documentation

AbstractBuffer* File_Namespace::GlobalFileMgr::alloc ( const size_t  numBytes)
inlineoverride

Definition at line 105 of file GlobalFileMgr.h.

References logger::FATAL, and LOG.

105  {
106  LOG(FATAL) << "Operation not supported";
107  return nullptr; // satisfy return-type warning
108  }
#define LOG(tag)
Definition: Logger.h:188
void File_Namespace::GlobalFileMgr::checkpoint ( )
override

Fsyncs data files, writes out epoch and fsyncs that.

Definition at line 83 of file GlobalFileMgr.cpp.

References fileMgrs_, and fileMgrs_mutex_.

83  {
84  mapd_lock_guard<mapd_shared_mutex> fileMgrsMutex(fileMgrs_mutex_);
85  for (auto fileMgrsIt = fileMgrs_.begin(); fileMgrsIt != fileMgrs_.end(); ++fileMgrsIt) {
86  fileMgrsIt->second->checkpoint();
87  }
88 }
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_
void File_Namespace::GlobalFileMgr::checkpoint ( const int  db_id,
const int  tb_id 
)
override

Definition at line 90 of file GlobalFileMgr.cpp.

References getFileMgr().

90  {
91  getFileMgr(db_id, tb_id)->checkpoint();
92 }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)

+ Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::clearSlabs ( )
inlineoverride

Definition at line 115 of file GlobalFileMgr.h.

115  { /* noop */
116  }
AbstractBuffer* File_Namespace::GlobalFileMgr::createBuffer ( const ChunkKey key,
size_t  pageSize = 0,
const size_t  numBytes = 0 
)
inlineoverride

Creates a chunk with the specified key and page size.

Definition at line 60 of file GlobalFileMgr.h.

62  {
63  return getFileMgr(key)->createBuffer(key, pageSize, numBytes);
64  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
void File_Namespace::GlobalFileMgr::deleteBuffer ( const ChunkKey key,
const bool  purge = true 
)
inlineoverride

Deletes the chunk with the specified key.

Definition at line 74 of file GlobalFileMgr.h.

74  {
75  return getFileMgr(key)->deleteBuffer(key, purge);
76  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
void File_Namespace::GlobalFileMgr::deleteBuffersWithPrefix ( const ChunkKey keyPrefix,
const bool  purge = true 
)
override

Definition at line 107 of file GlobalFileMgr.cpp.

References getFileMgr().

107  {
108  /* keyPrefix[0] can be -1 only for gpu or cpu buffers but not for FileMgr.
109  * There is no assert here, as GlobalFileMgr is being called with -1 value as well in
110  * the same loop with other buffers. So the case of -1 will just be ignored, as nothing
111  * needs to be done.
112  */
113  if (keyPrefix[0] != -1) {
114  return getFileMgr(keyPrefix)->deleteBuffersWithPrefix(keyPrefix, purge);
115  }
116 }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)

+ Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::fetchBuffer ( const ChunkKey key,
AbstractBuffer destBuffer,
const size_t  numBytes 
)
inlineoverride

Definition at line 86 of file GlobalFileMgr.h.

88  {
89  return getFileMgr(key)->fetchBuffer(key, destBuffer, numBytes);
90  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
AbstractBufferMgr * File_Namespace::GlobalFileMgr::findFileMgr ( const int  db_id,
const int  tb_id,
const bool  remove_from_map = false 
)

Definition at line 132 of file GlobalFileMgr.cpp.

References fileMgrs_, and fileMgrs_mutex_.

Referenced by getFileMgr(), removeTableRelatedDS(), and setTableEpoch().

134  {
135  AbstractBufferMgr* fm = nullptr;
136  const auto file_mgr_key = std::make_pair(db_id, tb_id);
137  {
138  mapd_lock_guard<mapd_shared_mutex> read_lock(fileMgrs_mutex_);
139  auto it = fileMgrs_.find(file_mgr_key);
140  if (it != fileMgrs_.end()) {
141  fm = it->second;
142  if (remove_from_map) {
143  fileMgrs_.erase(it);
144  }
145  }
146  }
147  return fm;
148 }
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_

+ Here is the caller graph for this function:

void File_Namespace::GlobalFileMgr::free ( AbstractBuffer buffer)
inlineoverride

Definition at line 110 of file GlobalFileMgr.h.

References logger::FATAL, and LOG.

110 { LOG(FATAL) << "Operation not supported"; }
#define LOG(tag)
Definition: Logger.h:188
size_t File_Namespace::GlobalFileMgr::getAllocated ( )
inlineoverride

Definition at line 119 of file GlobalFileMgr.h.

119 { return 0; }
std::string File_Namespace::GlobalFileMgr::getBasePath ( ) const
inline

Definition at line 156 of file GlobalFileMgr.h.

Referenced by Catalog_Namespace::abs_path(), File_Namespace::FileMgr::FileMgr(), and File_Namespace::FileMgr::init().

156 { return basePath_; }

+ Here is the caller graph for this function:

AbstractBuffer* File_Namespace::GlobalFileMgr::getBuffer ( const ChunkKey key,
const size_t  numBytes = 0 
)
inlineoverride

Returns the a pointer to the chunk with the specified key.

Definition at line 82 of file GlobalFileMgr.h.

82  {
83  return getFileMgr(key)->getBuffer(key, numBytes);
84  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
void File_Namespace::GlobalFileMgr::getChunkMetadataVec ( std::vector< std::pair< ChunkKey, ChunkMetadata >> &  chunkMetadataVec)
override

Definition at line 118 of file GlobalFileMgr.cpp.

References fileMgrs_, and fileMgrs_mutex_.

119  {
120  mapd_shared_lock<mapd_shared_mutex> fileMgrsMutex(fileMgrs_mutex_);
121  std::vector<std::pair<ChunkKey, ChunkMetadata>> chunkMetadataVecForFileMgr;
122  for (auto fileMgrsIt = fileMgrs_.begin(); fileMgrsIt != fileMgrs_.end(); ++fileMgrsIt) {
123  fileMgrsIt->second->getChunkMetadataVec(chunkMetadataVecForFileMgr);
124  while (!chunkMetadataVecForFileMgr.empty()) {
125  // norair - order of elements is reversed, consider optimising this later if needed
126  chunkMetadataVec.push_back(chunkMetadataVecForFileMgr.back());
127  chunkMetadataVecForFileMgr.pop_back();
128  }
129  }
130 }
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_
void File_Namespace::GlobalFileMgr::getChunkMetadataVecForKeyPrefix ( std::vector< std::pair< ChunkKey, ChunkMetadata >> &  chunkMetadataVec,
const ChunkKey keyPrefix 
)
inlineoverride

Definition at line 126 of file GlobalFileMgr.h.

128  {
129  return getFileMgr(keyPrefix)->getChunkMetadataVecForKeyPrefix(chunkMetadataVec,
130  keyPrefix);
131  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
bool File_Namespace::GlobalFileMgr::getDBConvert ( ) const
inline

Definition at line 162 of file GlobalFileMgr.h.

Referenced by File_Namespace::FileMgr::getDBConvert().

162 { return dbConvert_; }

+ Here is the caller graph for this function:

int File_Namespace::GlobalFileMgr::getDBVersion ( ) const
inline

Definition at line 161 of file GlobalFileMgr.h.

Referenced by File_Namespace::FileMgr::getDBVersion().

161 { return mapd_db_version_; }
int mapd_db_version_
default page size, used to set FileMgr defaultPageSize_

+ Here is the caller graph for this function:

size_t File_Namespace::GlobalFileMgr::getDefaultPageSize ( ) const
inline

Definition at line 157 of file GlobalFileMgr.h.

Referenced by Data_Namespace::DataMgr::convertDB().

157 { return defaultPageSize_; }

+ Here is the caller graph for this function:

AbstractBufferMgr * File_Namespace::GlobalFileMgr::getFileMgr ( const int  db_id,
const int  tb_id 
)

Definition at line 150 of file GlobalFileMgr.cpp.

References CHECK(), defaultPageSize_, epoch_, fileMgrs_, fileMgrs_mutex_, findFileMgr(), ForeignStorageInterface::lookupBufferManager(), and num_reader_threads_.

Referenced by checkpoint(), Data_Namespace::DataMgr::createTopLevelMetadata(), deleteBuffersWithPrefix(), getTableEpoch(), and File_Namespace::FileMgr::init().

150  {
151  { /* check if FileMgr already exists for (db_id, tb_id) */
152  AbstractBufferMgr* fm = findFileMgr(db_id, tb_id);
153  if (fm) {
154  return fm;
155  }
156  }
157 
158  { /* create new FileMgr for (db_id, tb_id) */
159  const auto file_mgr_key = std::make_pair(db_id, tb_id);
160  mapd_lock_guard<mapd_shared_mutex> write_lock(fileMgrs_mutex_);
161  auto it = fileMgrs_.find(file_mgr_key);
162  if (it != fileMgrs_.end()) {
163  return it->second;
164  }
165  const auto foreign_buffer_manager =
167  auto fm =
168  foreign_buffer_manager
169  ? foreign_buffer_manager
170  : new FileMgr(
171  0, this, file_mgr_key, num_reader_threads_, epoch_, defaultPageSize_);
172  auto it_ok = fileMgrs_.insert(std::make_pair(file_mgr_key, fm));
173  CHECK(it_ok.second);
174 
175  return fm;
176  }
177 }
static Data_Namespace::AbstractBufferMgr * lookupBufferManager(const int db_id, const int table_id)
int epoch_
number of threads used when loading data
AbstractBufferMgr * findFileMgr(const int db_id, const int tb_id, const bool remove_from_map=false)
CHECK(cgen_state)
size_t num_reader_threads_
The OS file system path containing the files.
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

AbstractBufferMgr* File_Namespace::GlobalFileMgr::getFileMgr ( const ChunkKey key)
inline

Definition at line 152 of file GlobalFileMgr.h.

152  {
153  return getFileMgr(key[0], key[1]);
154  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
size_t File_Namespace::GlobalFileMgr::getInUseSize ( )
inlineoverride

Definition at line 118 of file GlobalFileMgr.h.

118 { return 0; }
size_t File_Namespace::GlobalFileMgr::getMaxSize ( )
inlineoverride

Definition at line 117 of file GlobalFileMgr.h.

117 { return 0; }
MgrType File_Namespace::GlobalFileMgr::getMgrType ( )
inlineoverride

Definition at line 112 of file GlobalFileMgr.h.

112 { return GLOBAL_FILE_MGR; };
size_t File_Namespace::GlobalFileMgr::getNumChunks ( )
override

Definition at line 94 of file GlobalFileMgr.cpp.

References fileMgrs_, and fileMgrs_mutex_.

94  {
95  {
96  mapd_shared_lock<mapd_shared_mutex> fileMgrsMutex(fileMgrs_mutex_);
97  size_t num_chunks = 0;
98  for (auto fileMgrsIt = fileMgrs_.begin(); fileMgrsIt != fileMgrs_.end();
99  ++fileMgrsIt) {
100  num_chunks += fileMgrsIt->second->getNumChunks();
101  }
102 
103  return num_chunks;
104  }
105 }
mapd_shared_mutex fileMgrs_mutex_
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_
size_t File_Namespace::GlobalFileMgr::getNumReaderThreads ( )
inline

Returns number of threads defined by parameter num-reader-threads which should be used during initial load and consequent read of data.

Definition at line 144 of file GlobalFileMgr.h.

144 { return num_reader_threads_; }
size_t num_reader_threads_
The OS file system path containing the files.
std::string File_Namespace::GlobalFileMgr::getStringMgrType ( )
inlineoverride

Definition at line 113 of file GlobalFileMgr.h.

113 { return ToString(GLOBAL_FILE_MGR); }
size_t File_Namespace::GlobalFileMgr::getTableEpoch ( const int  db_id,
const int  tb_id 
)

Definition at line 231 of file GlobalFileMgr.cpp.

References CHECK(), and getFileMgr().

231  {
232  auto fm = dynamic_cast<FileMgr*>(getFileMgr(db_id, tb_id));
233  CHECK(fm);
234  return fm->epoch_;
235 }
CHECK(cgen_state)
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)

+ Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::init ( )

Definition at line 66 of file GlobalFileMgr.cpp.

References basePath_, logger::FATAL, and LOG.

Referenced by GlobalFileMgr().

66  {
67  // check if basePath_ already exists, and if not create one
68  boost::filesystem::path path(basePath_);
69  if (basePath_.size() > 0 && basePath_[basePath_.size() - 1] != '/') {
70  basePath_.push_back('/');
71  }
72  if (boost::filesystem::exists(path)) {
73  if (!boost::filesystem::is_directory(path)) {
74  LOG(FATAL) << "Specified path is not a directory.";
75  }
76  } else { // data directory does not exist
77  if (!boost::filesystem::create_directory(path)) {
78  LOG(FATAL) << "Could not create data directory";
79  }
80  }
81 }
#define LOG(tag)
Definition: Logger.h:188

+ Here is the caller graph for this function:

bool File_Namespace::GlobalFileMgr::isAllocationCapped ( )
inlineoverride

Definition at line 120 of file GlobalFileMgr.h.

120 { return false; }
bool File_Namespace::GlobalFileMgr::isBufferOnDevice ( const ChunkKey key)
inlineoverride

Definition at line 66 of file GlobalFileMgr.h.

66  {
67  return getFileMgr(key)->isBufferOnDevice(key);
68  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
std::string File_Namespace::GlobalFileMgr::printSlabs ( )
inlineoverride

Definition at line 114 of file GlobalFileMgr.h.

114 { return "Not Implemented"; }
AbstractBuffer* File_Namespace::GlobalFileMgr::putBuffer ( const ChunkKey key,
AbstractBuffer d,
const size_t  numBytes = 0 
)
inlineoverride

Puts the contents of d into the Chunk with the given key.

Parameters
key- Unique identifier for a Chunk.
d- An object representing the source data for the Chunk.
Returns
AbstractBuffer*

Definition at line 98 of file GlobalFileMgr.h.

100  {
101  return getFileMgr(key)->putBuffer(key, d, numBytes);
102  }
AbstractBufferMgr * getFileMgr(const int db_id, const int tb_id)
void File_Namespace::GlobalFileMgr::removeTableRelatedDS ( const int  db_id,
const int  tb_id 
)

Definition at line 196 of file GlobalFileMgr.cpp.

References findFileMgr().

196  {
197  auto fm = dynamic_cast<File_Namespace::FileMgr*>(findFileMgr(db_id, tb_id, true));
198  if (fm == nullptr) {
199  // fileMgr has not been initialized so there is no need to
200  // spend the time initializing
201  // initialize just enough to have to rename
202  const auto file_mgr_key = std::make_pair(db_id, tb_id);
203  fm = new FileMgr(0, this, file_mgr_key, true);
204  }
205  fm->closeRemovePhysical();
206  /* remove table related in-memory DS only if directory was removed successfully */
207 
208  delete fm;
209 }
AbstractBufferMgr * findFileMgr(const int db_id, const int tb_id, const bool remove_from_map=false)

+ Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::setDBConvert ( bool  val)
inline

Definition at line 163 of file GlobalFileMgr.h.

void File_Namespace::GlobalFileMgr::setTableEpoch ( const int  db_id,
const int  tb_id,
const int  start_epoch 
)

Definition at line 211 of file GlobalFileMgr.cpp.

References defaultPageSize_, findFileMgr(), logger::INFO, LOG, num_reader_threads_, and File_Namespace::FileMgr::setEpoch().

213  {
214  const auto file_mgr_key = std::make_pair(db_id, tb_id);
215  // this is where the real rollback of any data ahead of the currently set epoch is
216  // performed
217  FileMgr* fm = new FileMgr(
218  0, this, file_mgr_key, num_reader_threads_, start_epoch, defaultPageSize_);
219  fm->setEpoch(start_epoch - 1);
220  // remove the dummy one we built
221  delete fm;
222 
223  // see if one exists currently, and remove it
224  auto old_fm = findFileMgr(db_id, tb_id, true);
225  if (old_fm) {
226  LOG(INFO) << "found and removed fm";
227  delete old_fm;
228  }
229 }
#define LOG(tag)
Definition: Logger.h:188
AbstractBufferMgr * findFileMgr(const int db_id, const int tb_id, const bool remove_from_map=false)
size_t num_reader_threads_
The OS file system path containing the files.

+ Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::writeFileMgrData ( FileMgr fileMgr = 0)

Definition at line 179 of file GlobalFileMgr.cpp.

References CHECK(), File_Namespace::FileMgr::chunkIndex_, and fileMgrs_.

180  { // this function is not used, keep it for now for future needs
181  for (auto fileMgrIt = fileMgrs_.begin(); fileMgrIt != fileMgrs_.end(); fileMgrIt++) {
182  FileMgr* fm = dynamic_cast<FileMgr*>(fileMgrIt->second);
183  CHECK(fm);
184  if ((fileMgr != 0) && (fileMgr != fm)) {
185  continue;
186  }
187  for (auto chunkIt = fm->chunkIndex_.begin(); chunkIt != fm->chunkIndex_.end();
188  chunkIt++) {
189  chunkIt->second->write((int8_t*)chunkIt->second, chunkIt->second->size(), 0);
190  // chunkIt->second->write((int8_t*)chunkIt->second, chunkIt->second->size(), 0,
191  // CPU_LEVEL, -1);
192  }
193  }
194 }
CHECK(cgen_state)
std::map< std::pair< int, int >, AbstractBufferMgr * > fileMgrs_

+ Here is the call graph for this function:

Member Data Documentation

std::string File_Namespace::GlobalFileMgr::basePath_
private

Definition at line 170 of file GlobalFileMgr.h.

Referenced by init().

bool File_Namespace::GlobalFileMgr::dbConvert_
private

DB version for DataMgr DS and corresponding file buffer read/write code

Definition at line 185 of file GlobalFileMgr.h.

Referenced by GlobalFileMgr().

size_t File_Namespace::GlobalFileMgr::defaultPageSize_
private

Definition at line 176 of file GlobalFileMgr.h.

Referenced by getFileMgr(), and setTableEpoch().

int File_Namespace::GlobalFileMgr::epoch_
private

number of threads used when loading data

Definition at line 172 of file GlobalFileMgr.h.

Referenced by getFileMgr().

std::map<std::pair<int, int>, AbstractBufferMgr*> File_Namespace::GlobalFileMgr::fileMgrs_
private

true if conversion should be done between different "mapd_db_version_"

Definition at line 187 of file GlobalFileMgr.h.

Referenced by checkpoint(), findFileMgr(), getChunkMetadataVec(), getFileMgr(), getNumChunks(), writeFileMgrData(), and ~GlobalFileMgr().

mapd_shared_mutex File_Namespace::GlobalFileMgr::fileMgrs_mutex_
private
int File_Namespace::GlobalFileMgr::mapd_db_version_
private

default page size, used to set FileMgr defaultPageSize_

Definition at line 179 of file GlobalFileMgr.h.

Referenced by GlobalFileMgr().

size_t File_Namespace::GlobalFileMgr::num_reader_threads_
private

The OS file system path containing the files.

Definition at line 171 of file GlobalFileMgr.h.

Referenced by getFileMgr(), and setTableEpoch().


The documentation for this class was generated from the following files: