De-intern Sha

Author: Mark-Simulacrum

collector/src/lib.rs

@@ -1,5 +1,5 @@
 use chrono::NaiveDate;
-pub use database::{Commit, PatchName, QueryLabel, Sha};
+pub use database::{Commit, PatchName, QueryLabel};
 use serde::Deserialize;
 use std::cmp::PartialOrd;
 use std::fmt;

database/src/lib.rs

@@ -141,106 +141,9 @@ impl<'de> Deserialize<'de> for Date {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Sha {
-    /// Straight-up bytes of the 40-long hex-encoded sha
-    Hex([u8; 20]),
-    /// Usually a string ID provided by the user.
-    Raw(RawSha),
-}
-
-intern!(pub struct RawSha);
-
-impl PartialEq<str> for Sha {
-    fn eq(&self, other: &str) -> bool {
-        self.to_string() == other
-    }
-}
-
-fn hex_decode(s: &str) -> Option<[u8; 20]> {
-    let mut in_progress = 0;
-    let mut v = [0; 20];
-    for (idx, ch) in s.chars().enumerate() {
-        let offset = if idx % 2 == 0 { 4 } else { 0 };
-        in_progress |= (ch.to_digit(16)? as u8) << offset;
-        if idx % 2 != 0 {
-            v[idx / 2] = in_progress;
-            in_progress = 0;
-        }
-    }
-    Some(v)
-}
-
-impl<'a> From<&'a str> for Sha {
-    fn from(s: &'a str) -> Sha {
-        if let Some(v) = hex_decode(s) {
-            return Sha::Hex(v);
-        }
-
-        Sha::Raw(s.into())
-    }
-}
-
-impl Serialize for Sha {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        serializer.collect_str(&self)
-    }
-}
-
-impl<'de> Deserialize<'de> for Sha {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        use serde::de::Visitor;
-        struct ShaVisitor;
-        impl<'de> Visitor<'de> for ShaVisitor {
-            type Value = Sha;
-
-            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.write_str("a string")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Sha, E> {
-                Ok(s.into())
-            }
-
-            fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Sha, E> {
-                Ok(s.into())
-            }
-        }
-        deserializer.deserialize_str(ShaVisitor)
-    }
-}
-
-impl fmt::Debug for Sha {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self)
-    }
-}
-
-impl fmt::Display for Sha {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Sha::Hex(hex) => {
-                for &b in hex.iter() {
-                    write!(f, "{:x}{:x}", b >> 4, b & 0xf)?;
-                }
-            }
-            Sha::Raw(raw) => {
-                write!(f, "{}", raw)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Copy, Clone, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct Commit {
-    pub sha: Sha,
+    pub sha: String,
     pub date: Date,
 }
 
@@ -709,7 +612,7 @@ impl Index {
     }
 
     pub fn commits(&self) -> Vec<Commit> {
-        let mut commits = self.commits.map.keys().copied().collect::<Vec<_>>();
+        let mut commits = self.commits.map.keys().cloned().collect::<Vec<_>>();
         commits.sort();
         commits
     }

site/src/api.rs

@@ -108,7 +108,7 @@ pub mod data {
 }
 
 pub mod graph {
-    use collector::{Bound, Sha};
+    use collector::Bound;
     use serde::{Deserialize, Serialize};
     use std::collections::HashMap;
 
@@ -135,7 +135,7 @@ pub mod graph {
         pub benchmarks: HashMap<String, HashMap<String, Vec<(String, Vec<GraphData>)>>>,
         pub max: HashMap<String, f32>,
         pub colors: Vec<String>,
-        pub commits: Vec<Sha>,
+        pub commits: Vec<String>,
     }
 }
 

site/src/load.rs

@@ -26,7 +26,7 @@ use database::Date;
 use crate::api::github;
 use collector;
 use database::Pool;
-pub use database::{ArtifactId, Commit, Crate, Sha};
+pub use database::{ArtifactId, Commit, Crate};
 
 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub enum MissingReason {
@@ -73,7 +73,7 @@ pub struct Keys {
 pub struct Config {
     pub keys: Keys,
     #[serde(default)]
-    pub skip: HashSet<Sha>,
+    pub skip: HashSet<String>,
 }
 
 pub struct InputData {
@@ -167,8 +167,7 @@ impl InputData {
             .cloned()
             .filter(|c| now.signed_duration_since(c.time) < Duration::days(29))
             .filter_map(|c| {
-                let sha = c.sha.as_str().into();
-                if have.contains(&sha) || self.config.skip.contains(&sha) {
+                if have.contains(&c.sha) || self.config.skip.contains(&c.sha) {
                     None
                 } else {
                     Some((c, MissingReason::Sha))
@@ -208,7 +207,7 @@ impl InputData {
                     ret
                 },
             )
-            .filter(|c| !have.contains(&c.0.sha.as_str().into())) // we may have not updated the try-commits file
+            .filter(|c| !have.contains(&c.0.sha)) // we may have not updated the try-commits file
             .chain(missing)
             .collect::<Vec<_>>();
 

site/src/server.rs

@@ -45,7 +45,6 @@ use crate::interpolate::Interpolated;
 use crate::load::{Config, InputData};
 use crate::selector::{self, PathComponent, Tag};
 use collector::api::collected;
-use collector::Sha;
 use db::{ArtifactId, Lookup};
 use parking_lot::RwLock;
 
@@ -251,12 +250,12 @@ fn prettify_log(log: &str) -> Option<String> {
 
 pub async fn handle_status_page(data: Arc<InputData>) -> status::Response {
     let idx = data.index.load();
-    let last_commit = *idx.commits().last().unwrap();
+    let last_commit = idx.commits().last().unwrap().clone();
 
     let mut benchmark_state = data
         .conn()
         .await
-        .get_error(ArtifactId::from(last_commit).lookup(&idx).unwrap())
+        .get_error(ArtifactId::from(last_commit.clone()).lookup(&idx).unwrap())
         .await
         .into_iter()
         .map(|(name, error)| {
@@ -300,8 +299,8 @@ pub async fn handle_next_commit(data: Arc<InputData>) -> collector::api::next_co
 }
 
 struct CommitIdxCache {
-    commit_idx: RefCell<HashMap<Sha, u16>>,
-    commits: RefCell<Vec<Sha>>,
+    commit_idx: RefCell<HashMap<String, u16>>,
+    commits: RefCell<Vec<String>>,
 }
 
 impl CommitIdxCache {
@@ -312,15 +311,15 @@ impl CommitIdxCache {
         }
     }
 
-    fn into_commits(self) -> Vec<Sha> {
+    fn into_commits(self) -> Vec<String> {
         std::mem::take(&mut *self.commits.borrow_mut())
     }
 
-    fn lookup(&self, commit: Sha) -> u16 {
+    fn lookup(&self, commit: String) -> u16 {
         *self
             .commit_idx
             .borrow_mut()
-            .entry(commit)
+            .entry(commit.clone())
             .or_insert_with(|| {
                 let idx = self.commits.borrow().len();
                 self.commits.borrow_mut().push(commit);
@@ -365,7 +364,7 @@ fn to_graph_data<'a>(
 pub async fn handle_graph(body: graph::Request, data: &InputData) -> ServerResult<graph::Response> {
     let cc = CommitIdxCache::new();
     let range = data.data_range(body.start.clone()..=body.end.clone());
-    let commits: Arc<Vec<_>> = Arc::new(range.iter().map(|&c| c.into()).collect());
+    let commits: Arc<Vec<_>> = Arc::new(range.iter().map(|c| c.clone().into()).collect());
 
     let stat_selector = selector::Selector::One(body.stat.clone());
 
@@ -556,13 +555,13 @@ impl DateData {
         }
 
         DateData {
-            date: if let ArtifactId::Commit(c) = commit {
+            date: if let ArtifactId::Commit(c) = &commit {
                 Some(c.date)
             } else {
                 None
             },
             commit: match commit {
-                ArtifactId::Commit(c) => c.sha.to_string(),
+                ArtifactId::Commit(c) => c.sha,
                 ArtifactId::Artifact(i) => i,
             },
             data,
@@ -704,9 +703,9 @@ pub async fn handle_self_profile(
 
     let mut commits = vec![index
         .commits()
-        .iter()
+        .into_iter()
         .find(|c| c.sha == *body.commit.as_str())
-        .map(|c| database::ArtifactId::Commit(*c))
+        .map(|c| database::ArtifactId::Commit(c))
         .or_else(|| {
             index
                 .artifacts()
@@ -719,9 +718,9 @@ pub async fn handle_self_profile(
         commits.push(
             index
                 .commits()
-                .iter()
+                .into_iter()
                 .find(|c| c.sha == *bc.as_str())
-                .map(|c| database::ArtifactId::Commit(*c))
+                .map(|c| database::ArtifactId::Commit(c))
                 .or_else(|| {
                     index
                         .artifacts()