18264419436

Committed 05 Oct 2025 09:08PM UTC coverage: 43.978% (+0.4%) from 43.572%

Build # 18264419436

Build Type

push

github

Committed by

vigna

Commit Message

First version of Omega tables working

Run Details

1603 of 3645 relevant lines covered (43.98%)

2308723.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0

/src/codes/params.rs

/*
 * SPDX-FileCopyrightText: 2023 Tommaso Fontana
 * SPDX-FileCopyrightText: 2023 Inria
 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

/*!

Mechanisms for selecting parameters.

Traits and structures in this file are of no interest for the standard
user. Their purpose is to provide a systematic way, and in particular
a default way, to select parameters for parameterized traits
such as [`GammaReadParam`] and [`GammaWriteParam`].

The traits and structure in this module work closely with the
bitstream readers and writers in [`impls`](crate::impls), which have an
additional type parameter `RP`/`WP` that must
implement marker traits [`ReadParams`] or [`WriteParams`], respectively.
The type is then used as a selector type to provide blanket implementations
of parameterless traits in [`codes`](crate::codes) such as [`GammaRead`],
[`GammaWrite`], [`DeltaRead`], [`DeltaWrite`], and so on.

This module provides default selector types [`DefaultReadParams`] and [`DefaultWriteParams`]
which are also the default value for the parameter `RP`/`WP` in the bitstream
readers and writers in [`crate::impls`]. Type-selected blanket implementations
of all parameterless traits in [`crate::codes`] are provided for the bitstream
readers and writers in [`impls`](crate::impls). Thus, if you not specify a value for the
parameter `RP`/`WP`, you will obtain automatically
the blanket implementations for parameterless traits contained in this module.

However, you can also create new selector types implementing [`ReadParams`]/[`WriteParams`] and
write blanket implementations for the bitstream readers and writers in [`crate::impls`]
where `RP`/`WP` is set to your selector types. Then, by specifying your type as value of the
parameter `RP`/`WP` when creating such readers and writers you will use
automatically your blanket implementations instead of the ones provided by this module.

*/

use crate::codes::*;
use crate::impls::*;
use crate::traits::*;
use common_traits::*;
#[cfg(feature = "mem_dbg")]
use mem_dbg::{MemDbg, MemSize};
use std::error::Error;

/// Marker trait for read-parameters selector types.
///
/// Note that in principle marker traits are not necessary to use
/// selector types, but they are useful to avoid that the user specifies
/// a nonsensical type, and to document the meaning of type parameters.
pub trait ReadParams {}

/// A selector type for read parameters providing reasonable defaults.
///
/// If you want to optimize these choices for your architecture, we suggest to
/// run the benchmarks in the `benchmarks` directory and write your
/// own implementation.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
pub struct DefaultReadParams;
impl ReadParams for DefaultReadParams {}

macro_rules! impl_default_read_codes {
    ($($endianess:ident),*) => {$(
        impl<WR: WordRead> GammaRead<$endianess>
            for BufBitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_gamma(&mut self) -> Result<u64, Self::Error> {
                // From our tests, the ARM architecture is faster
                // without tables for ɣ codes.
                self.read_gamma_param::<false>()
            }
        }

        impl<WR: WordRead> DeltaRead<$endianess>
            for BufBitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_delta(&mut self) -> Result<u64, Self::Error> {
                self.read_delta_param::<false, true>()
            }
        }

        impl<WR: WordRead> OmegaRead<$endianess>
            for BufBitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_omega(&mut self) -> Result<u64, Self::Error> {
                self.read_omega_param::<true>()
            }
        }

        impl<WR: WordRead> ZetaRead<$endianess>
            for BufBitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_zeta(&mut self, k: usize) -> Result<u64, Self::Error> {
                self.read_zeta_param(k)
            }

            #[inline(always)]
            fn read_zeta3(&mut self) -> Result<u64, Self::Error> {
                self.read_zeta3_param::<true>()
            }
        }

        impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> GammaRead<$endianess>
            for BitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_gamma(&mut self) -> Result<u64, Self::Error> {
                // From our tests, the ARM architecture is faster
                // without tables for ɣ codes.
                self.read_gamma_param::<false>()
            }
        }

        impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> DeltaRead<$endianess>
            for BitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_delta(&mut self) -> Result<u64, Self::Error> {
                self.read_delta_param::<false, true>()
            }
        }

        impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> OmegaRead<$endianess>
            for BitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_omega(&mut self) -> Result<u64, Self::Error> {
                self.read_omega_param::<true>()
            }
        }

        impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> ZetaRead<$endianess>
            for BitReader<$endianess, WR, DefaultReadParams>
        where
            WR:: Word: DoubleType + UpcastableInto<u64>,
            <WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
        {
            #[inline(always)]
            fn read_zeta(&mut self, k: usize) -> Result<u64, Self::Error> {
                self.read_zeta_param(k)
            }

            #[inline(always)]
            fn read_zeta3(&mut self) -> Result<u64, Self::Error> {
                self.read_zeta3_param::<true>()
            }
        }
    )*};
}

