数据库修化神篇六——持久化到磁盘

SQLite克隆|第四步:磁盘持久化 磁盘持久化分页器分页器结构数据表结构new_table()get_page()read()函数write()函数get_page()db_close()pager_flush()调整main()函数文件内容 实现了在内存中储存硬编码的数据表之后,我们需要更近一步,将内存中的数据保存在文件中,即实现数据持久化。 为了使这一点变得容易,我们将创建一个称为分页器的抽象。我们向分页器询问页码x,它返回了一块内存。它首先在其缓存中查找。在发生高速缓存未命中时,它将数据从磁盘复制到内存中(通过读取数据库文件)。 分页器 阅读详情

持久化到磁盘

我们的数据库允许您插入记录并读回记录,但前提是您保持程序运行。如果您终止程序并重新启动它,则所有记录都将消失。

与 sqlite 一样,我们将通过将整个数据库保存到文件中来持久化记录。

我们已经通过将行序列化为页面大小的内存块来做到这一点。为了增加持久性,我们可以简单地将这些内存块写入文件,并在下次程序启动时将它们读回内存中。

为了简化此操作,我们将创建一个称为抽象的寻址器。我们向pager询问 页码 x ,pager会给我们一个内存块。它首先在其缓存中查找,在缓存未命中时,它会将数据从磁盘复制到内存中(通过读取数据库文件)。

如下图所示,我们的数据库架构和sqlite的映射关系如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ii4VPrh6-1689909153991)(./img/arch-part5.gif)]

pager访问页面缓存和文件。Table 对象通过pager发出页面请求:

 typedef struct {
-  uint32_t num_rows;
+  FILE *file_descriptor;
+  uint32_t file_length;
   void* pages[TABLE_MAX_PAGES];
+} Pager;
+
+typedef struct {
+  uint32_t num_rows;
+  Pager* pager;
 } Table;

我重命名为 new_table() db_open() ,因为它现在具有打开数据库连接的效果。打开一个连接意味着:

  • 打开数据库文件

  • 初始化pager数据结构

  • 初始化表数据结构

