pairs) of terms it is hard to
+determine the exact divergence point, and if we don't perform truncation at that
+point safety becomes questionable. Consider the following history, with
+safekeepers A, B, C, D, E. n_m means record created by proposer in term n with
+LSN m; (t=x, e=y) means safekeeper currently has term x and epoch y.
+
+1) P1 in term 1 writes 1.1 everywhere, which is committed, and some more only
+on A.
+
+
+A(t=1, e=1) 1.1 1.2 1.3 1.4
+B(t=1, e=1) 1.1
+C(t=1, e=1) 1.1
+D(t=1, e=1) 1.1
+E(t=1, e=1) 1.1
+
+
+2) P2 is elected by CDE in term 2, epochStartLsn is 2, and writes 2.2, 2.3 on CD:
+
+
+A(t=1, e=1) 1.1 1.2 1.3 1.4
+B(t=1, e=1) 1.1
+C(t=2, e=2) 1.1 2.2 2.3
+D(t=2, e=2) 1.1 2.2 2.3
+E(t=2, e=1) 1.1
+
+
+
+3) P3 is elected by CDE in term 3, epochStartLsn is 4, and writes 3.4 on D:
+
+
+A(t=1, e=1) 1.1 1.2 1.3 1.4
+B(t=1, e=1) 1.1
+C(t=3, e=2) 1.1 2.2 2.3
+D(t=3, e=3) 1.1 2.2 2.3 3.4
+E(t=3, e=1) 1.1
+
+
+
+Now, A gets back and P3 starts recovering it. How it should proceed? There are
+two options.
+
+## Don't try to find divergence point at all
+
+...start sending WAL conservatively since the horizon (1.1), and truncate
+obsolete part of WAL only when recovery is finished, i.e. epochStartLsn (4) is
+reached, i.e. 2.3 transferred -- that's what https://github.com/zenithdb/zenith/pull/505 proposes.
+
+Then the following is possible:
+
+4) P3 moves one record 2.2 to A.
+
+
+A(t=1, e=1) 1.1 2.2 1.3 1.4
+B(t=1, e=1) 1.1 1.2
+C(t=3, e=2) 1.1 2.2 2.3
+D(t=3, e=3) 1.1 2.2 2.3 3.4
+E(t=3, e=1) 1.1
+
+
+Now log of A is basically corrupted. Moreover, since ABE are all in epoch 1 and
+A's log is the longest one, they can elect P4 who will commit such log.
+
+Note that this particular history couldn't happen if we forbid to *create* new
+records in term n until majority of safekeepers switch to it. It would force CDE
+to switch to 2 before 2.2 is created, and A could never become donor while his
+log is corrupted. Generally with this additional barrier I believe the algorithm
+becomes safe, but
+ - I don't like this kind of artificial barrier;
+ - I also feel somewhat discomfortable about even temporary having intentionally
+ corrupted WAL;
+ - I'd still model check the idea.
+
+## Find divergence point and truncate at it
+
+Then step 4 would delete 1.3 1.4 on A, and we are ok. The question is, how do we
+do that? Without term switching history we have to resort to sending again since
+the horizon and memcmp'ing records, which is inefficient and ugly. Or we can
+maintain full history and determine truncation point by comparing 'wrong' and
+'right' histories -- much like pg_rewind does -- and perform truncation + start
+streaming right there.
+
+# Proposal
+
+- Add term history as array of pairs to safekeeper controlfile.
+- Return it to proposer with VoteResponse so 1) proposer can tell it to other
+ nodes and 2) determine personal streaming starting point. However, since we
+ don't append WAL and update controlfile atomically, let's first always update
+ controlfile but send only the history of what we really have (up to highest
+ term in history where begin_lsn >= end of wal; this highest term replaces
+ current `epoch`). We also send end of wal as we do now to determine the donor.
+- Create ProposerAnnouncement message which proposer sends before starting
+ streaming. It announces proposer as elected and
+ 1) Truncates wrong part of WAL on safekeeper
+ (divergence point is already calculated at proposer, but can be
+ cross-verified here).
+ 2) Communicates the 'right' history of its term (taken from donor). Seems
+ better to immediately put the history in the controlfile,
+ though safekeeper might not have full WAL for previous terms in it --
+ this way is simpler, and we can't update WAL and controlfile atomically anyway.
+
+ This also constitutes analogue of current epoch bump for those safekeepers
+ which don't need recovery, which is important for sync-safekeepers (bump
+ epoch without waiting records from new term).
+- After ProposerAnnouncement proposer streams WAL since calculated starting
+ point -- only what is missing.
+
+
+pros/cons:
++ (more) clear safety of WAL truncation -- we get very close to Raft
++ no unnecessary data sending (faster recovery for not-oldest-safekeepers, matters
+ only for 5+ nodes)
++ adds some observability at safekeepers
+
+- complexity, but not that much
+
+
+# Misc
+
+- During model checking I did truncation on first locally non existent or
+ different record -- analogue of 'memcmp' variant described above.
diff --git a/docs/rfcs/014-storage-lsm.md b/docs/rfcs/014-storage-lsm.md
new file mode 100644
index 0000000000..c6f8eb5914
--- /dev/null
+++ b/docs/rfcs/014-storage-lsm.md
@@ -0,0 +1,142 @@
+# Why LSM trees?
+
+In general, an LSM tree has the nice property that random updates are
+fast, but the disk writes are sequential. When a new file is created,
+it is immutable. New files are created and old ones are deleted, but
+existing files are never modified. That fits well with storing the
+files on S3.
+
+Currently, we create a lot of small files. That is mostly a problem
+with S3, because each GET/PUT operation is expensive, and LIST
+operation only returns 1000 objects at a time, and isn't free
+either. Currently, the files are "archived" together into larger
+checkpoint files before they're uploaded to S3 to alleviate that
+problem, but garbage collecting data from the archive files would be
+difficult and we have not implemented it. This proposal addresses that
+problem.
+
+
+# Overview
+
+
+```
+^ LSN
+|
+| Memtable: +-----------------------------+
+| | |
+| +-----------------------------+
+|
+|
+| L0: +-----------------------------+
+| | |
+| +-----------------------------+
+|
+| +-----------------------------+
+| | |
+| +-----------------------------+
+|
+| +-----------------------------+
+| | |
+| +-----------------------------+
+|
+| +-----------------------------+
+| | |
+| +-----------------------------+
+|
+|
+| L1: +-------+ +-----+ +--+ +-+
+| | | | | | | | |
+| | | | | | | | |
+| +-------+ +-----+ +--+ +-+
+|
+| +----+ +-----+ +--+ +----+
+| | | | | | | | |
+| | | | | | | | |
+| +----+ +-----+ +--+ +----+
+|
++--------------------------------------------------------------> Page ID
+
+
++---+
+| | Layer file
++---+
+```
+
+
+# Memtable
+
+When new WAL arrives, it is first put into the Memtable. Despite the
+name, the Memtable is not a purely in-memory data structure. It can
+spill to a temporary file on disk if the system is low on memory, and
+is accessed through a buffer cache.
+
+If the page server crashes, the Memtable is lost. It is rebuilt by
+processing again the WAL that's newer than the latest layer in L0.
+
+The size of the Memtable is equal to the "checkpoint distance", or the
+amount of WAL that we need to keep in the safekeeper.
+
+# L0
+
+When the Memtable fills up, it is written out to a new file in L0. The
+files are immutable; when a file is created, it is never
+modified. Each file in L0 is roughly 1 GB in size (*). Like the
+Memtable, each file in L0 covers the whole key range.
+
+When enough files have been accumulated in L0, compaction
+starts. Compaction processes all the files in L0 and reshuffles the
+data to create a new set of files in L1.
+
+
+(*) except in corner cases like if we want to shut down the page
+server and want to flush out the memtable to disk even though it's not
+full yet.
+
+
+# L1
+
+L1 consists of ~ 1 GB files like L0. But each file covers only part of
+the overall key space, and a larger range of LSNs. This speeds up
+searches. When you're looking for a given page, you need to check all
+the files in L0, to see if they contain a page version for the requested
+page. But in L1, you only need to check the files whose key range covers
+the requested page. This is particularly important at cold start, when
+checking a file means downloading it from S3.
+
+Partitioning by key range also helps with garbage collection. If only a
+part of the database is updated, we will accumulate more files for
+the hot part in L1, and old files can be removed without affecting the
+cold part.
+
+
+# Image layers
+
+So far, we've only talked about delta layers. In addition to the delta
+layers, we create image layers, when "enough" WAL has been accumulated
+for some part of the database. Each image layer covers a 1 GB range of
+key space. It contains images of the pages at a single LSN, a snapshot
+if you will.
+
+The exact heuristic for what "enough" means is not clear yet. Maybe
+create a new image layer when 10 GB of WAL has been accumulated for a
+1 GB segment.
+
+The image layers limit the number of layers that a search needs to
+check. That put a cap on read latency, and it also allows garbage
+collecting layers that are older than the GC horizon.
+
+
+# Partitioning scheme
+
+When compaction happens and creates a new set of files in L1, how do
+we partition the data into the files?
+
+- Goal is that each file is ~ 1 GB in size
+- Try to match partition boundaries at relation boundaries. (See [1]
+ for how PebblesDB does this, and for why that's important)
+- Greedy algorithm
+
+# Additional Reading
+
+[1] Paper on PebblesDB and how it does partitioning.
+https://www.cs.utexas.edu/~rak/papers/sosp17-pebblesdb.pdf
diff --git a/docs/rfcs/README.md b/docs/rfcs/README.md
new file mode 100644
index 0000000000..fdf6885929
--- /dev/null
+++ b/docs/rfcs/README.md
@@ -0,0 +1,95 @@
+This directory contains Request for Comments documents, or RFCs, for
+features or concepts that have been proposed. Alternative names:
+technical design doc, ERD, one-pager
+
+To make a new proposal, create a new text file in this directory and
+open a Pull Request with it. That gives others a chance and a forum
+to comment and discuss the design.
+
+When a feature is implemented and the code changes are committed, also
+include the corresponding RFC in this directory.
+
+Some of the RFCs in this directory have been implemented in some form
+or another, while others are on the roadmap, while still others are
+just obsolete and forgotten about. So read them with a grain of salt,
+but hopefully even the ones that don't reflect reality give useful
+context information.
+
+## What
+
+We use Tech Design RFC’s to summarize what we are planning to
+implement in our system. These RFCs should be created for large or not
+obvious technical tasks, e.g. changes of the architecture or bigger
+tasks that could take over a week, changes that touch multiple
+components or their interaction. RFCs should fit into a couple of
+pages, but could be longer on occasion.
+
+## Why
+
+We’re using RFCs to enable early review and collaboration, reduce
+uncertainties, risk and save time during the implementation phase that
+follows the Tech Design RFC.
+
+Tech Design RFCs also aim to avoid bus factor and are an additional
+measure to keep more peers up to date & familiar with our design and
+architecture.
+
+This is a crucial part for ensuring collaboration across timezones and
+setting up for success a distributed team that works on complex
+topics.
+
+## Prior art
+
+- Rust: [https://github.com/rust-lang/rfcs/blob/master/0000-template.md](https://github.com/rust-lang/rfcs/blob/master/0000-template.md)
+- React.js: [https://github.com/reactjs/rfcs/blob/main/0000-template.md](https://github.com/reactjs/rfcs/blob/main/0000-template.md)
+- Google fuchsia: [https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs/TEMPLATE](https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs/TEMPLATE)
+- Apache: [https://cwiki.apache.org/confluence/display/GEODE/RFC+Template](https://cwiki.apache.org/confluence/display/GEODE/RFC+Template) / [https://cwiki.apache.org/confluence/display/GEODE/Lightweight+RFC+Process](https://cwiki.apache.org/confluence/display/GEODE/Lightweight+RFC+Process)
+
+## How
+
+RFC lifecycle:
+
+- Should be submitted in a pull request with and full RFC text in a commited markdown file and copy of the Summary and Motivation sections also included in the PR body.
+- RFC should be published for review before most of the actual code is written. This isn’t a strict rule, don’t hesitate to experiment and build a POC in parallel with writing an RFC.
+- Add labels to the PR in the same manner as you do Issues. Example TBD
+- Request the review from your peers. Reviewing the RFCs from your peers is a priority, same as reviewing the actual code.
+- The Tech Design RFC should evolve based on the feedback received and further during the development phase if problems are discovered with the taken approach
+- RFCs stop evolving once the consensus is found or the proposal is implemented and merged.
+- RFCs are not intended as a documentation that’s kept up to date **after** the implementation is finished. Do not update the Tech Design RFC when merged functionality evolves later on. In such situation a new RFC may be appropriate.
+
+### RFC template
+
+Note, a lot of the sections are marked as ‘if relevant’. They are included into the template as a reminder and to help inspiration.
+
+```
+# Name
+Created on ..
+Implemented on ..
+
+## Summary
+
+## Motivation
+
+## Non Goals (if relevant)
+
+## Impacted components (e.g. pageserver, safekeeper, console, etc)
+
+## Proposed implementation
+
+### Reliability, failure modes and corner cases (if relevant)
+
+### Interaction/Sequence diagram (if relevant)
+
+### Scalability (if relevant)
+
+### Security implications (if relevant)
+
+### Unresolved questions (if relevant)
+
+## Alternative implementation (if relevant)
+
+## Pros/cons of proposed approaches (if relevant)
+
+## Definition of Done (if relevant)
+
+```
diff --git a/docs/rfcs/images/storage.jpeg b/docs/rfcs/images/storage.jpeg
new file mode 100644
index 0000000000..1d72a018dc
Binary files /dev/null and b/docs/rfcs/images/storage.jpeg differ
diff --git a/pageserver/Cargo.toml b/pageserver/Cargo.toml
index cfcb453732..09fa9fd8c9 100644
--- a/pageserver/Cargo.toml
+++ b/pageserver/Cargo.toml
@@ -12,6 +12,7 @@ bytes = { version = "1.0.1", features = ['serde'] }
byteorder = "1.4.3"
futures = "0.3.13"
hyper = "0.14"
+itertools = "0.10.3"
lazy_static = "1.4.0"
log = "0.4.14"
clap = "3.0"
@@ -50,6 +51,7 @@ postgres_ffi = { path = "../postgres_ffi" }
zenith_metrics = { path = "../zenith_metrics" }
zenith_utils = { path = "../zenith_utils" }
workspace_hack = { path = "../workspace_hack" }
+plotly = "0.7.0"
[dev-dependencies]
hex-literal = "0.3"
diff --git a/pageserver/src/basebackup.rs b/pageserver/src/basebackup.rs
index 1ee48eb2fc..0c4ca83272 100644
--- a/pageserver/src/basebackup.rs
+++ b/pageserver/src/basebackup.rs
@@ -22,6 +22,7 @@ use tar::{Builder, EntryType, Header};
use crate::relish::*;
use crate::repository::Timeline;
+use crate::DatadirTimelineImpl;
use postgres_ffi::xlog_utils::*;
use postgres_ffi::*;
use zenith_utils::lsn::Lsn;
@@ -31,7 +32,7 @@ use zenith_utils::lsn::Lsn;
/// used for constructing tarball.
pub struct Basebackup<'a> {
ar: Builder<&'a mut dyn Write>,
- timeline: &'a Arc,
+ timeline: &'a Arc,
pub lsn: Lsn,
prev_record_lsn: Lsn,
}
@@ -46,7 +47,7 @@ pub struct Basebackup<'a> {
impl<'a> Basebackup<'a> {
pub fn new(
write: &'a mut dyn Write,
- timeline: &'a Arc,
+ timeline: &'a Arc,
req_lsn: Option,
) -> Result> {
// Compute postgres doesn't have any previous WAL files, but the first
@@ -64,13 +65,13 @@ impl<'a> Basebackup<'a> {
// prev_lsn to Lsn(0) if we cannot provide the correct value.
let (backup_prev, backup_lsn) = if let Some(req_lsn) = req_lsn {
// Backup was requested at a particular LSN. Wait for it to arrive.
- timeline.wait_lsn(req_lsn)?;
+ timeline.tline.wait_lsn(req_lsn)?;
// If the requested point is the end of the timeline, we can
// provide prev_lsn. (get_last_record_rlsn() might return it as
// zero, though, if no WAL has been generated on this timeline
// yet.)
- let end_of_timeline = timeline.get_last_record_rlsn();
+ let end_of_timeline = timeline.tline.get_last_record_rlsn();
if req_lsn == end_of_timeline.last {
(end_of_timeline.prev, req_lsn)
} else {
@@ -78,7 +79,7 @@ impl<'a> Basebackup<'a> {
}
} else {
// Backup was requested at end of the timeline.
- let end_of_timeline = timeline.get_last_record_rlsn();
+ let end_of_timeline = timeline.tline.get_last_record_rlsn();
(end_of_timeline.prev, end_of_timeline.last)
};
@@ -115,21 +116,24 @@ impl<'a> Basebackup<'a> {
}
// Gather non-relational files from object storage pages.
- for obj in self.timeline.list_nonrels(self.lsn)? {
- match obj {
- RelishTag::Slru { slru, segno } => {
- self.add_slru_segment(slru, segno)?;
- }
- RelishTag::FileNodeMap { spcnode, dbnode } => {
- self.add_relmap_file(spcnode, dbnode)?;
- }
- RelishTag::TwoPhase { xid } => {
- self.add_twophase_file(xid)?;
- }
- _ => {}
+ for kind in [
+ SlruKind::Clog,
+ SlruKind::MultiXactOffsets,
+ SlruKind::MultiXactMembers,
+ ] {
+ for segno in self.timeline.list_slru_segments(kind, self.lsn)? {
+ self.add_slru_segment(kind, segno)?;
}
}
+ // Create tablespace directories
+ for ((spcnode, dbnode), has_relmap_file) in self.timeline.list_dbdirs(self.lsn)? {
+ self.add_dbdir(spcnode, dbnode, has_relmap_file)?;
+ }
+ for xid in self.timeline.list_twophase_files(self.lsn)? {
+ self.add_twophase_file(xid)?;
+ }
+
// Generate pg_control and bootstrap WAL segment.
self.add_pgcontrol_file()?;
self.ar.finish()?;
@@ -141,27 +145,14 @@ impl<'a> Basebackup<'a> {
// Generate SLRU segment files from repository.
//
fn add_slru_segment(&mut self, slru: SlruKind, segno: u32) -> anyhow::Result<()> {
- let seg_size = self
- .timeline
- .get_relish_size(RelishTag::Slru { slru, segno }, self.lsn)?;
-
- if seg_size == None {
- trace!(
- "SLRU segment {}/{:>04X} was truncated",
- slru.to_str(),
- segno
- );
- return Ok(());
- }
-
- let nblocks = seg_size.unwrap();
+ let nblocks = self.timeline.get_slru_segment_size(slru, segno, self.lsn)?;
let mut slru_buf: Vec =
Vec::with_capacity(nblocks as usize * pg_constants::BLCKSZ as usize);
for blknum in 0..nblocks {
- let img =
- self.timeline
- .get_page_at_lsn(RelishTag::Slru { slru, segno }, blknum, self.lsn)?;
+ let img = self
+ .timeline
+ .get_slru_page_at_lsn(slru, segno, blknum, self.lsn)?;
assert!(img.len() == pg_constants::BLCKSZ as usize);
slru_buf.extend_from_slice(&img);
@@ -176,16 +167,26 @@ impl<'a> Basebackup<'a> {
}
//
- // Extract pg_filenode.map files from repository
- // Along with them also send PG_VERSION for each database.
+ // Include database/tablespace directories.
//
- fn add_relmap_file(&mut self, spcnode: u32, dbnode: u32) -> anyhow::Result<()> {
- let img = self.timeline.get_page_at_lsn(
- RelishTag::FileNodeMap { spcnode, dbnode },
- 0,
- self.lsn,
- )?;
- let path = if spcnode == pg_constants::GLOBALTABLESPACE_OID {
+ // Each directory contains a PG_VERSION file, and the default database
+ // directories also contain pg_filenode.map files.
+ //
+ fn add_dbdir(
+ &mut self,
+ spcnode: u32,
+ dbnode: u32,
+ has_relmap_file: bool,
+ ) -> anyhow::Result<()> {
+ let relmap_img = if has_relmap_file {
+ let img = self.timeline.get_relmap_file(spcnode, dbnode, self.lsn)?;
+ assert!(img.len() == 512);
+ Some(img)
+ } else {
+ None
+ };
+
+ if spcnode == pg_constants::GLOBALTABLESPACE_OID {
let version_bytes = pg_constants::PG_MAJORVERSION.as_bytes();
let header = new_tar_header("PG_VERSION", version_bytes.len() as u64)?;
self.ar.append(&header, version_bytes)?;
@@ -193,9 +194,32 @@ impl<'a> Basebackup<'a> {
let header = new_tar_header("global/PG_VERSION", version_bytes.len() as u64)?;
self.ar.append(&header, version_bytes)?;
- String::from("global/pg_filenode.map") // filenode map for global tablespace
+ if let Some(img) = relmap_img {
+ // filenode map for global tablespace
+ let header = new_tar_header("global/pg_filenode.map", img.len() as u64)?;
+ self.ar.append(&header, &img[..])?;
+ } else {
+ warn!("global/pg_filenode.map is missing");
+ }
} else {
- // User defined tablespaces are not supported
+ // User defined tablespaces are not supported. However, as
+ // a special case, if a tablespace/db directory is
+ // completely empty, we can leave it out altogether. This
+ // makes taking a base backup after the 'tablespace'
+ // regression test pass, because the test drops the
+ // created tablespaces after the tests.
+ //
+ // FIXME: this wouldn't be necessary, if we handled
+ // XLOG_TBLSPC_DROP records. But we probably should just
+ // throw an error on CREATE TABLESPACE in the first place.
+ if !has_relmap_file
+ && self
+ .timeline
+ .list_rels(spcnode, dbnode, self.lsn)?
+ .is_empty()
+ {
+ return Ok(());
+ }
assert!(spcnode == pg_constants::DEFAULTTABLESPACE_OID);
// Append dir path for each database
@@ -203,16 +227,17 @@ impl<'a> Basebackup<'a> {
let header = new_tar_header_dir(&path)?;
self.ar.append(&header, &mut io::empty())?;
- let dst_path = format!("base/{}/PG_VERSION", dbnode);
- let version_bytes = pg_constants::PG_MAJORVERSION.as_bytes();
- let header = new_tar_header(&dst_path, version_bytes.len() as u64)?;
- self.ar.append(&header, version_bytes)?;
+ if let Some(img) = relmap_img {
+ let dst_path = format!("base/{}/PG_VERSION", dbnode);
+ let version_bytes = pg_constants::PG_MAJORVERSION.as_bytes();
+ let header = new_tar_header(&dst_path, version_bytes.len() as u64)?;
+ self.ar.append(&header, version_bytes)?;
- format!("base/{}/pg_filenode.map", dbnode)
+ let relmap_path = format!("base/{}/pg_filenode.map", dbnode);
+ let header = new_tar_header(&relmap_path, img.len() as u64)?;
+ self.ar.append(&header, &img[..])?;
+ }
};
- assert!(img.len() == 512);
- let header = new_tar_header(&path, img.len() as u64)?;
- self.ar.append(&header, &img[..])?;
Ok(())
}
@@ -220,9 +245,7 @@ impl<'a> Basebackup<'a> {
// Extract twophase state files
//
fn add_twophase_file(&mut self, xid: TransactionId) -> anyhow::Result<()> {
- let img = self
- .timeline
- .get_page_at_lsn(RelishTag::TwoPhase { xid }, 0, self.lsn)?;
+ let img = self.timeline.get_twophase_file(xid, self.lsn)?;
let mut buf = BytesMut::new();
buf.extend_from_slice(&img[..]);
@@ -242,11 +265,11 @@ impl<'a> Basebackup<'a> {
fn add_pgcontrol_file(&mut self) -> anyhow::Result<()> {
let checkpoint_bytes = self
.timeline
- .get_page_at_lsn(RelishTag::Checkpoint, 0, self.lsn)
+ .get_checkpoint(self.lsn)
.context("failed to get checkpoint bytes")?;
let pg_control_bytes = self
.timeline
- .get_page_at_lsn(RelishTag::ControlFile, 0, self.lsn)
+ .get_control_file(self.lsn)
.context("failed get control bytes")?;
let mut pg_control = ControlFileData::decode(&pg_control_bytes)?;
let mut checkpoint = CheckPoint::decode(&checkpoint_bytes)?;
@@ -267,7 +290,7 @@ impl<'a> Basebackup<'a> {
// add zenith.signal file
let mut zenith_signal = String::new();
if self.prev_record_lsn == Lsn(0) {
- if self.lsn == self.timeline.get_ancestor_lsn() {
+ if self.lsn == self.timeline.tline.get_ancestor_lsn() {
write!(zenith_signal, "PREV LSN: none")?;
} else {
write!(zenith_signal, "PREV LSN: invalid")?;
diff --git a/pageserver/src/bin/psbench.rs b/pageserver/src/bin/psbench.rs
index fdf5486c52..5c185b89aa 100644
--- a/pageserver/src/bin/psbench.rs
+++ b/pageserver/src/bin/psbench.rs
@@ -2,13 +2,14 @@
//!
//! Usually it's easier to write python perf tests, but here the performance
//! of the tester matters, and the API is easier to work with from rust.
-use std::{collections::HashMap, io::{BufRead, BufReader, Cursor}, net::SocketAddr, ops::AddAssign};
+use std::{collections::HashMap, io::{BufRead, BufReader, Cursor}, net::SocketAddr, ops::AddAssign, time::Duration};
use byteorder::ReadBytesExt;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use bytes::{BufMut, Bytes, BytesMut};
use clap::{App, Arg};
use std::fs::File;
use zenith_utils::{GIT_VERSION, pq_proto::{BeMessage, BeParameterStatusMessage, FeMessage}};
+use std::time::Instant;
use anyhow::Result;
@@ -54,7 +55,6 @@ pub async fn get_page(
102 => {
let mut page = Vec::::new();
cursor.read_to_end(&mut page).await?;
- dbg!(page.len());
if page.len() != 8 * 1024 {
panic!("Expected 8kb page, got: {:?}", page.len());
}
@@ -206,16 +206,38 @@ async fn main() -> Result<()> {
// TODO be mindful of caching, take multiple measurements, use monotonic time.
// TODO make harder test case. More writes, fewer images.
// TODO concurrent requests: multiple reads, also writes.
- use std::time::Instant;
- for (lsn, _pages) in writes_per_entry {
- if lsn >= *first_update {
- println!("Running get_page {:?} at {:?}", hottest_page, lsn);
+
+ // Do some warmup
+ let _page = get_page(&mut socket, &first_update, &hottest_page).await?;
+
+ let mut results: Vec<(Lsn, Duration)> = vec![];
+ for (i, (lsn, _pages)) in writes_per_entry.iter().enumerate() {
+ if lsn >= first_update {
+
+ // Just to speed up things
+ if i % 1000 != 0 {
+ continue
+ }
+
+ // println!("Running get_page {:?} at {:?}", hottest_page, lsn);
let start = Instant::now();
let _page = get_page(&mut socket, &lsn, &hottest_page).await?;
let duration = start.elapsed();
- println!("Time: {:?}", duration);
+ results.push((lsn.clone(), duration));
+ // println!("Time: {:?}", duration);
}
}
+ results.sort();
+ let x: Vec<_> = results.iter().map(|(lsn, _)| lsn.0).collect();
+ let y: Vec<_> = results.iter().map(|(_, duration)| duration.as_micros()).collect();
+
+ use plotly::{Plot, Scatter};
+ use plotly::common::Mode;
+ let get_page_trace = Scatter::new(x, y).name("get_page").mode(Mode::Lines);
+
+ let mut plot = Plot::new();
+ plot.add_trace(get_page_trace);
+ plot.show();
Ok(())
}
diff --git a/pageserver/src/config.rs b/pageserver/src/config.rs
index dc85c83c17..0bfc451a24 100644
--- a/pageserver/src/config.rs
+++ b/pageserver/src/config.rs
@@ -31,7 +31,8 @@ pub mod defaults {
// would be more appropriate. But a low value forces the code to be exercised more,
// which is good for now to trigger bugs.
pub const DEFAULT_CHECKPOINT_DISTANCE: u64 = 256 * 1024 * 1024;
- pub const DEFAULT_CHECKPOINT_PERIOD: &str = "1 s";
+
+ pub const DEFAULT_COMPACTION_PERIOD: &str = "1 s";
pub const DEFAULT_GC_HORIZON: u64 = 64 * 1024 * 1024;
pub const DEFAULT_GC_PERIOD: &str = "100 s";
@@ -57,7 +58,7 @@ pub mod defaults {
#listen_http_addr = '{DEFAULT_HTTP_LISTEN_ADDR}'
#checkpoint_distance = {DEFAULT_CHECKPOINT_DISTANCE} # in bytes
-#checkpoint_period = '{DEFAULT_CHECKPOINT_PERIOD}'
+#compaction_period = '{DEFAULT_COMPACTION_PERIOD}'
#gc_period = '{DEFAULT_GC_PERIOD}'
#gc_horizon = {DEFAULT_GC_HORIZON}
@@ -91,7 +92,9 @@ pub struct PageServerConf {
// This puts a backstop on how much WAL needs to be re-digested if the
// page server crashes.
pub checkpoint_distance: u64,
- pub checkpoint_period: Duration,
+
+ // How often to check if there's compaction work to be done.
+ pub compaction_period: Duration,
pub gc_horizon: u64,
pub gc_period: Duration,
@@ -145,7 +148,8 @@ struct PageServerConfigBuilder {
listen_http_addr: BuilderValue,
checkpoint_distance: BuilderValue,
- checkpoint_period: BuilderValue,
+
+ compaction_period: BuilderValue,
gc_horizon: BuilderValue,
gc_period: BuilderValue,
@@ -179,8 +183,8 @@ impl Default for PageServerConfigBuilder {
listen_pg_addr: Set(DEFAULT_PG_LISTEN_ADDR.to_string()),
listen_http_addr: Set(DEFAULT_HTTP_LISTEN_ADDR.to_string()),
checkpoint_distance: Set(DEFAULT_CHECKPOINT_DISTANCE),
- checkpoint_period: Set(humantime::parse_duration(DEFAULT_CHECKPOINT_PERIOD)
- .expect("cannot parse default checkpoint period")),
+ compaction_period: Set(humantime::parse_duration(DEFAULT_COMPACTION_PERIOD)
+ .expect("cannot parse default compaction period")),
gc_horizon: Set(DEFAULT_GC_HORIZON),
gc_period: Set(humantime::parse_duration(DEFAULT_GC_PERIOD)
.expect("cannot parse default gc period")),
@@ -216,8 +220,8 @@ impl PageServerConfigBuilder {
self.checkpoint_distance = BuilderValue::Set(checkpoint_distance)
}
- pub fn checkpoint_period(&mut self, checkpoint_period: Duration) {
- self.checkpoint_period = BuilderValue::Set(checkpoint_period)
+ pub fn compaction_period(&mut self, compaction_period: Duration) {
+ self.compaction_period = BuilderValue::Set(compaction_period)
}
pub fn gc_horizon(&mut self, gc_horizon: u64) {
@@ -286,9 +290,9 @@ impl PageServerConfigBuilder {
checkpoint_distance: self
.checkpoint_distance
.ok_or(anyhow::anyhow!("missing checkpoint_distance"))?,
- checkpoint_period: self
- .checkpoint_period
- .ok_or(anyhow::anyhow!("missing checkpoint_period"))?,
+ compaction_period: self
+ .compaction_period
+ .ok_or(anyhow::anyhow!("missing compaction_period"))?,
gc_horizon: self
.gc_horizon
.ok_or(anyhow::anyhow!("missing gc_horizon"))?,
@@ -425,7 +429,7 @@ impl PageServerConf {
"listen_pg_addr" => builder.listen_pg_addr(parse_toml_string(key, item)?),
"listen_http_addr" => builder.listen_http_addr(parse_toml_string(key, item)?),
"checkpoint_distance" => builder.checkpoint_distance(parse_toml_u64(key, item)?),
- "checkpoint_period" => builder.checkpoint_period(parse_toml_duration(key, item)?),
+ "compaction_period" => builder.compaction_period(parse_toml_duration(key, item)?),
"gc_horizon" => builder.gc_horizon(parse_toml_u64(key, item)?),
"gc_period" => builder.gc_period(parse_toml_duration(key, item)?),
"wait_lsn_timeout" => builder.wait_lsn_timeout(parse_toml_duration(key, item)?),
@@ -561,7 +565,7 @@ impl PageServerConf {
PageServerConf {
id: ZNodeId(0),
checkpoint_distance: defaults::DEFAULT_CHECKPOINT_DISTANCE,
- checkpoint_period: Duration::from_secs(10),
+ compaction_period: Duration::from_secs(10),
gc_horizon: defaults::DEFAULT_GC_HORIZON,
gc_period: Duration::from_secs(10),
wait_lsn_timeout: Duration::from_secs(60),
@@ -631,7 +635,8 @@ listen_pg_addr = '127.0.0.1:64000'
listen_http_addr = '127.0.0.1:9898'
checkpoint_distance = 111 # in bytes
-checkpoint_period = '111 s'
+
+compaction_period = '111 s'
gc_period = '222 s'
gc_horizon = 222
@@ -668,7 +673,7 @@ id = 10
listen_pg_addr: defaults::DEFAULT_PG_LISTEN_ADDR.to_string(),
listen_http_addr: defaults::DEFAULT_HTTP_LISTEN_ADDR.to_string(),
checkpoint_distance: defaults::DEFAULT_CHECKPOINT_DISTANCE,
- checkpoint_period: humantime::parse_duration(defaults::DEFAULT_CHECKPOINT_PERIOD)?,
+ compaction_period: humantime::parse_duration(defaults::DEFAULT_COMPACTION_PERIOD)?,
gc_horizon: defaults::DEFAULT_GC_HORIZON,
gc_period: humantime::parse_duration(defaults::DEFAULT_GC_PERIOD)?,
wait_lsn_timeout: humantime::parse_duration(defaults::DEFAULT_WAIT_LSN_TIMEOUT)?,
@@ -712,7 +717,7 @@ id = 10
listen_pg_addr: "127.0.0.1:64000".to_string(),
listen_http_addr: "127.0.0.1:9898".to_string(),
checkpoint_distance: 111,
- checkpoint_period: Duration::from_secs(111),
+ compaction_period: Duration::from_secs(111),
gc_horizon: 222,
gc_period: Duration::from_secs(222),
wait_lsn_timeout: Duration::from_secs(111),
diff --git a/pageserver/src/http/routes.rs b/pageserver/src/http/routes.rs
index 8365601042..a0964d162e 100644
--- a/pageserver/src/http/routes.rs
+++ b/pageserver/src/http/routes.rs
@@ -21,6 +21,7 @@ use zenith_utils::zid::{HexZTenantId, ZTimelineId};
use super::models::{
StatusResponse, TenantCreateRequest, TimelineCreateRequest, TimelineInfoResponse,
};
+use crate::repository::Repository;
use crate::repository::RepositoryTimeline;
use crate::timelines::TimelineInfo;
use crate::{config::PageServerConf, tenant_mgr, timelines, ZTenantId};
@@ -134,14 +135,9 @@ async fn timeline_detail_handler(request: Request) -> Result(TimelineInfo::from_repo_timeline(
- tenant_id,
- repo.get_timeline(timeline_id)?,
- include_non_incremental_logical_size,
- ))
+ TimelineInfo::from_ids(tenant_id, timeline_id, include_non_incremental_logical_size)
})
.await
.map_err(ApiError::from_err)?
diff --git a/pageserver/src/import_datadir.rs b/pageserver/src/import_datadir.rs
index e317118bb5..f31fea02f8 100644
--- a/pageserver/src/import_datadir.rs
+++ b/pageserver/src/import_datadir.rs
@@ -11,14 +11,15 @@ use anyhow::{bail, ensure, Context, Result};
use bytes::Bytes;
use tracing::*;
+use crate::pgdatadir_mapping::*;
use crate::relish::*;
-use crate::repository::*;
+use crate::repository::Repository;
use crate::walingest::WalIngest;
use postgres_ffi::relfile_utils::*;
use postgres_ffi::waldecoder::*;
use postgres_ffi::xlog_utils::*;
-use postgres_ffi::Oid;
use postgres_ffi::{pg_constants, ControlFileData, DBState_DB_SHUTDOWNED};
+use postgres_ffi::{Oid, TransactionId};
use zenith_utils::lsn::Lsn;
///
@@ -27,42 +28,42 @@ use zenith_utils::lsn::Lsn;
/// This is currently only used to import a cluster freshly created by initdb.
/// The code that deals with the checkpoint would not work right if the
/// cluster was not shut down cleanly.
-pub fn import_timeline_from_postgres_datadir(
+pub fn import_timeline_from_postgres_datadir(
path: &Path,
- writer: &dyn TimelineWriter,
+ tline: &mut DatadirTimeline,
lsn: Lsn,
) -> Result<()> {
let mut pg_control: Option = None;
+ let mut writer = tline.begin_record(lsn);
+ writer.init_empty()?;
+
// Scan 'global'
+ let mut relfiles: Vec = Vec::new();
for direntry in fs::read_dir(path.join("global"))? {
let direntry = direntry?;
match direntry.file_name().to_str() {
None => continue,
Some("pg_control") => {
- pg_control = Some(import_control_file(writer, lsn, &direntry.path())?);
+ pg_control = Some(import_control_file(&mut writer, &direntry.path())?);
+ }
+ Some("pg_filenode.map") => {
+ import_relmap_file(
+ &mut writer,
+ pg_constants::GLOBALTABLESPACE_OID,
+ 0,
+ &direntry.path(),
+ )?;
}
- Some("pg_filenode.map") => import_nonrel_file(
- writer,
- lsn,
- RelishTag::FileNodeMap {
- spcnode: pg_constants::GLOBALTABLESPACE_OID,
- dbnode: 0,
- },
- &direntry.path(),
- )?,
- // Load any relation files into the page server
- _ => import_relfile(
- &direntry.path(),
- writer,
- lsn,
- pg_constants::GLOBALTABLESPACE_OID,
- 0,
- )?,
+ // Load any relation files into the page server (but only after the other files)
+ _ => relfiles.push(direntry.path()),
}
}
+ for relfile in relfiles {
+ import_relfile(&mut writer, &relfile, pg_constants::GLOBALTABLESPACE_OID, 0)?;
+ }
// Scan 'base'. It contains database dirs, the database OID is the filename.
// E.g. 'base/12345', where 12345 is the database OID.
@@ -76,54 +77,56 @@ pub fn import_timeline_from_postgres_datadir(
let dboid = direntry.file_name().to_str().unwrap().parse::()?;
+ let mut relfiles: Vec = Vec::new();
for direntry in fs::read_dir(direntry.path())? {
let direntry = direntry?;
match direntry.file_name().to_str() {
None => continue,
- Some("PG_VERSION") => continue,
- Some("pg_filenode.map") => import_nonrel_file(
- writer,
- lsn,
- RelishTag::FileNodeMap {
- spcnode: pg_constants::DEFAULTTABLESPACE_OID,
- dbnode: dboid,
- },
+ Some("PG_VERSION") => {
+ //writer.put_dbdir_creation(pg_constants::DEFAULTTABLESPACE_OID, dboid)?;
+ }
+ Some("pg_filenode.map") => import_relmap_file(
+ &mut writer,
+ pg_constants::DEFAULTTABLESPACE_OID,
+ dboid,
&direntry.path(),
)?,
// Load any relation files into the page server
- _ => import_relfile(
- &direntry.path(),
- writer,
- lsn,
- pg_constants::DEFAULTTABLESPACE_OID,
- dboid,
- )?,
+ _ => relfiles.push(direntry.path()),
}
}
+ for relfile in relfiles {
+ import_relfile(
+ &mut writer,
+ &relfile,
+ pg_constants::DEFAULTTABLESPACE_OID,
+ dboid,
+ )?;
+ }
}
for entry in fs::read_dir(path.join("pg_xact"))? {
let entry = entry?;
- import_slru_file(writer, lsn, SlruKind::Clog, &entry.path())?;
+ import_slru_file(&mut writer, SlruKind::Clog, &entry.path())?;
}
for entry in fs::read_dir(path.join("pg_multixact").join("members"))? {
let entry = entry?;
- import_slru_file(writer, lsn, SlruKind::MultiXactMembers, &entry.path())?;
+ import_slru_file(&mut writer, SlruKind::MultiXactMembers, &entry.path())?;
}
for entry in fs::read_dir(path.join("pg_multixact").join("offsets"))? {
let entry = entry?;
- import_slru_file(writer, lsn, SlruKind::MultiXactOffsets, &entry.path())?;
+ import_slru_file(&mut writer, SlruKind::MultiXactOffsets, &entry.path())?;
}
for entry in fs::read_dir(path.join("pg_twophase"))? {
let entry = entry?;
let xid = u32::from_str_radix(entry.path().to_str().unwrap(), 16)?;
- import_nonrel_file(writer, lsn, RelishTag::TwoPhase { xid }, &entry.path())?;
+ import_twophase_file(&mut writer, xid, &entry.path())?;
}
// TODO: Scan pg_tblspc
// We're done importing all the data files.
- writer.advance_last_record_lsn(lsn);
+ writer.finish()?;
// We expect the Postgres server to be shut down cleanly.
let pg_control = pg_control.context("pg_control file not found")?;
@@ -141,7 +144,7 @@ pub fn import_timeline_from_postgres_datadir(
// *after* the checkpoint record. And crucially, it initializes the 'prev_lsn'.
import_wal(
&path.join("pg_wal"),
- writer,
+ tline,
Lsn(pg_control.checkPointCopy.redo),
lsn,
)?;
@@ -150,10 +153,9 @@ pub fn import_timeline_from_postgres_datadir(
}
// subroutine of import_timeline_from_postgres_datadir(), to load one relation file.
-fn import_relfile(
+fn import_relfile(
+ timeline: &mut DatadirTimelineWriter,
path: &Path,
- timeline: &dyn TimelineWriter,
- lsn: Lsn,
spcoid: Oid,
dboid: Oid,
) -> Result<()> {
@@ -170,26 +172,35 @@ fn import_relfile(
let mut file = File::open(path)?;
let mut buf: [u8; 8192] = [0u8; 8192];
+ let len = file.metadata().unwrap().len();
+ ensure!(len % pg_constants::BLCKSZ as u64 == 0);
+ let nblocks = len / pg_constants::BLCKSZ as u64;
+
+ if segno != 0 {
+ todo!();
+ }
+
+ let rel = RelTag {
+ spcnode: spcoid,
+ dbnode: dboid,
+ relnode,
+ forknum,
+ };
+ timeline.put_rel_creation(rel, nblocks as u32)?;
+
let mut blknum: u32 = segno * (1024 * 1024 * 1024 / pg_constants::BLCKSZ as u32);
loop {
let r = file.read_exact(&mut buf);
match r {
Ok(_) => {
- let rel = RelTag {
- spcnode: spcoid,
- dbnode: dboid,
- relnode,
- forknum,
- };
- let tag = RelishTag::Relation(rel);
- timeline.put_page_image(tag, blknum, lsn, Bytes::copy_from_slice(&buf))?;
+ timeline.put_rel_page_image(rel, blknum, Bytes::copy_from_slice(&buf))?;
}
// TODO: UnexpectedEof is expected
Err(err) => match err.kind() {
std::io::ErrorKind::UnexpectedEof => {
// reached EOF. That's expected.
- // FIXME: maybe check that we read the full length of the file?
+ ensure!(blknum == nblocks as u32, "unexpected EOF");
break;
}
_ => {
@@ -203,16 +214,28 @@ fn import_relfile(
Ok(())
}
-///
-/// Import a "non-blocky" file into the repository
-///
-/// This is used for small files like the control file, twophase files etc. that
-/// are just slurped into the repository as one blob.
-///
-fn import_nonrel_file(
- timeline: &dyn TimelineWriter,
- lsn: Lsn,
- tag: RelishTag,
+/// Import a relmapper (pg_filenode.map) file into the repository
+fn import_relmap_file(
+ timeline: &mut DatadirTimelineWriter,
+ spcnode: Oid,
+ dbnode: Oid,
+ path: &Path,
+) -> Result<()> {
+ let mut file = File::open(path)?;
+ let mut buffer = Vec::new();
+ // read the whole file
+ file.read_to_end(&mut buffer)?;
+
+ trace!("importing relmap file {}", path.display());
+
+ timeline.put_relmap_file(spcnode, dbnode, Bytes::copy_from_slice(&buffer[..]))?;
+ Ok(())
+}
+
+/// Import a twophase state file (pg_twophase/) into the repository
+fn import_twophase_file(
+ timeline: &mut DatadirTimelineWriter,
+ xid: TransactionId,
path: &Path,
) -> Result<()> {
let mut file = File::open(path)?;
@@ -222,7 +245,7 @@ fn import_nonrel_file(
trace!("importing non-rel file {}", path.display());
- timeline.put_page_image(tag, 0, lsn, Bytes::copy_from_slice(&buffer[..]))?;
+ timeline.put_twophase_file(xid, Bytes::copy_from_slice(&buffer[..]))?;
Ok(())
}
@@ -231,9 +254,8 @@ fn import_nonrel_file(
///
/// The control file is imported as is, but we also extract the checkpoint record
/// from it and store it separated.
-fn import_control_file(
- timeline: &dyn TimelineWriter,
- lsn: Lsn,
+fn import_control_file(
+ timeline: &mut DatadirTimelineWriter,
path: &Path,
) -> Result {
let mut file = File::open(path)?;
@@ -244,17 +266,12 @@ fn import_control_file(
trace!("importing control file {}", path.display());
// Import it as ControlFile
- timeline.put_page_image(
- RelishTag::ControlFile,
- 0,
- lsn,
- Bytes::copy_from_slice(&buffer[..]),
- )?;
+ timeline.put_control_file(Bytes::copy_from_slice(&buffer[..]))?;
// Extract the checkpoint record and import it separately.
let pg_control = ControlFileData::decode(&buffer)?;
let checkpoint_bytes = pg_control.checkPointCopy.encode();
- timeline.put_page_image(RelishTag::Checkpoint, 0, lsn, checkpoint_bytes)?;
+ timeline.put_checkpoint(checkpoint_bytes)?;
Ok(pg_control)
}
@@ -262,37 +279,38 @@ fn import_control_file(
///
/// Import an SLRU segment file
///
-fn import_slru_file(
- timeline: &dyn TimelineWriter,
- lsn: Lsn,
+fn import_slru_file(
+ timeline: &mut DatadirTimelineWriter,
slru: SlruKind,
path: &Path,
) -> Result<()> {
- // Does it look like an SLRU file?
+ trace!("importing slru file {}", path.display());
+
let mut file = File::open(path)?;
let mut buf: [u8; 8192] = [0u8; 8192];
let segno = u32::from_str_radix(path.file_name().unwrap().to_str().unwrap(), 16)?;
- trace!("importing slru file {}", path.display());
+ let len = file.metadata().unwrap().len();
+ ensure!(len % pg_constants::BLCKSZ as u64 == 0); // we assume SLRU block size is the same as BLCKSZ
+ let nblocks = len / pg_constants::BLCKSZ as u64;
+
+ ensure!(nblocks <= pg_constants::SLRU_PAGES_PER_SEGMENT as u64);
+
+ timeline.put_slru_segment_creation(slru, segno, nblocks as u32)?;
let mut rpageno = 0;
loop {
let r = file.read_exact(&mut buf);
match r {
Ok(_) => {
- timeline.put_page_image(
- RelishTag::Slru { slru, segno },
- rpageno,
- lsn,
- Bytes::copy_from_slice(&buf),
- )?;
+ timeline.put_slru_page_image(slru, segno, rpageno, Bytes::copy_from_slice(&buf))?;
}
// TODO: UnexpectedEof is expected
Err(err) => match err.kind() {
std::io::ErrorKind::UnexpectedEof => {
// reached EOF. That's expected.
- // FIXME: maybe check that we read the full length of the file?
+ ensure!(rpageno == nblocks as u32, "unexpected EOF");
break;
}
_ => {
@@ -301,8 +319,6 @@ fn import_slru_file(
},
};
rpageno += 1;
-
- // TODO: Check that the file isn't unexpectedly large, not larger than SLRU_PAGES_PER_SEGMENT pages
}
Ok(())
@@ -310,9 +326,9 @@ fn import_slru_file(
/// Scan PostgreSQL WAL files in given directory and load all records between
/// 'startpoint' and 'endpoint' into the repository.
-fn import_wal(
+fn import_wal(
walpath: &Path,
- writer: &dyn TimelineWriter,
+ tline: &mut DatadirTimeline,
startpoint: Lsn,
endpoint: Lsn,
) -> Result<()> {
@@ -322,7 +338,7 @@ fn import_wal(
let mut offset = startpoint.segment_offset(pg_constants::WAL_SEGMENT_SIZE);
let mut last_lsn = startpoint;
- let mut walingest = WalIngest::new(writer.deref(), startpoint)?;
+ let mut walingest = WalIngest::new(tline, startpoint)?;
while last_lsn <= endpoint {
// FIXME: assume postgresql tli 1 for now
@@ -355,7 +371,7 @@ fn import_wal(
let mut nrecords = 0;
while last_lsn <= endpoint {
if let Some((lsn, recdata)) = waldecoder.poll_decode()? {
- walingest.ingest_record(writer, recdata, lsn)?;
+ walingest.ingest_record(tline, recdata, lsn)?;
last_lsn = lsn;
nrecords += 1;
diff --git a/pageserver/src/keyspace.rs b/pageserver/src/keyspace.rs
new file mode 100644
index 0000000000..aeaceb37fc
--- /dev/null
+++ b/pageserver/src/keyspace.rs
@@ -0,0 +1,134 @@
+use crate::repository::{key_range_size, singleton_range, Key};
+use postgres_ffi::pg_constants;
+use std::ops::Range;
+
+// Target file size, when creating image and delta layers
+pub const TARGET_FILE_SIZE_BYTES: u64 = 128 * 1024 * 1024; // 128 MB
+
+///
+/// Represents a set of Keys, in a compact form.
+///
+#[derive(Clone, Debug)]
+pub struct KeySpace {
+ // Contiguous ranges of keys that belong to the key space. In key order, and
+ // with no overlap.
+ pub ranges: Vec>,
+}
+
+impl KeySpace {
+ ///
+ /// Partition a key space into roughly chunks of roughly 'target_size' bytes in
+ /// each patition.
+ ///
+ pub fn partition(&self, target_size: u64) -> KeyPartitioning {
+ // Assume that each value is 8k in size.
+ let target_nblocks = (target_size / pg_constants::BLCKSZ as u64) as usize;
+
+ let mut parts = Vec::new();
+ let mut current_part = Vec::new();
+ let mut current_part_size: usize = 0;
+ for range in &self.ranges {
+ // If appending the next contiguous range in the keyspace to the current
+ // partition would cause it to be too large, start a new partition.
+ let this_size = key_range_size(range) as usize;
+ if current_part_size + this_size > target_nblocks && !current_part.is_empty() {
+ parts.push(KeySpace {
+ ranges: current_part,
+ });
+ current_part = Vec::new();
+ current_part_size = 0;
+ }
+
+ // If the next range is larger than 'target_size', split it into
+ // 'target_size' chunks.
+ let mut remain_size = this_size;
+ let mut start = range.start;
+ while remain_size > target_nblocks {
+ let next = start.add(target_nblocks as u32);
+ parts.push(KeySpace {
+ ranges: vec![start..next],
+ });
+ start = next;
+ remain_size -= target_nblocks
+ }
+ current_part.push(start..range.end);
+ current_part_size += remain_size;
+ }
+
+ // add last partition that wasn't full yet.
+ if !current_part.is_empty() {
+ parts.push(KeySpace {
+ ranges: current_part,
+ });
+ }
+
+ KeyPartitioning { parts }
+ }
+}
+
+///
+/// Represents a partitioning of the key space.
+///
+/// The only kind of partitioning we do is to partition the key space into
+/// partitions that are roughly equal in physical size (see KeySpace::partition).
+/// But this data structure could represent any partitioning.
+///
+#[derive(Clone, Debug, Default)]
+pub struct KeyPartitioning {
+ pub parts: Vec,
+}
+
+impl KeyPartitioning {
+ pub fn new() -> Self {
+ KeyPartitioning { parts: Vec::new() }
+ }
+}
+
+///
+/// A helper object, to collect a set of keys and key ranges into a KeySpace
+/// object. This takes care of merging adjacent keys and key ranges into
+/// contiguous ranges.
+///
+#[derive(Clone, Debug, Default)]
+pub struct KeySpaceAccum {
+ accum: Option>,
+
+ ranges: Vec>,
+}
+
+impl KeySpaceAccum {
+ pub fn new() -> Self {
+ Self {
+ accum: None,
+ ranges: Vec::new(),
+ }
+ }
+
+ pub fn add_key(&mut self, key: Key) {
+ self.add_range(singleton_range(key))
+ }
+
+ pub fn add_range(&mut self, range: Range) {
+ match self.accum.as_mut() {
+ Some(accum) => {
+ if range.start == accum.end {
+ accum.end = range.end;
+ } else {
+ assert!(range.start > accum.end);
+ self.ranges.push(accum.clone());
+ *accum = range;
+ }
+ }
+ None => self.accum = Some(range),
+ }
+ }
+
+ pub fn to_keyspace(mut self) -> KeySpace {
+ if let Some(accum) = self.accum.take() {
+ self.ranges.push(accum);
+ }
+ KeySpace {
+ ranges: self.ranges,
+ }
+ }
+}
diff --git a/pageserver/src/layered_repository.rs b/pageserver/src/layered_repository.rs
index c3d42d1829..ca4dc7d6fe 100644
--- a/pageserver/src/layered_repository.rs
+++ b/pageserver/src/layered_repository.rs
@@ -14,32 +14,33 @@
use anyhow::{bail, ensure, Context, Result};
use bookfile::Book;
use bytes::Bytes;
+use fail::fail_point;
+use itertools::Itertools;
use lazy_static::lazy_static;
-use postgres_ffi::pg_constants::BLCKSZ;
use tracing::*;
-use std::cmp;
+use std::cmp::{max, min, Ordering};
use std::collections::hash_map::Entry;
+use std::collections::BTreeSet;
use std::collections::HashMap;
-use std::collections::{BTreeSet, HashSet};
use std::fs;
use std::fs::{File, OpenOptions};
use std::io::Write;
-use std::ops::{Bound::Included, Deref};
+use std::ops::{Bound::Included, Deref, Range};
use std::path::{Path, PathBuf};
-use std::sync::atomic::{self, AtomicBool, AtomicUsize};
-use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard};
+use std::sync::atomic::{self, AtomicBool};
+use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard, TryLockError};
use std::time::Instant;
use self::metadata::{metadata_path, TimelineMetadata, METADATA_FILE_NAME};
use crate::config::PageServerConf;
+use crate::keyspace::{KeyPartitioning, KeySpace};
use crate::page_cache;
-use crate::relish::*;
use crate::remote_storage::{schedule_timeline_checkpoint_upload, schedule_timeline_download};
use crate::repository::{
- BlockNumber, GcResult, Repository, RepositoryTimeline, Timeline, TimelineSyncState,
- TimelineWriter, ZenithWalRecord,
+ GcResult, Repository, RepositoryTimeline, Timeline, TimelineSyncState, TimelineWriter,
};
+use crate::repository::{Key, Value};
use crate::thread_mgr;
use crate::virtual_file::VirtualFile;
use crate::walreceiver::IS_WAL_RECEIVER;
@@ -47,10 +48,7 @@ use crate::walredo::WalRedoManager;
use crate::CheckpointConfig;
use crate::{ZTenantId, ZTimelineId};
-use zenith_metrics::{
- register_histogram, register_int_gauge_vec, Histogram, IntGauge, IntGaugeVec,
-};
-use zenith_metrics::{register_histogram_vec, HistogramVec};
+use zenith_metrics::{register_histogram_vec, Histogram, HistogramVec};
use zenith_utils::crashsafe_dir;
use zenith_utils::lsn::{AtomicLsn, Lsn, RecordLsn};
use zenith_utils::seqwait::SeqWait;
@@ -58,55 +56,40 @@ use zenith_utils::seqwait::SeqWait;
mod delta_layer;
mod ephemeral_file;
mod filename;
-mod global_layer_map;
mod image_layer;
mod inmemory_layer;
-mod interval_tree;
mod layer_map;
pub mod metadata;
mod par_fsync;
mod storage_layer;
-use delta_layer::DeltaLayer;
+use delta_layer::{DeltaLayer, DeltaLayerWriter};
use ephemeral_file::is_ephemeral_file;
use filename::{DeltaFileName, ImageFileName};
-use image_layer::ImageLayer;
+use image_layer::{ImageLayer, ImageLayerWriter};
use inmemory_layer::InMemoryLayer;
use layer_map::LayerMap;
-use storage_layer::{
- Layer, PageReconstructData, PageReconstructResult, SegmentBlk, SegmentTag, RELISH_SEG_SIZE,
-};
+use layer_map::SearchResult;
+use storage_layer::{Layer, ValueReconstructResult, ValueReconstructState};
// re-export this function so that page_cache.rs can use it.
pub use crate::layered_repository::ephemeral_file::writeback as writeback_ephemeral_file;
-static ZERO_PAGE: Bytes = Bytes::from_static(&[0u8; 8192]);
-
// Metrics collected on operations on the storage repository.
lazy_static! {
static ref STORAGE_TIME: HistogramVec = register_histogram_vec!(
"pageserver_storage_time",
"Time spent on storage operations",
- &["operation"]
+ &["operation", "tenant_id", "timeline_id"]
)
.expect("failed to define a metric");
}
// Metrics collected on operations on the storage repository.
lazy_static! {
- static ref RECONSTRUCT_TIME: Histogram = register_histogram!(
+ static ref RECONSTRUCT_TIME: HistogramVec = register_histogram_vec!(
"pageserver_getpage_reconstruct_time",
- "FIXME Time spent on storage operations"
- )
- .expect("failed to define a metric");
-}
-
-lazy_static! {
- // NOTE: can be zero if pageserver was restarted and there hasn't been any
- // activity yet.
- static ref LOGICAL_TIMELINE_SIZE: IntGaugeVec = register_int_gauge_vec!(
- "pageserver_logical_timeline_size",
- "Logical timeline size (bytes)",
+ "Time spent on storage operations",
&["tenant_id", "timeline_id"]
)
.expect("failed to define a metric");
@@ -119,7 +102,7 @@ pub const TIMELINES_SEGMENT_NAME: &str = "timelines";
/// Repository consists of multiple timelines. Keep them in a hash table.
///
pub struct LayeredRepository {
- conf: &'static PageServerConf,
+ pub conf: &'static PageServerConf,
tenantid: ZTenantId,
timelines: Mutex>,
// This mutex prevents creation of new timelines during GC.
@@ -136,14 +119,16 @@ pub struct LayeredRepository {
/// Public interface
impl Repository for LayeredRepository {
- fn get_timeline(&self, timelineid: ZTimelineId) -> Result {
+ type Timeline = LayeredTimeline;
+
+ fn get_timeline(&self, timelineid: ZTimelineId) -> Result> {
Ok(RepositoryTimeline::from(self.get_or_init_timeline(
timelineid,
&mut self.timelines.lock().unwrap(),
)?))
}
- fn list_timelines(&self) -> Result> {
+ fn list_timelines(&self) -> Result>> {
Ok(self
.timelines
.lock()
@@ -157,7 +142,7 @@ impl Repository for LayeredRepository {
&self,
timelineid: ZTimelineId,
initdb_lsn: Lsn,
- ) -> Result> {
+ ) -> Result> {
let mut timelines = self.timelines.lock().unwrap();
// Create the timeline directory, and write initial metadata to file.
@@ -173,9 +158,9 @@ impl Repository for LayeredRepository {
timelineid,
self.tenantid,
Arc::clone(&self.walredo_mgr),
- 0,
self.upload_relishes,
);
+ timeline.layers.lock().unwrap().next_open_layer_at = Some(initdb_lsn);
let timeline_rc = Arc::new(timeline);
let r = timelines.insert(timelineid, LayeredTimelineEntry::Local(timeline_rc.clone()));
@@ -248,30 +233,69 @@ impl Repository for LayeredRepository {
horizon: u64,
checkpoint_before_gc: bool,
) -> Result {
+ let timeline_str = target_timelineid
+ .map(|x| x.to_string())
+ .unwrap_or_else(|| "-".to_string());
+
STORAGE_TIME
- .with_label_values(&["gc"])
+ .with_label_values(&["gc", &self.tenantid.to_string(), &timeline_str])
.observe_closure_duration(|| {
self.gc_iteration_internal(target_timelineid, horizon, checkpoint_before_gc)
})
}
- fn checkpoint_iteration(&self, cconf: CheckpointConfig) -> Result<()> {
+ fn compaction_iteration(&self) -> Result<()> {
// Scan through the hashmap and collect a list of all the timelines,
// while holding the lock. Then drop the lock and actually perform the
- // checkpoints. We don't want to block everything else while the
- // checkpoint runs.
+ // compactions. We don't want to block everything else while the
+ // compaction runs.
let timelines = self.timelines.lock().unwrap();
- let timelines_to_checkpoint = timelines
+ let timelines_to_compact = timelines
.iter()
.map(|(timelineid, timeline)| (*timelineid, timeline.clone()))
.collect::>();
drop(timelines);
- for (timelineid, timeline) in &timelines_to_checkpoint {
+ for (timelineid, timeline) in &timelines_to_compact {
+ let _entered =
+ info_span!("compact", timeline = %timelineid, tenant = %self.tenantid).entered();
+ match timeline {
+ LayeredTimelineEntry::Local(timeline) => {
+ timeline.compact()?;
+ }
+ LayeredTimelineEntry::Remote { .. } => {
+ debug!("Cannot compact remote timeline {}", timelineid)
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ ///
+ /// Flush all in-memory data to disk.
+ ///
+ /// Used at shutdown.
+ ///
+ fn checkpoint(&self) -> Result<()> {
+ // Scan through the hashmap and collect a list of all the timelines,
+ // while holding the lock. Then drop the lock and actually perform the
+ // checkpoints. We don't want to block everything else while the
+ // checkpoint runs.
+ let timelines = self.timelines.lock().unwrap();
+ let timelines_to_compact = timelines
+ .iter()
+ .map(|(timelineid, timeline)| (*timelineid, timeline.clone()))
+ .collect::>();
+ drop(timelines);
+
+ for (timelineid, timeline) in &timelines_to_compact {
let _entered =
info_span!("checkpoint", timeline = %timelineid, tenant = %self.tenantid).entered();
match timeline {
- LayeredTimelineEntry::Local(timeline) => timeline.checkpoint(cconf)?,
+ LayeredTimelineEntry::Local(timeline) => {
+ timeline.checkpoint(CheckpointConfig::Flush)?;
+ }
LayeredTimelineEntry::Remote { .. } => debug!(
"Cannot run the checkpoint for remote timeline {}",
timelineid
@@ -401,9 +425,9 @@ impl LayeredTimelineEntry {
}
/// Gets local timeline data, if it's present. Otherwise schedules a download fot the remote timeline and returns `None`.
- fn local_or_schedule_download(&self, tenant_id: ZTenantId) -> Option<&LayeredTimeline> {
+ fn local_or_schedule_download(&self, tenant_id: ZTenantId) -> Option> {
match self {
- Self::Local(local) => Some(local.as_ref()),
+ Self::Local(local) => Some(Arc::clone(local)),
Self::Remote {
id: timeline_id, ..
} => {
@@ -429,7 +453,7 @@ impl LayeredTimelineEntry {
}
}
-impl From for RepositoryTimeline {
+impl From for RepositoryTimeline {
fn from(layered_timeline: LayeredTimelineEntry) -> Self {
match layered_timeline {
LayeredTimelineEntry::Local(timeline) => RepositoryTimeline::Local {
@@ -488,20 +512,18 @@ impl LayeredRepository {
let _enter =
info_span!("loading timeline", timeline = %timelineid, tenant = %self.tenantid)
.entered();
- let mut timeline = LayeredTimeline::new(
+ let timeline = LayeredTimeline::new(
self.conf,
metadata,
ancestor,
timelineid,
self.tenantid,
Arc::clone(&self.walredo_mgr),
- 0, // init with 0 and update after layers are loaded,
self.upload_relishes,
);
timeline
.load_layer_map(disk_consistent_lsn)
.context("failed to load layermap")?;
- timeline.init_current_logical_size()?;
Ok(Arc::new(timeline))
}
@@ -710,7 +732,8 @@ impl LayeredRepository {
timeline.checkpoint(CheckpointConfig::Forced)?;
info!("timeline {} checkpoint_before_gc done", timelineid);
}
- let result = timeline.gc_timeline(branchpoints, cutoff)?;
+ timeline.update_gc_info(branchpoints, cutoff);
+ let result = timeline.gc()?;
totals += result;
timelines = self.timelines.lock().unwrap();
@@ -730,6 +753,8 @@ pub struct LayeredTimeline {
layers: Mutex,
+ last_freeze_at: AtomicLsn,
+
// WAL redo manager
walredo_mgr: Arc,
@@ -762,24 +787,11 @@ pub struct LayeredTimeline {
ancestor_timeline: Option,
ancestor_lsn: Lsn,
- // this variable indicates how much space is used from user's point of view,
- // e.g. we do not account here for multiple versions of data and so on.
- // this is counted incrementally based on physical relishes (excluding FileNodeMap)
- // current_logical_size is not stored no disk and initialized on timeline creation using
- // get_current_logical_size_non_incremental in init_current_logical_size
- // this is needed because when we save it in metadata it can become out of sync
- // because current_logical_size is consistent on last_record_lsn, not ondisk_consistent_lsn
- // NOTE: current_logical_size also includes size of the ancestor
- current_logical_size: AtomicUsize, // bytes
-
- // To avoid calling .with_label_values and formatting the tenant and timeline IDs to strings
- // every time the logical size is updated, keep a direct reference to the Gauge here.
- // unfortunately it doesnt forward atomic methods like .fetch_add
- // so use two fields: actual size and metric
- // see https://github.com/zenithdb/zenith/issues/622 for discussion
- // TODO: it is possible to combine these two fields into single one using custom metric which uses SeqCst
- // ordering for its operations, but involves private modules, and macro trickery
- current_logical_size_gauge: IntGauge,
+ // Metrics histograms
+ reconstruct_time_histo: Histogram,
+ flush_time_histo: Histogram,
+ compact_time_histo: Histogram,
+ create_images_time_histo: Histogram,
/// If `true`, will backup its files that appear after each checkpointing to the remote storage.
upload_relishes: AtomicBool,
@@ -791,15 +803,24 @@ pub struct LayeredTimeline {
/// to avoid deadlock.
write_lock: Mutex<()>,
- // Prevent concurrent checkpoints.
- // Checkpoints are normally performed by one thread. But checkpoint can also be manually requested by admin
- // (that's used in tests), and shutdown also forces a checkpoint. These forced checkpoints run in a different thread
- // and could be triggered at the same time as a normal checkpoint.
- checkpoint_cs: Mutex<()>,
+ /// Used to ensure that there is only one thread
+ layer_flush_lock: Mutex<()>,
+
+ // Prevent concurrent compactions.
+ // Compactions are normally performed by one thread. But compaction can also be manually
+ // requested by admin (that's used in tests). These forced compactions run in a different
+ // thread and could be triggered at the same time as a normal, timed compaction.
+ compaction_cs: Mutex<()>,
// Needed to ensure that we can't create a branch at a point that was already garbage collected
latest_gc_cutoff_lsn: RwLock,
+ // List of child timelines and their branch points. This is needed to avoid
+ // garbage collecting data that is still needed by the child timelines.
+ gc_info: RwLock,
+
+ partitioning: RwLock>,
+
// It may change across major versions so for simplicity
// keep it after running initdb for a timeline.
// It is needed in checks when we want to error on some operations
@@ -809,6 +830,11 @@ pub struct LayeredTimeline {
initdb_lsn: Lsn,
}
+struct GcInfo {
+ retain_lsns: Vec,
+ cutoff: Lsn,
+}
+
/// Public interface functions
impl Timeline for LayeredTimeline {
fn get_ancestor_lsn(&self) -> Lsn {
@@ -846,163 +872,35 @@ impl Timeline for LayeredTimeline {
self.latest_gc_cutoff_lsn.read().unwrap()
}
- /// Look up given page version.
- fn get_page_at_lsn(&self, rel: RelishTag, rel_blknum: BlockNumber, lsn: Lsn) -> Result {
- if !rel.is_blocky() && rel_blknum != 0 {
- bail!(
- "invalid request for block {} for non-blocky relish {}",
- rel_blknum,
- rel
- );
- }
- debug_assert!(lsn <= self.get_last_record_lsn());
- let (seg, seg_blknum) = SegmentTag::from_blknum(rel, rel_blknum);
-
- if let Some((layer, lsn)) = self.get_layer_for_read(seg, lsn)? {
- RECONSTRUCT_TIME
- .observe_closure_duration(|| self.materialize_page(seg, seg_blknum, lsn, &*layer))
- } else {
- // FIXME: This can happen if PostgreSQL extends a relation but never writes
- // the page. See https://github.com/zenithdb/zenith/issues/841
- //
- // Would be nice to detect that situation better.
- if seg.segno > 0 && self.get_rel_exists(rel, lsn)? {
- warn!("Page {} blk {} at {} not found", rel, rel_blknum, lsn);
- return Ok(ZERO_PAGE.clone());
- }
-
- bail!("segment {} not found at {}", rel, lsn);
- }
- }
-
- fn get_relish_size(&self, rel: RelishTag, lsn: Lsn) -> Result> {
- if !rel.is_blocky() {
- bail!(
- "invalid get_relish_size request for non-blocky relish {}",
- rel
- );
- }
+ /// Look up the value with the given a key
+ fn get(&self, key: Key, lsn: Lsn) -> Result {
debug_assert!(lsn <= self.get_last_record_lsn());
- let mut segno = 0;
- loop {
- let seg = SegmentTag { rel, segno };
-
- let segsize;
- if let Some((layer, lsn)) = self.get_layer_for_read(seg, lsn)? {
- segsize = layer.get_seg_size(lsn)?;
- trace!("get_seg_size: {} at {} -> {}", seg, lsn, segsize);
- } else {
- if segno == 0 {
- return Ok(None);
+ // Check the page cache. We will get back the most recent page with lsn <= `lsn`.
+ // The cached image can be returned directly if there is no WAL between the cached image
+ // and requested LSN. The cached image can also be used to reduce the amount of WAL needed
+ // for redo.
+ let cached_page_img = match self.lookup_cached_page(&key, lsn) {
+ Some((cached_lsn, cached_img)) => {
+ match cached_lsn.cmp(&lsn) {
+ Ordering::Less => {} // there might be WAL between cached_lsn and lsn, we need to check
+ Ordering::Equal => return Ok(cached_img), // exact LSN match, return the image
+ Ordering::Greater => panic!(), // the returned lsn should never be after the requested lsn
}
- segsize = 0;
+ Some((cached_lsn, cached_img))
}
-
- if segsize != RELISH_SEG_SIZE {
- let result = segno * RELISH_SEG_SIZE + segsize;
- return Ok(Some(result));
- }
- segno += 1;
- }
- }
-
- fn get_rel_exists(&self, rel: RelishTag, lsn: Lsn) -> Result {
- debug_assert!(lsn <= self.get_last_record_lsn());
-
- let seg = SegmentTag { rel, segno: 0 };
-
- let result = if let Some((layer, lsn)) = self.get_layer_for_read(seg, lsn)? {
- layer.get_seg_exists(lsn)?
- } else {
- false
+ None => None,
};
- trace!("get_rel_exists: {} at {} -> {}", rel, lsn, result);
- Ok(result)
- }
-
- fn list_rels(&self, spcnode: u32, dbnode: u32, lsn: Lsn) -> Result> {
- let request_tag = RelTag {
- spcnode,
- dbnode,
- relnode: 0,
- forknum: 0,
+ let mut reconstruct_state = ValueReconstructState {
+ records: Vec::new(),
+ img: cached_page_img,
};
- self.list_relishes(Some(request_tag), lsn)
- }
+ self.get_reconstruct_data(key, lsn, &mut reconstruct_state)?;
- fn list_nonrels(&self, lsn: Lsn) -> Result> {
- info!("list_nonrels called at {}", lsn);
-
- self.list_relishes(None, lsn)
- }
-
- fn list_relishes(&self, tag: Option, lsn: Lsn) -> Result> {
- trace!("list_relishes called at {}", lsn);
- debug_assert!(lsn <= self.get_last_record_lsn());
-
- // List of all relishes along with a flag that marks if they exist at the given lsn.
- let mut all_relishes_map: HashMap = HashMap::new();
- let mut result = HashSet::new();
- let mut timeline = self;
-
- // Iterate through layers back in time and find the most
- // recent state of the relish. Don't add relish to the list
- // if newer version is already there.
- //
- // This most recent version can represent dropped or existing relish.
- // We will filter dropped relishes below.
- //
- loop {
- let rels = timeline.layers.lock().unwrap().list_relishes(tag, lsn)?;
-
- for (&new_relish, &new_relish_exists) in rels.iter() {
- match all_relishes_map.entry(new_relish) {
- Entry::Occupied(o) => {
- trace!(
- "Newer version of the object {} is already found: exists {}",
- new_relish,
- o.get(),
- );
- }
- Entry::Vacant(v) => {
- v.insert(new_relish_exists);
- trace!(
- "Newer version of the object {} NOT found. Insert NEW: exists {}",
- new_relish,
- new_relish_exists
- );
- }
- }
- }
-
- match &timeline.ancestor_timeline {
- None => break,
- Some(ancestor_entry) => {
- match ancestor_entry.local_or_schedule_download(self.tenantid) {
- Some(ancestor) => {
- timeline = ancestor;
- continue;
- }
- None => bail!("Cannot list relishes for timeline {} tenant {} due to its ancestor being remote only", self.timelineid, self.tenantid),
- }
- }
- }
- }
-
- // Filter out dropped relishes
- for (&new_relish, &new_relish_exists) in all_relishes_map.iter() {
- if new_relish_exists {
- result.insert(new_relish);
- trace!("List object {}", new_relish);
- } else {
- trace!("Filtered out dropped object {}", new_relish);
- }
- }
-
- Ok(result)
+ self.reconstruct_time_histo
+ .observe_closure_duration(|| self.reconstruct_value(key, lsn, reconstruct_state))
}
/// Public entry point for checkpoint(). All the logic is in the private
@@ -1010,15 +908,15 @@ impl Timeline for LayeredTimeline {
/// metrics collection.
fn checkpoint(&self, cconf: CheckpointConfig) -> Result<()> {
match cconf {
- CheckpointConfig::Flush => STORAGE_TIME
- .with_label_values(&["flush checkpoint"])
- .observe_closure_duration(|| self.checkpoint_internal(0, false)),
- CheckpointConfig::Forced => STORAGE_TIME
- .with_label_values(&["forced checkpoint"])
- .observe_closure_duration(|| self.checkpoint_internal(0, true)),
- CheckpointConfig::Distance(distance) => STORAGE_TIME
- .with_label_values(&["checkpoint"])
- .observe_closure_duration(|| self.checkpoint_internal(distance, true)),
+ CheckpointConfig::Flush => {
+ self.freeze_inmem_layer(false);
+ self.flush_frozen_layers(true)
+ }
+ CheckpointConfig::Forced => {
+ self.freeze_inmem_layer(false);
+ self.flush_frozen_layers(true)?;
+ self.compact()
+ }
}
}
@@ -1051,51 +949,24 @@ impl Timeline for LayeredTimeline {
self.last_record_lsn.load()
}
- fn get_current_logical_size(&self) -> usize {
- self.current_logical_size.load(atomic::Ordering::Acquire) as usize
- }
-
- fn get_current_logical_size_non_incremental(&self, lsn: Lsn) -> Result {
- let mut total_blocks: usize = 0;
-
- let _enter = info_span!("calc logical size", %lsn).entered();
-
- // list of all relations in this timeline, including ancestor timelines
- let all_rels = self.list_rels(0, 0, lsn)?;
-
- for rel in all_rels {
- if let Some(size) = self.get_relish_size(rel, lsn)? {
- total_blocks += size as usize;
- }
- }
-
- let non_rels = self.list_nonrels(lsn)?;
- for non_rel in non_rels {
- // TODO support TwoPhase
- if matches!(non_rel, RelishTag::Slru { slru: _, segno: _ }) {
- if let Some(size) = self.get_relish_size(non_rel, lsn)? {
- total_blocks += size as usize;
- }
- }
- }
-
- Ok(total_blocks * BLCKSZ as usize)
- }
-
fn get_disk_consistent_lsn(&self) -> Lsn {
self.disk_consistent_lsn.load()
}
+ fn hint_partitioning(&self, partitioning: KeyPartitioning, lsn: Lsn) -> Result<()> {
+ self.partitioning
+ .write()
+ .unwrap()
+ .replace((partitioning, lsn));
+ Ok(())
+ }
+
fn writer<'a>(&'a self) -> Box {
Box::new(LayeredTimelineWriter {
tl: self,
_write_guard: self.write_lock.lock().unwrap(),
})
}
-
- fn upgrade_to_layered_timeline(&self) -> &crate::layered_repository::LayeredTimeline {
- self
- }
}
impl LayeredTimeline {
@@ -1110,12 +981,33 @@ impl LayeredTimeline {
timelineid: ZTimelineId,
tenantid: ZTenantId,
walredo_mgr: Arc,
- current_logical_size: usize,
upload_relishes: bool,
) -> LayeredTimeline {
- let current_logical_size_gauge = LOGICAL_TIMELINE_SIZE
+ let reconstruct_time_histo = RECONSTRUCT_TIME
.get_metric_with_label_values(&[&tenantid.to_string(), &timelineid.to_string()])
.unwrap();
+ let flush_time_histo = STORAGE_TIME
+ .get_metric_with_label_values(&[
+ "layer flush",
+ &tenantid.to_string(),
+ &timelineid.to_string(),
+ ])
+ .unwrap();
+ let compact_time_histo = STORAGE_TIME
+ .get_metric_with_label_values(&[
+ "compact",
+ &tenantid.to_string(),
+ &timelineid.to_string(),
+ ])
+ .unwrap();
+ let create_images_time_histo = STORAGE_TIME
+ .get_metric_with_label_values(&[
+ "create images",
+ &tenantid.to_string(),
+ &timelineid.to_string(),
+ ])
+ .unwrap();
+
LayeredTimeline {
conf,
timelineid,
@@ -1131,14 +1023,27 @@ impl LayeredTimeline {
}),
disk_consistent_lsn: AtomicLsn::new(metadata.disk_consistent_lsn().0),
+ last_freeze_at: AtomicLsn::new(0),
+
ancestor_timeline: ancestor,
ancestor_lsn: metadata.ancestor_lsn(),
- current_logical_size: AtomicUsize::new(current_logical_size),
- current_logical_size_gauge,
+
+ reconstruct_time_histo,
+ flush_time_histo,
+ compact_time_histo,
+ create_images_time_histo,
+
upload_relishes: AtomicBool::new(upload_relishes),
write_lock: Mutex::new(()),
- checkpoint_cs: Mutex::new(()),
+ layer_flush_lock: Mutex::new(()),
+ compaction_cs: Mutex::new(()),
+
+ gc_info: RwLock::new(GcInfo {
+ retain_lsns: Vec::new(),
+ cutoff: Lsn(0),
+ }),
+ partitioning: RwLock::new(None),
latest_gc_cutoff_lsn: RwLock::new(metadata.latest_gc_cutoff_lsn()),
initdb_lsn: metadata.initdb_lsn(),
@@ -1182,13 +1087,12 @@ impl LayeredTimeline {
num_layers += 1;
} else if let Some(deltafilename) = DeltaFileName::parse_str(fname) {
// Create a DeltaLayer struct for each delta file.
- ensure!(deltafilename.start_lsn < deltafilename.end_lsn);
// The end-LSN is exclusive, while disk_consistent_lsn is
// inclusive. For example, if disk_consistent_lsn is 100, it is
// OK for a delta layer to have end LSN 101, but if the end LSN
// is 102, then it might not have been fully flushed to disk
// before crash.
- if deltafilename.end_lsn > disk_consistent_lsn + 1 {
+ if deltafilename.lsn_range.end > disk_consistent_lsn + 1 {
warn!(
"found future delta layer {} on timeline {} disk_consistent_lsn is {}",
deltafilename, self.timelineid, disk_consistent_lsn
@@ -1215,41 +1119,14 @@ impl LayeredTimeline {
}
}
- info!("loaded layer map with {} layers", num_layers);
+ layers.next_open_layer_at = Some(Lsn(disk_consistent_lsn.0) + 1);
- Ok(())
- }
-
- ///
- /// Used to init current logical size on startup
- ///
- fn init_current_logical_size(&mut self) -> Result<()> {
- if self.current_logical_size.load(atomic::Ordering::Relaxed) != 0 {
- bail!("cannot init already initialized current logical size")
- };
- let lsn = self.get_last_record_lsn();
- self.current_logical_size =
- AtomicUsize::new(self.get_current_logical_size_non_incremental(lsn)?);
- trace!(
- "current_logical_size initialized to {}",
- self.current_logical_size.load(atomic::Ordering::Relaxed)
+ info!(
+ "loaded layer map with {} layers at {}",
+ num_layers, disk_consistent_lsn
);
- Ok(())
- }
- ///
- /// Get a handle to a Layer for reading.
- ///
- /// The returned Layer might be from an ancestor timeline, if the
- /// segment hasn't been updated on this timeline yet.
- ///
- fn get_layer_for_read(
- &self,
- seg: SegmentTag,
- lsn: Lsn,
- ) -> Result, Lsn)>> {
- let self_layers = self.layers.lock().unwrap();
- self.get_layer_for_read_locked(seg, lsn, &self_layers)
+ Ok(())
}
///
@@ -1260,97 +1137,164 @@ impl LayeredTimeline {
///
/// This function takes the current timeline's locked LayerMap as an argument,
/// so callers can avoid potential race conditions.
- fn get_layer_for_read_locked(
+ fn get_reconstruct_data(
&self,
- seg: SegmentTag,
- lsn: Lsn,
- self_layers: &MutexGuard,
- ) -> Result, Lsn)>> {
- trace!("get_layer_for_read called for {} at {}", seg, lsn);
-
- // If you requested a page at an older LSN, before the branch point, dig into
- // the right ancestor timeline. This can only happen if you launch a read-only
- // node with an old LSN, a primary always uses a recent LSN in its requests.
+ key: Key,
+ request_lsn: Lsn,
+ reconstruct_state: &mut ValueReconstructState,
+ ) -> Result<()> {
+ // Start from the current timeline.
+ let mut timeline_owned;
let mut timeline = self;
- let mut lsn = lsn;
- while lsn < timeline.ancestor_lsn {
- trace!("going into ancestor {} ", timeline.ancestor_lsn);
- timeline = match timeline
- .ancestor_timeline
- .as_ref()
- .and_then(|ancestor_entry| ancestor_entry.local_or_schedule_download(self.tenantid))
- {
- Some(timeline) => timeline,
- None => {
+ let mut path: Vec<(ValueReconstructResult, Lsn, Arc)> = Vec::new();
+
+ // 'prev_lsn' tracks the last LSN that we were at in our search. It's used
+ // to check that each iteration make some progress, to break infinite
+ // looping if something goes wrong.
+ let mut prev_lsn = Lsn(u64::MAX);
+
+ let mut result = ValueReconstructResult::Continue;
+ let mut cont_lsn = Lsn(request_lsn.0 + 1);
+
+ 'outer: loop {
+ // The function should have updated 'state'
+ //info!("CALLED for {} at {}: {:?} with {} records", reconstruct_state.key, reconstruct_state.lsn, result, reconstruct_state.records.len());
+ match result {
+ ValueReconstructResult::Complete => return Ok(()),
+ ValueReconstructResult::Continue => {
+ if prev_lsn <= cont_lsn {
+ // Didn't make any progress in last iteration. Error out to avoid
+ // getting stuck in the loop.
+
+ // For debugging purposes, print the path of layers that we traversed
+ // through.
+ for (r, c, l) in path {
+ error!(
+ "PATH: result {:?}, cont_lsn {}, layer: {}",
+ r,
+ c,
+ l.filename().display()
+ );
+ }
+ bail!("could not find layer with more data for key {} at LSN {}, request LSN {}, ancestor {}",
+ key,
+ Lsn(cont_lsn.0 - 1),
+ request_lsn,
+ timeline.ancestor_lsn)
+ }
+ prev_lsn = cont_lsn;
+ }
+ ValueReconstructResult::Missing => {
bail!(
- "Cannot get the whole layer for read locked: timeline {} is not present locally",
- self.timelineid
+ "could not find data for key {} at LSN {}, for request at LSN {}",
+ key,
+ cont_lsn,
+ request_lsn
)
}
- };
- }
+ }
- // Now we have the right starting timeline for our search.
- loop {
- let layers_owned: MutexGuard;
- let layers = if self as *const LayeredTimeline != timeline as *const LayeredTimeline {
- layers_owned = timeline.layers.lock().unwrap();
- &layers_owned
- } else {
- self_layers
- };
-
- //
- // FIXME: If the relation has been dropped, does this return the right
- // thing? The compute node should not normally request dropped relations,
- // but if OID wraparound happens the same relfilenode might get reused
- // for an unrelated relation.
- //
-
- // Do we have a layer on this timeline?
- if let Some(layer) = layers.get(&seg, lsn) {
+ // Recurse into ancestor if needed
+ if Lsn(cont_lsn.0 - 1) <= timeline.ancestor_lsn {
trace!(
- "found layer in cache: {} {}-{}",
- timeline.timelineid,
- layer.get_start_lsn(),
- layer.get_end_lsn()
+ "going into ancestor {}, cont_lsn is {}",
+ timeline.ancestor_lsn,
+ cont_lsn
);
-
- assert!(layer.get_start_lsn() <= lsn);
-
- if layer.is_dropped() && layer.get_end_lsn() <= lsn {
- return Ok(None);
- }
-
- return Ok(Some((layer.clone(), lsn)));
+ let ancestor = timeline.get_ancestor_timeline()?;
+ timeline_owned = ancestor;
+ timeline = &*timeline_owned;
+ prev_lsn = Lsn(u64::MAX);
+ continue;
}
- // If not, check if there's a layer on the ancestor timeline
- match &timeline.ancestor_timeline {
- Some(ancestor_entry) => {
- match ancestor_entry.local_or_schedule_download(self.tenantid) {
- Some(ancestor) => {
- lsn = timeline.ancestor_lsn;
- timeline = ancestor;
- trace!("recursing into ancestor at {}/{}", timeline.timelineid, lsn);
- continue;
- }
- None => bail!(
- "Cannot get a layer for read from remote ancestor timeline {}",
- self.timelineid
- ),
- }
+ let layers = timeline.layers.lock().unwrap();
+
+ // Check the open and frozen in-memory layers first
+ if let Some(open_layer) = &layers.open_layer {
+ let start_lsn = open_layer.get_lsn_range().start;
+ if cont_lsn > start_lsn {
+ //info!("CHECKING for {} at {} on open layer {}", key, cont_lsn, open_layer.filename().display());
+ result = open_layer.get_value_reconstruct_data(
+ key,
+ open_layer.get_lsn_range().start..cont_lsn,
+ reconstruct_state,
+ )?;
+ cont_lsn = start_lsn;
+ path.push((result, cont_lsn, open_layer.clone()));
+ continue;
}
- None => return Ok(None),
+ }
+ for frozen_layer in layers.frozen_layers.iter() {
+ let start_lsn = frozen_layer.get_lsn_range().start;
+ if cont_lsn > start_lsn {
+ //info!("CHECKING for {} at {} on frozen layer {}", key, cont_lsn, frozen_layer.filename().display());
+ result = frozen_layer.get_value_reconstruct_data(
+ key,
+ frozen_layer.get_lsn_range().start..cont_lsn,
+ reconstruct_state,
+ )?;
+ cont_lsn = start_lsn;
+ path.push((result, cont_lsn, frozen_layer.clone()));
+ continue 'outer;
+ }
+ }
+
+ if let Some(SearchResult { lsn_floor, layer }) = layers.search(key, cont_lsn)? {
+ //info!("CHECKING for {} at {} on historic layer {}", key, cont_lsn, layer.filename().display());
+
+ result = layer.get_value_reconstruct_data(
+ key,
+ lsn_floor..cont_lsn,
+ reconstruct_state,
+ )?;
+ cont_lsn = lsn_floor;
+ path.push((result, cont_lsn, layer));
+ } else if self.ancestor_timeline.is_some() {
+ // Nothing on this timeline. Traverse to parent
+ result = ValueReconstructResult::Continue;
+ cont_lsn = Lsn(self.ancestor_lsn.0 + 1);
+ } else {
+ // Nothing found
+ result = ValueReconstructResult::Missing;
}
}
}
+ fn lookup_cached_page(&self, key: &Key, lsn: Lsn) -> Option<(Lsn, Bytes)> {
+ let cache = page_cache::get();
+
+ // FIXME: It's pointless to check the cache for things that are not 8kB pages.
+ // We should look at the key to determine if it's a cacheable object
+ let (lsn, read_guard) =
+ cache.lookup_materialized_page(self.tenantid, self.timelineid, key, lsn)?;
+ let img = Bytes::from(read_guard.to_vec());
+ Some((lsn, img))
+ }
+
+ fn get_ancestor_timeline(&self) -> Result> {
+ let ancestor_entry = self
+ .ancestor_timeline
+ .as_ref()
+ .expect("get_ancestor_timeline() called on timeline with no parent");
+
+ let timeline = match ancestor_entry.local_or_schedule_download(self.tenantid) {
+ Some(timeline) => timeline,
+ None => {
+ bail!(
+ "Cannot get the whole layer for read locked: ancestor of timeline {} is not present locally",
+ self.timelineid
+ )
+ }
+ };
+ Ok(timeline)
+ }
+
///
/// Get a handle to the latest layer for appending.
///
- fn get_layer_for_write(&self, seg: SegmentTag, lsn: Lsn) -> Result> {
+ fn get_layer_for_write(&self, lsn: Lsn) -> Result> {
let mut layers = self.layers.lock().unwrap();
assert!(lsn.is_aligned());
@@ -1365,236 +1309,186 @@ impl LayeredTimeline {
// Do we have a layer open for writing already?
let layer;
- if let Some(open_layer) = layers.get_open(&seg) {
- if open_layer.get_start_lsn() > lsn {
+ if let Some(open_layer) = &layers.open_layer {
+ if open_layer.get_lsn_range().start > lsn {
bail!("unexpected open layer in the future");
}
- // Open layer exists, but it is dropped, so create a new one.
- if open_layer.is_dropped() {
- assert!(!open_layer.is_writeable());
- // Layer that is created after dropped one represents a new relish segment.
- trace!(
- "creating layer for write for new relish segment after dropped layer {} at {}/{}",
- seg,
- self.timelineid,
- lsn
- );
-
- layer = InMemoryLayer::create(
- self.conf,
- self.timelineid,
- self.tenantid,
- seg,
- lsn,
- last_record_lsn,
- )?;
- } else {
- return Ok(open_layer);
- }
- }
- // No writeable layer for this relation. Create one.
- //
- // Is this a completely new relation? Or the first modification after branching?
- //
- else if let Some((prev_layer, _prev_lsn)) =
- self.get_layer_for_read_locked(seg, lsn, &layers)?
- {
- // Create new entry after the previous one.
- let start_lsn;
- if prev_layer.get_timeline_id() != self.timelineid {
- // First modification on this timeline
- start_lsn = self.ancestor_lsn + 1;
- trace!(
- "creating layer for write for {} at branch point {}",
- seg,
- start_lsn
- );
- } else {
- start_lsn = prev_layer.get_end_lsn();
- trace!(
- "creating layer for write for {} after previous layer {}",
- seg,
- start_lsn
- );
- }
- trace!(
- "prev layer is at {}/{} - {}",
- prev_layer.get_timeline_id(),
- prev_layer.get_start_lsn(),
- prev_layer.get_end_lsn()
- );
- layer = InMemoryLayer::create_successor_layer(
- self.conf,
- prev_layer,
- self.timelineid,
- self.tenantid,
- start_lsn,
- last_record_lsn,
- )?;
+ layer = Arc::clone(open_layer);
} else {
- // New relation.
+ // No writeable layer yet. Create one.
+ let start_lsn = layers.next_open_layer_at.unwrap();
+
trace!(
- "creating layer for write for new rel {} at {}/{}",
- seg,
+ "creating layer for write at {}/{} for record at {}",
self.timelineid,
+ start_lsn,
lsn
);
+ let new_layer =
+ InMemoryLayer::create(self.conf, self.timelineid, self.tenantid, start_lsn)?;
+ let layer_rc = Arc::new(new_layer);
- layer = InMemoryLayer::create(
- self.conf,
- self.timelineid,
- self.tenantid,
- seg,
- lsn,
- last_record_lsn,
- )?;
+ layers.open_layer = Some(Arc::clone(&layer_rc));
+ layers.next_open_layer_at = None;
+
+ layer = layer_rc;
}
-
- let layer_rc: Arc = Arc::new(layer);
- layers.insert_open(Arc::clone(&layer_rc));
-
- Ok(layer_rc)
+ Ok(layer)
}
- ///
- /// Flush to disk all data that was written with the put_* functions
- ///
- /// NOTE: This has nothing to do with checkpoint in PostgreSQL.
- fn checkpoint_internal(&self, checkpoint_distance: u64, reconstruct_pages: bool) -> Result<()> {
- // Prevent concurrent checkpoints
- let _checkpoint_cs = self.checkpoint_cs.lock().unwrap();
+ fn put_value(&self, key: Key, lsn: Lsn, val: Value) -> Result<()> {
+ //info!("PUT: key {} at {}", key, lsn);
+ let layer = self.get_layer_for_write(lsn)?;
+ layer.put_value(key, lsn, val)?;
+ Ok(())
+ }
- let write_guard = self.write_lock.lock().unwrap();
+ fn put_tombstone(&self, key_range: Range, lsn: Lsn) -> Result<()> {
+ let layer = self.get_layer_for_write(lsn)?;
+ layer.put_tombstone(key_range, lsn)?;
+
+ Ok(())
+ }
+
+ fn finish_write(&self, new_lsn: Lsn) {
+ assert!(new_lsn.is_aligned());
+
+ self.last_record_lsn.advance(new_lsn);
+ }
+
+ fn freeze_inmem_layer(&self, write_lock_held: bool) {
+ // Freeze the current open in-memory layer. It will be written to disk on next
+ // iteration.
+ let _write_guard = if write_lock_held {
+ None
+ } else {
+ Some(self.write_lock.lock().unwrap())
+ };
let mut layers = self.layers.lock().unwrap();
-
- // Bump the generation number in the layer map, so that we can distinguish
- // entries inserted after the checkpoint started
- let current_generation = layers.increment_generation();
-
- let RecordLsn {
- last: last_record_lsn,
- prev: prev_record_lsn,
- } = self.last_record_lsn.load();
-
- trace!("checkpoint starting at {}", last_record_lsn);
-
- // Take the in-memory layer with the oldest WAL record. If it's older
- // than the threshold, write it out to disk as a new image and delta file.
- // Repeat until all remaining in-memory layers are within the threshold.
- //
- // That's necessary to limit the amount of WAL that needs to be kept
- // in the safekeepers, and that needs to be reprocessed on page server
- // crash. TODO: It's not a great policy for keeping memory usage in
- // check, though. We should also aim at flushing layers that consume
- // a lot of memory and/or aren't receiving much updates anymore.
- let mut disk_consistent_lsn = last_record_lsn;
-
- let mut layer_paths = Vec::new();
- let mut freeze_end_lsn = Lsn(0);
- let mut evicted_layers = Vec::new();
-
- //
- // Determine which layers we need to evict and calculate max(latest_lsn)
- // among those layers.
- //
- while let Some((oldest_layer_id, oldest_layer, oldest_generation)) =
- layers.peek_oldest_open()
- {
- let oldest_lsn = oldest_layer.get_oldest_lsn();
+ if let Some(open_layer) = &layers.open_layer {
+ let open_layer_rc = Arc::clone(open_layer);
// Does this layer need freezing?
- //
- // Write out all in-memory layers that contain WAL older than CHECKPOINT_DISTANCE.
- // If we reach a layer with the same
- // generation number, we know that we have cycled through all layers that were open
- // when we started. We don't want to process layers inserted after we started, to
- // avoid getting into an infinite loop trying to process again entries that we
- // inserted ourselves.
- //
- // Once we have decided to write out at least one layer, we must also write out
- // any other layers that contain WAL older than the end LSN of the layers we have
- // already decided to write out. In other words, we must write out all layers
- // whose [oldest_lsn, latest_lsn) range overlaps with any of the other layers
- // that we are writing out. Otherwise, when we advance 'disk_consistent_lsn', it's
- // ambiguous whether those layers are already durable on disk or not. For example,
- // imagine that there are two layers in memory that contain page versions in the
- // following LSN ranges:
- //
- // A: 100-150
- // B: 110-200
- //
- // If we flush layer A, we must also flush layer B, because they overlap. If we
- // flushed only A, and advanced 'disk_consistent_lsn' to 150, we would break the
- // rule that all WAL older than 'disk_consistent_lsn' are durable on disk, because
- // B contains some WAL older than 150. On the other hand, if we flushed out A and
- // advanced 'disk_consistent_lsn' only up to 110, after crash and restart we would
- // delete the first layer because its end LSN is larger than 110. If we changed
- // the deletion logic to not delete it, then we would start streaming at 110, and
- // process again the WAL records in the range 110-150 that are already in layer A,
- // and the WAL processing code does not cope with that. We solve that dilemma by
- // insisting that if we write out the first layer, we also write out the second
- // layer, and advance disk_consistent_lsn all the way up to 200.
- //
- let distance = last_record_lsn.widening_sub(oldest_lsn);
- if (distance < 0
- || distance < checkpoint_distance.into()
- || oldest_generation == current_generation)
- && oldest_lsn >= freeze_end_lsn
- // this layer intersects with evicted layer and so also need to be evicted
- {
- info!(
- "the oldest layer is now {} which is {} bytes behind last_record_lsn",
- oldest_layer.filename().display(),
- distance
- );
- disk_consistent_lsn = oldest_lsn;
+ let end_lsn = Lsn(self.get_last_record_lsn().0 + 1);
+ open_layer.freeze(end_lsn);
+
+ // The layer is no longer open, update the layer map to reflect this.
+ // We will replace it with on-disk historics below.
+ layers.frozen_layers.push_back(open_layer_rc);
+ layers.open_layer = None;
+ layers.next_open_layer_at = Some(end_lsn);
+ self.last_freeze_at.store(end_lsn);
+ }
+ drop(layers);
+ }
+
+ pub fn check_checkpoint_distance(self: &Arc) -> Result<()> {
+ let last_lsn = self.get_last_record_lsn();
+
+ let distance = last_lsn.widening_sub(self.last_freeze_at.load());
+ if distance >= self.conf.checkpoint_distance.into() {
+ self.freeze_inmem_layer(true);
+ self.last_freeze_at.store(last_lsn);
+ }
+ if let Ok(guard) = self.layer_flush_lock.try_lock() {
+ drop(guard);
+ let self_clone = Arc::clone(self);
+ thread_mgr::spawn(
+ thread_mgr::ThreadKind::LayerFlushThread,
+ Some(self.tenantid),
+ Some(self.timelineid),
+ "layer flush thread",
+ move || self_clone.flush_frozen_layers(false),
+ )?;
+ }
+ Ok(())
+ }
+
+ /// Flush all frozen layers to disk.
+ ///
+ /// Only one thread at a time can be doing layer-flushing for a
+ /// given timeline. If 'wait' is true, and another thread is
+ /// currently doing the flushing, this function will wait for it
+ /// to finish. If 'wait' is false, this function will return
+ /// immediately instead.
+ fn flush_frozen_layers(&self, wait: bool) -> Result<()> {
+ let flush_lock_guard = if wait {
+ self.layer_flush_lock.lock().unwrap()
+ } else {
+ match self.layer_flush_lock.try_lock() {
+ Ok(guard) => guard,
+ Err(TryLockError::WouldBlock) => return Ok(()),
+ Err(TryLockError::Poisoned(err)) => panic!("{:?}", err),
+ }
+ };
+
+ let timer = self.flush_time_histo.start_timer();
+
+ loop {
+ let layers = self.layers.lock().unwrap();
+ if let Some(frozen_layer) = layers.frozen_layers.front() {
+ let frozen_layer = Arc::clone(frozen_layer);
+ drop(layers); // to allow concurrent reads and writes
+ self.flush_frozen_layer(frozen_layer)?;
+ } else {
+ // Drop the 'layer_flush_lock' *before* 'layers'. That
+ // way, if you freeze a layer, and then call
+ // flush_frozen_layers(false), it is guaranteed that
+ // if another thread was busy flushing layers and the
+ // call therefore returns immediately, the other
+ // thread will have seen the newly-frozen layer and
+ // will flush that too (assuming no errors).
+ drop(flush_lock_guard);
+ drop(layers);
break;
}
- let latest_lsn = oldest_layer.get_latest_lsn();
- if latest_lsn > freeze_end_lsn {
- freeze_end_lsn = latest_lsn; // calculate max of latest_lsn of the layers we're about to evict
- }
- layers.remove_open(oldest_layer_id);
- evicted_layers.push((oldest_layer_id, oldest_layer));
}
- // Freeze evicted layers
- for (_evicted_layer_id, evicted_layer) in evicted_layers.iter() {
- // Mark the layer as no longer accepting writes and record the end_lsn.
- // This happens in-place, no new layers are created now.
- evicted_layer.freeze(freeze_end_lsn);
- layers.insert_historic(evicted_layer.clone());
+ timer.stop_and_record();
+
+ Ok(())
+ }
+
+ /// Flush one frozen in-memory layer to disk, as a new delta layer.
+ fn flush_frozen_layer(&self, frozen_layer: Arc) -> Result<()> {
+ let new_delta = frozen_layer.write_to_disk()?;
+ let new_delta_path = new_delta.path();
+
+ // Sync the new layer to disk.
+ //
+ // We must also fsync the timeline dir to ensure the directory entries for
+ // new layer files are durable
+ //
+ // TODO: If we're running inside 'flush_frozen_layers' and there are multiple
+ // files to flush, it might be better to first write them all, and then fsync
+ // them all in parallel.
+ par_fsync::par_fsync(&[
+ new_delta_path.clone(),
+ self.conf.timeline_path(&self.timelineid, &self.tenantid),
+ ])?;
+
+ // Finally, replace the frozen in-memory layer with the new on-disk layers
+ {
+ let mut layers = self.layers.lock().unwrap();
+ let l = layers.frozen_layers.pop_front();
+
+ // Only one thread may call this function at a time (for this
+ // timeline). If two threads tried to flush the same frozen
+ // layer to disk at the same time, that would not work.
+ assert!(Arc::ptr_eq(&l.unwrap(), &frozen_layer));
+
+ // Add the new delta layer to the LayerMap
+ layers.insert_historic(Arc::new(new_delta));
+
+ // release lock on 'layers'
}
- // Call unload() on all frozen layers, to release memory.
- // This shouldn't be much memory, as only metadata is slurped
- // into memory.
- for layer in layers.iter_historic_layers() {
- layer.unload()?;
- }
-
- drop(layers);
- drop(write_guard);
-
- // Create delta/image layers for evicted layers
- for (_evicted_layer_id, evicted_layer) in evicted_layers.iter() {
- let mut this_layer_paths =
- self.evict_layer(evicted_layer.clone(), reconstruct_pages)?;
- layer_paths.append(&mut this_layer_paths);
- }
-
- // Sync layers
- if !layer_paths.is_empty() {
- // We must fsync the timeline dir to ensure the directory entries for
- // new layer files are durable
- layer_paths.push(self.conf.timeline_path(&self.timelineid, &self.tenantid));
-
- // Fsync all the layer files and directory using multiple threads to
- // minimize latency.
- par_fsync::par_fsync(&layer_paths)?;
-
- layer_paths.pop().unwrap();
- }
+ // Update the metadata file, with new 'disk_consistent_lsn'
+ //
+ // TODO: This perhaps should be done in 'flush_frozen_layers', after flushing
+ // *all* the layers, to avoid fsyncing the file multiple times.
+ let disk_consistent_lsn;
+ disk_consistent_lsn = Lsn(frozen_layer.get_lsn_range().end.0 - 1);
// If we were able to advance 'disk_consistent_lsn', save it the metadata file.
// After crash, we will restart WAL streaming and processing from that point.
@@ -1608,6 +1502,10 @@ impl LayeredTimeline {
// don't remember what the correct value that corresponds to some old
// LSN is. But if we flush everything, then the value corresponding
// current 'last_record_lsn' is correct and we can store it on disk.
+ let RecordLsn {
+ last: last_record_lsn,
+ prev: prev_record_lsn,
+ } = self.last_record_lsn.load();
let ondisk_prev_record_lsn = if disk_consistent_lsn == last_record_lsn {
Some(prev_record_lsn)
} else {
@@ -1628,6 +1526,11 @@ impl LayeredTimeline {
self.initdb_lsn,
);
+ fail_point!("checkpoint-before-saving-metadata", |x| bail!(
+ "{}",
+ x.unwrap()
+ ));
+
LayeredRepository::save_metadata(
self.conf,
self.timelineid,
@@ -1639,7 +1542,7 @@ impl LayeredTimeline {
schedule_timeline_checkpoint_upload(
self.tenantid,
self.timelineid,
- layer_paths,
+ vec![new_delta_path],
metadata,
);
}
@@ -1651,34 +1554,273 @@ impl LayeredTimeline {
Ok(())
}
- fn evict_layer(
- &self,
- layer: Arc,
- reconstruct_pages: bool,
- ) -> Result> {
- let new_historics = layer.write_to_disk(self, reconstruct_pages)?;
+ pub fn compact(&self) -> Result<()> {
+ //
+ // High level strategy for compaction / image creation:
+ //
+ // 1. First, calculate the desired "partitioning" of the
+ // currently in-use key space. The goal is to partition the
+ // key space into roughly fixed-size chunks, but also take into
+ // account any existing image layers, and try to align the
+ // chunk boundaries with the existing image layers to avoid
+ // too much churn. Also try to align chunk boundaries with
+ // relation boundaries. In principle, we don't know about
+ // relation boundaries here, we just deal with key-value
+ // pairs, and the code in pgdatadir_mapping.rs knows how to
+ // map relations into key-value pairs. But in practice we know
+ // that 'field6' is the block number, and the fields 1-5
+ // identify a relation. This is just an optimization,
+ // though.
+ //
+ // 2. Once we know the partitioning, for each partition,
+ // decide if it's time to create a new image layer. The
+ // criteria is: there has been too much "churn" since the last
+ // image layer? The "churn" is fuzzy concept, it's a
+ // combination of too many delta files, or too much WAL in
+ // total in the delta file. Or perhaps: if creating an image
+ // file would allow to delete some older files.
+ //
+ // 3. After that, we compact all level0 delta files if there
+ // are too many of them. While compacting, we also garbage
+ // collect any page versions that are no longer needed because
+ // of the new image layers we created in step 2.
+ //
+ // TODO: This hight level strategy hasn't been implemented yet.
+ // Below are functions compact_level0() and create_image_layers()
+ // but they are a bit ad hoc and don't quite work like it's explained
+ // above. Rewrite it.
+ let _compaction_cs = self.compaction_cs.lock().unwrap();
- let mut layer_paths = Vec::new();
- let _write_guard = self.write_lock.lock().unwrap();
- let mut layers = self.layers.lock().unwrap();
+ let target_file_size = self.conf.checkpoint_distance;
- // Finally, replace the frozen in-memory layer with the new on-disk layers
- layers.remove_historic(layer);
+ // 1. The partitioning was already done by the code in
+ // pgdatadir_mapping.rs. We just use it here.
+ let partitioning_guard = self.partitioning.read().unwrap();
+ if let Some((partitioning, lsn)) = partitioning_guard.as_ref() {
+ let timer = self.create_images_time_histo.start_timer();
+ // Make a copy of the partitioning, so that we can release
+ // the lock. Otherwise we could block the WAL receiver.
+ let lsn = *lsn;
+ let parts = partitioning.parts.clone();
+ drop(partitioning_guard);
- // Add the historics to the LayerMap
- for delta_layer in new_historics.delta_layers {
- layer_paths.push(delta_layer.path());
- layers.insert_historic(Arc::new(delta_layer));
+ // 2. Create new image layers for partitions that have been modified
+ // "enough".
+ for part in parts.iter() {
+ if self.time_for_new_image_layer(part, lsn, 3)? {
+ self.create_image_layer(part, lsn)?;
+ }
+ }
+ timer.stop_and_record();
+
+ // 3. Compact
+ let timer = self.compact_time_histo.start_timer();
+ self.compact_level0(target_file_size)?;
+ timer.stop_and_record();
+ } else {
+ info!("Could not compact because no partitioning specified yet");
}
- for image_layer in new_historics.image_layers {
- layer_paths.push(image_layer.path());
- layers.insert_historic(Arc::new(image_layer));
+
+ // Call unload() on all frozen layers, to release memory.
+ // This shouldn't be much memory, as only metadata is slurped
+ // into memory.
+ let layers = self.layers.lock().unwrap();
+ for layer in layers.iter_historic_layers() {
+ layer.unload()?;
}
- Ok(layer_paths)
+ drop(layers);
+
+ Ok(())
}
+ // Is it time to create a new image layer for the given partition?
+ fn time_for_new_image_layer(
+ &self,
+ partition: &KeySpace,
+ lsn: Lsn,
+ threshold: usize,
+ ) -> Result {
+ let layers = self.layers.lock().unwrap();
+
+ for part_range in &partition.ranges {
+ let image_coverage = layers.image_coverage(part_range, lsn)?;
+ for (img_range, last_img) in image_coverage {
+ let img_lsn = if let Some(ref last_img) = last_img {
+ last_img.get_lsn_range().end
+ } else {
+ Lsn(0)
+ };
+
+ let num_deltas = layers.count_deltas(&img_range, &(img_lsn..lsn))?;
+
+ info!(
+ "range {}-{}, has {} deltas on this timeline",
+ img_range.start, img_range.end, num_deltas
+ );
+ if num_deltas >= threshold {
+ return Ok(true);
+ }
+ }
+ }
+
+ Ok(false)
+ }
+
+ fn create_image_layer(&self, partition: &KeySpace, lsn: Lsn) -> Result<()> {
+ let img_range =
+ partition.ranges.first().unwrap().start..partition.ranges.last().unwrap().end;
+ let mut image_layer_writer =
+ ImageLayerWriter::new(self.conf, self.timelineid, self.tenantid, &img_range, lsn)?;
+
+ for range in &partition.ranges {
+ let mut key = range.start;
+ while key < range.end {
+ let img = self.get(key, lsn)?;
+ image_layer_writer.put_image(key, &img)?;
+ key = key.next();
+ }
+ }
+ let image_layer = image_layer_writer.finish()?;
+
+ // Sync the new layer to disk before adding it to the layer map, to make sure
+ // we don't garbage collect something based on the new layer, before it has
+ // reached the disk.
+ //
+ // We must also fsync the timeline dir to ensure the directory entries for
+ // new layer files are durable
+ //
+ // Compaction creates multiple image layers. It would be better to create them all
+ // and fsync them all in parallel.
+ par_fsync::par_fsync(&[
+ image_layer.path(),
+ self.conf.timeline_path(&self.timelineid, &self.tenantid),
+ ])?;
+
+ // FIXME: Do we need to do something to upload it to remote storage here?
+
+ let mut layers = self.layers.lock().unwrap();
+ layers.insert_historic(Arc::new(image_layer));
+ drop(layers);
+
+ Ok(())
+ }
+
+ fn compact_level0(&self, target_file_size: u64) -> Result<()> {
+ let layers = self.layers.lock().unwrap();
+
+ // We compact or "shuffle" the level-0 delta layers when 10 have
+ // accumulated.
+ static COMPACT_THRESHOLD: usize = 10;
+
+ let level0_deltas = layers.get_level0_deltas()?;
+
+ if level0_deltas.len() < COMPACT_THRESHOLD {
+ return Ok(());
+ }
+ drop(layers);
+
+ // FIXME: this function probably won't work correctly if there's overlap
+ // in the deltas.
+ let lsn_range = level0_deltas
+ .iter()
+ .map(|l| l.get_lsn_range())
+ .reduce(|a, b| min(a.start, b.start)..max(a.end, b.end))
+ .unwrap();
+
+ let all_values_iter = level0_deltas.iter().map(|l| l.iter()).kmerge_by(|a, b| {
+ if let Ok((a_key, a_lsn, _)) = a {
+ if let Ok((b_key, b_lsn, _)) = b {
+ match a_key.cmp(b_key) {
+ Ordering::Less => true,
+ Ordering::Equal => a_lsn <= b_lsn,
+ Ordering::Greater => false,
+ }
+ } else {
+ false
+ }
+ } else {
+ true
+ }
+ });
+
+ // Merge the contents of all the input delta layers into a new set
+ // of delta layers, based on the current partitioning.
+ //
+ // TODO: this actually divides the layers into fixed-size chunks, not
+ // based on the partitioning.
+ //
+ // TODO: we should also opportunistically materialize and
+ // garbage collect what we can.
+ let mut new_layers = Vec::new();
+ let mut prev_key: Option = None;
+ let mut writer: Option = None;
+ for x in all_values_iter {
+ let (key, lsn, value) = x?;
+
+ if let Some(prev_key) = prev_key {
+ if key != prev_key && writer.is_some() {
+ let size = writer.as_mut().unwrap().size();
+ if size > target_file_size {
+ new_layers.push(writer.take().unwrap().finish(prev_key.next())?);
+ writer = None;
+ }
+ }
+ }
+
+ if writer.is_none() {
+ writer = Some(DeltaLayerWriter::new(
+ self.conf,
+ self.timelineid,
+ self.tenantid,
+ key,
+ lsn_range.clone(),
+ )?);
+ }
+
+ writer.as_mut().unwrap().put_value(key, lsn, value)?;
+ prev_key = Some(key);
+ }
+ if let Some(writer) = writer {
+ new_layers.push(writer.finish(prev_key.unwrap().next())?);
+ }
+
+ // Sync layers
+ if !new_layers.is_empty() {
+ let mut layer_paths: Vec = new_layers.iter().map(|l| l.path()).collect();
+
+ // also sync the directory
+ layer_paths.push(self.conf.timeline_path(&self.timelineid, &self.tenantid));
+
+ // Fsync all the layer files and directory using multiple threads to
+ // minimize latency.
+ par_fsync::par_fsync(&layer_paths)?;
+
+ layer_paths.pop().unwrap();
+ }
+
+ let mut layers = self.layers.lock().unwrap();
+ for l in new_layers {
+ layers.insert_historic(Arc::new(l));
+ }
+
+ // Now that we have reshuffled the data to set of new delta layers, we can
+ // delete the old ones
+ for l in level0_deltas {
+ l.delete()?;
+ layers.remove_historic(l.clone());
+ }
+ drop(layers);
+
+ Ok(())
+ }
+
+ /// Update information about which layer files need to be retained on
+ /// garbage collection. This is separate from actually performing the GC,
+ /// and is updated more frequently, so that compaction can remove obsolete
+ /// page versions more aggressively.
///
- /// Garbage collect layer files on a timeline that are no longer needed.
+ /// TODO: that's wishful thinking, compaction doesn't actually do that
+ /// currently.
///
/// The caller specifies how much history is needed with the two arguments:
///
@@ -1695,15 +1837,29 @@ impl LayeredTimeline {
/// the latest LSN subtracted by a constant, and doesn't do anything smart
/// to figure out what read-only nodes might actually need.)
///
+ fn update_gc_info(&self, retain_lsns: Vec, cutoff: Lsn) {
+ let mut gc_info = self.gc_info.write().unwrap();
+ gc_info.retain_lsns = retain_lsns;
+ gc_info.cutoff = cutoff;
+ }
+
+ ///
+ /// Garbage collect layer files on a timeline that are no longer needed.
+ ///
/// Currently, we don't make any attempt at removing unneeded page versions
/// within a layer file. We can only remove the whole file if it's fully
/// obsolete.
///
- pub fn gc_timeline(&self, retain_lsns: Vec, cutoff: Lsn) -> Result {
+ fn gc(&self) -> Result {
let now = Instant::now();
let mut result: GcResult = Default::default();
let disk_consistent_lsn = self.get_disk_consistent_lsn();
- let _checkpoint_cs = self.checkpoint_cs.lock().unwrap();
+
+ let _compaction_cs = self.compaction_cs.lock().unwrap();
+
+ let gc_info = self.gc_info.read().unwrap();
+ let retain_lsns = &gc_info.retain_lsns;
+ let cutoff = gc_info.cutoff;
let _enter = info_span!("garbage collection", timeline = %self.timelineid, tenant = %self.tenantid, cutoff = %cutoff).entered();
@@ -1722,8 +1878,7 @@ impl LayeredTimeline {
// Garbage collect the layer if all conditions are satisfied:
// 1. it is older than cutoff LSN;
// 2. it doesn't need to be retained for 'retain_lsns';
- // 3. newer on-disk layer exists (only for non-dropped segments);
- // 4. this layer doesn't serve as a tombstone for some older layer;
+ // 3. newer on-disk image layers cover the layer's whole key range
//
let mut layers = self.layers.lock().unwrap();
'outer: for l in layers.iter_historic_layers() {
@@ -1737,28 +1892,16 @@ impl LayeredTimeline {
continue;
}
- let seg = l.get_seg_tag();
-
- if seg.rel.is_relation() {
- result.ondisk_relfiles_total += 1;
- } else {
- result.ondisk_nonrelfiles_total += 1;
- }
+ result.layers_total += 1;
// 1. Is it newer than cutoff point?
- if l.get_end_lsn() > cutoff {
+ if l.get_lsn_range().end > cutoff {
info!(
- "keeping {} {}-{} because it's newer than cutoff {}",
- seg,
- l.get_start_lsn(),
- l.get_end_lsn(),
+ "keeping {} because it's newer than cutoff {}",
+ l.filename().display(),
cutoff
);
- if seg.rel.is_relation() {
- result.ondisk_relfiles_needed_by_cutoff += 1;
- } else {
- result.ondisk_nonrelfiles_needed_by_cutoff += 1;
- }
+ result.layers_needed_by_cutoff += 1;
continue 'outer;
}
@@ -1767,135 +1910,47 @@ impl LayeredTimeline {
// might be referenced by child branches forever.
// We can track this in child timeline GC and delete parent layers when
// they are no longer needed. This might be complicated with long inheritance chains.
- for retain_lsn in &retain_lsns {
+ for retain_lsn in retain_lsns {
// start_lsn is inclusive
- if &l.get_start_lsn() <= retain_lsn {
+ if &l.get_lsn_range().start <= retain_lsn {
info!(
- "keeping {} {}-{} because it's still might be referenced by child branch forked at {} is_dropped: {} is_incremental: {}",
- seg,
- l.get_start_lsn(),
- l.get_end_lsn(),
+ "keeping {} because it's still might be referenced by child branch forked at {} is_dropped: xx is_incremental: {}",
+ l.filename().display(),
retain_lsn,
- l.is_dropped(),
l.is_incremental(),
);
- if seg.rel.is_relation() {
- result.ondisk_relfiles_needed_by_branches += 1;
- } else {
- result.ondisk_nonrelfiles_needed_by_branches += 1;
- }
+ result.layers_needed_by_branches += 1;
continue 'outer;
}
}
// 3. Is there a later on-disk layer for this relation?
- if !l.is_dropped()
- && !layers.newer_image_layer_exists(
- l.get_seg_tag(),
- l.get_end_lsn(),
- disk_consistent_lsn,
- )
- {
+ //
+ // The end-LSN is exclusive, while disk_consistent_lsn is
+ // inclusive. For example, if disk_consistent_lsn is 100, it is
+ // OK for a delta layer to have end LSN 101, but if the end LSN
+ // is 102, then it might not have been fully flushed to disk
+ // before crash.
+ if !layers.newer_image_layer_exists(
+ &l.get_key_range(),
+ l.get_lsn_range().end,
+ disk_consistent_lsn + 1,
+ )? {
info!(
- "keeping {} {}-{} because it is the latest layer",
- seg,
- l.get_start_lsn(),
- l.get_end_lsn()
+ "keeping {} because it is the latest layer",
+ l.filename().display()
);
- if seg.rel.is_relation() {
- result.ondisk_relfiles_not_updated += 1;
- } else {
- result.ondisk_nonrelfiles_not_updated += 1;
- }
+ result.layers_not_updated += 1;
continue 'outer;
}
- // 4. Does this layer serve as a tombstone for some older layer?
- if l.is_dropped() {
- let prior_lsn = l.get_start_lsn().checked_sub(1u64).unwrap();
-
- // Check if this layer serves as a tombstone for this timeline
- // We have to do this separately from timeline check below,
- // because LayerMap of this timeline is already locked.
- let mut is_tombstone = layers.layer_exists_at_lsn(l.get_seg_tag(), prior_lsn)?;
- if is_tombstone {
- info!(
- "earlier layer exists at {} in {}",
- prior_lsn, self.timelineid
- );
- }
- // Now check ancestor timelines, if any are present locally
- else if let Some(ancestor) =
- self.ancestor_timeline.as_ref().and_then(|timeline_entry| {
- timeline_entry.local_or_schedule_download(self.tenantid)
- })
- {
- let prior_lsn = ancestor.get_last_record_lsn();
- if seg.rel.is_blocky() {
- info!(
- "check blocky relish size {} at {} in {} for layer {}-{}",
- seg,
- prior_lsn,
- ancestor.timelineid,
- l.get_start_lsn(),
- l.get_end_lsn()
- );
- match ancestor.get_relish_size(seg.rel, prior_lsn).unwrap() {
- Some(size) => {
- let (last_live_seg, _rel_blknum) =
- SegmentTag::from_blknum(seg.rel, size - 1);
- info!(
- "blocky rel size is {} last_live_seg.segno {} seg.segno {}",
- size, last_live_seg.segno, seg.segno
- );
- if last_live_seg.segno >= seg.segno {
- is_tombstone = true;
- }
- }
- _ => {
- info!("blocky rel doesn't exist");
- }
- }
- } else {
- info!(
- "check non-blocky relish existence {} at {} in {} for layer {}-{}",
- seg,
- prior_lsn,
- ancestor.timelineid,
- l.get_start_lsn(),
- l.get_end_lsn()
- );
- is_tombstone = ancestor.get_rel_exists(seg.rel, prior_lsn).unwrap_or(false);
- }
- }
-
- if is_tombstone {
- info!(
- "keeping {} {}-{} because this layer serves as a tombstone for older layer",
- seg,
- l.get_start_lsn(),
- l.get_end_lsn()
- );
-
- if seg.rel.is_relation() {
- result.ondisk_relfiles_needed_as_tombstone += 1;
- } else {
- result.ondisk_nonrelfiles_needed_as_tombstone += 1;
- }
- continue 'outer;
- }
- }
-
// We didn't find any reason to keep this file, so remove it.
info!(
- "garbage collecting {} {}-{} is_dropped: {} is_incremental: {}",
- l.get_seg_tag(),
- l.get_start_lsn(),
- l.get_end_lsn(),
- l.is_dropped(),
+ "garbage collecting {} is_dropped: xx is_incremental: {}",
+ l.filename().display(),
l.is_incremental(),
);
- layers_to_remove.push(Arc::clone(&l));
+ layers_to_remove.push(Arc::clone(l));
}
// Actually delete the layers from disk and remove them from the map.
@@ -1905,218 +1960,75 @@ impl LayeredTimeline {
doomed_layer.delete()?;
layers.remove_historic(doomed_layer.clone());
- match (
- doomed_layer.is_dropped(),
- doomed_layer.get_seg_tag().rel.is_relation(),
- ) {
- (true, true) => result.ondisk_relfiles_dropped += 1,
- (true, false) => result.ondisk_nonrelfiles_dropped += 1,
- (false, true) => result.ondisk_relfiles_removed += 1,
- (false, false) => result.ondisk_nonrelfiles_removed += 1,
- }
+ result.layers_removed += 1;
}
result.elapsed = now.elapsed();
Ok(result)
}
- fn lookup_cached_page(
+ ///
+ /// Reconstruct a value, using the given base image and WAL records in 'data'.
+ ///
+ fn reconstruct_value(
&self,
- rel: &RelishTag,
- rel_blknum: BlockNumber,
- lsn: Lsn,
- ) -> Option<(Lsn, Bytes)> {
- let cache = page_cache::get();
- if let RelishTag::Relation(rel_tag) = &rel {
- let (lsn, read_guard) = cache.lookup_materialized_page(
- self.tenantid,
- self.timelineid,
- *rel_tag,
- rel_blknum,
- lsn,
- )?;
- let img = Bytes::from(read_guard.to_vec());
- Some((lsn, img))
- } else {
- None
- }
- }
-
- ///
- /// Reconstruct a page version from given Layer
- ///
- fn materialize_page(
- &self,
- seg: SegmentTag,
- seg_blknum: SegmentBlk,
- lsn: Lsn,
- layer: &dyn Layer,
- ) -> Result {
- // Check the page cache. We will get back the most recent page with lsn <= `lsn`.
- // The cached image can be returned directly if there is no WAL between the cached image
- // and requested LSN. The cached image can also be used to reduce the amount of WAL needed
- // for redo.
- let rel = seg.rel;
- let rel_blknum = seg.segno * RELISH_SEG_SIZE + seg_blknum;
- let cached_page_img = match self.lookup_cached_page(&rel, rel_blknum, lsn) {
- Some((cached_lsn, cached_img)) => {
- match cached_lsn.cmp(&lsn) {
- cmp::Ordering::Less => {} // there might be WAL between cached_lsn and lsn, we need to check
- cmp::Ordering::Equal => return Ok(cached_img), // exact LSN match, return the image
- cmp::Ordering::Greater => panic!(), // the returned lsn should never be after the requested lsn
- }
- Some((cached_lsn, cached_img))
- }
- None => None,
- };
-
- let mut data = PageReconstructData {
- records: Vec::new(),
- page_img: cached_page_img,
- };
-
- // Holds an Arc reference to 'layer_ref' when iterating in the loop below.
- let mut layer_arc: Arc;
-
- // Call the layer's get_page_reconstruct_data function to get the base image
- // and WAL records needed to materialize the page. If it returns 'Continue',
- // call it again on the predecessor layer until we have all the required data.
- let mut layer_ref = layer;
- let mut curr_lsn = lsn;
- loop {
- let result = layer_ref
- .get_page_reconstruct_data(seg_blknum, curr_lsn, &mut data)
- .with_context(|| {
- format!(
- "Failed to get reconstruct data {} {:?} {} {}",
- layer_ref.get_seg_tag(),
- layer_ref.filename(),
- seg_blknum,
- curr_lsn,
- )
- })?;
- match result {
- PageReconstructResult::Complete => break,
- PageReconstructResult::Continue(cont_lsn) => {
- // Fetch base image / more WAL from the returned predecessor layer
- if let Some((cont_layer, cont_lsn)) = self.get_layer_for_read(seg, cont_lsn)? {
- if cont_lsn == curr_lsn {
- // We landed on the same layer again. Shouldn't happen, but if it does,
- // don't get stuck in an infinite loop.
- bail!(
- "could not find predecessor of layer {} at {}, layer returned its own LSN",
- layer_ref.filename().display(),
- cont_lsn
- );
- }
- layer_arc = cont_layer;
- layer_ref = &*layer_arc;
- curr_lsn = cont_lsn;
- continue;
- } else {
- bail!(
- "could not find predecessor of layer {} at {}",
- layer_ref.filename().display(),
- cont_lsn
- );
- }
- }
- PageReconstructResult::Missing(lsn) => {
- // Oops, we could not reconstruct the page.
- if data.records.is_empty() {
- // no records, and no base image. This can happen if PostgreSQL extends a relation
- // but never writes the page.
- //
- // Would be nice to detect that situation better.
- warn!("Page {} blk {} at {} not found", rel, rel_blknum, lsn);
- return Ok(ZERO_PAGE.clone());
- }
- bail!(
- "No base image found for page {} blk {} at {}/{}",
- rel,
- rel_blknum,
- self.timelineid,
- lsn,
- );
- }
- }
- }
-
- self.reconstruct_page(rel, rel_blknum, lsn, data)
- }
-
- ///
- /// Reconstruct a page version, using the given base image and WAL records in 'data'.
- ///
- fn reconstruct_page(
- &self,
- rel: RelishTag,
- rel_blknum: BlockNumber,
+ key: Key,
request_lsn: Lsn,
- mut data: PageReconstructData,
+ mut data: ValueReconstructState,
) -> Result {
// Perform WAL redo if needed
data.records.reverse();
// If we have a page image, and no WAL, we're all set
if data.records.is_empty() {
- if let Some((img_lsn, img)) = &data.page_img {
+ if let Some((img_lsn, img)) = &data.img {
trace!(
- "found page image for blk {} in {} at {}, no WAL redo required",
- rel_blknum,
- rel,
+ "found page image for key {} at {}, no WAL redo required",
+ key,
img_lsn
);
Ok(img.clone())
} else {
- // FIXME: this ought to be an error?
- warn!(
- "Page {} blk {} at {} not found",
- rel, rel_blknum, request_lsn
- );
- Ok(ZERO_PAGE.clone())
+ bail!("base image for {} at {} not found", key, request_lsn);
}
} else {
// We need to do WAL redo.
//
// If we don't have a base image, then the oldest WAL record better initialize
// the page
- if data.page_img.is_none() && !data.records.first().unwrap().1.will_init() {
- // FIXME: this ought to be an error?
- warn!(
- "Base image for page {}/{} at {} not found, but got {} WAL records",
- rel,
- rel_blknum,
+ if data.img.is_none() && !data.records.first().unwrap().1.will_init() {
+ bail!(
+ "Base image for {} at {} not found, but got {} WAL records",
+ key,
request_lsn,
data.records.len()
);
- Ok(ZERO_PAGE.clone())
} else {
- let base_img = if let Some((_lsn, img)) = data.page_img {
- trace!("found {} WAL records and a base image for blk {} in {} at {}, performing WAL redo", data.records.len(), rel_blknum, rel, request_lsn);
+ let base_img = if let Some((_lsn, img)) = data.img {
+ trace!(
+ "found {} WAL records and a base image for {} at {}, performing WAL redo",
+ data.records.len(),
+ key,
+ request_lsn
+ );
Some(img)
} else {
- trace!("found {} WAL records that will init the page for blk {} in {} at {}, performing WAL redo", data.records.len(), rel_blknum, rel, request_lsn);
+ trace!("found {} WAL records that will init the page for {} at {}, performing WAL redo", data.records.len(), key, request_lsn);
None
};
let last_rec_lsn = data.records.last().unwrap().0;
- let img = self.walredo_mgr.request_redo(
- rel,
- rel_blknum,
- request_lsn,
- base_img,
- data.records,
- )?;
+ let img =
+ self.walredo_mgr
+ .request_redo(key, request_lsn, base_img, data.records)?;
- if let RelishTag::Relation(rel_tag) = &rel {
+ if img.len() == page_cache::PAGE_SZ {
let cache = page_cache::get();
cache.memorize_materialized_page(
self.tenantid,
self.timelineid,
- *rel_tag,
- rel_blknum,
+ key,
last_rec_lsn,
&img,
);
@@ -2126,40 +2038,6 @@ impl LayeredTimeline {
}
}
}
-
- ///
- /// This is a helper function to increase current_total_relation_size
- ///
- fn increase_current_logical_size(&self, diff: u32) {
- let val = self
- .current_logical_size
- .fetch_add(diff as usize, atomic::Ordering::SeqCst);
- trace!(
- "increase_current_logical_size: {} + {} = {}",
- val,
- diff,
- val + diff as usize,
- );
- self.current_logical_size_gauge
- .set(val as i64 + diff as i64);
- }
-
- ///
- /// This is a helper function to decrease current_total_relation_size
- ///
- fn decrease_current_logical_size(&self, diff: u32) {
- let val = self
- .current_logical_size
- .fetch_sub(diff as usize, atomic::Ordering::SeqCst);
- trace!(
- "decrease_current_logical_size: {} - {} = {}",
- val,
- diff,
- val - diff as usize,
- );
- self.current_logical_size_gauge
- .set(val as i64 - diff as i64);
- }
}
struct LayeredTimelineWriter<'a> {
@@ -2175,159 +2053,20 @@ impl Deref for LayeredTimelineWriter<'_> {
}
}
-impl<'a> TimelineWriter for LayeredTimelineWriter<'a> {
- fn put_wal_record(
- &self,
- lsn: Lsn,
- rel: RelishTag,
- rel_blknum: u32,
- rec: ZenithWalRecord,
- ) -> Result<()> {
- if !rel.is_blocky() && rel_blknum != 0 {
- bail!(
- "invalid request for block {} for non-blocky relish {}",
- rel_blknum,
- rel
- );
- }
- ensure!(lsn.is_aligned(), "unaligned record LSN");
-
- let (seg, seg_blknum) = SegmentTag::from_blknum(rel, rel_blknum);
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- let delta_size = layer.put_wal_record(lsn, seg_blknum, rec)?;
- self.tl
- .increase_current_logical_size(delta_size * BLCKSZ as u32);
- Ok(())
+impl<'a> TimelineWriter<'_> for LayeredTimelineWriter<'a> {
+ fn put(&self, key: Key, lsn: Lsn, value: Value) -> Result<()> {
+ self.tl.put_value(key, lsn, value)
}
- fn put_page_image(
- &self,
- rel: RelishTag,
- rel_blknum: BlockNumber,
- lsn: Lsn,
- img: Bytes,
- ) -> Result<()> {
- if !rel.is_blocky() && rel_blknum != 0 {
- bail!(
- "invalid request for block {} for non-blocky relish {}",
- rel_blknum,
- rel
- );
- }
- ensure!(lsn.is_aligned(), "unaligned record LSN");
-
- let (seg, seg_blknum) = SegmentTag::from_blknum(rel, rel_blknum);
-
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- let delta_size = layer.put_page_image(seg_blknum, lsn, img)?;
-
- self.tl
- .increase_current_logical_size(delta_size * BLCKSZ as u32);
- Ok(())
- }
-
- fn put_truncation(&self, rel: RelishTag, lsn: Lsn, relsize: BlockNumber) -> Result<()> {
- if !rel.is_blocky() {
- bail!("invalid truncation for non-blocky relish {}", rel);
- }
- ensure!(lsn.is_aligned(), "unaligned record LSN");
-
- debug!("put_truncation: {} to {} blocks at {}", rel, relsize, lsn);
-
- let oldsize = self
- .tl
- .get_relish_size(rel, self.tl.get_last_record_lsn())?
- .with_context(|| {
- format!(
- "attempted to truncate non-existent relish {} at {}",
- rel, lsn
- )
- })?;
-
- if oldsize <= relsize {
- return Ok(());
- }
- let old_last_seg = (oldsize - 1) / RELISH_SEG_SIZE;
-
- let last_remain_seg = if relsize == 0 {
- 0
- } else {
- (relsize - 1) / RELISH_SEG_SIZE
- };
-
- // Drop segments beyond the last remaining segment.
- for remove_segno in (last_remain_seg + 1)..=old_last_seg {
- let seg = SegmentTag {
- rel,
- segno: remove_segno,
- };
-
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- layer.drop_segment(lsn);
- }
-
- // Truncate the last remaining segment to the specified size
- if relsize == 0 || relsize % RELISH_SEG_SIZE != 0 {
- let seg = SegmentTag {
- rel,
- segno: last_remain_seg,
- };
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- layer.put_truncation(lsn, relsize % RELISH_SEG_SIZE)
- }
- self.tl
- .decrease_current_logical_size((oldsize - relsize) * BLCKSZ as u32);
- Ok(())
- }
-
- fn drop_relish(&self, rel: RelishTag, lsn: Lsn) -> Result<()> {
- trace!("drop_segment: {} at {}", rel, lsn);
-
- if rel.is_blocky() {
- if let Some(oldsize) = self
- .tl
- .get_relish_size(rel, self.tl.get_last_record_lsn())?
- {
- let old_last_seg = if oldsize == 0 {
- 0
- } else {
- (oldsize - 1) / RELISH_SEG_SIZE
- };
-
- // Drop all segments of the relish
- for remove_segno in 0..=old_last_seg {
- let seg = SegmentTag {
- rel,
- segno: remove_segno,
- };
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- layer.drop_segment(lsn);
- }
- self.tl
- .decrease_current_logical_size(oldsize * BLCKSZ as u32);
- } else {
- warn!(
- "drop_segment called on non-existent relish {} at {}",
- rel, lsn
- );
- }
- } else {
- // TODO handle TwoPhase relishes
- let (seg, _seg_blknum) = SegmentTag::from_blknum(rel, 0);
- let layer = self.tl.get_layer_for_write(seg, lsn)?;
- layer.drop_segment(lsn);
- }
-
- Ok(())
+ fn delete(&self, key_range: Range, lsn: Lsn) -> Result<()> {
+ self.tl.put_tombstone(key_range, lsn)
}
///
/// Remember the (end of) last valid WAL record remembered in the timeline.
///
- fn advance_last_record_lsn(&self, new_lsn: Lsn) {
- assert!(new_lsn.is_aligned());
-
- self.tl.last_record_lsn.advance(new_lsn);
+ fn finish_write(&self, new_lsn: Lsn) {
+ self.tl.finish_write(new_lsn);
}
}
@@ -2374,9 +2113,12 @@ fn rename_to_backup(path: PathBuf) -> anyhow::Result<()> {
/// file format and directory layout. The test here are more low level.
///
#[cfg(test)]
-mod tests {
+pub mod tests {
use super::*;
+ use crate::keyspace::KeySpaceAccum;
use crate::repository::repo_harness::*;
+ use rand::thread_rng;
+ use rand::Rng;
#[test]
fn corrupt_metadata() -> Result<()> {
@@ -2407,113 +2149,265 @@ mod tests {
Ok(())
}
- ///
- /// Test the logic in 'load_layer_map' that removes layer files that are
- /// newer than 'disk_consistent_lsn'.
- ///
+ // Target file size in the unit tests. In production, the target
+ // file size is much larger, maybe 1 GB. But a small size makes it
+ // much faster to exercise all the logic for creating the files,
+ // garbage collection, compaction etc.
+ pub const TEST_FILE_SIZE: u64 = 4 * 1024 * 1024;
+
#[test]
- fn future_layerfiles() -> Result<()> {
- const TEST_NAME: &str = "future_layerfiles";
- let harness = RepoHarness::create(TEST_NAME)?;
- let repo = harness.load();
+ fn test_images() -> Result<()> {
+ let repo = RepoHarness::create("test_images")?.load();
+ let tline = repo.create_empty_timeline(TIMELINE_ID, Lsn(0))?;
+
+ #[allow(non_snake_case)]
+ let TEST_KEY: Key = Key::from_hex("112222222233333333444444445500000001").unwrap();
- // Create a timeline with disk_consistent_lsn = 8000
- let tline = repo.create_empty_timeline(TIMELINE_ID, Lsn(0x8000))?;
let writer = tline.writer();
- writer.advance_last_record_lsn(Lsn(0x8000));
+ writer.put(TEST_KEY, Lsn(0x10), Value::Image(TEST_IMG("foo at 0x10")))?;
+ writer.finish_write(Lsn(0x10));
drop(writer);
- repo.checkpoint_iteration(CheckpointConfig::Forced)?;
- drop(repo);
- let timeline_path = harness.timeline_path(&TIMELINE_ID);
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
- let make_empty_file = |filename: &str| -> std::io::Result<()> {
- let path = timeline_path.join(filename);
+ let writer = tline.writer();
+ writer.put(TEST_KEY, Lsn(0x20), Value::Image(TEST_IMG("foo at 0x20")))?;
+ writer.finish_write(Lsn(0x20));
+ drop(writer);
- assert!(!path.exists());
- std::fs::write(&path, &[])?;
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
- Ok(())
- };
+ let writer = tline.writer();
+ writer.put(TEST_KEY, Lsn(0x30), Value::Image(TEST_IMG("foo at 0x30")))?;
+ writer.finish_write(Lsn(0x30));
+ drop(writer);
- // Helper function to check that a relation file exists, and a corresponding
- // .0.old file does not.
- let assert_exists = |filename: &str| {
- let path = timeline_path.join(filename);
- assert!(path.exists(), "file {} was removed", filename);
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
- // Check that there is no .old file
- let backup_path = timeline_path.join(format!("{}.0.old", filename));
- assert!(
- !backup_path.exists(),
- "unexpected backup file {}",
- backup_path.display()
- );
- };
+ let writer = tline.writer();
+ writer.put(TEST_KEY, Lsn(0x40), Value::Image(TEST_IMG("foo at 0x40")))?;
+ writer.finish_write(Lsn(0x40));
+ drop(writer);
- // Helper function to check that a relation file does *not* exists, and a corresponding
- // ..old file does.
- let assert_is_renamed = |filename: &str, num: u32| {
- let path = timeline_path.join(filename);
- assert!(
- !path.exists(),
- "file {} was not removed as expected",
- filename
- );
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
- let backup_path = timeline_path.join(format!("{}.{}.old", filename, num));
- assert!(
- backup_path.exists(),
- "backup file {} was not created",
- backup_path.display()
- );
- };
+ assert_eq!(tline.get(TEST_KEY, Lsn(0x10))?, TEST_IMG("foo at 0x10"));
+ assert_eq!(tline.get(TEST_KEY, Lsn(0x1f))?, TEST_IMG("foo at 0x10"));
+ assert_eq!(tline.get(TEST_KEY, Lsn(0x20))?, TEST_IMG("foo at 0x20"));
+ assert_eq!(tline.get(TEST_KEY, Lsn(0x30))?, TEST_IMG("foo at 0x30"));
+ assert_eq!(tline.get(TEST_KEY, Lsn(0x40))?, TEST_IMG("foo at 0x40"));
- // These files are considered to be in the future and will be renamed out
- // of the way
- let future_filenames = vec![
- format!("pg_control_0_{:016X}", 0x8001),
- format!("pg_control_0_{:016X}_{:016X}", 0x8001, 0x8008),
- ];
- // But these are not:
- let past_filenames = vec![
- format!("pg_control_0_{:016X}", 0x8000),
- format!("pg_control_0_{:016X}_{:016X}", 0x7000, 0x8001),
- ];
+ Ok(())
+ }
- for filename in future_filenames.iter().chain(past_filenames.iter()) {
- make_empty_file(filename)?;
+ //
+ // Insert 1000 key-value pairs with increasing keys, checkpoint,
+ // repeat 50 times.
+ //
+ #[test]
+ fn test_bulk_insert() -> Result<()> {
+ let repo = RepoHarness::create("test_bulk_insert")?.load();
+ let tline = repo.create_empty_timeline(TIMELINE_ID, Lsn(0))?;
+
+ let mut lsn = Lsn(0x10);
+
+ let mut keyspace = KeySpaceAccum::new();
+
+ let mut test_key = Key::from_hex("012222222233333333444444445500000000").unwrap();
+ let mut blknum = 0;
+ for _ in 0..50 {
+ for _ in 0..1000 {
+ test_key.field6 = blknum;
+ let writer = tline.writer();
+ writer.put(
+ test_key,
+ lsn,
+ Value::Image(TEST_IMG(&format!("{} at {}", blknum, lsn))),
+ )?;
+ writer.finish_write(lsn);
+ drop(writer);
+
+ keyspace.add_key(test_key);
+
+ lsn = Lsn(lsn.0 + 0x10);
+ blknum += 1;
+ }
+
+ let cutoff = tline.get_last_record_lsn();
+ let parts = keyspace
+ .clone()
+ .to_keyspace()
+ .partition(TEST_FILE_SIZE as u64);
+ tline.hint_partitioning(parts.clone(), lsn)?;
+
+ tline.update_gc_info(Vec::new(), cutoff);
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
+ tline.gc()?;
}
- // Load the timeline. This will cause the files in the "future" to be renamed
- // away.
- let new_repo = harness.load();
- new_repo.get_timeline(TIMELINE_ID).unwrap();
- drop(new_repo);
+ Ok(())
+ }
- for filename in future_filenames.iter() {
- assert_is_renamed(filename, 0);
- }
- for filename in past_filenames.iter() {
- assert_exists(filename);
+ #[test]
+ fn test_random_updates() -> Result<()> {
+ let repo = RepoHarness::create("test_random_updates")?.load();
+ let tline = repo.create_empty_timeline(TIMELINE_ID, Lsn(0))?;
+
+ const NUM_KEYS: usize = 1000;
+
+ let mut test_key = Key::from_hex("012222222233333333444444445500000000").unwrap();
+
+ let mut keyspace = KeySpaceAccum::new();
+
+ // Track when each page was last modified. Used to assert that
+ // a read sees the latest page version.
+ let mut updated = [Lsn(0); NUM_KEYS];
+
+ let mut lsn = Lsn(0);
+ #[allow(clippy::needless_range_loop)]
+ for blknum in 0..NUM_KEYS {
+ lsn = Lsn(lsn.0 + 0x10);
+ test_key.field6 = blknum as u32;
+ let writer = tline.writer();
+ writer.put(
+ test_key,
+ lsn,
+ Value::Image(TEST_IMG(&format!("{} at {}", blknum, lsn))),
+ )?;
+ writer.finish_write(lsn);
+ updated[blknum] = lsn;
+ drop(writer);
+
+ keyspace.add_key(test_key);
}
- // Create the future files again, and load again. They should be renamed to
- // *.1.old this time.
- for filename in future_filenames.iter() {
- make_empty_file(filename)?;
+ let parts = keyspace.to_keyspace().partition(TEST_FILE_SIZE as u64);
+ tline.hint_partitioning(parts, lsn)?;
+
+ for _ in 0..50 {
+ for _ in 0..NUM_KEYS {
+ lsn = Lsn(lsn.0 + 0x10);
+ let blknum = thread_rng().gen_range(0..NUM_KEYS);
+ test_key.field6 = blknum as u32;
+ let writer = tline.writer();
+ writer.put(
+ test_key,
+ lsn,
+ Value::Image(TEST_IMG(&format!("{} at {}", blknum, lsn))),
+ )?;
+ println!("updating {} at {}", blknum, lsn);
+ writer.finish_write(lsn);
+ drop(writer);
+ updated[blknum] = lsn;
+ }
+
+ // Read all the blocks
+ for (blknum, last_lsn) in updated.iter().enumerate() {
+ test_key.field6 = blknum as u32;
+ assert_eq!(
+ tline.get(test_key, lsn)?,
+ TEST_IMG(&format!("{} at {}", blknum, last_lsn))
+ );
+ }
+
+ // Perform a cycle of checkpoint, compaction, and GC
+ println!("checkpointing {}", lsn);
+ let cutoff = tline.get_last_record_lsn();
+ tline.update_gc_info(Vec::new(), cutoff);
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
+ tline.gc()?;
}
- let new_repo = harness.load();
- new_repo.get_timeline(TIMELINE_ID).unwrap();
- drop(new_repo);
+ Ok(())
+ }
- for filename in future_filenames.iter() {
- assert_is_renamed(filename, 0);
- assert_is_renamed(filename, 1);
+ #[test]
+ fn test_traverse_branches() -> Result<()> {
+ let repo = RepoHarness::create("test_traverse_branches")?.load();
+ let mut tline = repo.create_empty_timeline(TIMELINE_ID, Lsn(0))?;
+
+ const NUM_KEYS: usize = 1000;
+
+ let mut test_key = Key::from_hex("012222222233333333444444445500000000").unwrap();
+
+ let mut keyspace = KeySpaceAccum::new();
+
+ // Track when each page was last modified. Used to assert that
+ // a read sees the latest page version.
+ let mut updated = [Lsn(0); NUM_KEYS];
+
+ let mut lsn = Lsn(0);
+ #[allow(clippy::needless_range_loop)]
+ for blknum in 0..NUM_KEYS {
+ lsn = Lsn(lsn.0 + 0x10);
+ test_key.field6 = blknum as u32;
+ let writer = tline.writer();
+ writer.put(
+ test_key,
+ lsn,
+ Value::Image(TEST_IMG(&format!("{} at {}", blknum, lsn))),
+ )?;
+ writer.finish_write(lsn);
+ updated[blknum] = lsn;
+ drop(writer);
+
+ keyspace.add_key(test_key);
}
- for filename in past_filenames.iter() {
- assert_exists(filename);
+
+ let parts = keyspace.to_keyspace().partition(TEST_FILE_SIZE as u64);
+ tline.hint_partitioning(parts, lsn)?;
+
+ let mut tline_id = TIMELINE_ID;
+ for _ in 0..50 {
+ let new_tline_id = ZTimelineId::generate();
+ repo.branch_timeline(tline_id, new_tline_id, lsn)?;
+ tline = if let RepositoryTimeline::Local { id: _, timeline } =
+ repo.get_timeline(new_tline_id)?
+ {
+ timeline
+ } else {
+ panic!("unexpected timeline state");
+ };
+ tline_id = new_tline_id;
+
+ for _ in 0..NUM_KEYS {
+ lsn = Lsn(lsn.0 + 0x10);
+ let blknum = thread_rng().gen_range(0..NUM_KEYS);
+ test_key.field6 = blknum as u32;
+ let writer = tline.writer();
+ writer.put(
+ test_key,
+ lsn,
+ Value::Image(TEST_IMG(&format!("{} at {}", blknum, lsn))),
+ )?;
+ println!("updating {} at {}", blknum, lsn);
+ writer.finish_write(lsn);
+ drop(writer);
+ updated[blknum] = lsn;
+ }
+
+ // Read all the blocks
+ for (blknum, last_lsn) in updated.iter().enumerate() {
+ test_key.field6 = blknum as u32;
+ assert_eq!(
+ tline.get(test_key, lsn)?,
+ TEST_IMG(&format!("{} at {}", blknum, last_lsn))
+ );
+ }
+
+ // Perform a cycle of checkpoint, compaction, and GC
+ println!("checkpointing {}", lsn);
+ let cutoff = tline.get_last_record_lsn();
+ tline.update_gc_info(Vec::new(), cutoff);
+ tline.checkpoint(CheckpointConfig::Forced)?;
+ tline.compact()?;
+ tline.gc()?;
}
Ok(())
diff --git a/pageserver/src/layered_repository/delta_layer.rs b/pageserver/src/layered_repository/delta_layer.rs
index 7434b8de11..56fd86b4c0 100644
--- a/pageserver/src/layered_repository/delta_layer.rs
+++ b/pageserver/src/layered_repository/delta_layer.rs
@@ -1,6 +1,5 @@
-//!
//! A DeltaLayer represents a collection of WAL records or page images in a range of
-//! LSNs, for one segment. It is stored on a file on disk.
+//! LSNs, and in a range of Keys. It is stored on a file on disk.
//!
//! Usually a delta layer only contains differences - in the form of WAL records against
//! a base LSN. However, if a segment is newly created, by creating a new relation or
@@ -11,84 +10,76 @@
//! can happen when you create a new branch in the middle of a delta layer, and the WAL
//! records on the new branch are put in a new delta layer.
//!
-//! When a delta file needs to be accessed, we slurp the metadata and segsize chapters
+//! When a delta file needs to be accessed, we slurp the 'index' metadata
//! into memory, into the DeltaLayerInner struct. See load() and unload() functions.
-//! To access a page/WAL record, we search `page_version_metas` for the block # and LSN.
-//! The byte ranges in the metadata can be used to find the page/WAL record in
-//! PAGE_VERSIONS_CHAPTER.
+//! To access a particular value, we search `index` for the given key.
+//! The byte offset in the index can be used to find the value in
+//! VALUES_CHAPTER.
//!
//! On disk, the delta files are stored in timelines/ directory.
//! Currently, there are no subdirectories, and each delta file is named like this:
//!
-//! ______
+//! -__- page/WAL record
+/// byte ranges in VALUES_CHAPTER
+static INDEX_CHAPTER: u64 = 1;
-/// Mapping from (block #, lsn) -> page/WAL record
-/// byte ranges in PAGE_VERSIONS_CHAPTER
-static PAGE_VERSION_METAS_CHAPTER: u64 = 1;
/// Page/WAL bytes - cannot be interpreted
-/// without PAGE_VERSION_METAS_CHAPTER
-static PAGE_VERSIONS_CHAPTER: u64 = 2;
-static SEG_SIZES_CHAPTER: u64 = 3;
+/// without the page versions from the INDEX_CHAPTER
+static VALUES_CHAPTER: u64 = 2;
/// Contains the [`Summary`] struct
-static SUMMARY_CHAPTER: u64 = 4;
+static SUMMARY_CHAPTER: u64 = 3;
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct Summary {
tenantid: ZTenantId,
timelineid: ZTimelineId,
- seg: SegmentTag,
-
- start_lsn: Lsn,
- end_lsn: Lsn,
-
- dropped: bool,
+ key_range: Range,
+ lsn_range: Range,
}
impl From<&DeltaLayer> for Summary {
@@ -96,33 +87,17 @@ impl From<&DeltaLayer> for Summary {
Self {
tenantid: layer.tenantid,
timelineid: layer.timelineid,
- seg: layer.seg,
-
- start_lsn: layer.start_lsn,
- end_lsn: layer.end_lsn,
-
- dropped: layer.dropped,
+ key_range: layer.key_range.clone(),
+ lsn_range: layer.lsn_range.clone(),
}
}
}
-#[derive(Serialize, Deserialize)]
-struct BlobRange {
- offset: u64,
- size: usize,
-}
-
-fn read_blob(reader: &BoundedReader<&'_ F>, range: &BlobRange) -> Result> {
- let mut buf = vec![0u8; range.size];
- reader.read_exact_at(&mut buf, range.offset)?;
- Ok(buf)
-}
-
///
/// DeltaLayer is the in-memory data structure associated with an
/// on-disk delta file. We keep a DeltaLayer in memory for each
/// file, in the LayerMap. If a layer is in "loaded" state, we have a
-/// copy of the file in memory, in 'inner'. Otherwise the struct is
+/// copy of the index in memory, in 'inner'. Otherwise the struct is
/// just a placeholder for a file that exists on disk, and it needs to
/// be loaded before using it in queries.
///
@@ -131,47 +106,24 @@ pub struct DeltaLayer {
pub tenantid: ZTenantId,
pub timelineid: ZTimelineId,
- pub seg: SegmentTag,
+ pub key_range: Range,
+ pub lsn_range: Range,
- //
- // This entry contains all the changes from 'start_lsn' to 'end_lsn'. The
- // start is inclusive, and end is exclusive.
- //
- pub start_lsn: Lsn,
- pub end_lsn: Lsn,
-
- dropped: bool,
-
- inner: Mutex,
+ inner: RwLock,
}
pub struct DeltaLayerInner {
- /// If false, the 'page_version_metas' and 'seg_sizes' have not been
- /// loaded into memory yet.
+ /// If false, the 'index' has not been loaded into memory yet.
loaded: bool,
+ ///
+ /// All versions of all pages in the layer are kept here.
+ /// Indexed by block number and LSN. The value is an offset into the
+ /// chapter where the page version is stored.
+ ///
+ index: HashMap>,
+
book: Option>,
-
- /// All versions of all pages in the file are are kept here.
- /// Indexed by block number and LSN.
- page_version_metas: VecMap<(SegmentBlk, Lsn), BlobRange>,
-
- /// `seg_sizes` tracks the size of the segment at different points in time.
- seg_sizes: VecMap,
-}
-
-impl DeltaLayerInner {
- fn get_seg_size(&self, lsn: Lsn) -> Result {
- // Scan the VecMap backwards, starting from the given entry.
- let slice = self
- .seg_sizes
- .slice_range((Included(&Lsn(0)), Included(&lsn)));
- if let Some((_entry_lsn, entry)) = slice.last() {
- Ok(*entry)
- } else {
- bail!("could not find seg size in delta layer")
- }
- }
}
impl Layer for DeltaLayer {
@@ -183,132 +135,93 @@ impl Layer for DeltaLayer {
self.timelineid
}
- fn get_seg_tag(&self) -> SegmentTag {
- self.seg
+ fn get_key_range(&self) -> Range {
+ self.key_range.clone()
}
- fn is_dropped(&self) -> bool {
- self.dropped
- }
-
- fn get_start_lsn(&self) -> Lsn {
- self.start_lsn
- }
-
- fn get_end_lsn(&self) -> Lsn {
- self.end_lsn
+ fn get_lsn_range(&self) -> Range {
+ self.lsn_range.clone()
}
fn filename(&self) -> PathBuf {
PathBuf::from(self.layer_name().to_string())
}
- /// Look up given page in the cache.
- fn get_page_reconstruct_data(
+ fn get_value_reconstruct_data(
&self,
- blknum: SegmentBlk,
- lsn: Lsn,
- reconstruct_data: &mut PageReconstructData,
- ) -> Result {
+ key: Key,
+ lsn_range: Range,
+ reconstruct_state: &mut ValueReconstructState,
+ ) -> Result {
let mut need_image = true;
- assert!((0..RELISH_SEG_SIZE).contains(&blknum));
-
- match &reconstruct_data.page_img {
- Some((cached_lsn, _)) if &self.end_lsn <= cached_lsn => {
- return Ok(PageReconstructResult::Complete)
- }
- _ => {}
- }
+ assert!(self.key_range.contains(&key));
{
// Open the file and lock the metadata in memory
let inner = self.load()?;
- let page_version_reader = inner
+ let values_reader = inner
.book
.as_ref()
.expect("should be loaded in load call above")
- .chapter_reader(PAGE_VERSIONS_CHAPTER)?;
+ .chapter_reader(VALUES_CHAPTER)?;
- // Scan the metadata VecMap backwards, starting from the given entry.
- let minkey = (blknum, Lsn(0));
- let maxkey = (blknum, lsn);
- let iter = inner
- .page_version_metas
- .slice_range((Included(&minkey), Included(&maxkey)))
- .iter()
- .rev();
- for ((_blknum, pv_lsn), blob_range) in iter {
- match &reconstruct_data.page_img {
- Some((cached_lsn, _)) if pv_lsn <= cached_lsn => {
- return Ok(PageReconstructResult::Complete)
- }
- _ => {}
- }
-
- let pv = PageVersion::des(&read_blob(&page_version_reader, blob_range)?)?;
-
- match pv {
- PageVersion::Page(img) => {
- // Found a page image, return it
- reconstruct_data.page_img = Some((*pv_lsn, img));
- need_image = false;
+ // Scan the page versions backwards, starting from `lsn`.
+ if let Some(vec_map) = inner.index.get(&key) {
+ let slice = vec_map.slice_range(lsn_range);
+ let mut size = 0usize;
+ let mut first_pos = 0u64;
+ for (_entry_lsn, blob_ref) in slice.iter().rev() {
+ size += blob_ref.size();
+ first_pos = blob_ref.pos();
+ if blob_ref.will_init() {
break;
}
- PageVersion::Wal(rec) => {
- let will_init = rec.will_init();
- reconstruct_data.records.push((*pv_lsn, rec));
- if will_init {
- // This WAL record initializes the page, so no need to go further back
- need_image = false;
- break;
+ }
+ if size != 0 {
+ let mut buf = vec![0u8; size];
+ values_reader.read_exact_at(&mut buf, first_pos)?;
+ for (entry_lsn, blob_ref) in slice.iter().rev() {
+ let offs = (blob_ref.pos() - first_pos) as usize;
+ let val = Value::des(&buf[offs..offs + blob_ref.size()])?;
+ match val {
+ Value::Image(img) => {
+ reconstruct_state.img = Some((*entry_lsn, img));
+ need_image = false;
+ break;
+ }
+ Value::WalRecord(rec) => {
+ let will_init = rec.will_init();
+ reconstruct_state.records.push((*entry_lsn, rec));
+ if will_init {
+ // This WAL record initializes the page, so no need to go further back
+ need_image = false;
+ break;
+ }
+ }
}
}
}
}
-
- // If we didn't find any records for this, check if the request is beyond EOF
- if need_image
- && reconstruct_data.records.is_empty()
- && self.seg.rel.is_blocky()
- && blknum >= inner.get_seg_size(lsn)?
- {
- return Ok(PageReconstructResult::Missing(self.start_lsn));
- }
-
// release metadata lock and close the file
}
// If an older page image is needed to reconstruct the page, let the
// caller know.
if need_image {
- Ok(PageReconstructResult::Continue(Lsn(self.start_lsn.0 - 1)))
+ Ok(ValueReconstructResult::Continue)
} else {
- Ok(PageReconstructResult::Complete)
+ Ok(ValueReconstructResult::Complete)
}
}
- /// Get size of the relation at given LSN
- fn get_seg_size(&self, lsn: Lsn) -> Result {
- assert!(lsn >= self.start_lsn);
- ensure!(
- self.seg.rel.is_blocky(),
- "get_seg_size() called on a non-blocky rel"
- );
+ fn iter(&self) -> Box> + '_> {
+ let inner = self.load().unwrap();
- let inner = self.load()?;
- inner.get_seg_size(lsn)
- }
-
- /// Does this segment exist at given LSN?
- fn get_seg_exists(&self, lsn: Lsn) -> Result {
- // Is the requested LSN after the rel was dropped?
- if self.dropped && lsn >= self.end_lsn {
- return Ok(false);
+ match DeltaValueIter::new(inner) {
+ Ok(iter) => Box::new(iter),
+ Err(err) => Box::new(std::iter::once(Err(err))),
}
-
- // Otherwise, it exists.
- Ok(true)
}
///
@@ -316,14 +229,24 @@ impl Layer for DeltaLayer {
/// it will need to be loaded back.
///
fn unload(&self) -> Result<()> {
- let mut inner = self.inner.lock().unwrap();
- inner.page_version_metas = VecMap::default();
- inner.seg_sizes = VecMap::default();
- inner.loaded = false;
+ // FIXME: In debug mode, loading and unloading the index slows
+ // things down so much that you get timeout errors. At least
+ // with the test_parallel_copy test. So as an even more ad hoc
+ // stopgap fix for that, only unload every on average 10
+ // checkpoint cycles.
+ use rand::RngCore;
+ if rand::thread_rng().next_u32() > (u32::MAX / 10) {
+ return Ok(());
+ }
- // Note: we keep the Book open. Is that a good idea? The virtual file
- // machinery has its own rules for closing the file descriptor if it's not
- // needed, but the Book struct uses up some memory, too.
+ if let Ok(mut inner) = self.inner.try_write() {
+ inner.index = HashMap::default();
+ inner.loaded = false;
+
+ // Note: we keep the Book open. Is that a good idea? The virtual file
+ // machinery has its own rules for closing the file descriptor if it's not
+ // needed, but the Book struct uses up some memory, too.
+ }
Ok(())
}
@@ -345,45 +268,52 @@ impl Layer for DeltaLayer {
/// debugging function to print out the contents of the layer
fn dump(&self) -> Result<()> {
println!(
- "----- delta layer for ten {} tli {} seg {} {}-{} ----",
- self.tenantid, self.timelineid, self.seg, self.start_lsn, self.end_lsn
+ "----- delta layer for ten {} tli {} keys {}-{} lsn {}-{} ----",
+ self.tenantid,
+ self.timelineid,
+ self.key_range.start,
+ self.key_range.end,
+ self.lsn_range.start,
+ self.lsn_range.end
);
- println!("--- seg sizes ---");
let inner = self.load()?;
- for (k, v) in inner.seg_sizes.as_slice() {
- println!(" {}: {}", k, v);
- }
- println!("--- page versions ---");
let path = self.path();
let file = std::fs::File::open(&path)?;
let book = Book::new(file)?;
+ let chapter = book.chapter_reader(VALUES_CHAPTER)?;
- let chapter = book.chapter_reader(PAGE_VERSIONS_CHAPTER)?;
- for ((blk, lsn), blob_range) in inner.page_version_metas.as_slice() {
- let mut desc = String::new();
+ let mut values: Vec<(&Key, &VecMap)> = inner.index.iter().collect();
+ values.sort_by_key(|k| k.0);
- let buf = read_blob(&chapter, blob_range)?;
- let pv = PageVersion::des(&buf)?;
+ for (key, versions) in values {
+ for (lsn, blob_ref) in versions.as_slice() {
+ let mut desc = String::new();
+ let mut buf = vec![0u8; blob_ref.size()];
+ chapter.read_exact_at(&mut buf, blob_ref.pos())?;
+ let val = Value::des(&buf);
- match pv {
- PageVersion::Page(img) => {
- write!(&mut desc, " img {} bytes", img.len())?;
- }
- PageVersion::Wal(rec) => {
- let wal_desc = walrecord::describe_wal_record(&rec);
- write!(
- &mut desc,
- " rec {} bytes will_init: {} {}",
- blob_range.size,
- rec.will_init(),
- wal_desc
- )?;
+ match val {
+ Ok(Value::Image(img)) => {
+ write!(&mut desc, " img {} bytes", img.len())?;
+ }
+ Ok(Value::WalRecord(rec)) => {
+ let wal_desc = walrecord::describe_wal_record(&rec);
+ write!(
+ &mut desc,
+ " rec {} bytes will_init: {} {}",
+ buf.len(),
+ rec.will_init(),
+ wal_desc
+ )?;
+ }
+ Err(err) => {
+ write!(&mut desc, " DESERIALIZATION ERROR: {}", err)?;
+ }
}
+ println!(" key {} at {}: {}", key, lsn, desc);
}
-
- println!(" blk {} at {}: {}", blk, lsn, desc);
}
Ok(())
@@ -408,61 +338,61 @@ impl DeltaLayer {
///
/// Load the contents of the file into memory
///
- fn load(&self) -> Result> {
- // quick exit if already loaded
- let mut inner = self.inner.lock().unwrap();
+ fn load(&self) -> Result> {
+ loop {
+ // quick exit if already loaded
+ {
+ let inner = self.inner.read().unwrap();
- if inner.loaded {
- return Ok(inner);
- }
-
- let path = self.path();
-
- // Open the file if it's not open already.
- if inner.book.is_none() {
- let file = VirtualFile::open(&path)?;
- inner.book = Some(Book::new(file)?);
- }
- let book = inner.book.as_ref().unwrap();
-
- match &self.path_or_conf {
- PathOrConf::Conf(_) => {
- let chapter = book.read_chapter(SUMMARY_CHAPTER)?;
- let actual_summary = Summary::des(&chapter)?;
-
- let expected_summary = Summary::from(self);
-
- if actual_summary != expected_summary {
- bail!("in-file summary does not match expected summary. actual = {:?} expected = {:?}", actual_summary, expected_summary);
+ if inner.loaded {
+ return Ok(inner);
}
}
- PathOrConf::Path(path) => {
- let actual_filename = Path::new(path.file_name().unwrap());
- let expected_filename = self.filename();
+ // need to upgrade to write lock
+ let mut inner = self.inner.write().unwrap();
- if actual_filename != expected_filename {
- println!(
- "warning: filename does not match what is expected from in-file summary"
- );
- println!("actual: {:?}", actual_filename);
- println!("expected: {:?}", expected_filename);
+ let path = self.path();
+
+ // Open the file if it's not open already.
+ if inner.book.is_none() {
+ let file = VirtualFile::open(&path)?;
+ inner.book = Some(Book::new(file)?);
+ }
+ let book = inner.book.as_ref().unwrap();
+
+ match &self.path_or_conf {
+ PathOrConf::Conf(_) => {
+ let chapter = book.read_chapter(SUMMARY_CHAPTER)?;
+ let actual_summary = Summary::des(&chapter)?;
+
+ let expected_summary = Summary::from(self);
+
+ if actual_summary != expected_summary {
+ bail!("in-file summary does not match expected summary. actual = {:?} expected = {:?}", actual_summary, expected_summary);
+ }
+ }
+ PathOrConf::Path(path) => {
+ let actual_filename = Path::new(path.file_name().unwrap());
+ let expected_filename = self.filename();
+
+ if actual_filename != expected_filename {
+ println!(
+ "warning: filename does not match what is expected from in-file summary"
+ );
+ println!("actual: {:?}", actual_filename);
+ println!("expected: {:?}", expected_filename);
+ }
}
}
+
+ let chapter = book.read_chapter(INDEX_CHAPTER)?;
+ let index = HashMap::des(&chapter)?;
+
+ debug!("loaded from {}", &path.display());
+
+ inner.index = index;
+ inner.loaded = true;
}
-
- let chapter = book.read_chapter(PAGE_VERSION_METAS_CHAPTER)?;
- let page_version_metas = VecMap::des(&chapter)?;
-
- let chapter = book.read_chapter(SEG_SIZES_CHAPTER)?;
- let seg_sizes = VecMap::des(&chapter)?;
-
- debug!("loaded from {}", &path.display());
-
- inner.page_version_metas = page_version_metas;
- inner.seg_sizes = seg_sizes;
- inner.loaded = true;
-
- Ok(inner)
}
/// Create a DeltaLayer struct representing an existing file on disk.
@@ -476,15 +406,12 @@ impl DeltaLayer {
path_or_conf: PathOrConf::Conf(conf),
timelineid,
tenantid,
- seg: filename.seg,
- start_lsn: filename.start_lsn,
- end_lsn: filename.end_lsn,
- dropped: filename.dropped,
- inner: Mutex::new(DeltaLayerInner {
+ key_range: filename.key_range.clone(),
+ lsn_range: filename.lsn_range.clone(),
+ inner: RwLock::new(DeltaLayerInner {
loaded: false,
book: None,
- page_version_metas: VecMap::default(),
- seg_sizes: VecMap::default(),
+ index: HashMap::default(),
}),
}
}
@@ -494,7 +421,7 @@ impl DeltaLayer {
/// This variant is only used for debugging purposes, by the 'dump_layerfile' binary.
pub fn new_for_path(path: &Path, book: &Book) -> Result
where
- F: std::os::unix::prelude::FileExt,
+ F: FileExt,
{
let chapter = book.read_chapter(SUMMARY_CHAPTER)?;
let summary = Summary::des(&chapter)?;
@@ -503,25 +430,20 @@ impl DeltaLayer {
path_or_conf: PathOrConf::Path(path.to_path_buf()),
timelineid: summary.timelineid,
tenantid: summary.tenantid,
- seg: summary.seg,
- start_lsn: summary.start_lsn,
- end_lsn: summary.end_lsn,
- dropped: summary.dropped,
- inner: Mutex::new(DeltaLayerInner {
+ key_range: summary.key_range,
+ lsn_range: summary.lsn_range,
+ inner: RwLock::new(DeltaLayerInner {
loaded: false,
book: None,
- page_version_metas: VecMap::default(),
- seg_sizes: VecMap::default(),
+ index: HashMap::default(),
}),
})
}
fn layer_name(&self) -> DeltaFileName {
DeltaFileName {
- seg: self.seg,
- start_lsn: self.start_lsn,
- end_lsn: self.end_lsn,
- dropped: self.dropped,
+ key_range: self.key_range.clone(),
+ lsn_range: self.lsn_range.clone(),
}
}
@@ -542,24 +464,24 @@ impl DeltaLayer {
///
/// 1. Create the DeltaLayerWriter by calling DeltaLayerWriter::new(...)
///
-/// 2. Write the contents by calling `put_page_version` for every page
+/// 2. Write the contents by calling `put_value` for every page
/// version to store in the layer.
///
/// 3. Call `finish`.
///
pub struct DeltaLayerWriter {
conf: &'static PageServerConf,
+ path: PathBuf,
timelineid: ZTimelineId,
tenantid: ZTenantId,
- seg: SegmentTag,
- start_lsn: Lsn,
- end_lsn: Lsn,
- dropped: bool,
- page_version_writer: ChapterWriter>,
- pv_offset: u64,
+ key_start: Key,
+ lsn_range: Range,
- page_version_metas: VecMap<(SegmentBlk, Lsn), BlobRange>,
+ index: HashMap>,
+
+ values_writer: ChapterWriter>,
+ end_offset: u64,
}
impl DeltaLayerWriter {
@@ -570,94 +492,88 @@ impl DeltaLayerWriter {
conf: &'static PageServerConf,
timelineid: ZTimelineId,
tenantid: ZTenantId,
- seg: SegmentTag,
- start_lsn: Lsn,
- end_lsn: Lsn,
- dropped: bool,
+ key_start: Key,
+ lsn_range: Range,
) -> Result {
// Create the file
//
// Note: This overwrites any existing file. There shouldn't be any.
// FIXME: throw an error instead?
- let path = DeltaLayer::path_for(
- &PathOrConf::Conf(conf),
- timelineid,
- tenantid,
- &DeltaFileName {
- seg,
- start_lsn,
- end_lsn,
- dropped,
- },
- );
+
+ let path = conf.timeline_path(&timelineid, &tenantid).join(format!(
+ "{}-XXX__{:016X}-{:016X}.temp",
+ key_start,
+ u64::from(lsn_range.start),
+ u64::from(lsn_range.end)
+ ));
+ info!("temp deltalayer path {}", path.display());
let file = VirtualFile::create(&path)?;
let buf_writer = BufWriter::new(file);
let book = BookWriter::new(buf_writer, DELTA_FILE_MAGIC)?;
// Open the page-versions chapter for writing. The calls to
- // `put_page_version` will use this to write the contents.
- let page_version_writer = book.new_chapter(PAGE_VERSIONS_CHAPTER);
+ // `put_value` will use this to write the contents.
+ let values_writer = book.new_chapter(VALUES_CHAPTER);
Ok(DeltaLayerWriter {
conf,
+ path,
timelineid,
tenantid,
- seg,
- start_lsn,
- end_lsn,
- dropped,
- page_version_writer,
- page_version_metas: VecMap::default(),
- pv_offset: 0,
+ key_start,
+ lsn_range,
+ index: HashMap::new(),
+ values_writer,
+ end_offset: 0,
})
}
///
- /// Append a page version to the file.
+ /// Append a key-value pair to the file.
///
- /// 'buf' is a serialized PageVersion.
- /// The page versions must be appended in blknum, lsn order.
+ /// The values must be appended in key, lsn order.
///
- pub fn put_page_version(&mut self, blknum: SegmentBlk, lsn: Lsn, buf: &[u8]) -> Result<()> {
+ pub fn put_value(&mut self, key: Key, lsn: Lsn, val: Value) -> Result<()> {
+ //info!("DELTA: key {} at {} on {}", key, lsn, self.path.display());
+ assert!(self.lsn_range.start <= lsn);
// Remember the offset and size metadata. The metadata is written
// to a separate chapter, in `finish`.
- let blob_range = BlobRange {
- offset: self.pv_offset,
- size: buf.len(),
- };
- self.page_version_metas
- .append((blknum, lsn), blob_range)
- .unwrap();
-
- // write the page version
- self.page_version_writer.write_all(buf)?;
- self.pv_offset += buf.len() as u64;
+ let off = self.end_offset;
+ let buf = Value::ser(&val)?;
+ let len = buf.len();
+ self.values_writer.write_all(&buf)?;
+ self.end_offset += len as u64;
+ let vec_map = self.index.entry(key).or_default();
+ let blob_ref = BlobRef::new(off, len, val.will_init());
+ let old = vec_map.append_or_update_last(lsn, blob_ref).unwrap().0;
+ if old.is_some() {
+ // We already had an entry for this LSN. That's odd..
+ bail!(
+ "Value for {} at {} already exists in delta layer being built",
+ key,
+ lsn
+ );
+ }
Ok(())
}
+ pub fn size(&self) -> u64 {
+ self.end_offset
+ }
+
///
/// Finish writing the delta layer.
///
/// 'seg_sizes' is a list of size changes to store with the actual data.
///
- pub fn finish(self, seg_sizes: VecMap) -> Result {
- // Close the page-versions chapter
- let book = self.page_version_writer.close()?;
+ pub fn finish(self, key_end: Key) -> Result {
+ // Close the values chapter
+ let book = self.values_writer.close()?;
- // Write out page versions metadata
- let mut chapter = book.new_chapter(PAGE_VERSION_METAS_CHAPTER);
- let buf = VecMap::ser(&self.page_version_metas)?;
- chapter.write_all(&buf)?;
- let book = chapter.close()?;
-
- if self.seg.rel.is_blocky() {
- assert!(!seg_sizes.is_empty());
- }
-
- // and seg_sizes to separate chapter
- let mut chapter = book.new_chapter(SEG_SIZES_CHAPTER);
- let buf = VecMap::ser(&seg_sizes)?;
+ // Write out the index
+ let mut chapter = book.new_chapter(INDEX_CHAPTER);
+ let buf = HashMap::ser(&self.index)?;
chapter.write_all(&buf)?;
let book = chapter.close()?;
@@ -665,12 +581,8 @@ impl DeltaLayerWriter {
let summary = Summary {
tenantid: self.tenantid,
timelineid: self.timelineid,
- seg: self.seg,
-
- start_lsn: self.start_lsn,
- end_lsn: self.end_lsn,
-
- dropped: self.dropped,
+ key_range: self.key_start..key_end,
+ lsn_range: self.lsn_range.clone(),
};
Summary::ser_into(&summary, &mut chapter)?;
let book = chapter.close()?;
@@ -685,20 +597,111 @@ impl DeltaLayerWriter {
path_or_conf: PathOrConf::Conf(self.conf),
tenantid: self.tenantid,
timelineid: self.timelineid,
- seg: self.seg,
- start_lsn: self.start_lsn,
- end_lsn: self.end_lsn,
- dropped: self.dropped,
- inner: Mutex::new(DeltaLayerInner {
+ key_range: self.key_start..key_end,
+ lsn_range: self.lsn_range.clone(),
+ inner: RwLock::new(DeltaLayerInner {
loaded: false,
+ index: HashMap::new(),
book: None,
- page_version_metas: VecMap::default(),
- seg_sizes: VecMap::default(),
}),
};
- trace!("created delta layer {}", &layer.path().display());
+ // Rename the file to its final name
+ //
+ // Note: This overwrites any existing file. There shouldn't be any.
+ // FIXME: throw an error instead?
+ let final_path = DeltaLayer::path_for(
+ &PathOrConf::Conf(self.conf),
+ self.timelineid,
+ self.tenantid,
+ &DeltaFileName {
+ key_range: self.key_start..key_end,
+ lsn_range: self.lsn_range,
+ },
+ );
+ std::fs::rename(self.path, &final_path)?;
+
+ trace!("created delta layer {}", final_path.display());
Ok(layer)
}
+
+ pub fn abort(self) {
+ match self.values_writer.close() {
+ Ok(book) => {
+ if let Err(err) = book.close() {
+ error!("error while closing delta layer file: {}", err);
+ }
+ }
+ Err(err) => {
+ error!("error while closing chapter writer: {}", err);
+ }
+ }
+ if let Err(err) = std::fs::remove_file(self.path) {
+ error!("error removing unfinished delta layer file: {}", err);
+ }
+ }
+}
+
+///
+/// Iterator over all key-value pairse stored in a delta layer
+///
+/// FIXME: This creates a Vector to hold the offsets of all key value pairs.
+/// That takes up quite a lot of memory. Should do this in a more streaming
+/// fashion.
+///
+struct DeltaValueIter {
+ all_offsets: Vec<(Key, Lsn, BlobRef)>,
+ next_idx: usize,
+ data: Vec,
+}
+
+impl Iterator for DeltaValueIter {
+ type Item = Result<(Key, Lsn, Value)>;
+
+ fn next(&mut self) -> Option {
+ self.next_res().transpose()
+ }
+}
+
+impl DeltaValueIter {
+ fn new(inner: RwLockReadGuard) -> Result {
+ let mut index: Vec<(&Key, &VecMap)> = inner.index.iter().collect();
+ index.sort_by_key(|x| x.0);
+
+ let mut all_offsets: Vec<(Key, Lsn, BlobRef)> = Vec::new();
+ for (key, vec_map) in index.iter() {
+ for (lsn, blob_ref) in vec_map.as_slice().iter() {
+ all_offsets.push((**key, *lsn, *blob_ref));
+ }
+ }
+
+ let values_reader = inner
+ .book
+ .as_ref()
+ .expect("should be loaded in load call above")
+ .chapter_reader(VALUES_CHAPTER)?;
+ let file_size = values_reader.len() as usize;
+ let mut layer = DeltaValueIter {
+ all_offsets,
+ next_idx: 0,
+ data: vec![0u8; file_size],
+ };
+ values_reader.read_exact_at(&mut layer.data, 0)?;
+
+ Ok(layer)
+ }
+
+ fn next_res(&mut self) -> Result> {
+ if self.next_idx < self.all_offsets.len() {
+ let (key, lsn, blob_ref) = self.all_offsets[self.next_idx];
+ let offs = blob_ref.pos() as usize;
+ let size = blob_ref.size();
+ let val = Value::des(&self.data[offs..offs + size])?;
+ self.next_idx += 1;
+ Ok(Some((key, lsn, val)))
+ } else {
+ Ok(None)
+ }
+ }
}
diff --git a/pageserver/src/layered_repository/filename.rs b/pageserver/src/layered_repository/filename.rs
index df23700dfd..cd63f014c4 100644
--- a/pageserver/src/layered_repository/filename.rs
+++ b/pageserver/src/layered_repository/filename.rs
@@ -2,29 +2,52 @@
//! Helper functions for dealing with filenames of the image and delta layer files.
//!
use crate::config::PageServerConf;
-use crate::layered_repository::storage_layer::SegmentTag;
-use crate::relish::*;
+use crate::repository::Key;
+use std::cmp::Ordering;
use std::fmt;
+use std::ops::Range;
use std::path::PathBuf;
use zenith_utils::lsn::Lsn;
// Note: LayeredTimeline::load_layer_map() relies on this sort order
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DeltaFileName {
- pub seg: SegmentTag,
- pub start_lsn: Lsn,
- pub end_lsn: Lsn,
- pub dropped: bool,
+ pub key_range: Range,
+ pub lsn_range: Range,
+}
+
+impl PartialOrd for DeltaFileName {
+ fn partial_cmp(&self, other: &Self) -> Option {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for DeltaFileName {
+ fn cmp(&self, other: &Self) -> Ordering {
+ let mut cmp;
+
+ cmp = self.key_range.start.cmp(&other.key_range.start);
+ if cmp != Ordering::Equal {
+ return cmp;
+ }
+ cmp = self.key_range.end.cmp(&other.key_range.end);
+ if cmp != Ordering::Equal {
+ return cmp;
+ }
+ cmp = self.lsn_range.start.cmp(&other.lsn_range.start);
+ if cmp != Ordering::Equal {
+ return cmp;
+ }
+ cmp = self.lsn_range.end.cmp(&other.lsn_range.end);
+
+ cmp
+ }
}
/// Represents the filename of a DeltaLayer
///
-/// ______
-///
-/// or if it was dropped:
-///
-/// _______DROPPED
+/// -__-
///
impl DeltaFileName {
///
@@ -32,234 +55,123 @@ impl DeltaFileName {
/// match the expected pattern.
///
pub fn parse_str(fname: &str) -> Option {
- let rel;
- let mut parts;
- if let Some(rest) = fname.strip_prefix("rel_") {
- parts = rest.split('_');
- rel = RelishTag::Relation(RelTag {
- spcnode: parts.next()?.parse::().ok()?,
- dbnode: parts.next()?.parse::().ok()?,
- relnode: parts.next()?.parse::().ok()?,
- forknum: parts.next()?.parse::().ok()?,
- });
- } else if let Some(rest) = fname.strip_prefix("pg_xact_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::Clog,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_multixact_members_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::MultiXactMembers,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_multixact_offsets_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::MultiXactOffsets,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_filenodemap_") {
- parts = rest.split('_');
- rel = RelishTag::FileNodeMap {
- spcnode: parts.next()?.parse::().ok()?,
- dbnode: parts.next()?.parse::().ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_twophase_") {
- parts = rest.split('_');
- rel = RelishTag::TwoPhase {
- xid: parts.next()?.parse::().ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_control_checkpoint_") {
- parts = rest.split('_');
- rel = RelishTag::Checkpoint;
- } else if let Some(rest) = fname.strip_prefix("pg_control_") {
- parts = rest.split('_');
- rel = RelishTag::ControlFile;
- } else {
+ let mut parts = fname.split("__");
+ let mut key_parts = parts.next()?.split('-');
+ let mut lsn_parts = parts.next()?.split('-');
+
+ let key_start_str = key_parts.next()?;
+ let key_end_str = key_parts.next()?;
+ let lsn_start_str = lsn_parts.next()?;
+ let lsn_end_str = lsn_parts.next()?;
+ if parts.next().is_some() || key_parts.next().is_some() || key_parts.next().is_some() {
return None;
}
- let segno = parts.next()?.parse::().ok()?;
+ let key_start = Key::from_hex(key_start_str).ok()?;
+ let key_end = Key::from_hex(key_end_str).ok()?;
- let seg = SegmentTag { rel, segno };
+ let start_lsn = Lsn::from_hex(lsn_start_str).ok()?;
+ let end_lsn = Lsn::from_hex(lsn_end_str).ok()?;
- let start_lsn = Lsn::from_hex(parts.next()?).ok()?;
- let end_lsn = Lsn::from_hex(parts.next()?).ok()?;
-
- let mut dropped = false;
- if let Some(suffix) = parts.next() {
- if suffix == "DROPPED" {
- dropped = true;
- } else {
- return None;
- }
- }
- if parts.next().is_some() {
+ if start_lsn >= end_lsn {
return None;
+ // or panic?
+ }
+
+ if key_start >= key_end {
+ return None;
+ // or panic?
}
Some(DeltaFileName {
- seg,
- start_lsn,
- end_lsn,
- dropped,
+ key_range: key_start..key_end,
+ lsn_range: start_lsn..end_lsn,
})
}
}
impl fmt::Display for DeltaFileName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let basename = match self.seg.rel {
- RelishTag::Relation(reltag) => format!(
- "rel_{}_{}_{}_{}",
- reltag.spcnode, reltag.dbnode, reltag.relnode, reltag.forknum
- ),
- RelishTag::Slru {
- slru: SlruKind::Clog,
- segno,
- } => format!("pg_xact_{:04X}", segno),
- RelishTag::Slru {
- slru: SlruKind::MultiXactMembers,
- segno,
- } => format!("pg_multixact_members_{:04X}", segno),
- RelishTag::Slru {
- slru: SlruKind::MultiXactOffsets,
- segno,
- } => format!("pg_multixact_offsets_{:04X}", segno),
- RelishTag::FileNodeMap { spcnode, dbnode } => {
- format!("pg_filenodemap_{}_{}", spcnode, dbnode)
- }
- RelishTag::TwoPhase { xid } => format!("pg_twophase_{}", xid),
- RelishTag::Checkpoint => "pg_control_checkpoint".to_string(),
- RelishTag::ControlFile => "pg_control".to_string(),
- };
-
write!(
f,
- "{}_{}_{:016X}_{:016X}{}",
- basename,
- self.seg.segno,
- u64::from(self.start_lsn),
- u64::from(self.end_lsn),
- if self.dropped { "_DROPPED" } else { "" }
+ "{}-{}__{:016X}-{:016X}",
+ self.key_range.start,
+ self.key_range.end,
+ u64::from(self.lsn_range.start),
+ u64::from(self.lsn_range.end),
)
}
}
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ImageFileName {
- pub seg: SegmentTag,
+ pub key_range: Range,
pub lsn: Lsn,
}
+impl PartialOrd for ImageFileName {
+ fn partial_cmp(&self, other: &Self) -> Option {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for ImageFileName {
+ fn cmp(&self, other: &Self) -> Ordering {
+ let mut cmp;
+
+ cmp = self.key_range.start.cmp(&other.key_range.start);
+ if cmp != Ordering::Equal {
+ return cmp;
+ }
+ cmp = self.key_range.end.cmp(&other.key_range.end);
+ if cmp != Ordering::Equal {
+ return cmp;
+ }
+ cmp = self.lsn.cmp(&other.lsn);
+
+ cmp
+ }
+}
+
///
/// Represents the filename of an ImageLayer
///
-/// _____
-///
+/// -__
impl ImageFileName {
///
/// Parse a string as an image file name. Returns None if the filename does not
/// match the expected pattern.
///
pub fn parse_str(fname: &str) -> Option {
- let rel;
- let mut parts;
- if let Some(rest) = fname.strip_prefix("rel_") {
- parts = rest.split('_');
- rel = RelishTag::Relation(RelTag {
- spcnode: parts.next()?.parse::().ok()?,
- dbnode: parts.next()?.parse::().ok()?,
- relnode: parts.next()?.parse::().ok()?,
- forknum: parts.next()?.parse::().ok()?,
- });
- } else if let Some(rest) = fname.strip_prefix("pg_xact_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::Clog,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_multixact_members_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::MultiXactMembers,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_multixact_offsets_") {
- parts = rest.split('_');
- rel = RelishTag::Slru {
- slru: SlruKind::MultiXactOffsets,
- segno: u32::from_str_radix(parts.next()?, 16).ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_filenodemap_") {
- parts = rest.split('_');
- rel = RelishTag::FileNodeMap {
- spcnode: parts.next()?.parse::().ok()?,
- dbnode: parts.next()?.parse::().ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_twophase_") {
- parts = rest.split('_');
- rel = RelishTag::TwoPhase {
- xid: parts.next()?.parse::().ok()?,
- };
- } else if let Some(rest) = fname.strip_prefix("pg_control_checkpoint_") {
- parts = rest.split('_');
- rel = RelishTag::Checkpoint;
- } else if let Some(rest) = fname.strip_prefix("pg_control_") {
- parts = rest.split('_');
- rel = RelishTag::ControlFile;
- } else {
+ let mut parts = fname.split("__");
+ let mut key_parts = parts.next()?.split('-');
+
+ let key_start_str = key_parts.next()?;
+ let key_end_str = key_parts.next()?;
+ let lsn_str = parts.next()?;
+ if parts.next().is_some() || key_parts.next().is_some() {
return None;
}
- let segno = parts.next()?.parse::().ok()?;
+ let key_start = Key::from_hex(key_start_str).ok()?;
+ let key_end = Key::from_hex(key_end_str).ok()?;
- let seg = SegmentTag { rel, segno };
+ let lsn = Lsn::from_hex(lsn_str).ok()?;
- let lsn = Lsn::from_hex(parts.next()?).ok()?;
-
- if parts.next().is_some() {
- return None;
- }
-
- Some(ImageFileName { seg, lsn })
+ Some(ImageFileName {
+ key_range: key_start..key_end,
+ lsn,
+ })
}
}
impl fmt::Display for ImageFileName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let basename = match self.seg.rel {
- RelishTag::Relation(reltag) => format!(
- "rel_{}_{}_{}_{}",
- reltag.spcnode, reltag.dbnode, reltag.relnode, reltag.forknum
- ),
- RelishTag::Slru {
- slru: SlruKind::Clog,
- segno,
- } => format!("pg_xact_{:04X}", segno),
- RelishTag::Slru {
- slru: SlruKind::MultiXactMembers,
- segno,
- } => format!("pg_multixact_members_{:04X}", segno),
- RelishTag::Slru {
- slru: SlruKind::MultiXactOffsets,
- segno,
- } => format!("pg_multixact_offsets_{:04X}", segno),
- RelishTag::FileNodeMap { spcnode, dbnode } => {
- format!("pg_filenodemap_{}_{}", spcnode, dbnode)
- }
- RelishTag::TwoPhase { xid } => format!("pg_twophase_{}", xid),
- RelishTag::Checkpoint => "pg_control_checkpoint".to_string(),
- RelishTag::ControlFile => "pg_control".to_string(),
- };
-
write!(
f,
- "{}_{}_{:016X}",
- basename,
- self.seg.segno,
+ "{}-{}__{:016X}",
+ self.key_range.start,
+ self.key_range.end,
u64::from(self.lsn),
)
}
diff --git a/pageserver/src/layered_repository/global_layer_map.rs b/pageserver/src/layered_repository/global_layer_map.rs
deleted file mode 100644
index 169a89650a..0000000000
--- a/pageserver/src/layered_repository/global_layer_map.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-//!
-//! Global registry of open layers.
-//!
-//! Whenever a new in-memory layer is created to hold incoming WAL, it is registered
-//! in [`GLOBAL_LAYER_MAP`], so that we can keep track of the total number of
-//! in-memory layers in the system, and know when we need to evict some to release
-//! memory.
-//!
-//! Each layer is assigned a unique ID when it's registered in the global registry.
-//! The ID can be used to relocate the layer later, without having to hold locks.
-//!
-
-use std::sync::atomic::{AtomicU8, Ordering};
-use std::sync::{Arc, RwLock};
-
-use super::inmemory_layer::InMemoryLayer;
-
-use lazy_static::lazy_static;
-
-const MAX_USAGE_COUNT: u8 = 5;
-
-lazy_static! {
- pub static ref GLOBAL_LAYER_MAP: RwLock =
- RwLock::new(InMemoryLayers::default());
-}
-
-// TODO these types can probably be smaller
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub struct LayerId {
- index: usize,
- tag: u64, // to avoid ABA problem
-}
-
-enum SlotData {
- Occupied(Arc),
- /// Vacant slots form a linked list, the value is the index
- /// of the next vacant slot in the list.
- Vacant(Option),
-}
-
-struct Slot {
- tag: u64,
- data: SlotData,
- usage_count: AtomicU8, // for clock algorithm
-}
-
-#[derive(Default)]
-pub struct InMemoryLayers {
- slots: Vec,
- num_occupied: usize,
-
- // Head of free-slot list.
- next_empty_slot_idx: Option,
-}
-
-impl InMemoryLayers {
- pub fn insert(&mut self, layer: Arc) -> LayerId {
- let slot_idx = match self.next_empty_slot_idx {
- Some(slot_idx) => slot_idx,
- None => {
- let idx = self.slots.len();
- self.slots.push(Slot {
- tag: 0,
- data: SlotData::Vacant(None),
- usage_count: AtomicU8::new(0),
- });
- idx
- }
- };
- let slots_len = self.slots.len();
-
- let slot = &mut self.slots[slot_idx];
-
- match slot.data {
- SlotData::Occupied(_) => {
- panic!("an occupied slot was in the free list");
- }
- SlotData::Vacant(next_empty_slot_idx) => {
- self.next_empty_slot_idx = next_empty_slot_idx;
- }
- }
-
- slot.data = SlotData::Occupied(layer);
- slot.usage_count.store(1, Ordering::Relaxed);
-
- self.num_occupied += 1;
- assert!(self.num_occupied <= slots_len);
-
- LayerId {
- index: slot_idx,
- tag: slot.tag,
- }
- }
-
- pub fn get(&self, layer_id: &LayerId) -> Option> {
- let slot = self.slots.get(layer_id.index)?; // TODO should out of bounds indexes just panic?
- if slot.tag != layer_id.tag {
- return None;
- }
-
- if let SlotData::Occupied(layer) = &slot.data {
- let _ = slot.usage_count.fetch_update(
- Ordering::Relaxed,
- Ordering::Relaxed,
- |old_usage_count| {
- if old_usage_count < MAX_USAGE_COUNT {
- Some(old_usage_count + 1)
- } else {
- None
- }
- },
- );
- Some(Arc::clone(layer))
- } else {
- None
- }
- }
-
- // TODO this won't be a public API in the future
- pub fn remove(&mut self, layer_id: &LayerId) {
- let slot = &mut self.slots[layer_id.index];
-
- if slot.tag != layer_id.tag {
- return;
- }
-
- match &slot.data {
- SlotData::Occupied(_layer) => {
- // TODO evict the layer
- }
- SlotData::Vacant(_) => unimplemented!(),
- }
-
- slot.data = SlotData::Vacant(self.next_empty_slot_idx);
- self.next_empty_slot_idx = Some(layer_id.index);
-
- assert!(self.num_occupied > 0);
- self.num_occupied -= 1;
-
- slot.tag = slot.tag.wrapping_add(1);
- }
-}
diff --git a/pageserver/src/layered_repository/image_layer.rs b/pageserver/src/layered_repository/image_layer.rs
index 24445ff7e9..948e5b1433 100644
--- a/pageserver/src/layered_repository/image_layer.rs
+++ b/pageserver/src/layered_repository/image_layer.rs
@@ -1,41 +1,39 @@
-//! An ImageLayer represents an image or a snapshot of a segment at one particular LSN.
-//! It is stored in a file on disk.
+//! An ImageLayer represents an image or a snapshot of a key-range at
+//! one particular LSN. It contains an image of all key-value pairs
+//! in its key-range. Any key that falls into the image layer's range
+//! but does not exist in the layer, does not exist.
//!
-//! On disk, the image files are stored in timelines/ directory.
-//! Currently, there are no subdirectories, and each image layer file is named like this:
+//! An image layer is stored in a file on disk. The file is stored in
+//! timelines/ directory. Currently, there are no
+//! subdirectories, and each image layer file is named like this:
//!
-//! Note that segno is
-//! _____
+//! -__
//!
//! For example:
//!
-//! 1663_13990_2609_0_5_000000000169C348
+//! 000000067F000032BE0000400000000070B6-000000067F000032BE0000400000000080B6__00000000346BC568
//!
//! An image file is constructed using the 'bookfile' crate.
//!
//! Only metadata is loaded into memory by the load function.
//! When images are needed, they are read directly from disk.
//!
-//! For blocky relishes, the images are stored in BLOCKY_IMAGES_CHAPTER.
-//! All the images are required to be BLOCK_SIZE, which allows for random access.
-//!
-//! For non-blocky relishes, the image can be found in NONBLOCKY_IMAGE_CHAPTER.
-//!
use crate::config::PageServerConf;
use crate::layered_repository::filename::{ImageFileName, PathOrConf};
use crate::layered_repository::storage_layer::{
- Layer, PageReconstructData, PageReconstructResult, SegmentBlk, SegmentTag,
+ BlobRef, Layer, ValueReconstructResult, ValueReconstructState,
};
-use crate::layered_repository::RELISH_SEG_SIZE;
+use crate::repository::{Key, Value};
use crate::virtual_file::VirtualFile;
use crate::{ZTenantId, ZTimelineId};
-use anyhow::{anyhow, bail, ensure, Context, Result};
+use anyhow::{bail, Context, Result};
use bytes::Bytes;
use log::*;
use serde::{Deserialize, Serialize};
-use std::convert::TryInto;
+use std::collections::HashMap;
use std::fs;
use std::io::{BufWriter, Write};
+use std::ops::Range;
use std::path::{Path, PathBuf};
use std::sync::{Mutex, MutexGuard};
@@ -44,12 +42,15 @@ use bookfile::{Book, BookWriter, ChapterWriter};
use zenith_utils::bin_ser::BeSer;
use zenith_utils::lsn::Lsn;
-// Magic constant to identify a Zenith segment image file
-pub const IMAGE_FILE_MAGIC: u32 = 0x5A616E01 + 1;
+// Magic constant to identify a Zenith image layer file
+pub const IMAGE_FILE_MAGIC: u32 = 0x5A616E11 + 1;
+
+/// Mapping from (key, lsn) -> page/WAL record
+/// byte ranges in VALUES_CHAPTER
+static INDEX_CHAPTER: u64 = 1;
/// Contains each block in block # order
-const BLOCKY_IMAGES_CHAPTER: u64 = 1;
-const NONBLOCKY_IMAGE_CHAPTER: u64 = 2;
+const VALUES_CHAPTER: u64 = 2;
/// Contains the [`Summary`] struct
const SUMMARY_CHAPTER: u64 = 3;
@@ -58,7 +59,7 @@ const SUMMARY_CHAPTER: u64 = 3;
struct Summary {
tenantid: ZTenantId,
timelineid: ZTimelineId,
- seg: SegmentTag,
+ key_range: Range,
lsn: Lsn,
}
@@ -68,19 +69,17 @@ impl From<&ImageLayer> for Summary {
Self {
tenantid: layer.tenantid,
timelineid: layer.timelineid,
- seg: layer.seg,
+ key_range: layer.key_range.clone(),
lsn: layer.lsn,
}
}
}
-const BLOCK_SIZE: usize = 8192;
-
///
/// ImageLayer is the in-memory data structure associated with an on-disk image
/// file. We keep an ImageLayer in memory for each file, in the LayerMap. If a
-/// layer is in "loaded" state, we have a copy of the file in memory, in 'inner'.
+/// layer is in "loaded" state, we have a copy of the index in memory, in 'inner'.
/// Otherwise the struct is just a placeholder for a file that exists on disk,
/// and it needs to be loaded before using it in queries.
///
@@ -88,7 +87,7 @@ pub struct ImageLayer {
path_or_conf: PathOrConf,
pub tenantid: ZTenantId,
pub timelineid: ZTimelineId,
- pub seg: SegmentTag,
+ pub key_range: Range,
// This entry contains an image of all pages as of this LSN
pub lsn: Lsn,
@@ -96,18 +95,16 @@ pub struct ImageLayer {
inner: Mutex,
}
-#[derive(Clone)]
-enum ImageType {
- Blocky { num_blocks: SegmentBlk },
- NonBlocky,
-}
-
pub struct ImageLayerInner {
- /// If None, the 'image_type' has not been loaded into memory yet.
+ /// If false, the 'index' has not been loaded into memory yet.
+ loaded: bool,
+
+ /// The underlying (virtual) file handle. None if the layer hasn't been loaded
+ /// yet.
book: Option>,
- /// Derived from filename and bookfile chapter metadata
- image_type: ImageType,
+ /// offset of each value
+ index: HashMap,
}
impl Layer for ImageLayer {
@@ -123,98 +120,78 @@ impl Layer for ImageLayer {
self.timelineid
}
- fn get_seg_tag(&self) -> SegmentTag {
- self.seg
+ fn get_key_range(&self) -> Range {
+ self.key_range.clone()
}
- fn is_dropped(&self) -> bool {
- false
- }
-
- fn get_start_lsn(&self) -> Lsn {
- self.lsn
- }
-
- fn get_end_lsn(&self) -> Lsn {
+ fn get_lsn_range(&self) -> Range {
// End-bound is exclusive
- self.lsn + 1
+ self.lsn..(self.lsn + 1)
}
/// Look up given page in the file
- fn get_page_reconstruct_data(
+ fn get_value_reconstruct_data(
&self,
- blknum: SegmentBlk,
- lsn: Lsn,
- reconstruct_data: &mut PageReconstructData,
- ) -> Result {
- assert!((0..RELISH_SEG_SIZE).contains(&blknum));
- assert!(lsn >= self.lsn);
-
- match reconstruct_data.page_img {
- Some((cached_lsn, _)) if self.lsn <= cached_lsn => {
- return Ok(PageReconstructResult::Complete)
- }
- _ => {}
- }
+ key: Key,
+ lsn_range: Range,
+ reconstruct_state: &mut ValueReconstructState,
+ ) -> Result {
+ assert!(self.key_range.contains(&key));
+ assert!(lsn_range.end >= self.lsn);
let inner = self.load()?;
- let buf = match &inner.image_type {
- ImageType::Blocky { num_blocks } => {
- // Check if the request is beyond EOF
- if blknum >= *num_blocks {
- return Ok(PageReconstructResult::Missing(lsn));
- }
+ if let Some(blob_ref) = inner.index.get(&key) {
+ let chapter = inner
+ .book
+ .as_ref()
+ .unwrap()
+ .chapter_reader(VALUES_CHAPTER)?;
- let mut buf = vec![0u8; BLOCK_SIZE];
- let offset = BLOCK_SIZE as u64 * blknum as u64;
-
- let chapter = inner
- .book
- .as_ref()
- .unwrap()
- .chapter_reader(BLOCKY_IMAGES_CHAPTER)?;
-
- chapter.read_exact_at(&mut buf, offset).with_context(|| {
+ let mut blob = vec![0; blob_ref.size()];
+ chapter
+ .read_exact_at(&mut blob, blob_ref.pos())
+ .with_context(|| {
format!(
- "failed to read page from data file {} at offset {}",
+ "failed to read {} bytes from data file {} at offset {}",
+ blob_ref.size(),
self.filename().display(),
- offset
+ blob_ref.pos()
)
})?;
+ let value = Bytes::from(blob);
- buf
- }
- ImageType::NonBlocky => {
- ensure!(blknum == 0);
- inner
- .book
- .as_ref()
- .unwrap()
- .read_chapter(NONBLOCKY_IMAGE_CHAPTER)?
- .into_vec()
- }
- };
-
- reconstruct_data.page_img = Some((self.lsn, Bytes::from(buf)));
- Ok(PageReconstructResult::Complete)
- }
-
- /// Get size of the segment
- fn get_seg_size(&self, _lsn: Lsn) -> Result {
- let inner = self.load()?;
- match inner.image_type {
- ImageType::Blocky { num_blocks } => Ok(num_blocks),
- ImageType::NonBlocky => Err(anyhow!("get_seg_size called for non-blocky segment")),
+ reconstruct_state.img = Some((self.lsn, value));
+ Ok(ValueReconstructResult::Complete)
+ } else {
+ Ok(ValueReconstructResult::Missing)
}
}
- /// Does this segment exist at given LSN?
- fn get_seg_exists(&self, _lsn: Lsn) -> Result {
- Ok(true)
+ fn iter(&self) -> Box>> {
+ todo!();
}
fn unload(&self) -> Result<()> {
+ // Unload the index.
+ //
+ // TODO: we should access the index directly from pages on the disk,
+ // using the buffer cache. This load/unload mechanism is really ad hoc.
+
+ // FIXME: In debug mode, loading and unloading the index slows
+ // things down so much that you get timeout errors. At least
+ // with the test_parallel_copy test. So as an even more ad hoc
+ // stopgap fix for that, only unload every on average 10
+ // checkpoint cycles.
+ use rand::RngCore;
+ if rand::thread_rng().next_u32() > (u32::MAX / 10) {
+ return Ok(());
+ }
+
+ let mut inner = self.inner.lock().unwrap();
+ inner.index = HashMap::default();
+ inner.loaded = false;
+
Ok(())
}
@@ -235,22 +212,22 @@ impl Layer for ImageLayer {
/// debugging function to print out the contents of the layer
fn dump(&self) -> Result<()> {
println!(
- "----- image layer for ten {} tli {} seg {} at {} ----",
- self.tenantid, self.timelineid, self.seg, self.lsn
+ "----- image layer for ten {} tli {} key {}-{} at {} ----",
+ self.tenantid, self.timelineid, self.key_range.start, self.key_range.end, self.lsn
);
let inner = self.load()?;
- match inner.image_type {
- ImageType::Blocky { num_blocks } => println!("({}) blocks ", num_blocks),
- ImageType::NonBlocky => {
- let chapter = inner
- .book
- .as_ref()
- .unwrap()
- .read_chapter(NONBLOCKY_IMAGE_CHAPTER)?;
- println!("non-blocky ({} bytes)", chapter.len());
- }
+ let mut index_vec: Vec<(&Key, &BlobRef)> = inner.index.iter().collect();
+ index_vec.sort_by_key(|x| x.1.pos());
+
+ for (key, blob_ref) in index_vec {
+ println!(
+ "key: {} size {} offset {}",
+ key,
+ blob_ref.size(),
+ blob_ref.pos()
+ );
}
Ok(())
@@ -279,19 +256,21 @@ impl ImageLayer {
// quick exit if already loaded
let mut inner = self.inner.lock().unwrap();
- if inner.book.is_some() {
+ if inner.loaded {
return Ok(inner);
}
let path = self.path();
- let file = VirtualFile::open(&path)
- .with_context(|| format!("Failed to open virtual file '{}'", path.display()))?;
- let book = Book::new(file).with_context(|| {
- format!(
- "Failed to open virtual file '{}' as a bookfile",
- path.display()
- )
- })?;
+
+ // Open the file if it's not open already.
+ if inner.book.is_none() {
+ let file = VirtualFile::open(&path)
+ .with_context(|| format!("Failed to open file '{}'", path.display()))?;
+ inner.book = Some(Book::new(file).with_context(|| {
+ format!("Failed to open file '{}' as a bookfile", path.display())
+ })?);
+ }
+ let book = inner.book.as_ref().unwrap();
match &self.path_or_conf {
PathOrConf::Conf(_) => {
@@ -318,23 +297,13 @@ impl ImageLayer {
}
}
- let image_type = if self.seg.rel.is_blocky() {
- let chapter = book.chapter_reader(BLOCKY_IMAGES_CHAPTER)?;
- let images_len = chapter.len();
- ensure!(images_len % BLOCK_SIZE as u64 == 0);
- let num_blocks: SegmentBlk = (images_len / BLOCK_SIZE as u64).try_into()?;
- ImageType::Blocky { num_blocks }
- } else {
- let _chapter = book.chapter_reader(NONBLOCKY_IMAGE_CHAPTER)?;
- ImageType::NonBlocky
- };
+ let chapter = book.read_chapter(INDEX_CHAPTER)?;
+ let index = HashMap::des(&chapter)?;
- debug!("loaded from {}", &path.display());
+ info!("loaded from {}", &path.display());
- *inner = ImageLayerInner {
- book: Some(book),
- image_type,
- };
+ inner.index = index;
+ inner.loaded = true;
Ok(inner)
}
@@ -350,11 +319,12 @@ impl ImageLayer {
path_or_conf: PathOrConf::Conf(conf),
timelineid,
tenantid,
- seg: filename.seg,
+ key_range: filename.key_range.clone(),
lsn: filename.lsn,
inner: Mutex::new(ImageLayerInner {
book: None,
- image_type: ImageType::Blocky { num_blocks: 0 },
+ index: HashMap::new(),
+ loaded: false,
}),
}
}
@@ -373,18 +343,19 @@ impl ImageLayer {
path_or_conf: PathOrConf::Path(path.to_path_buf()),
timelineid: summary.timelineid,
tenantid: summary.tenantid,
- seg: summary.seg,
+ key_range: summary.key_range,
lsn: summary.lsn,
inner: Mutex::new(ImageLayerInner {
book: None,
- image_type: ImageType::Blocky { num_blocks: 0 },
+ index: HashMap::new(),
+ loaded: false,
}),
})
}
fn layer_name(&self) -> ImageFileName {
ImageFileName {
- seg: self.seg,
+ key_range: self.key_range.clone(),
lsn: self.lsn,
}
}
@@ -413,15 +384,18 @@ impl ImageLayer {
///
pub struct ImageLayerWriter {
conf: &'static PageServerConf,
+ path: PathBuf,
timelineid: ZTimelineId,
tenantid: ZTenantId,
- seg: SegmentTag,
+ key_range: Range
+
+Few databases are stored in one chunk, replicated three times
+
+- When database can't fit into one storage node it can occupy lots of chunks that were split while database was growing. Chunk placement on nodes is controlled by us with some automatization, but we alway may manually move chunks around the cluster.
+
+
+
+Here one big database occupies two set of nodes. Also some chunks were moved around to restore replication factor after disk failure. In this case we also have "sharded" storage for a big database and issue wal writes to different chunks in parallel.
+
+## **Chunk placement strategies**
+
+There are few scenarios where we may want to move chunks around the cluster:
+
+- disk usage on some node is big
+- some disk experienced a failure
+- some node experienced a failure or need maintenance
+
+## **Chunk replication**
+
+Chunk replication may be done by cloning page ranges with respect to some lsn from peer nodes, updating global metadata, waiting for WAL to come, replaying previous WAL and becoming online -- more or less like during chunk split.
+
diff --git a/docs/rfcs/003-laptop-cli.md b/docs/rfcs/003-laptop-cli.md
new file mode 100644
index 0000000000..4d1f0a68f0
--- /dev/null
+++ b/docs/rfcs/003-laptop-cli.md
@@ -0,0 +1,267 @@
+# Command line interface (end-user)
+
+Zenith CLI as it is described here mostly resides on the same conceptual level as pg_ctl/initdb/pg_recvxlog/etc and replaces some of them in an opinionated way. I would also suggest bundling our patched postgres inside zenith distribution at least at the start.
+
+This proposal is focused on managing local installations. For cluster operations, different tooling would be needed. The point of integration between the two is storage URL: no matter how complex cluster setup is it may provide an endpoint where the user may push snapshots.
+
+The most important concept here is a snapshot, which can be created/pushed/pulled/exported. Also, we may start temporary read-only postgres instance over any local snapshot. A more complex scenario would consist of several basic operations over snapshots.
+
+# Possible usage scenarios
+
+## Install zenith, run a postgres
+
+```
+> brew install pg-zenith
+> zenith pg create # creates pgdata with default pattern pgdata$i
+> zenith pg list
+ID PGDATA USED STORAGE ENDPOINT
+primary1 pgdata1 0G zenith-local localhost:5432
+```
+
+## Import standalone postgres to zenith
+
+```
+> zenith snapshot import --from=basebackup://replication@localhost:5432/ oldpg
+[====================------------] 60% | 20MB/s
+> zenith snapshot list
+ID SIZE PARENT
+oldpg 5G -
+
+> zenith pg create --snapshot oldpg
+Started postgres on localhost:5432
+
+> zenith pg list
+ID PGDATA USED STORAGE ENDPOINT
+primary1 pgdata1 5G zenith-local localhost:5432
+
+> zenith snapshot destroy oldpg
+Ok
+```
+
+Also, we may start snapshot import implicitly by looking at snapshot schema
+
+```
+> zenith pg create --snapshot basebackup://replication@localhost:5432/
+Downloading snapshot... Done.
+Started postgres on localhost:5432
+Destroying snapshot... Done.
+```
+
+## Pull snapshot with some publicly shared database
+
+Since we may export the whole snapshot as one big file (tar of basebackup, maybe with some manifest) it may be shared over conventional means: http, ssh, [git+lfs](https://docs.github.com/en/github/managing-large-files/about-git-large-file-storage).
+
+```
+> zenith pg create --snapshot http://learn-postgres.com/movies_db.zenith movies
+```
+
+## Create snapshot and push it to the cloud
+
+```
+> zenith snapshot create pgdata1@snap1
+> zenith snapshot push --to ssh://stas@zenith.tech pgdata1@snap1
+```
+
+## Rollback database to the snapshot
+
+One way to rollback the database is just to init a new database from the snapshot and destroy the old one. But creating a new database from a snapshot would require a copy of that snapshot which is time consuming operation. Another option that would be cool to support is the ability to create the copy-on-write database from the snapshot without copying data, and store updated pages in a separate location, however that way would have performance implications. So to properly rollback the database to the older state we have `zenith pg checkout`.
+
+```
+> zenith pg list
+ID PGDATA USED STORAGE ENDPOINT
+primary1 pgdata1 5G zenith-local localhost:5432
+
+> zenith snapshot create pgdata1@snap1
+
+> zenith snapshot list
+ID SIZE PARENT
+oldpg 5G -
+pgdata1@snap1 6G -
+pgdata1@CURRENT 6G -
+
+> zenith pg checkout pgdata1@snap1
+Stopping postgres on pgdata1.
+Rolling back pgdata1@CURRENT to pgdata1@snap1.
+Starting postgres on pgdata1.
+
+> zenith snapshot list
+ID SIZE PARENT
+oldpg 5G -
+pgdata1@snap1 6G -
+pgdata1@HEAD{0} 6G -
+pgdata1@CURRENT 6G -
+```
+
+Some notes: pgdata1@CURRENT -- implicit snapshot representing the current state of the database in the data directory. When we are checking out some snapshot CURRENT will be set to this snapshot and the old CURRENT state will be named HEAD{0} (0 is the number of postgres timeline, it would be incremented after each such checkout).
+
+## Configure PITR area (Point In Time Recovery).
+
+PITR area acts like a continuous snapshot where you can reset the database to any point in time within this area (by area I mean some TTL period or some size limit, both possibly infinite).
+
+```
+> zenith pitr create --storage s3tank --ttl 30d --name pitr_last_month
+```
+
+Resetting the database to some state in past would require creating a snapshot on some lsn / time in this pirt area.
+
+# Manual
+
+## storage
+
+Storage is either zenith pagestore or s3. Users may create a database in a pagestore and create/move *snapshots* and *pitr regions* in both pagestore and s3. Storage is a concept similar to `git remote`. After installation, I imagine one local storage is available by default.
+
+**zenith storage attach** -t [native|s3] -c key=value -n name
+
+Attaches/initializes storage. For --type=s3, user credentials and path should be provided. For --type=native we may support --path=/local/path and --url=zenith.tech/stas/mystore. Other possible term for native is 'zstore'.
+
+
+**zenith storage list**
+
+Show currently attached storages. For example:
+
+```
+> zenith storage list
+NAME USED TYPE OPTIONS PATH
+local 5.1G zenith-local /opt/zenith/store/local
+local.compr 20.4G zenith-local comression=on /opt/zenith/store/local.compr
+zcloud 60G zenith-remote zenith.tech/stas/mystore
+s3tank 80G S3
+```
+
+**zenith storage detach**
+
+**zenith storage show**
+
+
+
+## pg
+
+Manages postgres data directories and can start postgreses with proper configuration. An experienced user may avoid using that (except pg create) and configure/run postgres by themself.
+
+Pg is a term for a single postgres running on some data. I'm trying to avoid here separation of datadir management and postgres instance management -- both that concepts bundled here together.
+
+**zenith pg create** [--no-start --snapshot --cow] -s storage-name -n pgdata
+
+Creates (initializes) new data directory in given storage and starts postgres. I imagine that storage for this operation may be only local and data movement to remote location happens through snapshots/pitr.
+
+--no-start: just init datadir without creating
+
+--snapshot snap: init from the snapshot. Snap is a name or URL (zenith.tech/stas/mystore/snap1)
+
+--cow: initialize Copy-on-Write data directory on top of some snapshot (makes sense if it is a snapshot of currently running a database)
+
+**zenith pg destroy**
+
+**zenith pg start** [--replica] pgdata
+
+Start postgres with proper extensions preloaded/installed.
+
+**zenith pg checkout**
+
+Rollback data directory to some previous snapshot.
+
+**zenith pg stop** pg_id
+
+**zenith pg list**
+
+```
+ROLE PGDATA USED STORAGE ENDPOINT
+primary my_pg 5.1G local localhost:5432
+replica-1 localhost:5433
+replica-2 localhost:5434
+primary my_pg2 3.2G local.compr localhost:5435
+- my_pg3 9.2G local.compr -
+```
+
+**zenith pg show**
+
+```
+my_pg:
+ storage: local
+ space used on local: 5.1G
+ space used on all storages: 15.1G
+ snapshots:
+ on local:
+ snap1: 1G
+ snap2: 1G
+ on zcloud:
+ snap2: 1G
+ on s3tank:
+ snap5: 2G
+ pitr:
+ on s3tank:
+ pitr_one_month: 45G
+
+```
+
+**zenith pg start-rest/graphql** pgdata
+
+Starts REST/GraphQL proxy on top of postgres master. Not sure we should do that, just an idea.
+
+
+## snapshot
+
+Snapshot creation is cheap -- no actual data is copied, we just start retaining old pages. Snapshot size means the amount of retained data, not all data. Snapshot name looks like pgdata_name@tag_name. tag_name is set by the user during snapshot creation. There are some reserved tag names: CURRENT represents the current state of the data directory; HEAD{i} represents the data directory state that resided in the database before i-th checkout.
+
+**zenith snapshot create** pgdata_name@snap_name
+
+Creates a new snapshot in the same storage where pgdata_name exists.
+
+**zenith snapshot push** --to url pgdata_name@snap_name
+
+Produces binary stream of a given snapshot. Under the hood starts temp read-only postgres over this snapshot and sends basebackup stream. Receiving side should start `zenith snapshot recv` before push happens. If url has some special schema like zenith:// receiving side may require auth start `zenith snapshot recv` on the go.
+
+**zenith snapshot recv**
+
+Starts a port listening for a basebackup stream, prints connection info to stdout (so that user may use that in push command), and expects data on that socket.
+
+**zenith snapshot pull** --from url or path
+
+Connects to a remote zenith/s3/file and pulls snapshot. The remote site should be zenith service or files in our format.
+
+**zenith snapshot import** --from basebackup://<...> or path
+
+Creates a new snapshot out of running postgres via basebackup protocol or basebackup files.
+
+**zenith snapshot export**
+
+Starts read-only postgres over this snapshot and exports data in some format (pg_dump, or COPY TO on some/all tables). One of the options may be zenith own format which is handy for us (but I think just tar of basebackup would be okay).
+
+**zenith snapshot diff** snap1 snap2
+
+Shows size of data changed between two snapshots. We also may provide options to diff schema/data in tables. To do that start temp read-only postgreses.
+
+**zenith snapshot destroy**
+
+## pitr
+
+Pitr represents wal stream and ttl policy for that stream
+
+XXX: any suggestions on a better name?
+
+**zenith pitr create** name
+
+--ttl = inf | period
+
+--size-limit = inf | limit
+
+--storage = storage_name
+
+**zenith pitr extract-snapshot** pitr_name --lsn xxx
+
+Creates a snapshot out of some lsn in PITR area. The obtained snapshot may be managed with snapshot routines (move/send/export)
+
+**zenith pitr gc** pitr_name
+
+Force garbage collection on some PITR area.
+
+**zenith pitr list**
+
+**zenith pitr destroy**
+
+
+## console
+
+**zenith console**
+
+Opens browser targeted at web console with the more or less same functionality as described here.
diff --git a/docs/rfcs/004-durability.md b/docs/rfcs/004-durability.md
new file mode 100644
index 0000000000..4543be3dae
--- /dev/null
+++ b/docs/rfcs/004-durability.md
@@ -0,0 +1,218 @@
+Durability & Consensus
+======================
+
+When a transaction commits, a commit record is generated in the WAL.
+When do we consider the WAL record as durable, so that we can
+acknowledge the commit to the client and be reasonably certain that we
+will not lose the transaction?
+
+Zenith uses a group of WAL safekeeper nodes to hold the generated WAL.
+A WAL record is considered durable, when it has been written to a
+majority of WAL safekeeper nodes. In this document, I use 5
+safekeepers, because I have five fingers. A WAL record is durable,
+when at least 3 safekeepers have written it to disk.
+
+First, assume that only one primary node can be running at a
+time. This can be achieved by Kubernetes or etcd or some
+cloud-provider specific facility, or we can implement it
+ourselves. These options are discussed in later chapters. For now,
+assume that there is a Magic STONITH Fairy that ensures that.
+
+In addition to the WAL safekeeper nodes, the WAL is archived in
+S3. WAL that has been archived to S3 can be removed from the
+safekeepers, so the safekeepers don't need a lot of disk space.
+
+
+ +----------------+
+ +-----> | WAL safekeeper |
+ | +----------------+
+ | +----------------+
+ +-----> | WAL safekeeper |
++------------+ | +----------------+
+| Primary | | +----------------+
+| Processing | ---------+-----> | WAL safekeeper |
+| Node | | +----------------+
++------------+ | +----------------+
+ \ +-----> | WAL safekeeper |
+ \ | +----------------+
+ \ | +----------------+
+ \ +-----> | WAL safekeeper |
+ \ +----------------+
+ \
+ \
+ \
+ \
+ \ +--------+
+ \ | |
+ +--> | S3 |
+ | |
+ +--------+
+
+
+Every WAL safekeeper holds a section of WAL, and a VCL value.
+The WAL can be divided into three portions:
+
+
+ VCL LSN
+ | |
+ V V
+.................ccccccccccccccccccccXXXXXXXXXXXXXXXXXXXXXXX
+Archived WAL Completed WAL In-flight WAL
+
+
+Note that all this WAL kept in a safekeeper is a contiguous section.
+This is different from Aurora: In Aurora, there can be holes in the
+WAL, and there is a Gossip protocol to fill the holes. That could be
+implemented in the future, but let's keep it simple for now. WAL needs
+to be written to a safekeeper in order. However, during crash
+recovery, In-flight WAL that has already been stored in a safekeeper
+can be truncated or overwritten.
+
+The Archived WAL has already been stored in S3, and can be removed from
+the safekeeper.
+
+The Completed WAL has been written to at least three safekeepers. The
+algorithm ensures that it is not lost, when at most two nodes fail at
+the same time.
+
+The In-flight WAL has been persisted in the safekeeper, but if a crash
+happens, it may still be overwritten or truncated.
+
+
+The VCL point is determined in the Primary. It is not strictly
+necessary to store it in the safekeepers, but it allows some
+optimizations and sanity checks and is probably generally useful for
+the system as whole. The VCL values stored in the safekeepers can lag
+behind the VCL computed by the primary.
+
+
+Primary node Normal operation
+-----------------------------
+
+1. Generate some WAL.
+
+2. Send the WAL to all the safekeepers that you can reach.
+
+3. As soon as a quorum of safekeepers have acknowledged that they have
+ received and durably stored the WAL up to that LSN, update local VCL
+ value in memory, and acknowledge commits to the clients.
+
+4. Send the new VCL to all the safekeepers that were part of the quorum.
+ (Optional)
+
+
+Primary Crash recovery
+----------------------
+
+When a new Primary node starts up, before it can generate any new WAL
+it needs to contact a majority of the WAL safekeepers to compute the
+VCL. Remember that there is a Magic STONITH fairy that ensures that
+only node process can be doing this at a time.
+
+1. Contact all WAL safekeepers. Find the Max((Epoch, LSN)) tuple among the ones you
+ can reach. This is the Winner safekeeper, and its LSN becomes the new VCL.
+
+2. Update the other safekeepers you can reach, by copying all the WAL
+ from the Winner, starting from each safekeeper's old VCL point. Any old
+ In-Flight WAL from previous Epoch is truncated away.
+
+3. Increment Epoch, and send the new Epoch to the quorum of
+ safekeepers. (This ensures that if any of the safekeepers that we
+ could not reach later come back online, they will be considered as
+ older than this in any future recovery)
+
+You can now start generating new WAL, starting from the newly-computed
+VCL.
+
+Optimizations
+-------------
+
+As described, the Primary node sends all the WAL to all the WAL safekeepers. That
+can be a lot of network traffic. Instead of sending the WAL directly from Primary,
+some safekeepers can be daisy-chained off other safekeepers, or there can be a
+broadcast mechanism among them. There should still be a direct connection from the
+each safekeeper to the Primary for the acknowledgments though.
+
+Similarly, the responsibility for archiving WAL to S3 can be delegated to one of
+the safekeepers, to reduce the load on the primary.
+
+
+Magic STONITH fairy
+-------------------
+
+Now that we have a system that works as long as only one primary node is running at a time, how
+do we ensure that?
+
+1. Use etcd to grant a lease on a key. The primary node is only allowed to operate as primary
+ when it's holding a valid lease. If the primary node dies, the lease expires after a timeout
+ period, and a new node is allowed to become the primary.
+
+2. Use S3 to store the lease. S3's consistency guarantees are more lenient, so in theory you
+ cannot do this safely. In practice, it would probably be OK if you make the lease times and
+ timeouts long enough. This has the advantage that we don't need to introduce a new
+ component to the architecture.
+
+3. Use Raft or Paxos, with the WAL safekeepers acting as the Acceptors to form the quorum. The
+ next chapter describes this option.
+
+
+Built-in Paxos
+--------------
+
+The WAL safekeepers act as PAXOS Acceptors, and the Processing nodes
+as both Proposers and Learners.
+
+Each WAL safekeeper holds an Epoch value in addition to the VCL and
+the WAL. Each request by the primary to safekeep WAL is accompanied by
+an Epoch value. If a safekeeper receives a request with Epoch that
+doesn't match its current Accepted Epoch, it must ignore (NACK) it.
+(In different Paxos papers, Epochs are called "terms" or "round
+numbers")
+
+When a node wants to become the primary, it generates a new Epoch
+value that is higher than any previously observed Epoch value, and
+globally unique.
+
+
+Accepted Epoch: 555 VCL LSN
+ | |
+ V V
+.................ccccccccccccccccccccXXXXXXXXXXXXXXXXXXXXXXX
+Archived WAL Completed WAL In-flight WAL
+
+
+Primary node startup:
+
+1. Contact all WAL safekeepers that you can reach (if you cannot
+ connect to a quorum of them, you can give up immediately). Find the
+ latest Epoch among them.
+
+2. Generate a new globally unique Epoch, greater than the latest Epoch
+ found in previous step.
+
+2. Send the new Epoch in a Prepare message to a quorum of
+ safekeepers. (PAXOS Prepare message)
+
+3. Each safekeeper responds with a Promise. If a safekeeper has
+ already made a promise with a higher Epoch, it doesn't respond (or
+ responds with a NACK). After making a promise, the safekeeper stops
+ responding to any write requests with earlier Epoch.
+
+4. Once you have received a majority of promises, you know that the
+ VCL cannot advance on the old Epoch anymore. This effectively kills
+ any old primary server.
+
+5. Find the highest written LSN among the quorum of safekeepers (these
+ can be included in the Promise messages already). This is the new
+ VCL. If a new node starts the election process after this point,
+ it will compute the same or higher VCL.
+
+6. Copy the WAL from the safekeeper with the highest LSN to the other
+ safekeepers in the quorum, using the new Epoch. (PAXOS Accept
+ phase)
+
+7. You can now start generating new WAL starting from the VCL. If
+ another process starts the election process after this point and
+ gains control of a majority of the safekeepers, we will no longer
+ be able to advance the VCL.
+
diff --git a/docs/rfcs/005-zenith_local.md b/docs/rfcs/005-zenith_local.md
new file mode 100644
index 0000000000..7b078e9ec0
--- /dev/null
+++ b/docs/rfcs/005-zenith_local.md
@@ -0,0 +1,103 @@
+# Zenith local
+
+Here I list some objectives to keep in mind when discussing zenith-local design and a proposal that brings all components together. Your comments on both parts are very welcome.
+
+#### Why do we need it?
+- For distribution - this easy to use binary will help us to build adoption among developers.
+- For internal use - to test all components together.
+
+In my understanding, we consider it to be just a mock-up version of zenith-cloud.
+> Question: How much should we care about durability and security issues for a local setup?
+
+
+#### Why is it better than a simple local postgres?
+
+- Easy one-line setup. As simple as `cargo install zenith && zenith start`
+
+- Quick and cheap creation of compute nodes over the same storage.
+> Question: How can we describe a use-case for this feature?
+
+- Zenith-local can work with S3 directly.
+
+- Push and pull images (snapshots) to remote S3 to exchange data with other users.
+
+- Quick and cheap snapshot checkouts to switch back and forth in the database history.
+> Question: Do we want it in the very first release? This feature seems quite complicated.
+
+#### Distribution:
+
+Ideally, just one binary that incorporates all elements we need.
+> Question: Let's discuss pros and cons of having a separate package with modified PostgreSQL.
+
+#### Components:
+
+- **zenith-CLI** - interface for end-users. Turns commands to REST requests and handles responces to show them in a user-friendly way.
+CLI proposal is here https://github.com/libzenith/rfcs/blob/003-laptop-cli.md/003-laptop-cli.md
+WIP code is here: https://github.com/libzenith/postgres/tree/main/pageserver/src/bin/cli
+
+- **zenith-console** - WEB UI with same functionality as CLI.
+>Note: not for the first release.
+
+- **zenith-local** - entrypoint. Service that starts all other components and handles REST API requests. See REST API proposal below.
+ > Idea: spawn all other components as child processes, so that we could shutdown everything by stopping zenith-local.
+
+- **zenith-pageserver** - consists of a storage and WAL-replaying service (modified PG in current implementation).
+> Question: Probably, for local setup we should be able to bypass page-storage and interact directly with S3 to avoid double caching in shared buffers and page-server?
+
+WIP code is here: https://github.com/libzenith/postgres/tree/main/pageserver/src
+
+- **zenith-S3** - stores base images of the database and WAL in S3 object storage. Import and export images from/to zenith.
+> Question: How should it operate in a local setup? Will we manage it ourselves or ask user to provide credentials for existing S3 object storage (i.e. minio)?
+> Question: Do we use it together with local page store or they are interchangeable?
+
+WIP code is ???
+
+- **zenith-safekeeper** - receives WAL from postgres, stores it durably, answers to Postgres that "sync" is succeed.
+> Question: How should it operate in a local setup? In my understanding it should push WAL directly to S3 (if we use it) or store all data locally (if we use local page storage). The latter option seems meaningless (extra overhead and no gain), but it is still good to test the system.
+
+WIP code is here: https://github.com/libzenith/postgres/tree/main/src/bin/safekeeper
+
+- **zenith-computenode** - bottomless PostgreSQL, ideally upstream, but for a start - our modified version. User can quickly create and destroy them and work with it as a regular postgres database.
+
+ WIP code is in main branch and here: https://github.com/libzenith/postgres/commits/compute_node
+
+#### REST API:
+
+Service endpoint: `http://localhost:3000`
+
+Resources:
+- /storages - Where data lives: zenith-pageserver or zenith-s3
+- /pgs - Postgres - zenith-computenode
+- /snapshots - snapshots **TODO**
+
+>Question: Do we want to extend this API to manage zenith components? I.e. start page-server, manage safekeepers and so on? Or they will be hardcoded to just start once and for all?
+
+Methods and their mapping to CLI:
+
+- /storages - zenith-pageserver or zenith-s3
+
+CLI | REST API
+------------- | -------------
+storage attach -n name --type [native\s3] --path=[datadir\URL] | PUT -d { "name": "name", "type": "native", "path": "/tmp" } /storages
+storage detach -n name | DELETE /storages/:storage_name
+storage list | GET /storages
+storage show -n name | GET /storages/:storage_name
+
+
+- /pgs - zenith-computenode
+
+CLI | REST API
+------------- | -------------
+pg create -n name --s storage_name | PUT -d { "name": "name", "storage_name": "storage_name" } /pgs
+pg destroy -n name | DELETE /pgs/:pg_name
+pg start -n name --replica | POST -d {"action": "start", "is_replica":"replica"} /pgs/:pg_name /actions
+pg stop -n name | POST -d {"action": "stop"} /pgs/:pg_name /actions
+pg promote -n name | POST -d {"action": "promote"} /pgs/:pg_name /actions
+pg list | GET /pgs
+pg show -n name | GET /pgs/:pg_name
+
+- /snapshots **TODO**
+
+CLI | REST API
+------------- | -------------
+
diff --git a/docs/rfcs/006-laptop-cli-v2-CLI.md b/docs/rfcs/006-laptop-cli-v2-CLI.md
new file mode 100644
index 0000000000..a04536922a
--- /dev/null
+++ b/docs/rfcs/006-laptop-cli-v2-CLI.md
@@ -0,0 +1,64 @@
+Zenith CLI allows you to operate database clusters (catalog clusters) and their commit history locally and in the cloud. Since ANSI calls them catalog clusters and cluster is a loaded term in the modern infrastructure we will call it "catalog".
+
+# CLI v2 (after chatting with Carl)
+
+Zenith introduces the notion of a repository.
+
+```bash
+zenith init
+zenith clone zenith://zenith.tech/piedpiper/northwind -- clones a repo to the northwind directory
+```
+
+Once you have a cluster catalog you can explore it
+
+```bash
+zenith log -- returns a list of commits
+zenith status -- returns if there are changes in the catalog that can be committed
+zenith commit -- commits the changes and generates a new commit hash
+zenith branch experimental