impl_default_read_codes! {LittleEndian, BigEndian}

/// Marker trait for write-parameters selector types.
///
/// Note that in principle marker traits are not necessary to use
/// selector types, but they are useful to avoid that the user specifies
/// a nonsensical type, and to document the meaning of type parameters.
pub trait WriteParams {}

/// A selector type for write parameters providing reasonable defaults.
///
/// If you want to optimize these choices for your architecture, we suggest to
/// run the benchmarks in the `benchmarks` directory and write your
/// own implementation.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
pub struct DefaultWriteParams;
impl WriteParams for DefaultWriteParams {}

macro_rules! impl_default_write_codes {
    ($($endianess:ident),*) => {$(
        impl<WR: WordWrite> GammaWrite<$endianess>
            for BufBitWriter<$endianess, WR, DefaultWriteParams>
            where u64: CastableInto<WR::Word>,
        {
            #[inline(always)]
            fn write_gamma(&mut self, value: u64) -> Result<usize, Self::Error> {
                self.write_gamma_param::<true>(value)
            }
        }

        impl<WR: WordWrite, DC: WriteParams> DeltaWrite<$endianess>
            for BufBitWriter<$endianess, WR, DC>
            where u64: CastableInto<WR::Word>,
        {
            #[inline(always)]
            fn write_delta(&mut self, value: u64) -> Result<usize, Self::Error> {
                self.write_delta_param::<true, true>(value)
            }
        }

        impl<WR: WordWrite, WP: WriteParams> OmegaWrite<$endianess>
            for BufBitWriter<$endianess, WR, WP>
            where u64: CastableInto<WR::Word>,
        {
            #[inline(always)]
            fn write_omega(&mut self, value: u64) -> Result<usize, Self::Error> {
                self.write_omega_param::<true>(value)
            }
        }

        impl<WR: WordWrite, DC: WriteParams> ZetaWrite<$endianess>
            for BufBitWriter<$endianess, WR, DC>
            where u64: CastableInto<WR::Word>,
        {
            #[inline(always)]
            fn write_zeta(&mut self, value: u64, k: usize) -> Result<usize, Self::Error> {
                self.write_zeta_param::<true>(value, k)
            }

            #[inline(always)]
            fn write_zeta3(&mut self, value: u64) -> Result<usize, Self::Error> {
                self.write_zeta3_param::<true>(value)
            }
        }

    )*};
}

impl_default_write_codes! {LittleEndian, BigEndian}

