Modify inline hints

pitdicker · pitdicker · commit c3c1eec4f0af · 2018-03-04T21:18:22.000+01:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -726,45 +726,41 @@ pub trait Rng: RngCore + Sized {
 impl<R: RngCore> Rng for R {}
 
 impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R {
-    #[inline]
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         (**self).next_u32()
     }
 
-    #[inline]
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         (**self).next_u64()
     }
 
-    #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         (**self).fill_bytes(dest)
     }
-    
-    #[inline]
+
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         (**self).try_fill_bytes(dest)
     }
 }
 
 #[cfg(any(feature="std", feature="alloc"))]
 impl<R: RngCore + ?Sized> RngCore for Box<R> {
-    #[inline]
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         (**self).next_u32()
     }
 
-    #[inline]
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         (**self).next_u64()
     }
 
-    #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         (**self).fill_bytes(dest)
     }
-    
-    #[inline]
+
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         (**self).try_fill_bytes(dest)
     }
@@ -1028,10 +1024,12 @@ pub trait BlockRngCore<T>: Sized {
 pub struct StdRng(Hc128Rng);
 
 impl RngCore for StdRng {
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }
 
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }
diff --git a/src/prng/hc128.rs b/src/prng/hc128.rs
@@ -66,22 +66,20 @@ const SEED_WORDS: usize = 8; // 128 bit key followed by 128 bit iv
 pub struct Hc128Rng(BlockRng<Hc128Core>);
 
 impl RngCore for Hc128Rng {
-    #[inline]
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }
 
-    #[inline]
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }
 
-    #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest)
     }
 
-    #[inline]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
diff --git a/src/reseeding.rs b/src/reseeding.rs
@@ -93,22 +93,20 @@ where R: BlockRngCore<u32> + SeedableRng,
 }
 
 impl<R: BlockRngCore<u32> + SeedableRng, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr> {
-    #[inline]
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }
 
-    #[inline]
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }
 
-    #[inline]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest)
     }
 
-    #[inline]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
diff --git a/src/thread_rng.rs b/src/thread_rng.rs
@@ -78,22 +78,20 @@ pub fn thread_rng() -> ThreadRng {
 }
 
 impl RngCore for ThreadRng {
-    #[inline]
+    #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.rng.borrow_mut().next_u32()
     }
 
-    #[inline]
+    #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.rng.borrow_mut().next_u64()
     }
 
-    #[inline]
     fn fill_bytes(&mut self, bytes: &mut [u8]) {
         self.rng.borrow_mut().fill_bytes(bytes)
     }
-    
-    #[inline]
+
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.rng.borrow_mut().try_fill_bytes(dest)
     }

Original file line number	Diff line number	Diff line change
`@@ -726,45 +726,41 @@ pub trait Rng: RngCore + Sized {`
`726`	`726`	`impl<R: RngCore> Rng for R {}`
`727`	`727`
`728`	`728`	`impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R {`
`729`		`- #[inline]`
	`729`	`+ #[inline(always)]`
`730`	`730`	`fn next_u32(&mut self) -> u32 {`
`731`	`731`	`(**self).next_u32()`
`732`	`732`	`}`
`733`	`733`
`734`		`- #[inline]`
	`734`	`+ #[inline(always)]`
`735`	`735`	`fn next_u64(&mut self) -> u64 {`
`736`	`736`	`(**self).next_u64()`
`737`	`737`	`}`
`738`	`738`
`739`		`- #[inline]`
`740`	`739`	`fn fill_bytes(&mut self, dest: &mut [u8]) {`
`741`	`740`	`(**self).fill_bytes(dest)`
`742`	`741`	`}`
`743`		`-`
`744`		`- #[inline]`
	`742`	`+`
`745`	`743`	`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {`
`746`	`744`	`(**self).try_fill_bytes(dest)`
`747`	`745`	`}`
`748`	`746`	`}`
`749`	`747`
`750`	`748`	`#[cfg(any(feature="std", feature="alloc"))]`
`751`	`749`	`impl<R: RngCore + ?Sized> RngCore for Box<R> {`
`752`		`- #[inline]`
	`750`	`+ #[inline(always)]`
`753`	`751`	`fn next_u32(&mut self) -> u32 {`
`754`	`752`	`(**self).next_u32()`
`755`	`753`	`}`
`756`	`754`
`757`		`- #[inline]`
	`755`	`+ #[inline(always)]`
