Better R/W but only if multithreaded :(

Author: AyoubKaz07

src/include/storage/disk/disk_manager.h

@@ -100,6 +100,9 @@ class DiskManager {
   // stream to write db file
   std::fstream db_io_;
   std::string file_name_;
+  int db_fd_;
+  int log_fd_;
+
   int num_flushes_{0};
   int num_writes_{0};
   bool flush_log_{false};

src/storage/disk/disk_manager.cpp

@@ -21,6 +21,8 @@
 #include "common/exception.h"
 #include "common/logger.h"
 #include "storage/disk/disk_manager.h"
+#include <unistd.h>
+#include <fcntl.h>
 
 namespace bustub {
 
@@ -38,40 +40,32 @@ DiskManager::DiskManager(const std::string &db_file) : file_name_(db_file) {
   }
   log_name_ = file_name_.substr(0, n) + ".log";
 
-  log_io_.open(log_name_, std::ios::binary | std::ios::in | std::ios::app | std::ios::out);
-  // directory or file does not exist
-  if (!log_io_.is_open()) {
-    log_io_.clear();
-    // create a new file
-    log_io_.open(log_name_, std::ios::binary | std::ios::trunc | std::ios::out | std::ios::in);
-    if (!log_io_.is_open()) {
-      throw Exception("can't open dblog file");
-    }
+  // Open log file using file descriptor
+  log_fd_ = open(log_name_.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+  if (log_fd_ < 0) {
+    throw Exception("can't open log file");
   }
 
-  std::scoped_lock scoped_db_io_latch(db_io_latch_);
-  db_io_.open(db_file, std::ios::binary | std::ios::in | std::ios::out);
-  // directory or file does not exist
-  if (!db_io_.is_open()) {
-    db_io_.clear();
-    // create a new file
-    db_io_.open(db_file, std::ios::binary | std::ios::trunc | std::ios::out | std::ios::in);
-    if (!db_io_.is_open()) {
-      throw Exception("can't open db file");
-    }
+  // Open db file using file descriptor
+  db_fd_ = open(db_file.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+  if (db_fd_ < 0) {
+    close(log_fd_);
+    throw Exception("can't open db file");
   }
+
   buffer_used = nullptr;
 }
 
+
 /**
  * Close all file streams
  */
 void DiskManager::ShutDown() {
   {
     std::scoped_lock scoped_db_io_latch(db_io_latch_);
-    db_io_.close();
+    close(db_fd_);  // Close the db file descriptor
   }
-  log_io_.close();
+  close(log_fd_);  // Close the log file descriptor
 }
 
 /**
@@ -80,19 +74,16 @@ void DiskManager::ShutDown() {
 void DiskManager::WritePage(page_id_t page_id, const char *page_data) {
   std::scoped_lock scoped_db_io_latch(db_io_latch_);
   size_t offset = static_cast<size_t>(page_id) * BUSTUB_PAGE_SIZE;
-  // set write cursor to offset
-  num_writes_ += 1;
-  db_io_.seekp(offset);
-  db_io_.write(page_data, BUSTUB_PAGE_SIZE);
-  // check for I/O error
-  if (db_io_.bad()) {
-    LOG_DEBUG("I/O error while writing");
+
+  ssize_t bytes_written = pwrite(db_fd_, page_data, BUSTUB_PAGE_SIZE, offset);
+  if (bytes_written == -1) {
+    LOG_DEBUG("I/O error while writing with pwrite");
     return;
   }
-  // needs to flush to keep disk file in sync
-  db_io_.flush();
+  num_writes_ += 1;
 }
 
+
 /**
  * Read the contents of the specified page into the given memory area
  */
@@ -102,22 +93,18 @@ void DiskManager::ReadPage(page_id_t page_id, char *page_data) {
   // check if read beyond file length
   if (offset > GetFileSize(file_name_)) {
     LOG_DEBUG("I/O error reading past end of file");
-    // std::cerr << "I/O error while reading" << std::endl;
   } else {
-    // set read cursor to offset
-    db_io_.seekp(offset);
-    db_io_.read(page_data, BUSTUB_PAGE_SIZE);
-    if (db_io_.bad()) {
-      LOG_DEBUG("I/O error while reading");
+
+    ssize_t bytes_read = pread(db_fd_, page_data, BUSTUB_PAGE_SIZE, offset);
+    if (bytes_read == -1) {
+      LOG_DEBUG("I/O error while reading with pread");
       return;
     }
-    // if file ends before reading BUSTUB_PAGE_SIZE
-    int read_count = db_io_.gcount();
-    if (read_count < BUSTUB_PAGE_SIZE) {
+
+    // If file ends before reading BUSTUB_PAGE_SIZE
+    if (bytes_read < BUSTUB_PAGE_SIZE) {
       LOG_DEBUG("Read less than a page");
-      db_io_.clear();
-      // std::cerr << "Read less than a page" << std::endl;
-      memset(page_data + read_count, 0, BUSTUB_PAGE_SIZE - read_count);
+      memset(page_data + bytes_read, 0, BUSTUB_PAGE_SIZE - bytes_read);
     }
   }
 }
@@ -127,7 +114,6 @@ void DiskManager::ReadPage(page_id_t page_id, char *page_data) {
  * Only return when sync is done, and only perform sequence write
  */
 void DiskManager::WriteLog(char *log_data, int size) {
-  // enforce swap log buffer
   assert(log_data != buffer_used);
   buffer_used = log_data;
 
@@ -137,48 +123,35 @@ void DiskManager::WriteLog(char *log_data, int size) {
 
   flush_log_ = true;
 
-  if (flush_log_f_ != nullptr) {
-    // used for checking non-blocking flushing
-    assert(flush_log_f_->wait_for(std::chrono::seconds(10)) == std::future_status::ready);
-  }
-
   num_flushes_ += 1;
-  // sequence write
-  log_io_.write(log_data, size);
-
-  // check for I/O error
-  if (log_io_.bad()) {
-    LOG_DEBUG("I/O error while writing log");
+  ssize_t bytes_written = pwrite(log_fd_, log_data, size, 0);  // Always appending
+  if (bytes_written == -1) {
+    LOG_DEBUG("I/O error while writing log with pwrite");
     return;
   }
-  // needs to flush to keep disk file in sync
-  log_io_.flush();
+
   flush_log_ = false;
 }
 
+
 /**
  * Read the contents of the log into the given memory area
  * Always read from the beginning and perform sequence read
  * @return: false means already reach the end
  */
-auto DiskManager::ReadLog(char *log_data, int size, int offset) -> bool {
+bool DiskManager::ReadLog(char *log_data, int size, int offset) {
   if (offset >= GetFileSize(log_name_)) {
-    // LOG_DEBUG("end of log file");
-    // LOG_DEBUG("file size is %d", GetFileSize(log_name_));
     return false;
   }
-  log_io_.seekp(offset);
-  log_io_.read(log_data, size);
 
-  if (log_io_.bad()) {
-    LOG_DEBUG("I/O error while reading log");
+  ssize_t bytes_read = pread(log_fd_, log_data, size, offset);
+  if (bytes_read == -1) {
+    LOG_DEBUG("I/O error while reading log with pread");
     return false;
   }
-  // if log file ends before reading "size"
-  int read_count = log_io_.gcount();
-  if (read_count < size) {
-    log_io_.clear();
-    memset(log_data + read_count, 0, size - read_count);
+
+  if (bytes_read < size) {
+    memset(log_data + bytes_read, 0, size - bytes_read);
   }
 
   return true;