Update random number generator

Author: thejpster

Cargo.toml

@@ -61,8 +61,7 @@ itoa = []
 memchr = []
 qsort = []
 rand_r = []
-rand = ["rand_r", "dep:portable-atomic"]
-rand-cs = ["rand", "portable-atomic/critical-section"]
+rand = ["rand_r"]
 signal = ["dep:portable-atomic"]
 signal-cs = ["portable-atomic/critical-section"]
 snprintf = []

examples/rand.rs

@@ -0,0 +1,24 @@
+fn main() {
+	let mut distribution = std::collections::BTreeMap::new();
+
+	let mut seedp = 1;
+	for _ in 0..4 {
+		println!(".");
+		for _ in 0..1_000_000 {
+			let random = unsafe { tinyrlibc::rand_r(&mut seedp) };
+			for place in 0..core::ffi::c_int::BITS {
+				let random_bit = (random & (1 << place)) != 0;
+				if random_bit {
+					distribution
+						.entry(place)
+						.and_modify(|v| *v += 1)
+						.or_insert(1);
+				}
+			}
+		}
+	}
+
+	for (k, v) in distribution.iter() {
+		println!("{:02} => {}", k, v);
+	}
+}

src/rand.rs

@@ -8,7 +8,7 @@ use core::{
 
 use portable_atomic::AtomicU32;
 
-static RAND_STATE: AtomicU32 = AtomicU32::new(0x0);
+static RAND_STATE: AtomicU32 = AtomicU32::new(1);
 
 /// Rust implementation of C library function `srand`
 #[cfg_attr(feature = "rand", no_mangle)]
@@ -17,43 +17,25 @@ pub extern "C" fn srand(seed: c_uint) {
 }
 
 /// Rust implementation of C library function `rand`.
-///
-/// Returns a pseudo-random integer in the range 0 to [`RAND_MAX`](crate::RAND_MAX) (inclusive).
-/// This requires CAS operations. If your platform does not support them natively,
-/// you either have to enable the `rand-cs` feature of `tinyrlibc`,
-/// or the [`critical-section`](https://docs.rs/portable-atomic/1.9.0/portable_atomic/#optional-features-critical-section) feature,
-/// or the [`unsafe-assume-single-core`](https://docs.rs/portable-atomic/1.9.0/portable_atomic/#optional-features-unsafe-assume-single-core) feature
-/// in [`portable-atomic`](https://crates.io/crates/portable-atomic).
 #[cfg_attr(feature = "rand", no_mangle)]
 pub extern "C" fn rand() -> c_int {
-	let mut current_state = RAND_STATE.load(Ordering::Relaxed);
-
-	loop {
-		let mut new_state = current_state;
-		let result = unsafe { crate::rand_r(&mut new_state as *mut _) };
-		match RAND_STATE.compare_exchange_weak(
-			current_state,
-			new_state,
-			Ordering::Relaxed,
-			Ordering::Relaxed,
-		) {
-			Ok(_) => return result as _,
-			Err(c) => current_state = c,
-		}
-	}
+	let mut state = RAND_STATE.load(Ordering::Relaxed);
+	let result = unsafe { crate::rand_r(&mut state) };
+	RAND_STATE.store(state);
+	result
 }
 
 #[cfg(test)]
 mod test {
 	use super::*;
 	#[test]
 	fn test_rand() {
-		assert_eq!(rand(), 1012483);
-		assert_eq!(rand(), 1716955678);
-		assert_eq!(rand(), 1792309081);
+		assert_eq!(rand(), 1012484);
+		assert_eq!(rand(), 1716955679);
+		assert_eq!(rand(), 1792309082);
 		srand(5);
-		assert_eq!(rand(), 234104183);
-		assert_eq!(rand(), 1214203243);
-		assert_eq!(rand(), 1803669307);
+		assert_eq!(rand(), 234104184);
+		assert_eq!(rand(), 1214203244);
+		assert_eq!(rand(), 1803669308);
 	}
 }

src/rand_r.rs

@@ -5,35 +5,43 @@ use core::ffi::{c_int, c_uint};
 
 #[cfg_attr(not(feature = "rand_r"), export_name = "tinyrlibc_RAND_MAX")]
 #[cfg_attr(feature = "rand_r", no_mangle)]
-pub static RAND_MAX: c_int = 0x7FFF_FFFC as _;
+pub static RAND_MAX: c_int = c_int::MAX;
 
 /// Rust implementation of C library function `rand_r`
 ///
 /// Passing NULL (core::ptr::null()) gives undefined behaviour.
 #[cfg_attr(not(feature = "rand_r"), export_name = "tinyrlibc_rand_r")]
 #[cfg_attr(feature = "rand_r", no_mangle)]
 pub unsafe extern "C" fn rand_r(seedp: *mut c_uint) -> c_int {
-	// This algorithm is mentioned in the ISO C standard, here extended for 32 bits.
-	let mut next = *seedp;
-	let mut result: c_int;
-
-	next = next.wrapping_mul(1103515245);
-	next = next.wrapping_add(12345);
-	result = ((next / 65536) % 2048) as c_int;
+	let mut result;
 
-	next = next.wrapping_mul(1103515245);
-	next = next.wrapping_add(12345);
-	result <<= 10;
-	result ^= ((next / 65536) % 1024) as c_int;
+	fn pump(input: c_uint) -> c_uint {
+		// This algorithm is mentioned in the ISO C standard
+		input.wrapping_mul(1103515245).wrapping_add(12345)
+	}
 
-	next = next.wrapping_mul(1103515245);
-	next = next.wrapping_add(12345);
-	result <<= 10;
-	result ^= ((next / 65536) % 1024) as c_int;
+	fn select_top(state: c_uint, bits: usize) -> c_uint {
+		// ignore the lower 16 bits, as they are low quality
+		(state >> 16) & ((1 << bits) - 1)
+	}
 
+	let mut next = *seedp;
+	if c_int::MAX == 32767 {
+		// pull 15 bits in one go
+		next = pump(next);
+		result = select_top(next, 15);
+	} else {
+		// pull 31 bits in three goes
+		next = pump(next);
+		result = select_top(next, 11) << 20;
+		next = pump(next);
+		result |= select_top(next, 10) << 10;
+		next = pump(next);
+		result |= select_top(next, 10);
+	}
 	*seedp = next;
 
-	result - 1
+	result as c_int
 }
 
 #[cfg(test)]
@@ -43,10 +51,9 @@ mod test {
 	fn test_rand_r() {
 		unsafe {
 			let mut seed = 5;
-			// Values taken from glibc implementation
-			assert_eq!(rand_r(&mut seed), 234104183);
-			assert_eq!(rand_r(&mut seed), 1214203243);
-			assert_eq!(rand_r(&mut seed), 1803669307);
+			assert_eq!(rand_r(&mut seed), 234104184);
+			assert_eq!(rand_r(&mut seed), 1214203244);
+			assert_eq!(rand_r(&mut seed), 1803669308);
 		}
 	}
 }