refactor(example): change examples stress function

Author: omarabid

examples/async.rs

@@ -1,19 +1,34 @@
 extern crate pyroscope;
 
 use pyroscope::{PyroscopeAgent, Result};
+use std::hash::{Hash, Hasher};
 
-fn fibonacci1(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci1(n - 1) + fibonacci1(n - 2),
+fn hash_rounds1(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
-fn fibonacci2(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci2(n - 1) + fibonacci2(n - 2),
+fn hash_rounds2(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 #[tokio::main]
@@ -26,14 +41,14 @@ async fn main() -> Result<()> {
     agent.start()?;
 
     tokio::task::spawn(async {
-        let n = fibonacci1(45);
+        let n = hash_rounds1(300_000);
         println!("Thread 1: {}", n);
     })
     .await
     .unwrap();
 
     tokio::task::spawn(async {
-        let n = fibonacci2(45);
+        let n = hash_rounds2(300_000);
         println!("Thread 2: {}", n);
     })
     .await

examples/backend.rs

@@ -2,12 +2,20 @@ extern crate pyroscope;
 
 use pyroscope::{PyroscopeAgent, Result};
 use pyroscope_backends::pprof::{Pprof, PprofConfig};
+use std::hash::{Hash, Hasher};
 
-fn fibonacci(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci(n - 1) + fibonacci(n - 2),
+fn hash_rounds(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 fn main() -> Result<()> {
@@ -17,7 +25,7 @@ fn main() -> Result<()> {
         .build()?;
 
     agent.start()?;
-    let _result = fibonacci(45);
+    let _result = hash_rounds(300_000);
     agent.stop()?;
 
     Ok(())

examples/basic.rs

@@ -1,12 +1,20 @@
 extern crate pyroscope;
 
 use pyroscope::{PyroscopeAgent, Result};
+use std::hash::{Hash, Hasher};
 
-fn fibonacci(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci(n - 1) + fibonacci(n - 2),
+fn hash_rounds(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 fn main() -> Result<()> {
@@ -24,7 +32,7 @@ fn main() -> Result<()> {
     // Start Agent
     agent.start()?;
 
-    let _result = fibonacci(47);
+    let _result = hash_rounds(300_000);
 
     // Show stop time
     let stop = std::time::SystemTime::now()

examples/multi-thread.rs

@@ -1,21 +1,38 @@
 extern crate pyroscope;
 
 use pyroscope::{PyroscopeAgent, Result};
-
-use std::thread;
-
-fn fibonacci1(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci1(n - 1) + fibonacci1(n - 2),
+use std::{
+    collections::hash_map::DefaultHasher,
+    hash::{Hash, Hasher},
+    thread,
+};
+
+fn hash_rounds1(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
-fn fibonacci2(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci2(n - 1) + fibonacci2(n - 2),
+fn hash_rounds2(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 fn main() -> Result<()> {
@@ -26,11 +43,11 @@ fn main() -> Result<()> {
     agent.start()?;
 
     let handle_1 = thread::spawn(|| {
-        fibonacci1(45);
+        hash_rounds1(300_000);
     });
 
     let handle_2 = thread::spawn(|| {
-        fibonacci2(45);
+        hash_rounds2(500_000);
     });
 
     // Wait for the threads to complete

examples/tags.rs

@@ -1,12 +1,20 @@
 extern crate pyroscope;
 
 use pyroscope::{PyroscopeAgent, Result};
+use std::hash::{Hash, Hasher};
 
-fn fibonacci(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci(n - 1) + fibonacci(n - 2),
+fn hash_rounds(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 fn main() -> Result<()> {
@@ -18,13 +26,13 @@ fn main() -> Result<()> {
     agent.start()?;
 
     // Make some calculation
-    let _result = fibonacci(47);
+    let _result = hash_rounds(300_000);
 
     // Add Tags
     agent.add_tags(&[("series", "Number 2")])?;
 
     // Do more calculation
-    let _result = fibonacci(47);
+    let _result = hash_rounds(500_000);
 
     // Stop Agent
     agent.stop()?;

examples/with-logger.rs

@@ -3,12 +3,20 @@ extern crate pyroscope;
 use log::info;
 
 use pyroscope::{PyroscopeAgent, Result};
+use std::hash::{Hash, Hasher};
 
-fn fibonacci(n: u64) -> u64 {
-    match n {
-        0 | 1 => 1,
-        n => fibonacci(n - 1) + fibonacci(n - 2),
+fn hash_rounds(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
     }
+
+    n
 }
 
 fn main() -> Result<()> {
@@ -26,7 +34,7 @@ fn main() -> Result<()> {
     // Start Agent
     agent.start()?;
 
-    let _result = fibonacci(47);
+    let _result = hash_rounds(300_000);
 
     // Stop Agent
     agent.stop()?;