Struct BitLayout 

pub struct BitLayout { /* private fields */ }

Describes how the 63 usable bits of an i64 snowflake ID are partitioned.

All four fields must sum to exactly 63. The sign bit is reserved so that all generated IDs are positive and can be stored in signed integer columns without surprises.

Field ordering (MSB → LSB)

[sign(1)] [timestamp(T)] [machine_id(M)] [node_id(N)] [sequence(S)]

Example

use snowflake_gen::BitLayout;

// Classic Twitter layout
let layout = BitLayout::default();
assert_eq!(layout.max_sequence(), 4095);
assert_eq!(layout.max_machine_id(), 31);
assert_eq!(layout.max_node_id(), 31);

Implementations

impl BitLayout

pub fn new( timestamp_bits: u8, machine_id_bits: u8, node_id_bits: u8, sequence_bits: u8, ) -> Result<Self, SnowflakeError>

Creates a validated BitLayout.

Returns SnowflakeError::InvalidBitLayout if the four bit widths do not sum to exactly 63.

Example

use snowflake_gen::BitLayout;

let layout = BitLayout::new(41, 5, 5, 12).unwrap(); // classic Twitter
let bad    = BitLayout::new(40, 5, 5, 12);          // sums to 62 → error
assert!(bad.is_err());

Examples found in repository

examples/benchmark.rs (line 9)

fn main() {
    // 1. Initialize for a machine with a 5/5 sub-node layout (32 threads)
    let layout = BitLayout::new(41, 5, 5, 12).unwrap();
    init(1, layout).expect("could not initialize global snowflake");

    println!("Starting benchmark with 32 threads...");
    let thread_count = 32;
    let iterations_per_thread = 1_000_000;

    let counter = Arc::new(AtomicU64::new(0));
    let start = Instant::now();

    let handles: Vec<_> = (0..thread_count)
        .map(|_| {
            let cnt = Arc::clone(&counter);
            thread::spawn(move || {
                let mut local_count = 0;
                for _ in 0..iterations_per_thread {
                    if let Ok(_) = next_id() {
                        local_count += 1;
                    }
                }
                cnt.fetch_add(local_count, Ordering::Relaxed);
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }

    let duration = start.elapsed();
    let total_ids = counter.load(Ordering::Relaxed);
    let ids_per_sec = total_ids as f64 / duration.as_secs_f64();

    println!("Generated {} IDs in {:?}", total_ids, duration);
    println!(
        "Throughput: {:.2} million IDs / sec",
        ids_per_sec / 1_000_000.0
    );
}

pub const fn timestamp_bits(&self) -> u8

Returns the number of bits allocated to the timestamp.

pub const fn machine_id_bits(&self) -> u8

Returns the number of bits allocated to the machine identifier.

pub const fn node_id_bits(&self) -> u8

Returns the number of bits allocated to the node identifier.

pub const fn sequence_bits(&self) -> u8

Returns the number of bits allocated to the sequence counter.

pub const fn max_sequence(&self) -> u32

Maximum allowed sequence value (IDs per millisecond − 1).

use snowflake_gen::BitLayout;
assert_eq!(BitLayout::default().max_sequence(), 4095);

pub const fn max_machine_id(&self) -> i64

Maximum allowed machine_id.

use snowflake_gen::BitLayout;
assert_eq!(BitLayout::default().max_machine_id(), 31);

pub const fn max_node_id(&self) -> i64

Maximum allowed node_id.

use snowflake_gen::BitLayout;
assert_eq!(BitLayout::default().max_node_id(), 31);

pub const fn max_timestamp_millis(&self) -> i64

Maximum milliseconds the timestamp field can represent.

With 41 timestamp bits this is ~69 years from epoch.

pub fn max_ids_per_second(&self) -> u64

Maximum IDs that can be generated per second across all nodes.

Trait Implementations

impl Clone for BitLayout

fn clone(&self) -> BitLayout

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BitLayout

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BitLayout

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for BitLayout

fn eq(&self, other: &BitLayout) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BitLayout

impl Eq for BitLayout

impl StructuralPartialEq for BitLayout