risingwave_common/
sequence.rs

1// Copyright 2025 RisingWave Labs
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::sync::atomic::{AtomicU64, Ordering};
16
17pub type Sequence = u64;
18pub type AtomicSequence = AtomicU64;
19
20pub static SEQUENCE_GLOBAL: AtomicSequence = AtomicSequence::new(0);
21
22/// An globally unique and approximate ascending sequence generator with local optimization.
23///
24/// [`Sequencer`] can be used to generate globally unique sequence (id) in an approximate order. [`Sequencer`] allow
25/// the generated sequence to be disordered in a certain window. The larger the allowed disordered sequence window is,
26/// the better multithreading performance of the generator will be.
27///
28/// The window is controlled with two arguments, `step` and `lag`. `step` controls the size of the batch of the
29/// sequences to allocate by the local sequence generator. `lag` controls the maximum lag between the local generator
30/// and the global generator to avoid skew.
31pub struct Sequencer {
32    local: Sequence,
33    target: Sequence,
34
35    step: Sequence,
36    lag: Sequence,
37}
38
39impl Sequencer {
40    pub const DEFAULT_LAG: Sequence = Self::DEFAULT_STEP * 32;
41    pub const DEFAULT_STEP: Sequence = 64;
42
43    /// Create a new local sequence generator.
44    pub const fn new(step: Sequence, lag: Sequence) -> Self {
45        Self {
46            local: 0,
47            target: 0,
48            step,
49            lag,
50        }
51    }
52
53    /// Get the global sequence to allocate.
54    pub fn global(&self) -> Sequence {
55        SEQUENCE_GLOBAL.load(Ordering::Relaxed)
56    }
57
58    /// Get the local sequence to allocate.
59    pub fn local(&self) -> Sequence {
60        self.local
61    }
62
63    /// Allocate a new sequence. The allocated sequences from the same [`Sequencer`] are strictly ascending, the
64    /// allocated sequences from different [`Sequencer`]s are approximate ascending.
65    pub fn alloc(&mut self) -> Sequence {
66        self.try_alloc();
67        let res = self.local;
68        self.local += 1;
69        res
70    }
71
72    #[inline(always)]
73    fn try_alloc(&mut self) {
74        if self.local == self.target
75            || self.local + self.lag < SEQUENCE_GLOBAL.load(Ordering::Relaxed)
76        {
77            self.alloc_inner()
78        }
79    }
80
81    #[inline(always)]
82    fn alloc_inner(&mut self) {
83        self.local = SEQUENCE_GLOBAL.fetch_add(self.step, Ordering::Relaxed);
84        self.target = self.local + self.step;
85    }
86}
risingwave_common/sequence.rs

risingwave_common/
sequence.rs
