Implement --deterministic, for chaotic but repeatable color selection

src/bin/flamegraph.rs

@@ -20,10 +20,15 @@ struct Opt {
     #[structopt(long = "cp")]
     cp: bool,
 
-    /// Colors are keyed by function name hash
-    #[structopt(long = "hash")]
+    /// Colors are selected by hashing the function name, weighting earlier characters more
+    /// heavily
+    #[structopt(long = "hash", conflicts_with = "deterministic")]
     hash: bool,
 
+    /// Colors are selected such that the color of a function does not change between runs
+    #[structopt(long = "deterministic")]
+    deterministic: bool,
+
     /// Plot the flame graph up-side-down
     #[structopt(short = "i", long = "inverted")]
     inverted: bool,
@@ -208,6 +213,7 @@ impl<'a> Opt {
         options.colors = self.colors;
         options.bgcolors = self.bgcolors;
         options.hash = self.hash;
+        options.deterministic = self.deterministic;
 
         self.set_func_frameattrs(&mut options);
 

src/flamegraph/color/mod.rs

@@ -331,6 +331,7 @@ fn rgb_components_for_palette(palette: Palette, name: &str, v1: f32, v2: f32, v3
 pub(super) fn color(
     palette: Palette,
     hash: bool,
+    deterministic: bool,
     name: &str,
     mut rng: impl FnMut() -> f32,
 ) -> Color {
@@ -339,6 +340,19 @@ pub(super) fn color(
         let reverse_name_hash = namehash(name.bytes().rev());
 
         (name_hash, reverse_name_hash, reverse_name_hash)
+    } else if deterministic {
+        use std::hash::Hasher;
+        let prefixed_hash = |name: &str, prefix: u8| {
+            let mut hasher = ahash::AHasher::default();
+            hasher.write_u8(prefix);
+            hasher.write(name.as_bytes());
+            (hasher.finish() as f64 / u64::MAX as f64) as f32
+        };
+        (
+            prefixed_hash(name, 0),
+            prefixed_hash(name, 1),
+            prefixed_hash(name, 2),
+        )
     } else {
         (rng(), rng(), rng())
     };

src/flamegraph/mod.rs

@@ -107,6 +107,10 @@ pub struct Options<'a> {
     /// This will cause similar functions to be colored similarly.
     pub hash: bool,
 
+    /// Choose names based on the hashes of function names, without the weighting scheme that
+    /// `hash` uses.
+    pub deterministic: bool,
+
     /// Store the choice of color for each function so that later invocations use the same colors.
     ///
     /// With this option enabled, a file called `palette.map` will be created the first time a
@@ -297,6 +301,7 @@ impl<'a> Default for Options<'a> {
             subtitle: Default::default(),
             bgcolors: Default::default(),
             hash: Default::default(),
+            deterministic: Default::default(),
             palette_map: Default::default(),
             direction: Default::default(),
             negate_differentials: Default::default(),
@@ -623,13 +628,15 @@ where
         } else if let Some(ref mut palette_map) = opt.palette_map {
             let colors = opt.colors;
             let hash = opt.hash;
+            let deterministic = opt.deterministic;
             palette_map.find_color_for(&frame.location.function, |name| {
-                color::color(colors, hash, name, &mut thread_rng)
+                color::color(colors, hash, deterministic, name, &mut thread_rng)
             })
         } else {
             color::color(
                 opt.colors,
                 opt.hash,
+                opt.deterministic,
                 frame.location.function,
                 &mut thread_rng,
             )