---

yaml
---
r: 95278
b: refs/heads/dist-snap
c: f39a215
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 39a69d323da95ce642ea7fe8d40eb8bdd6a277c8
+refs/heads/dist-snap: f39a215f270bc8c958a19cc9f693720232340cbc
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/rand/mod.rs

@@ -643,8 +643,46 @@ pub trait Rng {
 /// available in Rust. If you require a specifically seeded `Rng` for
 /// consistency over time you should pick one algorithm and create the
 /// `Rng` yourself.
-pub fn rng() -> IsaacRng {
-    IsaacRng::new()
+///
+/// This is a very expensive operation as it has to read randomness
+/// from the operating system and use this in an expensive seeding
+/// operation. If one does not require high performance, `task_rng`
+/// and/or `random` may be more appropriate.
+pub fn rng() -> StdRng {
+    StdRng::new()
+}
+
+/// The standard RNG. This is designed to be efficient on the current
+/// platform.
+#[cfg(not(target_word_size="64"))]
+pub struct StdRng { priv rng: IsaacRng }
+
+/// The standard RNG. This is designed to be efficient on the current
+/// platform.
+#[cfg(target_word_size="64")]
+pub struct StdRng { priv rng: Isaac64Rng }
+
+impl StdRng {
+    #[cfg(not(target_word_size="64"))]
+    fn new() -> StdRng {
+        StdRng { rng: IsaacRng::new() }
+    }
+    #[cfg(target_word_size="64")]
+    fn new() -> StdRng {
+        StdRng { rng: Isaac64Rng::new() }
+    }
+}
+
+impl Rng for StdRng {
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        self.rng.next_u32()
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        self.rng.next_u64()
+    }
 }
 
 /// Create a weak random number generator with a default algorithm and seed.
@@ -728,23 +766,23 @@ pub fn seed(n: uint) -> ~[u8] {
 }
 
 // used to make space in TLS for a random number generator
-local_data_key!(tls_rng_state: @@mut IsaacRng)
+local_data_key!(tls_rng_state: @mut StdRng)
 
 /**
  * Gives back a lazily initialized task-local random number generator,
  * seeded by the system. Intended to be used in method chaining style, ie
  * `task_rng().gen::<int>()`.
  */
 #[inline]
-pub fn task_rng() -> @mut IsaacRng {
+pub fn task_rng() -> @mut StdRng {
     let r = local_data::get(tls_rng_state, |k| k.map(|&k| *k));
     match r {
         None => {
-            let rng = @@mut IsaacRng::new();
+            let rng = @mut StdRng::new();
             local_data::set(tls_rng_state, rng);
-            *rng
+            rng
         }
-        Some(rng) => *rng
+        Some(rng) => rng
     }
 }
 
@@ -985,6 +1023,15 @@ mod bench {
         bh.bytes = size_of::<uint>() as u64;
     }
 
+    #[bench]
+    fn rand_std(bh: &mut BenchHarness) {
+        let mut rng = StdRng::new();
+        do bh.iter {
+            rng.gen::<uint>();
+        }
+        bh.bytes = size_of::<uint>() as u64;
+    }
+
     #[bench]
     fn rand_shuffle_100(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();