1	/*
2	* SPDX-FileCopyrightText: 2023 Tommaso Fontana
3	* SPDX-FileCopyrightText: 2023 Inria
4	* SPDX-FileCopyrightText: 2023 Sebastiano Vigna
5	*
6	* SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
7	*/
8
9	/*!
10
11	Mechanisms for selecting parameters.
12
13	Traits and structures in this file are of no interest for the standard
14	user. Their purpose is to provide a systematic way, and in particular
15	a default way, to select parameters for parameterized traits
16	such as [`GammaReadParam`] and [`GammaWriteParam`].
17
18	The traits and structure in this module work closely with the
19	bitstream readers and writers in [`impls`](crate::impls), which have an
20	additional type parameter `RP`/`WP` that must
21	implement marker traits [`ReadParams`] or [`WriteParams`], respectively.
22	The type is then used as a selector type to provide blanket implementations
23	of parameterless traits in [`codes`](crate::codes) such as [`GammaRead`],
24	[`GammaWrite`], [`DeltaRead`], [`DeltaWrite`], and so on.
25
26	This module provides default selector types [`DefaultReadParams`] and [`DefaultWriteParams`]
27	which are also the default value for the parameter `RP`/`WP` in the bitstream
28	readers and writers in [`crate::impls`]. Type-selected blanket implementations
29	of all parameterless traits in [`crate::codes`] are provided for the bitstream
30	readers and writers in [`impls`](crate::impls). Thus, if you not specify a value for the
31	parameter `RP`/`WP`, you will obtain automatically
32	the blanket implementations for parameterless traits contained in this module.
33
34	However, you can also create new selector types implementing [`ReadParams`]/[`WriteParams`] and
35	write blanket implementations for the bitstream readers and writers in [`crate::impls`]
36	where `RP`/`WP` is set to your selector types. Then, by specifying your type as value of the
37	parameter `RP`/`WP` when creating such readers and writers you will use
38	automatically your blanket implementations instead of the ones provided by this module.
39
40	*/
41
42	use crate::codes::*;
43	use crate::impls::*;
44	use crate::traits::*;
45	use common_traits::*;
46	#[cfg(feature = "mem_dbg")]
47	use mem_dbg::{MemDbg, MemSize};
48	use std::error::Error;
49
50	/// Marker trait for read-parameters selector types.
51	///
52	/// Note that in principle marker traits are not necessary to use
53	/// selector types, but they are useful to avoid that the user specifies
54	/// a nonsensical type, and to document the meaning of type parameters.
55	pub trait ReadParams {}
56
57	/// A selector type for read parameters providing reasonable defaults.
58	///
59	/// If you want to optimize these choices for your architecture, we suggest to
60	/// run the benchmarks in the `benchmarks` directory and write your
61	/// own implementation.
62	#[derive(Debug, Clone)]
63	#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
64	pub struct DefaultReadParams;
65	impl ReadParams for DefaultReadParams {}
66
67	macro_rules! impl_default_read_codes {
68	($($endianess:ident),*) => {$(
69	impl<WR: WordRead> GammaRead<$endianess>
70	for BufBitReader<$endianess, WR, DefaultReadParams>
71	where
72	WR:: Word: DoubleType + UpcastableInto<u64>,
73	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
74	{
75	#[inline(always)]
76	fn read_gamma(&mut self) -> Result<u64, Self::Error> {	28,048,291✔
77	// From our tests, the ARM architecture is faster
78	// without tables for ɣ codes.
79	self.read_gamma_param::<false>()	56,096,582✔
80	}
81	}
82
83	impl<WR: WordRead> DeltaRead<$endianess>
84	for BufBitReader<$endianess, WR, DefaultReadParams>
85	where
86	WR:: Word: DoubleType + UpcastableInto<u64>,
87	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
88	{
89	#[inline(always)]
90	fn read_delta(&mut self) -> Result<u64, Self::Error> {	28,004,357✔
91	self.read_delta_param::<false, true>()	56,008,714✔
92	}
93	}
94
95	impl<WR: WordRead> OmegaRead<$endianess>
96	for BufBitReader<$endianess, WR, DefaultReadParams>
97	where
98	WR:: Word: DoubleType + UpcastableInto<u64>,
99	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
100	{
101	#[inline(always)]
102	fn read_omega(&mut self) -> Result<u64, Self::Error> {	4,376✔
103	self.read_omega_param::<true>()	8,752✔
104	}
105	}
106
107	impl<WR: WordRead> ZetaRead<$endianess>
108	for BufBitReader<$endianess, WR, DefaultReadParams>
109	where
110	WR:: Word: DoubleType + UpcastableInto<u64>,
111	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
112	{
113	#[inline(always)]
114	fn read_zeta(&mut self, k: usize) -> Result<u64, Self::Error> {	34,849✔
115	self.read_zeta_param(k)	104,547✔
116	}
117
118	#[inline(always)]
119	fn read_zeta3(&mut self) -> Result<u64, Self::Error> {	4,357✔
120	self.read_zeta3_param::<true>()	8,714✔
121	}
122	}
123
124	impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> GammaRead<$endianess>
125	for BitReader<$endianess, WR, DefaultReadParams>
126	where
127	WR:: Word: DoubleType + UpcastableInto<u64>,
128	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
129	{
130	#[inline(always)]
131	fn read_gamma(&mut self) -> Result<u64, Self::Error> {	138✔
132	// From our tests, the ARM architecture is faster
133	// without tables for ɣ codes.
134	self.read_gamma_param::<false>()	276✔
135	}
136	}
137
138	impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> DeltaRead<$endianess>
139	for BitReader<$endianess, WR, DefaultReadParams>
140	where
141	WR:: Word: DoubleType + UpcastableInto<u64>,
142	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
143	{
144	#[inline(always)]
145	fn read_delta(&mut self) -> Result<u64, Self::Error> {	×
146	self.read_delta_param::<false, true>()	×
147	}
148	}
149
150	impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> OmegaRead<$endianess>
151	for BitReader<$endianess, WR, DefaultReadParams>
152	where
153	WR:: Word: DoubleType + UpcastableInto<u64>,
154	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
155	{
156	#[inline(always)]
157	fn read_omega(&mut self) -> Result<u64, Self::Error> {	20✔
158	self.read_omega_param::<true>()	40✔
159	}
160	}
161
162	impl<E: Error + Send + Sync + 'static, WR: WordRead<Error = E, Word = u64> + WordSeek<Error = E>> ZetaRead<$endianess>
163	for BitReader<$endianess, WR, DefaultReadParams>
164	where
165	WR:: Word: DoubleType + UpcastableInto<u64>,
166	<WR::Word as DoubleType>::DoubleType: CastableInto<u64>,
167	{
168	#[inline(always)]
169	fn read_zeta(&mut self, k: usize) -> Result<u64, Self::Error> {	×
170	self.read_zeta_param(k)	×
171	}
172
173	#[inline(always)]
174	fn read_zeta3(&mut self) -> Result<u64, Self::Error> {	×
175	self.read_zeta3_param::<true>()	×
176	}
177	}
178	)*};
179	}
180
181	impl_default_read_codes! {LittleEndian, BigEndian}
182
183	/// Marker trait for write-parameters selector types.
184	///
185	/// Note that in principle marker traits are not necessary to use
186	/// selector types, but they are useful to avoid that the user specifies
187	/// a nonsensical type, and to document the meaning of type parameters.
188	pub trait WriteParams {}
189
190	/// A selector type for write parameters providing reasonable defaults.
191	///
192	/// If you want to optimize these choices for your architecture, we suggest to
193	/// run the benchmarks in the `benchmarks` directory and write your
194	/// own implementation.
195	#[derive(Debug, Clone)]
196	#[cfg_attr(feature = "mem_dbg", derive(MemDbg, MemSize))]
197	pub struct DefaultWriteParams;
198	impl WriteParams for DefaultWriteParams {}
199
200	macro_rules! impl_default_write_codes {
201	($($endianess:ident),*) => {$(
202	impl<WR: WordWrite> GammaWrite<$endianess>
203	for BufBitWriter<$endianess, WR, DefaultWriteParams>
204	where u64: CastableInto<WR::Word>,
205	{
206	#[inline(always)]
207	fn write_gamma(&mut self, value: u64) -> Result<usize, Self::Error> {	20,052,668✔
208	self.write_gamma_param::<true>(value)	60,158,004✔
209	}
210	}
211
212	impl<WR: WordWrite, DC: WriteParams> DeltaWrite<$endianess>
213	for BufBitWriter<$endianess, WR, DC>
214	where u64: CastableInto<WR::Word>,
215	{
216	#[inline(always)]
217	fn write_delta(&mut self, value: u64) -> Result<usize, Self::Error> {	20,004,394✔
218	self.write_delta_param::<true, true>(value)	60,013,182✔
219	}
220	}
221
222	impl<WR: WordWrite, WP: WriteParams> OmegaWrite<$endianess>
223	for BufBitWriter<$endianess, WR, WP>
224	where u64: CastableInto<WR::Word>,
225	{
226	#[inline(always)]
227	fn write_omega(&mut self, value: u64) -> Result<usize, Self::Error> {	4,400✔
228	self.write_omega_param::<true>(value)	13,200✔
229	}
230	}
231
232	impl<WR: WordWrite, DC: WriteParams> ZetaWrite<$endianess>
233	for BufBitWriter<$endianess, WR, DC>
234	where u64: CastableInto<WR::Word>,
235	{
236	#[inline(always)]
237	fn write_zeta(&mut self, value: u64, k: usize) -> Result<usize, Self::Error> {	30,814✔
238	self.write_zeta_param::<true>(value, k)	123,256✔
239	}
240
241	#[inline(always)]
242	fn write_zeta3(&mut self, value: u64) -> Result<usize, Self::Error> {	4,379✔
243	self.write_zeta3_param::<true>(value)	13,137✔
244	}
245	}
246
247	)*};
248	}
249
250	impl_default_write_codes! {LittleEndian, BigEndian}

vigna / dsi-bitstream-rs / 18264419436

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous