github/ValueScript
1
1
Fork 0
mirror of https://github.com/voltrevo/ValueScript.git synced 2026-04-18 03:00:27 -04:00
Code Issues Packages Projects Releases Wiki Activity

key -> ptr

Browse Source
This commit is contained in:
Andrew Morris
2023-10-30 11:55:17 +11:00
parent eee410d6d0
commit e5dea00280
7 changed files with 67 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
storage/src/memory_backend.rs
View File

@@ -65,14 +65,14 @@ impl<'a, E> StorageBackendHandle<'a, E> for MemoryStorageHandle<'a> {
&mut self.cache
}
fn read_bytes<T>(&self, key: StoragePtr<T>) -> Result<Option<Vec<u8>>, E> {
Ok(self.storage.data.get(&key.data).cloned())
fn read_bytes<T>(&self, ptr: StoragePtr<T>) -> Result<Option<Vec<u8>>, E> {
Ok(self.storage.data.get(&ptr.data).cloned())
}
fn write_bytes<T>(&mut self, key: StoragePtr<T>, data: Option<Vec<u8>>) -> Result<(), E> {
fn write_bytes<T>(&mut self, ptr: StoragePtr<T>, data: Option<Vec<u8>>) -> Result<(), E> {
match data {
Some(data) => self.storage.data.insert(key.data, data),
None => self.storage.data.remove(&key.data),
Some(data) => self.storage.data.insert(ptr.data, data),
None => self.storage.data.remove(&ptr.data),
};
Ok(())

10
storage/src/sled_backend.rs
View File

@@ -78,20 +78,20 @@ impl<'a, E> StorageBackendHandle<'a, sled::transaction::ConflictableTransactionE
fn read_bytes<T>(
&self,
key: StoragePtr<T>,
ptr: StoragePtr<T>,
) -> Result<Option<Vec<u8>>, sled::transaction::ConflictableTransactionError<E>> {
let value = self.tx.get(key.to_bytes())?.map(|value| value.to_vec());
let value = self.tx.get(ptr.to_bytes())?.map(|value| value.to_vec());
Ok(value)
}
fn write_bytes<T>(
&mut self,
key: StoragePtr<T>,
ptr: StoragePtr<T>,
data: Option<Vec<u8>>,
) -> Result<(), sled::transaction::ConflictableTransactionError<E>> {
match data {
Some(data) => self.tx.insert(key.to_bytes(), data)?,
None => self.tx.remove(key.to_bytes())?,
Some(data) => self.tx.insert(ptr.to_bytes(), data)?,
None => self.tx.remove(ptr.to_bytes())?,
};
Ok(())

10
storage/src/storage.rs
View File

@@ -32,11 +32,9 @@ impl<SB: StorageBackend> Storage<SB> {
sb.write(tmp_count_ptr(), Some(&(tmp_count + 1)))?;
let key = sb
.read(tmp_ptr)?
.unwrap_or_else(|| panic!("Missing tmp key"));
let ptr = sb.read(tmp_ptr)?.unwrap_or_else(|| panic!("Ptr not found"));
Ok(key)
Ok(ptr)
})
}
@@ -61,10 +59,10 @@ impl<SB: StorageBackend> Storage<SB> {
#[cfg(test)]
pub(crate) fn get_ref_count(
&mut self,
key: StorageEntryPtr,
ptr: StorageEntryPtr,
) -> Result<Option<u64>, SB::Error<()>> {
self
.sb
.transaction(|sb| Ok(sb.read(key)?.map(|entry| entry.ref_count)))
.transaction(|sb| Ok(sb.read(ptr)?.map(|entry| entry.ref_count)))
}
}

4
storage/src/storage_backend.rs
View File

@@ -8,8 +8,8 @@ use crate::{
pub trait StorageBackendHandle<'a, E> {
fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64>;
fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr>;
fn read_bytes<T>(&self, key: StoragePtr<T>) -> Result<Option<Vec<u8>>, E>;
fn write_bytes<T>(&mut self, key: StoragePtr<T>, data: Option<Vec<u8>>) -> Result<(), E>;
fn read_bytes<T>(&self, ptr: StoragePtr<T>) -> Result<Option<Vec<u8>>, E>;
fn write_bytes<T>(&mut self, ptr: StoragePtr<T>, data: Option<Vec<u8>>) -> Result<(), E>;
}
pub trait StorageBackend {

76
storage/src/storage_ops.rs
View File

@@ -11,8 +11,8 @@ use crate::{
};
pub trait StorageOps<E> {
fn read<T: for<'de> Deserialize<'de>>(&mut self, key: StoragePtr<T>) -> Result<Option<T>, E>;
fn write<T: Serialize>(&mut self, key: StoragePtr<T>, data: Option<&T>) -> Result<(), E>;
fn read<T: for<'de> Deserialize<'de>>(&mut self, ptr: StoragePtr<T>) -> Result<Option<T>, E>;
fn write<T: Serialize>(&mut self, ptr: StoragePtr<T>, data: Option<&T>) -> Result<(), E>;
fn get_head(&mut self, ptr: StorageHeadPtr) -> Result<Option<StorageVal>, E>;
fn set_head(&mut self, ptr: StorageHeadPtr, value: Option<&StorageVal>) -> Result<(), E>;
@@ -20,7 +20,7 @@ pub trait StorageOps<E> {
fn store_with_replacements(&mut self, value: &StorageVal) -> Result<StorageEntryPtr, E>;
fn store(&mut self, value: &StorageVal) -> Result<StorageEntryPtr, E>;
fn ref_delta<T>(&mut self, key: StoragePtr<T>, delta: i64) -> Result<(), E>;
fn ref_delta<T>(&mut self, ptr: StoragePtr<T>, delta: i64) -> Result<(), E>;
fn flush_ref_deltas(&mut self) -> Result<(), E>;
fn cache_get(&mut self, key: RcKey) -> Option<StorageEntryPtr>;
@@ -31,8 +31,8 @@ impl<'a, Handle, E> StorageOps<E> for Handle
where
Handle: StorageBackendHandle<'a, E>,
{
fn read<T: for<'de> Deserialize<'de>>(&mut self, key: StoragePtr<T>) -> Result<Option<T>, E> {
let data = match self.read_bytes(key)? {
fn read<T: for<'de> Deserialize<'de>>(&mut self, ptr: StoragePtr<T>) -> Result<Option<T>, E> {
let data = match self.read_bytes(ptr)? {
Some(data) => data,
None => return Ok(None),
};
@@ -40,63 +40,63 @@ where
Ok(Some(bincode::deserialize(&data).unwrap()))
}
fn write<T: Serialize>(&mut self, key: StoragePtr<T>, data: Option<&T>) -> Result<(), E> {
self.write_bytes(key, data.map(|data| bincode::serialize(&data).unwrap()))
fn write<T: Serialize>(&mut self, ptr: StoragePtr<T>, data: Option<&T>) -> Result<(), E> {
self.write_bytes(ptr, data.map(|data| bincode::serialize(&data).unwrap()))
}
fn get_head(&mut self, ptr: StorageHeadPtr) -> Result<Option<StorageVal>, E> {
let key = match self.read(ptr)? {
Some(key) => key,
fn get_head(&mut self, head_ptr: StorageHeadPtr) -> Result<Option<StorageVal>, E> {
let entry_ptr = match self.read(head_ptr)? {
Some(entry_ptr) => entry_ptr,
None => return Ok(None),
};
let value = self.read(key)?.map(StorageVal::from_entry);
let value = self.read(entry_ptr)?.map(StorageVal::from_entry);
Ok(value)
}
fn set_head(&mut self, ptr: StorageHeadPtr, value: Option<&StorageVal>) -> Result<(), E> {
fn set_head(&mut self, head_ptr: StorageHeadPtr, value: Option<&StorageVal>) -> Result<(), E> {
if let Some(value) = value {
let key = self.store_with_replacements(value)?;
self.ref_delta(key, 1)?;
let entry_ptr = self.store_with_replacements(value)?;
self.ref_delta(entry_ptr, 1)?;
if let Some(old_key) = self.read(ptr)? {
self.ref_delta(old_key, -1)?;
if let Some(old_entry_ptr) = self.read(head_ptr)? {
self.ref_delta(old_entry_ptr, -1)?;
}
self.write(ptr, Some(&key))
self.write(head_ptr, Some(&entry_ptr))
} else {
if let Some(old_key) = self.read(ptr)? {
self.ref_delta(old_key, -1)?;
if let Some(old_entry_ptr) = self.read(head_ptr)? {
self.ref_delta(old_entry_ptr, -1)?;
}
self.write(ptr, None)
self.write(head_ptr, None)
}
}
fn store_with_replacements(&mut self, value: &StorageVal) -> Result<StorageEntryPtr, E> {
if let Some(key) = value.maybe_replace_store(self)? {
return Ok(key);
if let Some(ptr) = value.maybe_replace_store(self)? {
return Ok(ptr);
}
self.store(value)
}
fn store(&mut self, value: &StorageVal) -> Result<StorageEntryPtr, E> {
let key = StoragePtr::random(&mut thread_rng());
let ptr = StoragePtr::random(&mut thread_rng());
let entry = value.to_entry();
self.write(key, Some(&entry))?;
self.ref_delta(key, -1)?; // Cancel out the assumed single reference
self.write(ptr, Some(&entry))?;
self.ref_delta(ptr, -1)?; // Cancel out the assumed single reference
for subkey in &entry.refs {
self.ref_delta(*subkey, 1)?;
for subptr in &entry.refs {
self.ref_delta(*subptr, 1)?;
}
Ok(key)
Ok(ptr)
}
fn ref_delta<T>(&mut self, key: StoragePtr<T>, delta: i64) -> Result<(), E> {
let ref_delta = self.ref_deltas().entry(key.data).or_insert(0);
fn ref_delta<T>(&mut self, ptr: StoragePtr<T>, delta: i64) -> Result<(), E> {
let ref_delta = self.ref_deltas().entry(ptr.data).or_insert(0);
*ref_delta += delta;
Ok(())
@@ -106,18 +106,18 @@ where
while !self.ref_deltas().is_empty() {
let ref_deltas = take(self.ref_deltas());
for (key, delta) in ref_deltas.iter() {
for (ptr, delta) in ref_deltas.iter() {
let delta = *delta;
if delta <= 0 {
continue;
}
let ptr = StorageEntryPtr::from_data(*key);
let ptr = StorageEntryPtr::from_data(*ptr);
let mut entry = match self.read(ptr)? {
Some(entry) => entry,
None => panic!("Key does not exist"),
None => panic!("Ptr not found"),
};
entry.ref_count += delta as u64;
@@ -125,27 +125,27 @@ where
self.write(ptr, Some(&entry))?;
}
for (key, delta) in ref_deltas.iter() {
for (ptr, delta) in ref_deltas.iter() {
let delta = *delta;
if delta >= 0 {
continue;
}
let ptr = StorageEntryPtr::from_data(*key);
let ptr = StorageEntryPtr::from_data(*ptr);
let decrement = (-delta) as u64;
let mut entry = match self.read(ptr)? {
Some(entry) => entry,
None => panic!("Key does not exist"),
None => panic!("Ptr not found"),
};
if entry.ref_count == decrement {
self.write(ptr, None)?;
for subkey in entry.refs.iter() {
self.ref_delta(*subkey, -1)?;
for subptr in entry.refs.iter() {
self.ref_delta(*subptr, -1)?;
}
continue;

18
storage/src/storage_ptr.rs
View File

@@ -42,9 +42,9 @@ impl<T> StoragePtr<T> {
panic!("Too many bytes");
}
let mut key = [0u8; 24];
key[..bytes.len()].copy_from_slice(bytes);
bincode::deserialize(&key).unwrap()
let mut ptr = [0u8; 24];
ptr[..bytes.len()].copy_from_slice(bytes);
bincode::deserialize(&ptr).unwrap()
}
pub(crate) fn from_data(data: (u64, u64, u64)) -> Self {
@@ -71,15 +71,15 @@ pub fn storage_head_ptr(name: &[u8]) -> StorageHeadPtr {
}
pub(crate) fn tmp_count_ptr() -> StoragePtr<u64> {
let mut key = StoragePtr::<u64>::from_bytes(b"tmp");
key.data.2 = 1;
let mut ptr = StoragePtr::<u64>::from_bytes(b"tmp");
ptr.data.2 = 1;
key
ptr
}
pub(crate) fn tmp_at_ptr(i: u64) -> StorageHeadPtr {
let mut key = StorageHeadPtr::from_bytes(b"tmp");
key.data.2 = i + 2;
let mut ptr = StorageHeadPtr::from_bytes(b"tmp");
ptr.data.2 = i + 2;
key
ptr
}

8
storage/src/storage_val.rs
View File

@@ -88,8 +88,8 @@ impl StorageVal {
tx: &mut SO,
) -> Result<Option<StorageEntryPtr>, E> {
if let Some(id) = self.cache_id() {
if let Some(key) = tx.cache_get(id) {
return Ok(Some(key));
if let Some(ptr) = tx.cache_get(id) {
return Ok(Some(ptr));
}
}
@@ -100,8 +100,8 @@ impl StorageVal {
let mut replacements: Vec<(usize, StorageEntryPtr)> = Vec::new();
for i in 0..arr.items.len() {
if let Some(key) = arr.items[i].maybe_replace_store(tx)? {
replacements.push((i, key));
if let Some(ptr) = arr.items[i].maybe_replace_store(tx)? {
replacements.push((i, ptr));
}
}