`758`	`756`	`fn next_u64(&mut self) -> u64 {`
`759`	`757`	`(**self).next_u64()`
`760`	`758`	`}`
`761`	`759`
`762`		`- #[inline]`
`763`	`760`	`fn fill_bytes(&mut self, dest: &mut [u8]) {`
`764`	`761`	`(**self).fill_bytes(dest)`
`765`	`762`	`}`
`766`		`-`
`767`		`- #[inline]`
	`763`	`+`
`768`	`764`	`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {`
`769`	`765`	`(**self).try_fill_bytes(dest)`
`770`	`766`	`}`
`@@ -1028,10 +1024,12 @@ pub trait BlockRngCore<T>: Sized {`
`1028`	`1024`	`pub struct StdRng(Hc128Rng);`
`1029`	`1025`
`1030`	`1026`	`impl RngCore for StdRng {`
	`1027`	`+ #[inline(always)]`
`1031`	`1028`	`fn next_u32(&mut self) -> u32 {`
`1032`	`1029`	`self.0.next_u32()`
`1033`	`1030`	`}`
`1034`	`1031`
	`1032`	`+ #[inline(always)]`
`1035`	`1033`	`fn next_u64(&mut self) -> u64 {`
`1036`	`1034`	`self.0.next_u64()`
`1037`	`1035`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,22 +66,20 @@ const SEED_WORDS: usize = 8; // 128 bit key followed by 128 bit iv`
`66`	`66`	`pub struct Hc128Rng(BlockRng<Hc128Core>);`
`67`	`67`
`68`	`68`	`impl RngCore for Hc128Rng {`
`69`		`- #[inline]`
	`69`	`+ #[inline(always)]`
`70`	`70`	`fn next_u32(&mut self) -> u32 {`
`71`	`71`	`self.0.next_u32()`
`72`	`72`	`}`
`73`	`73`
`74`		`- #[inline]`
	`74`	`+ #[inline(always)]`
`75`	`75`	`fn next_u64(&mut self) -> u64 {`
`76`	`76`	`self.0.next_u64()`
`77`	`77`	`}`
`78`	`78`
`79`		`- #[inline]`
`80`	`79`	`fn fill_bytes(&mut self, dest: &mut [u8]) {`
`81`	`80`	`self.0.fill_bytes(dest)`
`82`	`81`	`}`
`83`	`82`
`84`		`- #[inline]`
`85`	`83`	`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {`
`86`	`84`	`self.0.try_fill_bytes(dest)`
`87`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,22 +93,20 @@ where R: BlockRngCore<u32> + SeedableRng,`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`impl<R: BlockRngCore<u32> + SeedableRng, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr> {`
`96`		`- #[inline]`
	`96`	`+ #[inline(always)]`
`97`	`97`	`fn next_u32(&mut self) -> u32 {`
`98`	`98`	`self.0.next_u32()`
`99`	`99`	`}`
`100`	`100`
`101`		`- #[inline]`
	`101`	`+ #[inline(always)]`
`102`	`102`	`fn next_u64(&mut self) -> u64 {`
`103`	`103`	`self.0.next_u64()`
`104`	`104`	`}`
`105`	`105`
`106`		`- #[inline]`
`107`	`106`	`fn fill_bytes(&mut self, dest: &mut [u8]) {`
`108`	`107`	`self.0.fill_bytes(dest)`
`109`	`108`	`}`
`110`	`109`
`111`		`- #[inline]`
`112`	`110`	`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {`
`113`	`111`	`self.0.try_fill_bytes(dest)`
`114`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,22 +78,20 @@ pub fn thread_rng() -> ThreadRng {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`impl RngCore for ThreadRng {`
`81`		`- #[inline]`
	`81`	`+ #[inline(always)]`
`82`	`82`	`fn next_u32(&mut self) -> u32 {`
`83`	`83`	`self.rng.borrow_mut().next_u32()`
`84`	`84`	`}`
`85`	`85`
`86`		`- #[inline]`
	`86`	`+ #[inline(always)]`
`87`	`87`	`fn next_u64(&mut self) -> u64 {`
`88`	`88`	`self.rng.borrow_mut().next_u64()`
`89`	`89`	`}`
`90`	`90`
`91`		`- #[inline]`
`92`	`91`	`fn fill_bytes(&mut self, bytes: &mut [u8]) {`
`93`	`92`	`self.rng.borrow_mut().fill_bytes(bytes)`
`94`	`93`	`}`
`95`		`-`
`96`		`- #[inline]`
	`94`	`+`
`97`	`95`	`fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {`
`98`	`96`	`self.rng.borrow_mut().try_fill_bytes(dest)`
`99`	`97`	`}`