OmniSciDB  c1a53651b2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
FileInfo.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2022 HEAVY.AI, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "FileInfo.h"
18 #include <iostream>
19 #include "../../Shared/File.h"
20 #include "FileMgr.h"
21 #include "Page.h"
22 
23 #include <utility>
24 using namespace std;
25 
26 extern bool g_read_only;
27 extern bool g_multi_instance;
28 
29 namespace File_Namespace {
30 
31 FileInfo::FileInfo(FileMgr* fileMgr,
32  const int32_t fileId,
33  FILE* f,
34  const size_t pageSize,
35  size_t numPages,
36  const std::string& file_path,
37  bool init)
38  : fileMgr(fileMgr)
39  , fileId(fileId)
40  , f(f)
41  , pageSize(pageSize)
42  , numPages(numPages)
43  , file_path(file_path) {
44  if (init) {
45  initNewFile();
46  }
47 }
48 
50  // close file, if applicable
51  if (f) {
52  close(f);
53  }
54 }
55 
57  // initialize pages and free page list
58  // Also zeroes out first four bytes of every header
59 
60  int32_t headerSize = 0;
61  int8_t* headerSizePtr = (int8_t*)(&headerSize);
62  for (size_t pageId = 0; pageId < numPages; ++pageId) {
63  File_Namespace::write(f, pageId * pageSize, sizeof(int32_t), headerSizePtr);
64  freePages.insert(pageId);
65  }
66  isDirty = true;
67 }
68 
69 size_t FileInfo::write(const size_t offset, const size_t size, const int8_t* buf) {
70  std::lock_guard<std::mutex> lock(readWriteMutex_);
71  isDirty = true;
72  return File_Namespace::write(f, offset, size, buf);
73 }
74 
75 size_t FileInfo::read(const size_t offset, const size_t size, int8_t* buf) {
76  std::lock_guard<std::mutex> lock(readWriteMutex_);
77  return File_Namespace::read(f, offset, size, buf, file_path);
78 }
79 
80 void FileInfo::openExistingFile(std::vector<HeaderInfo>& headerVec) {
81  // HeaderInfo is defined in Page.h
82 
83  // Oct 2020: Changing semantics such that fileMgrEpoch should be last checkpointed
84  // epoch, not incremented epoch. This changes some of the gt/gte/lt/lte comparison below
85  ChunkKey oldChunkKey(4);
86  int32_t oldPageId = -99;
87  int32_t oldVersionEpoch = -99;
88  int32_t skipped = 0;
89  for (size_t pageNum = 0; pageNum < numPages; ++pageNum) {
90  // TODO(Misiu): It would be nice to replace this array with a struct that would
91  // clarify what is being read and have a single definition (currently this code is
92  // replicated in TableArchiver and possibly elsewhere).
93  constexpr size_t MAX_INTS_TO_READ{10}; // currently use 1+6 ints
94  int32_t ints[MAX_INTS_TO_READ];
95  CHECK_EQ(fseek(f, pageNum * pageSize, SEEK_SET), 0);
96  CHECK_EQ(fread(ints, sizeof(int32_t), MAX_INTS_TO_READ, f), MAX_INTS_TO_READ);
97 
98  auto headerSize = ints[0];
99  if (headerSize == 0) {
100  // no header for this page - insert into free list
101  freePages.insert(pageNum);
102  continue;
103  }
104 
105  // headerSize doesn't include headerSize itself
106  // We're tying ourself to headers of ints here
107  size_t numHeaderElems = headerSize / sizeof(int32_t);
108  CHECK_GE(numHeaderElems, size_t(2));
109  // We don't want to read headerSize in our header - so start
110  // reading 4 bytes past it
111  ChunkKey chunkKey(&ints[1], &ints[1 + numHeaderElems - 2]);
112  if (fileMgr->updatePageIfDeleted(this, chunkKey, ints[1], ints[2], pageNum)) {
113  continue;
114  }
115  // Last two elements of header are always PageId and Version
116  // epoch - these are not in the chunk key so seperate them
117  int32_t pageId = ints[1 + numHeaderElems - 2];
118  int32_t versionEpoch = ints[1 + numHeaderElems - 1];
119  if (chunkKey != oldChunkKey || oldPageId != pageId - (1 + skipped)) {
120  if (skipped > 0) {
121  VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
122  << " Chunk key: " << show_chunk(oldChunkKey)
123  << " Page id from : " << oldPageId << " to : " << oldPageId + skipped
124  << " Epoch: " << oldVersionEpoch;
125  } else if (oldPageId != -99) {
126  VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
127  << " Chunk key: " << show_chunk(oldChunkKey) << " Page id: " << oldPageId
128  << " Epoch: " << oldVersionEpoch;
129  }
130  oldPageId = pageId;
131  oldVersionEpoch = versionEpoch;
132  oldChunkKey = chunkKey;
133  skipped = 0;
134  } else {
135  skipped++;
136  }
137 
138  /* Check if version epoch is equal to
139  * or greater (note: should never be greater)
140  * than FileMgr epoch_ - this means that this
141  * page wasn't checkpointed and thus we should
142  * not use it
143  */
144  int32_t fileMgrEpoch =
145  fileMgr->epoch(chunkKey[CHUNK_KEY_DB_IDX], chunkKey[CHUNK_KEY_TABLE_IDX]);
146  if (versionEpoch > fileMgrEpoch) {
147  // First write 0 to first four bytes of
148  // header to mark as free
149  if (!g_read_only && !g_multi_instance) {
150  // TODO(sy): Confirm that proper locking is held before writing here.
151  freePageImmediate(pageNum);
152  LOG(WARNING) << "Was not checkpointed: Chunk key: " << show_chunk(chunkKey)
153  << " Page id: " << pageId << " Epoch: " << versionEpoch
154  << " FileMgrEpoch " << fileMgrEpoch << endl;
155  }
156  } else { // page was checkpointed properly
157  Page page(fileId, pageNum);
158  headerVec.emplace_back(chunkKey, pageId, versionEpoch, page);
159  }
160  }
161  // printlast
162  if (oldPageId != -99) {
163  if (skipped > 0) {
164  VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
165  << " Chunk key: " << show_chunk(oldChunkKey)
166  << " Page id from : " << oldPageId << " to : " << oldPageId + skipped
167  << " Epoch: " << oldVersionEpoch;
168  } else {
169  VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
170  << " Chunk key: " << show_chunk(oldChunkKey) << " Page id: " << oldPageId
171  << " Epoch: " << oldVersionEpoch;
172  }
173  }
174 }
175 
176 void FileInfo::freePageDeferred(int32_t pageId) {
177  std::lock_guard<std::mutex> lock(freePagesMutex_);
178  freePages.insert(pageId);
179 }
180 
181 #ifdef ENABLE_CRASH_CORRUPTION_TEST
182 #warning "!!!!! DB corruption crash test is enabled !!!!!"
183 #include <signal.h>
184 static bool goto_crash;
185 static void sighandler(int sig) {
186  if (getenv("ENABLE_CRASH_CORRUPTION_TEST"))
187  goto_crash = true;
188 }
189 #endif
190 
191 void FileInfo::freePage(int pageId, const bool isRolloff, int32_t epoch) {
192  std::lock_guard<std::mutex> lock(readWriteMutex_);
193  int32_t epoch_freed_page[2] = {DELETE_CONTINGENT, epoch};
194  if (isRolloff) {
195  epoch_freed_page[0] = ROLLOFF_CONTINGENT;
196  }
198  pageId * pageSize + sizeof(int32_t),
199  sizeof(epoch_freed_page),
200  reinterpret_cast<const int8_t*>(epoch_freed_page));
201  fileMgr->free_page(std::make_pair(this, pageId));
202  isDirty = true;
203 
204 #ifdef ENABLE_CRASH_CORRUPTION_TEST
205  signal(SIGUSR2, sighandler);
206  if (goto_crash)
207  CHECK(pageId % 8 != 4);
208 #endif
209 }
210 
212  // returns -1 if there is no free page
213  std::lock_guard<std::mutex> lock(freePagesMutex_);
214  if (freePages.size() == 0) {
215  return -1;
216  }
217  auto pageIt = freePages.begin();
218  int32_t pageNum = *pageIt;
219  freePages.erase(pageIt);
220  return pageNum;
221 }
222 
223 std::string FileInfo::print() const {
224  std::stringstream ss;
225  ss << "File: " << fileId << std::endl;
226  ss << "Size: " << size() << std::endl;
227  ss << "Used: " << used() << std::endl;
228  ss << "Free: " << available() << std::endl;
229  return ss.str();
230 }
231 
233  std::lock_guard<std::mutex> lock(readWriteMutex_);
234  if (isDirty) {
235  if (fflush(f) != 0) {
236  LOG(FATAL) << "Error trying to flush changes to disk, the error was: "
237  << std::strerror(errno);
238  }
239 #ifdef __APPLE__
240  const int32_t sync_result = fcntl(fileno(f), 51);
241 #else
242  const int32_t sync_result = heavyai::fsync(fileno(f));
243 #endif
244  if (sync_result == 0) {
245  isDirty = false;
246  }
247  return sync_result;
248  }
249  return 0; // if file was not dirty and no syncing was needed
250 }
251 
252 void FileInfo::freePageImmediate(int32_t page_num) {
253  // we should not get here but putting protection in place
254  // as it seems we are no guaranteed to have f/synced so
255  // protecting from RO trying to write
256  if (!g_read_only && !g_multi_instance) {
257  int32_t zero{0};
259  f, page_num * pageSize, sizeof(int32_t), reinterpret_cast<const int8_t*>(&zero));
260  freePageDeferred(page_num);
261  }
262 }
263 
264 // Overwrites delete/rollback contingents by re-writing chunk key to page.
265 void FileInfo::recoverPage(const ChunkKey& chunk_key, int32_t page_num) {
266  // we should not get here but putting protection in place
267  // as it seems we are no guaranteed to have f/synced so
268  // protecting from RO trying to write
269  if (!g_read_only && !g_multi_instance) {
271  page_num * pageSize + sizeof(int32_t),
272  2 * sizeof(int32_t),
273  reinterpret_cast<const int8_t*>(chunk_key.data()));
274  }
275 }
276 
277 bool is_page_deleted_with_checkpoint(int32_t table_epoch,
278  int32_t page_epoch,
279  int32_t contingent) {
280  const bool delete_contingent =
281  (contingent == DELETE_CONTINGENT || contingent == ROLLOFF_CONTINGENT);
282  // Check if page was deleted with a checkpointed epoch
283  if (delete_contingent && (table_epoch >= page_epoch)) {
284  return true;
285  }
286  return false;
287 }
288 
289 bool is_page_deleted_without_checkpoint(int32_t table_epoch,
290  int32_t page_epoch,
291  int32_t contingent) {
292  const bool delete_contingent =
293  (contingent == DELETE_CONTINGENT || contingent == ROLLOFF_CONTINGENT);
294  // Check if page was deleted but the epoch was not yet checkpointed.
295  if (delete_contingent && (table_epoch < page_epoch)) {
296  return true;
297  }
298  return false;
299 }
300 } // namespace File_Namespace
virtual int32_t epoch(int32_t db_id, int32_t tb_id) const
Returns current value of epoch - should be one greater than recorded at last checkpoint. Because FileMgr only contains buffers from one table we can just return the FileMgr&#39;s epoch instead of finding a table-specific epoch.
Definition: FileMgr.h:277
#define CHECK_EQ(x, y)
Definition: Logger.h:301
std::vector< int > ChunkKey
Definition: types.h:36
size_t write(const size_t offset, const size_t size, const int8_t *buf)
Definition: FileInfo.cpp:69
bool g_multi_instance
Definition: heavyai_locks.h:21
bool is_page_deleted_without_checkpoint(int32_t table_epoch, int32_t page_epoch, int32_t contingent)
Definition: FileInfo.cpp:289
A logical page (Page) belongs to a file on disk.
Definition: Page.h:46
#define LOG(tag)
Definition: Logger.h:285
std::mutex readWriteMutex_
Definition: FileInfo.h:65
#define CHUNK_KEY_DB_IDX
Definition: types.h:38
void freePageImmediate(int32_t page_num)
Definition: FileInfo.cpp:252
This file includes the class specification for the FILE manager (FileMgr), and related data structure...
#define CHECK_GE(x, y)
Definition: Logger.h:306
std::string print() const
Prints a summary of the file to stdout.
Definition: FileInfo.cpp:223
virtual bool updatePageIfDeleted(FileInfo *file_info, ChunkKey &chunk_key, int32_t contingent, int32_t page_epoch, int32_t page_num)
deletes or recovers a page based on last checkpointed epoch.
Definition: FileMgr.cpp:1615
std::string file_path
set of page numbers of free pages
Definition: FileInfo.h:63
constexpr double f
Definition: Utm.h:31
std::string show_chunk(const ChunkKey &key)
Definition: types.h:98
void freePage(int32_t pageId, const bool isRolloff, int32_t epoch)
Definition: FileInfo.cpp:191
size_t write(FILE *f, const size_t offset, const size_t size, const int8_t *buf)
Writes the specified number of bytes to the offset position in file f from buf.
Definition: File.cpp:160
std::set< size_t > freePages
Definition: FileInfo.h:62
size_t pageSize
file stream object for the represented file
Definition: FileInfo.h:59
constexpr int32_t DELETE_CONTINGENT
A FileInfo type has a file pointer and metadata about a file.
Definition: FileInfo.h:51
void init(LogOptions const &log_opts)
Definition: Logger.cpp:360
size_t used() const
Returns the amount of used bytes; size() - available()
Definition: FileInfo.h:116
void initNewFile()
Adds all pages to freePages and zeroes first four bytes of header.
Definition: FileInfo.cpp:56
size_t size() const
Returns the number of bytes used by the file.
Definition: FileInfo.h:95
#define CHUNK_KEY_TABLE_IDX
Definition: types.h:39
std::mutex freePagesMutex_
Definition: FileInfo.h:64
size_t read(FILE *f, const size_t offset, const size_t size, int8_t *buf, const std::string &file_path)
Reads the specified number of bytes from the offset position in file f into buf.
Definition: File.cpp:142
constexpr int32_t ROLLOFF_CONTINGENT
Definition: FileInfo.h:52
bool g_read_only
Definition: File.cpp:40
~FileInfo()
Destructor.
Definition: FileInfo.cpp:49
size_t read(const size_t offset, const size_t size, int8_t *buf)
Definition: FileInfo.cpp:75
bool is_page_deleted_with_checkpoint(int32_t table_epoch, int32_t page_epoch, int32_t contingent)
Definition: FileInfo.cpp:277
virtual void free_page(std::pair< FileInfo *, int32_t > &&page)
Definition: FileMgr.cpp:1201
FILE * f
unique file identifier (i.e., used for a file name)
Definition: FileInfo.h:58
int fsync(int fd)
Definition: heavyai_fs.cpp:62
This file contains the declaration and definition of a Page type and a MultiPage type.
void openExistingFile(std::vector< HeaderInfo > &headerVec)
Definition: FileInfo.cpp:80
#define CHECK(condition)
Definition: Logger.h:291
void recoverPage(const ChunkKey &chunk_key, int32_t page_num)
Definition: FileInfo.cpp:265
void close(FILE *f)
Closes the file pointed to by the FILE pointer.
Definition: File.cpp:128
void freePageDeferred(int32_t pageId)
Definition: FileInfo.cpp:176
size_t available() const
Returns the number of free bytes available.
Definition: FileInfo.h:102
size_t numPages
the fixed size of each page in the file
Definition: FileInfo.h:60
bool isDirty
the number of pages in the file
Definition: FileInfo.h:61
#define VLOG(n)
Definition: Logger.h:387