-void free_table(Table* table) {
-    for (int i = 0; table->pages[i]; i++) {
-       free(table->pages[i]);
-    }
-    free(table);
+Table* db_open(const char* filename) {
+  Pager* pager = pager_open(filename);
+  uint32_t num_rows = pager->file_length / ROW_SIZE;
+  Table* table = (Table*)malloc(sizeof(Table));
+  table->pager = pager;
+  table->num_rows = num_rows;
+
+  return table;
 }

db_open() 调用 pager_open() 打开数据库文件并跟踪其大小。它还将页面缓存初始化为所有 NULL。

-Table* new_table() {
-  Table* table = (Table*)malloc(sizeof(Table));
-  table->num_rows = 0;
+Pager* pager_open(const char* filename) {
+  FILE* fd = fopen(filename, "rw+");
+  if (fd == NULL) {
+    fd = fopen(filename, "w+");
+    if (fd == NULL) {
+      printf("Unable to open file\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+  fseek(fd, 0, SEEK_END);
+  off_t file_length = ftell(fd);
+  Pager* pager = malloc(sizeof(Pager));
+  pager->file_descriptor = fd;
+  pager->file_length = file_length;
+
   for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
-     table->pages[i] = NULL;
+    pager->pages[i] = NULL;
   }
-  return table;
+
+  return pager;
 }

按照我们的新抽象,我们将获取页面的逻辑移动到它自己的方法中:

void* row_slot(Table* table, uint32_t row_num) {
   uint32_t page_num = row_num / ROWS_PER_PAGE;
-  void* page = table->pages[page_num];
-  if (page == NULL) {
-    // Allocate memory only when we try to access page
-    page = table->pages[page_num] = malloc(PAGE_SIZE);
-  }
+  void* page = get_page(table->pager, page_num);
+
   uint32_t row_offset = row_num % ROWS_PER_PAGE;
   uint32_t byte_offset = row_offset * ROW_SIZE;
+
   return page + byte_offset;
 }

该方法 get_page() 具有处理缓存未命中的逻辑。我们假设页面一个接一个地保存在数据库文件中:第 0 页位于偏移量 0,第 1 页位于偏移量 4096,第 2 页位于偏移量 8192,依此类推。如果请求的页面位于文件边界之外,我们知道它应该是空白的,所以我们只是分配一些内存并返回它。稍后将缓存刷新到磁盘时,该页面将添加到文件中。


+void* get_page(Pager* pager, uint32_t page_num) {
+  Row *row = NULL;
+  if (page_num > TABLE_MAX_PAGES) {
+    printf("Tried to fetch page number out of bounds. %d > %d\n", page_num,
+           TABLE_MAX_PAGES);
+    exit(EXIT_FAILURE);
+  }
+
+  if (pager->pages[page_num] == NULL) {
+    // Cache miss. Allocate memory and load from file.
+    void* page = malloc(PAGE_SIZE);
+    memset(page, 0, PAGE_SIZE);
+    uint32_t num_pages = pager->file_length / PAGE_SIZE;
+
+    // We might save a partial page at the end of the file
+    if (pager->file_length % PAGE_SIZE) {
+      num_pages = 1;
+    }
+
+    if (page_num <= num_pages) {
+      fseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
+      ssize_t bytes_read = fread(page, PAGE_SIZE, 1, pager->file_descriptor);
+      row = (Row*)page;
+      if (bytes_read == -1) {
+        printf("Error reading file: %d\n", errno);
+        exit(EXIT_FAILURE);
+      }
+    }
+
+    pager->pages[page_num] = page;
+  }
+
+  return pager->pages[page_num];
+}

现在,我们将等待将缓存刷新到磁盘,直到用户关闭与数据库的连接。当用户退出时,我们将调用一个名为 db_close() 的新方法 ,它负责如下操作:

  • 将页面缓存刷新到磁盘

  • 关闭数据库文件

  • 释放寻址器和数据结构的内存

+void db_close(Table* table) {
+  Pager* pager = table->pager;
+  uint32_t num_full_pages = table->num_rows / ROWS_PER_PAGE;
+
+  for (uint32_t i = 0; i < num_full_pages; i++) {
+    if (pager->pages[i] == NULL) {
+      continue;
+    }
+    pager_flush(pager, i, PAGE_SIZE);
+    free(pager->pages[i]);
+    pager->pages[i] = NULL;
+  }
+
+  // There may be a partial page to write to the end of the file
+  // This should not be needed after we switch to a B-tree
+  uint32_t num_additional_rows = table->num_rows % ROWS_PER_PAGE;
+  if (num_additional_rows > 0) {
+    uint32_t page_num = num_full_pages;
+    if (pager->pages[page_num] != NULL) {
+      pager_flush(pager, page_num, num_additional_rows * ROW_SIZE);
+      free(pager->pages[page_num]);
+      pager->pages[page_num] = NULL;
+    }
+  }
+
+  int result = fclose(pager->file_descriptor);
+  if (result == -1) {
+    printf("Error closing db file.\n");
+    exit(EXIT_FAILURE);
+  }
+  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
+    void* page = pager->pages[i];
+    if (page) {
+      free(page);
+      pager->pages[i] = NULL;
+    }
+  }
+  free(pager);
+  free(table);
+}
+
+MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table* table) {
   if (strcmp(input_buffer->buffer, ".exit") == 0) {
+    db_close(table);
     exit(EXIT_SUCCESS);
   } else {
     return META_COMMAND_UNRECOGNIZED_COMMAND;
@@ -229,64 +332,89 @@ void close_input_buffer(InputBuffer* input_buffer) {
     free(input_buffer);
 }

在我们当前的设计中,数据库中有多少行硬编码在文件的长度中心,因此我们需要在文件末尾写入文件长度。这就是为什么 pager_flush() 同时需要页码和大小的原因。这不是最合理的设计,但是当我们开始实现B树时,它会很快消失。

+void pager_flush(Pager* pager, uint32_t page_num, uint32_t size) {
+  if (pager->pages[page_num] == NULL) {
+    printf("Tried to flush null page\n");
+    exit(EXIT_FAILURE);
+  }
+
+  fseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
+  off_t offset = ftell(pager->file_descriptor);
+  if (offset == -1) {
+    printf("Error seeking: %d\n", errno);
+    exit(EXIT_FAILURE);
+  }
+
+  ssize_t bytes_written = fwrite(pager->pages[page_num], size, 1, pager->file_descriptor);
+      //write(pager->file_descriptor, pager->pages[page_num], size);
+
+  if (bytes_written == -1) {
+    printf("Error writing: %d\n", errno);
+    exit(EXIT_FAILURE);
+  }
+}

最后,我们需要接受文件名作为命令行参数,并将额外的参数添加到 do_meta_command :

int main(int argc, char* argv[]) {
-  Table* table = new_table();
+  if (argc < 2) {
+    printf("Must supply a database filename.\n");
+    exit(EXIT_FAILURE);
+  }
+
+  char* filename = argv[1];
+  Table* table = db_open(filename);
+
   InputBuffer* input_buffer = new_input_buffer();
   while (true) {
     print_prompt();
     read_input(input_buffer);

     if (input_buffer->buffer[0] == '.') {
-      switch (do_meta_command(input_buffer)) {
+      switch (do_meta_command(input_buffer, table)) {

通过这些更改,我们能够关闭然后重新打开数据库,我们的记录仍然存在!

PS D:\code\db021\code> .\db.exe
[warnning] maybe you need supply a database filename,we would use "mydb.db".
db > insert 1 test test@qq.com
Executed.
db > insert 2 test2 test2@qq.com 
Executed.
db > select
(1, test, test@qq.com)
(2, test2, test2@qq.com)
Executed.
db > .exit
PS D:\code\db021\code> .\db.exe
[warnning] maybe you need supply a database filename,we would use "mydb.db".
db > select
(1, test, test@qq.com)
(2, test2, test2@qq.com)
Executed.
db > 

此时当我们退出数据库时,数据会被写入文件里,这里我们写入的文件是mydb.db。我们使用vim作为十六进制编辑器来查看文件的内容:

vim mydb.db
:%!xxd

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gysi5frh-1689909153994)(./img/file_format.png)]

前四个字节是第一行的 id(4 个字节,因为我们存储了一个 uint32_t )。它以小端字节顺序存储,因此最低有效字节排在第一位 (01),然后是高阶字节 (00 00 00)。我们过去常常 memcpy() 将字节从 Row 我们的结构复制到页面缓存中,这意味着结构以小端字节顺序布置在内存中。这是我为其编译程序的机器的属性。如果我们想在我的机器上写入一个数据库文件,然后在大端机器上读取它,我们必须更改我们的 serialize_row() and deserialize_row() 方法,以始终以相同的顺序存储和读取字节。

接下来的 33 个字节将用户名存储为以 null 结尾的字符串。显然,ASCII 十六进制中的 “test” 是 74 65 73 74 ,后跟一个空字符 ( 00 )。其余的 33 个字节未使用。

接下来的 256 个字节以相同的方式存储电子邮件。因为在分配page时我们初始化了内存,因而除了我们写入的有效数据外,其余均为初始化后的0.

结论

到这里,我们已经有了磁盘持久化,但这还不是最完美的。比如在没有输入.exit的情况下终止程序,则更改还是会丢失。除此而外,我们不管页面有没有改变,我们会把所有的页面写入磁盘。这些问题都是后面我们需要解决的。

下一篇文章我们为了简单容易地实现b树,我们会引入游标。

代码差异

@@ -57,8 +57,14 @@ typedef struct {
 #define TABLE_MAX_ROWS  (ROWS_PER_PAGE * TABLE_MAX_PAGES)

 typedef struct {
-  uint32_t num_rows;
+  FILE *file_descriptor;
+  uint32_t file_length;
   void* pages[TABLE_MAX_PAGES];
+} Pager;
+
+typedef struct {
+  uint32_t num_rows;
+  Pager* pager;
 } Table;

 typedef struct {
@@ -88,15 +94,48 @@ void deserialize_row(void* source, Row* destination) {
   memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
 }

+void* get_page(Pager* pager, uint32_t page_num) {
+  Row *row = NULL;
+  if (page_num > TABLE_MAX_PAGES) {
+    printf("Tried to fetch page number out of bounds. %d > %d\n", page_num,
+           TABLE_MAX_PAGES);
+    exit(EXIT_FAILURE);
+  }
+
+  if (pager->pages[page_num] == NULL) {
+    // Cache miss. Allocate memory and load from file.
+    void* page = malloc(PAGE_SIZE);
+    memset(page, 0, PAGE_SIZE);
+    uint32_t num_pages = pager->file_length / PAGE_SIZE;
+
+    // We might save a partial page at the end of the file
+    if (pager->file_length % PAGE_SIZE) {
+      num_pages = 1;
+    }
+
+    if (page_num <= num_pages) {
+      fseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
+      ssize_t bytes_read = fread(page, PAGE_SIZE, 1, pager->file_descriptor);
+      row = (Row*)page;
+      if (bytes_read == -1) {
+        printf("Error reading file: %d\n", errno);
+        exit(EXIT_FAILURE);
+      }
+    }
+
+    pager->pages[page_num] = page;
+  }
+
+  return pager->pages[page_num];
+}
+
 void* row_slot(Table* table, uint32_t row_num) {
   uint32_t page_num = row_num / ROWS_PER_PAGE;
-  void* page = table->pages[page_num];
-  if (page == NULL) {
-    // Allocate memory only when we try to access page
-    page = table->pages[page_num] = malloc(PAGE_SIZE);
-  }
+  void* page = get_page(table->pager, page_num);
+
   uint32_t row_offset = row_num % ROWS_PER_PAGE;
   uint32_t byte_offset = row_offset * ROW_SIZE;
+
   return page + byte_offset;
 }

@@ -113,8 +152,72 @@ InputBuffer* new_input_buffer() {
   return input_buffer;
 }

-MetaCommandResult do_meta_command(InputBuffer* input_buffer) {
+void pager_flush(Pager* pager, uint32_t page_num, uint32_t size) {
+  if (pager->pages[page_num] == NULL) {
+    printf("Tried to flush null page\n");
+    exit(EXIT_FAILURE);
+  }
+
+  fseek(pager->file_descriptor, page_num * PAGE_SIZE, SEEK_SET);
+  off_t offset = ftell(pager->file_descriptor);
+  if (offset == -1) {
+    printf("Error seeking: %d\n", errno);
+    exit(EXIT_FAILURE);
+  }
+
+  ssize_t bytes_written = fwrite(pager->pages[page_num], size, 1, pager->file_descriptor);
+      //write(pager->file_descriptor, pager->pages[page_num], size);
+
+  if (bytes_written == -1) {
+    printf("Error writing: %d\n", errno);
+    exit(EXIT_FAILURE);
+  }
+}
+
+void db_close(Table* table) {
+  Pager* pager = table->pager;
+  uint32_t num_full_pages = table->num_rows / ROWS_PER_PAGE;
+
+  for (uint32_t i = 0; i < num_full_pages; i++) {
+    if (pager->pages[i] == NULL) {
+      continue;
+    }
+    pager_flush(pager, i, PAGE_SIZE);
+    free(pager->pages[i]);
+    pager->pages[i] = NULL;
+  }
+
+  // There may be a partial page to write to the end of the file
+  // This should not be needed after we switch to a B-tree
+  uint32_t num_additional_rows = table->num_rows % ROWS_PER_PAGE;
+  if (num_additional_rows > 0) {
+    uint32_t page_num = num_full_pages;
+    if (pager->pages[page_num] != NULL) {
+      pager_flush(pager, page_num, num_additional_rows * ROW_SIZE);
+      free(pager->pages[page_num]);
+      pager->pages[page_num] = NULL;
+    }
+  }
+
+  int result = fclose(pager->file_descriptor);
+  if (result == -1) {
+    printf("Error closing db file.\n");
+    exit(EXIT_FAILURE);
+  }
+  for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
+    void* page = pager->pages[i];
+    if (page) {
+      free(page);
+      pager->pages[i] = NULL;
+    }
+  }
+  free(pager);
+  free(table);
+}
+
+MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table* table) {
   if (strcmp(input_buffer->buffer, ".exit") == 0) {
+    db_close(table);
     exit(EXIT_SUCCESS);
   } else {
     return META_COMMAND_UNRECOGNIZED_COMMAND;
@@ -229,64 +332,89 @@ void close_input_buffer(InputBuffer* input_buffer) {
     free(input_buffer);
 }

-Table* new_table() {
-  Table* table = (Table*)malloc(sizeof(Table));
-  table->num_rows = 0;
+Pager* pager_open(const char* filename) {
+  FILE* fd = fopen(filename, "rw+");
+  if (fd == NULL) {
+    fd = fopen(filename, "w+");
+    if (fd == NULL) {
+      printf("Unable to open file\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+  fseek(fd, 0, SEEK_END);
+  off_t file_length = ftell(fd);
+  Pager* pager = malloc(sizeof(Pager));
+  pager->file_descriptor = fd;
+  pager->file_length = file_length;
+
   for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
-     table->pages[i] = NULL;
+    pager->pages[i] = NULL;
   }
-  return table;
+
+  return pager;
 }

-void free_table(Table* table) {
-    for (int i = 0; table->pages[i]; i++) {
-       free(table->pages[i]);
-    }
-    free(table);
+Table* db_open(const char* filename) {
+  Pager* pager = pager_open(filename);
+  uint32_t num_rows = pager->file_length / ROW_SIZE;
+  Table* table = (Table*)malloc(sizeof(Table));
+  table->pager = pager;
+  table->num_rows = num_rows;
+
+  return table;
 }

 int main(int argc, char* argv[]) {
-    Table* table = new_table();
-    InputBuffer* input_buffer = new_input_buffer();
-    while (true) {
-        print_prompt();
-        read_input(input_buffer);
-
-        if (input_buffer->buffer[0] == '.') {
-            switch (do_meta_command(input_buffer)) {
-            case (META_COMMAND_SUCCESS):
-                continue;
-            case (META_COMMAND_UNRECOGNIZED_COMMAND):
-                printf("Unrecognized command '%s'\n", input_buffer->buffer);
-                continue;
+  char* filename = NULL;
+  Table* table = NULL;
+  InputBuffer* input_buffer = NULL;
+  Statement statement = {0};
+  if (argc < 2) {
+    printf("[warnning] maybe you need supply a database filename,we would use \"mydb.db\".\n");
+    filename = "mydb.db";
+  } else {
+    filename = argv[1];
+  }
+  table = db_open(filename);
+  input_buffer = new_input_buffer();
+  while (true) {
+    print_prompt();
+    read_input(input_buffer);
+
+    if (input_buffer->buffer[0] == '.') {
+        switch (do_meta_command(input_buffer, table)) {
+        case (META_COMMAND_SUCCESS):
+            continue;
+        case (META_COMMAND_UNRECOGNIZED_COMMAND):
+            printf("Unrecognized command '%s'\n", input_buffer->buffer);
+            continue;
         }
     }

-    Statement statement;
-        switch (prepare_statement(input_buffer, &statement)) {
-        case (PREPARE_SUCCESS):
-            break;
-        case (PREPARE_NEGATIVE_ID):
-            printf("ID must be positive.\n");
-            continue;
-        case (PREPARE_STRING_TOO_LONG):
-            printf("String is too long.\n");
-            continue;
-        case (PREPARE_SYNTAX_ERROR):
-            printf("Syntax error. Could not parse statement.\n");
-            continue;
-        case (PREPARE_UNRECOGNIZED_STATEMENT):
-            printf("Unrecognized keyword at start of '%s'.\n",
-               input_buffer->buffer);
-            continue;
+    switch (prepare_statement(input_buffer, &statement)) {
+      case (PREPARE_SUCCESS):
+          break;
+      case (PREPARE_NEGATIVE_ID):
+          printf("ID must be positive.\n");
+          continue;
+      case (PREPARE_STRING_TOO_LONG):
+          printf("String is too long.\n");
+          continue;
+      case (PREPARE_SYNTAX_ERROR):
+          printf("Syntax error. Could not parse statement.\n");
+          continue;
+      case (PREPARE_UNRECOGNIZED_STATEMENT):
+          printf("Unrecognized keyword at start of '%s'.\n",
+              input_buffer->buffer);
+          continue;
     }
     switch (execute_statement(&statement, table)) {
-        case (EXECUTE_SUCCESS):
-            printf("Executed.\n");
-            break;
-        case (EXECUTE_TABLE_FULL):
-            printf("Error: Table full.\n");
-            break;
+      case (EXECUTE_SUCCESS):
+          printf("Executed.\n");
+          break;
+      case (EXECUTE_TABLE_FULL):
+          printf("Error: Table full.\n");
+          break;
     }
   }
 }
一文深度揭开Redis的磁盘持久化机制 Redis 是内存数据库,数据都是存储在内存中,为了避免进程退出导致数据的永久丢失,需要定期将 Redis 中的数据以数据或命令的形式从内存保存到本地磁盘。当下次 Redis 重启时,利用持久化文件进行数据恢复。Redis 提供了 RDB 和 AOF 两种持久化机制,前者将当前的数据保存到磁盘,后者则是将每次执行的写命令保存到磁盘(类似于 MySQL 的 Binlog)。本文将详细介绍 RDB 和 AOF 两种持久化方案,包括操作方法和持久化的实现原理。 阅读详情

相关推荐

MySQL基础篇1——数据库概述+安装篇

MySQL基础篇1——数据库概述+安装篇

无 1260

确保数据存入磁盘

原文:Ensuring data reaches disk 在理想的情况下,系统崩溃、断电、磁盘访问失败这些情况是不会出现的,开发者编写程序时也不用为这些情况担忧。不幸的是,这些情况比我们想像的还经常出现。本文描述了数据是怎样一步步被写入磁盘上的,尤其是其中被缓冲的几个步骤。本文也提供了数据被正确写盘的最佳实践,以确保意外发生的时候,数据不会丢失。主要是面向 C 语言的,其中的系

bodogbo11的专栏 821

数据库和数据仓库的区别

数据库是一种用于存储、管理和处理结构化数据的软件系统。它的设计目的是支持大规模的数据持久化和高效的数据检索、插入、更新和删除操作。数据库中的数据通常以表格形式存储,可以通过SQL等查询语言进行访问和操作。数据库通常用于在线事务处理(OLTP)场景,例如管理用户账户、订单、库存等业务数据。

优快云 精品推荐 1697

强制把系统缓存写入文件sync和f s y n c函数

传统的U N I X实现在内核中设有缓冲存储器,大多数磁盘I / O都通过缓存进行。当将数据写到文件上时,通常该数据先由内核复制到缓存中,如果该缓存尚未写满,则并不将其排入输出队列,而是等待其写满或者当内核需要重用该缓存以便存放其他磁盘块数据时,再将该缓存排入输出队列,然后待其到达队首时,才进行实际的I / O操作。这种输出方式被称之为延迟写(delayed write)(Bach 〔1 9 8

攻城狮冷静--博客和微信公众号同名 9500

DB40数据库:对象存储与检索实战

DB40是一个为高性能应用设计的面向对象的数据库管理系统,它将数据组织为对象,并将对象存储在内存中,从而提供高速的数据存取和处理能力。本章将介绍DB40的基本概念,同时对其核心特性进行深入解析,为理解后续章节提供坚实的基础。DB40的设计哲学是简化应用开发,它通过透明的持久化机制和面向对象的编程模型,让开发者能够在保持业务逻辑和数据模型一致性的同时,提高开发效率和应用性能。该数据库广泛适用于需要处理大量数据和复杂数据关系的场合,如金融服务、电信、医疗保健以及物联网等。

weixin_42518334的博客 831

无线网卡选购指南:哪些型号支持Kali Linux的监听模式?附免驱动网卡推荐

本文详细解析了如何在Kali Linux下选购支持监听模式的无线网卡。核心在于选择兼容的芯片组,如Atheros AR9271和Ralink RT3070等经典型号,并提供了免驱动网卡推荐与实战配置指南,帮助安全研究人员和爱好者快速搭建无线测试环境。

wind6的博客 1566

磁盘管理-将文件系统Buffer中的数据强制刷新,保存到磁盘

写入缓存设置<br />存储设备中的“写入缓存”指使用高速易失存储器收集发送到数据存储设备的写入命令,并缓存这些命令直至速度较慢的存储媒体(物理磁盘或低成本闪存)能够容纳下它们。大部分使用写入缓存的设备都要求有稳定的电源。快速删除<br />如果您经常从系统频繁移除设备(如 USB 闪存驱动器、SD、MMC、紧凑式闪存卡或类似内存卡以及其他外部附加的存储),此选项通常是最好的选择。<br />选择“快速删除”选项后,Windows 将使用名为“写入缓存”的方法来管理发送到设备的命令。在写入缓存中,设备在写入

快乐工作,精彩生活 2525

python特征选择pso_【来点干货】机器学习中常用的特征选择方法及非常详细的Python实例...

花费了很长时间整理编辑,转载请联系作者授权,违者必究。特征选择(Feature selection)是在构建预测模型的过程中减少输入变量的一个过程。它是机器学习中非常重要的一步并在很大程度上可以提高模型预测精度。这里我总结了一些机器学习中常见的比较有用的特征选择方法并附上相关python实现code。希望可以给大家一些启发。首先,我们为什么要进行特征选择呢?它有以下几个优点:减少过拟合:冗余数据常...

weixin_39927158的博客 1166

一文深度揭秘Redis的磁盘持久化机制

前言 Redis 是内存数据库,数据都是存储在内存中,为了避免进程退出导致数据的永久丢失,需要定期将 Redis 中的数据以数据或命令的形式从内存保存到本地磁盘。当下次 Redis 重启时,利用持久化文件进行数据恢复。Redis 提供了 RDB 和 AOF 两种持久化机制,前者将当前的数据保存到磁盘,后者则是将每次执行的写命令保存到磁盘(类似于 MySQL 的 Binlog)。本文将详细介绍 R...

AlbenXie的博客 631

天线学习笔记——串馈网络设计

工程中通常更倾向于使用50Ω、70.7Ω、100Ω的固定阻抗的带宽,实际中可以分别使用固定阻抗的带宽和计算得到的带宽进行仿真,观察二者的性能,取性能更优者即可。本系列是一个记录天线设计的笔记,分享出来也希望能够帮助到大家,后续本系列文章还会不定期更新,如有需要可关注,任何问题均可在评论区或私信提出,看到必回。如果对大家有帮助可进行打赏哦~

Ethan的博客 7883

本地Qwen + ComfyUI 制作AI漫剧完整保姆级教程(2026年3月最新版)

本文介绍了一个零成本、本地化AI漫剧制作方案,整合Qwen大模型和ComfyUI工作流。Qwen负责剧本创作、分镜设计和提示词生成,ComfyUI处理图像生成、角色一致性保持和动态视频制作。该方案支持8GB显存设备运行(推荐12GB),包含详细安装指南和完整制作流程:从Ollama安装Qwen模型,到ComfyUI配置及必备节点安装,再到分镜生成、角色固定、批量出图和视频合成。文章还提供了常见问题解决方案和优化技巧,全流程1-2小时即可完成3分钟竖屏漫剧制作,适合新手和日更创作者。

posstos的博客 5580

Elasticsearch 8.9 flush刷新缓存中的数据到磁盘源码

ES 把内存中segment和translog刷进磁盘

胖墩的IT博客 2064

“傻瓜”stata入门——熟悉操作界面

小白开始学习stata和matlab,零基础上手

nnpersistent的博客 4461

数据库修化神篇三——数据库是如何工作的

数据库是如何工作的

growdu的网络博客 400

uniapp原生安卓插件开发之路

声明: 我的功能需求:全局悬浮框,也就是在其他应用上依旧能悬浮。查遍uni文档,无法实现,甚至native.js也无法实现,无奈只能走上原生插件开发这条不归路了。(吐槽:天天写前端js,突然写了下android简直要炸,public static String啥的,var不香嘛,不过别人严谨肯定还是有别人道理的,加油吧,争取能入个门!) 本人不懂安卓开发,完全安卓小白,所以安卓方面可能表达的不是很好,安卓代码可能写的不优美,但我功能最终还是实现了。但是为了需求,能力总能被“逼”出来。有描述错误的还望指正

Jone's Area 1万+

【AI平台】n8n入门2:第一个工作流,调用本地大模型

n8n是一款开源的,专注于AI工作流构建,支持灵活的自定义与集成。就是可以把大模型和其他工具联合起来,这就厉害了。而且,免费功能又强大,目前很火,来研究一下。

正经教主是个热衷于正经学习分享的教主。 4536

从零实现一个数据库(DataBase) Go语言实现版 6.持久化到磁盘

下面是更新master page的功能. 与用于读取的代码不同, 它不使用映射地址进行写入.这是因为通过mmap修改页不是原子性的. 内核可能会在中途刷新页并损坏磁盘文件, 而不跨越页边界的小的write操作则保证是原子性的.随着文件的增长, 我们可能需要扩展映射的范围. 扩展mmap范围的系统调用是mremap.不幸的是, 当通过重新映射扩展范围时. 我们可能无法保留起始地址. 我们扩展映射的方法是使用多个映射–为溢出文件范围创建一个新的映射.新映射的大小呈指数增长, 因此我们不必频繁调用mmap.

www.iqer.info 1255

【逐函数讲解ORB_SLAM3源码】获取普通帧率、关键帧、IMU数据

获得imu的旋转 mRwc * mImuCalib.mTcb.rotationMatrix(); Sophus::SE3 mTwc 创建ORB_SLAM3系统 Create SLAM system. It initializes all system threads and gets ready to process frames. ORB_SLAM3::System SLAM(argv[1],argv[2],ORB_SLAM3::System::IMU_RGBD, true, 0, file_nam

小秋 AI SLAM 入门实战教程 1247

Redis持久化之RDB(Redis DataBase)

Redis是一个基于内存的数据库,它的数据是存放在内存中,内存有个问题就是关闭服务或者断电会丢失。Redis的数据也支持写到硬盘中,这个过程就叫做持久化。Redis提供了2种不同形式的持久化方式。

夕拾的博客 1475

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

05.简单了解redis replication核心原理/断点续传/无磁盘化复制以及master持久化的意义

1、redis replication基本原理 (1) 当启动一个 slave node 的时候,它会发送一个 PSYNC 命令给 master node。 (2) 如果这是 slave node 初次连接到 master node,那么会触发一次 full resynchronization 全量复制。 (3) 此时 master 会启动一个后台线程,开始生成一份 RDB 快照文件,同时还会将从客户端 client 新收到的所有写命令缓存在内存中。 (4) master 会将这个 RDB 发送给 slav

Mr Mirror的博客 364

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

数据库修化神篇五——仅支持追加的单表内存数据库

我们将从更简单的东西开始。像B树一样,它会将行分组到页面中,但不是将这些页面排列为树,而是将它们排列为一个数组。我将页面大小设为 4 KB,因为它与大多数计算机体系结构的虚拟内存系统中使用的页面大小相同。这意味着我们数据库中的一页对应于操作系统使用的一个页面。当我们切换到树结构时,数据库的最大大小将仅受文件最大大小的限制。由于页面在内存中可能不会彼此相邻存在,为了使读取/写入行变得更加容易,我们假设行不应跨越页面边界。这是一个简单的架构,但它要求我们能够支持多种数据类型和多种大小的文本数据类型。

growdu的网络博客 208

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

六.Redis 持久化之 RDB

Redis

java领域分享 7152

本地磁盘数据目录的存储、挂载和持久化

通过以上步骤,您可以高效地管理本地磁盘数据目录的存储和持久化,确保数据安全性和系统稳定性。:临时缓存(如 Redis 缓存、会话数据)。

ssjnbnbnb的博客 2212

AI Agent(学习六-FAISS 持久化到磁盘(重启不丢记忆))

FAISS 持久化到磁盘

wanping15825992341的博客 1267

剖析 Redis 持久化流程:从数据写入到磁盘存储的全链路

RDB 优点:文件小、恢复快,适合备份和灾难恢复;缺点:可能丢失数据(取决于触发间隔)。AOF 优点:数据安全高,可恢复到最后一次操作;缺点:文件大、恢复慢。最佳实践:生产环境常同时启用,AOF 确保数据安全,RDB 用于快速恢复。通过监控磁盘 I/O 和配置优化(如),可平衡性能和可靠性。此剖析基于 Redis 标准实现(版本 6.x+),真实可靠。如需深入配置细节,可参考 Redis 官方文档。

2501_93877797的博客 804

TanStack DB 是什么?一份带持久化方案的初学者指南(RxDB 版)

**TanStack DB** 是一个面向 JavaScript 应用的反应式客户端数据仓库(reactive client store):它以类型化的集合(collection)在内存中持有数据,运行随数据变化自动更新的 live query,并支持带错误回滚的乐观更新(optimistic mutation)。持久化与同步并不是它的核心职责,而是由你选择的集合类型(collection typ

gitblog_00237的博客 205
上一篇: 数据库修仙金丹篇十二——ptp1588v2实现方案
下一篇: 数据库修仙筑基篇十——corosync-qnetd投票机制
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我在数据库世界里修仙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值