mirror of
https://github.com/denoland/deno.git
synced 2024-12-27 01:29:14 -05:00
86c3c4f343
This gets SQLite off the flamegraph and reduces initialization time by somewhere between 0.2ms and 0.5ms. In addition, I took the opportunity to move all the cache management code to a single place and reduce duplication. While the PR has a net gain of lines, much of that is just being a bit more deliberate with how we're recovering from errors. The existing caches had various policies for dealing with cache corruption, so I've unified them and tried to isolate the decisions we make for recovery in a single place (see `open_connection` in `CacheDB`). The policy I chose was: 1. Retry twice to open on-disk caches 2. If that fails, try to delete the file and recreate it on-disk 3. If we fail to delete the file or re-create a new cache, use a fallback strategy that can be chosen per-cache: InMemory (temporary cache for the process run), BlackHole (ignore writes, return empty reads), or Error (fail on every operation). The caches all use the same general code now, and share the cache failure recovery policy. In addition, it cleans up a TODO in the `NodeAnalysisCache`.
45 lines
907 B
Rust
45 lines
907 B
Rust
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
|
|
|
use std::hash::Hasher;
|
|
|
|
/// A very fast insecure hasher that uses the xxHash algorithm.
|
|
#[derive(Default)]
|
|
pub struct FastInsecureHasher(twox_hash::XxHash64);
|
|
|
|
impl FastInsecureHasher {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
pub fn write_str(&mut self, text: &str) -> &mut Self {
|
|
self.write(text.as_bytes());
|
|
self
|
|
}
|
|
|
|
pub fn write(&mut self, bytes: &[u8]) -> &mut Self {
|
|
self.0.write(bytes);
|
|
self
|
|
}
|
|
|
|
pub fn write_u8(&mut self, value: u8) -> &mut Self {
|
|
self.0.write_u8(value);
|
|
self
|
|
}
|
|
|
|
pub fn write_u64(&mut self, value: u64) -> &mut Self {
|
|
self.0.write_u64(value);
|
|
self
|
|
}
|
|
|
|
pub fn write_hashable(
|
|
&mut self,
|
|
hashable: &impl std::hash::Hash,
|
|
) -> &mut Self {
|
|
hashable.hash(&mut self.0);
|
|
self
|
|
}
|
|
|
|
pub fn finish(&self) -> u64 {
|
|
self.0.finish()
|
|
}
|
|
}
|