fluencelabs/parity-wasm
1
0
Fork 0
mirror of https://github.com/fluencelabs/parity-wasm synced 2025-06-20 10:16:49 +00:00
Code Issues Projects Releases Wiki Activity

Use RefCell instead of RwLock

Browse Source
This commit is contained in:
Sergey Pepyakin
2017-12-18 16:13:14 +03:00
parent e74b47758a
commit 4946bf957c
2 changed files with 18 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/interpreter/memory.rs
View File

@ -2,7 +2,7 @@ use std::u32;
use std::ops::Range; use std::ops::Range;
use std::cmp; use std::cmp;
use std::fmt; use std::fmt;
use parking_lot::RwLock; use std::cell::RefCell;
use elements::{MemoryType, ResizableLimits}; use elements::{MemoryType, ResizableLimits};
use interpreter::Error; use interpreter::Error;
use interpreter::module::check_limits; use interpreter::module::check_limits;
@ -17,7 +17,7 @@ pub struct MemoryInstance {
/// Memofy limits. /// Memofy limits.
limits: ResizableLimits, limits: ResizableLimits,
/// Linear memory buffer. /// Linear memory buffer.
buffer: RwLock<Vec<u8>>, buffer: RefCell<Vec<u8>>,
/// Maximum buffer size. /// Maximum buffer size.
maximum_size: u32, maximum_size: u32,
} }
@ -26,7 +26,7 @@ impl fmt::Debug for MemoryInstance {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("MemoryInstance") f.debug_struct("MemoryInstance")
.field("limits", &self.limits) .field("limits", &self.limits)
.field("buffer.len", &self.buffer.read().len()) .field("buffer.len", &self.buffer.borrow().len())
.field("maximum_size", &self.maximum_size) .field("maximum_size", &self.maximum_size)
.finish() .finish()
} }
@ -71,7 +71,7 @@ impl MemoryInstance {
let memory = MemoryInstance { let memory = MemoryInstance {
limits: memory_type.limits().clone(), limits: memory_type.limits().clone(),
buffer: RwLock::new(vec![0; initial_size as usize]), buffer: RefCell::new(vec![0; initial_size as usize]),
maximum_size: maximum_size, maximum_size: maximum_size,
}; };
@ -85,12 +85,12 @@ impl MemoryInstance {
/// Return linear memory size (in pages). /// Return linear memory size (in pages).
pub fn size(&self) -> u32 { pub fn size(&self) -> u32 {
self.buffer.read().len() as u32 / LINEAR_MEMORY_PAGE_SIZE self.buffer.borrow().len() as u32 / LINEAR_MEMORY_PAGE_SIZE
} }
/// Get data at given offset. /// Get data at given offset.
pub fn get(&self, offset: u32, size: usize) -> Result<Vec<u8>, Error> { pub fn get(&self, offset: u32, size: usize) -> Result<Vec<u8>, Error> {
let buffer = self.buffer.read(); let buffer = self.buffer.borrow();
let region = self.checked_region(&buffer, offset as usize, size)?; let region = self.checked_region(&buffer, offset as usize, size)?;
Ok(region.slice().to_vec()) Ok(region.slice().to_vec())
@ -98,7 +98,7 @@ impl MemoryInstance {
/// Write memory slice into another slice /// Write memory slice into another slice
pub fn get_into(&self, offset: u32, target: &mut [u8]) -> Result<(), Error> { pub fn get_into(&self, offset: u32, target: &mut [u8]) -> Result<(), Error> {
let buffer = self.buffer.read(); let buffer = self.buffer.borrow();
let region = self.checked_region(&buffer, offset as usize, target.len())?; let region = self.checked_region(&buffer, offset as usize, target.len())?;
target.copy_from_slice(region.slice()); target.copy_from_slice(region.slice());
@ -108,7 +108,7 @@ impl MemoryInstance {
/// Set data at given offset. /// Set data at given offset.
pub fn set(&self, offset: u32, value: &[u8]) -> Result<(), Error> { pub fn set(&self, offset: u32, value: &[u8]) -> Result<(), Error> {
let mut buffer = self.buffer.write(); let mut buffer = self.buffer.borrow_mut();
let range = self.checked_region(&buffer, offset as usize, value.len())?.range(); let range = self.checked_region(&buffer, offset as usize, value.len())?.range();
buffer[range].copy_from_slice(value); buffer[range].copy_from_slice(value);
@ -119,7 +119,7 @@ impl MemoryInstance {
/// Increases the size of the linear memory by given number of pages. /// Increases the size of the linear memory by given number of pages.
/// Returns -1 if allocation fails or previous memory size, if succeeds. /// Returns -1 if allocation fails or previous memory size, if succeeds.
pub fn grow(&self, pages: u32) -> Result<u32, Error> { pub fn grow(&self, pages: u32) -> Result<u32, Error> {
let mut buffer = self.buffer.write(); let mut buffer = self.buffer.borrow_mut();
let old_size = buffer.len() as u32; let old_size = buffer.len() as u32;
match calculate_memory_size(old_size, pages, self.maximum_size) { match calculate_memory_size(old_size, pages, self.maximum_size) {
None => Ok(u32::MAX), None => Ok(u32::MAX),
@ -149,7 +149,7 @@ impl MemoryInstance {
/// Copy memory region. Semantically equivalent to `memmove`. /// Copy memory region. Semantically equivalent to `memmove`.
pub fn copy(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> { pub fn copy(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> {
let buffer = self.buffer.write(); let buffer = self.buffer.borrow_mut();
let read_region = self.checked_region(&buffer, src_offset, len)?; let read_region = self.checked_region(&buffer, src_offset, len)?;
let write_region = self.checked_region(&buffer, dst_offset, len)?; let write_region = self.checked_region(&buffer, dst_offset, len)?;
@ -166,7 +166,7 @@ impl MemoryInstance {
/// Copy memory region, non-overlapping version. Semantically equivalent to `memcpy`, /// Copy memory region, non-overlapping version. Semantically equivalent to `memcpy`,
/// but returns Error if source overlaping with destination. /// but returns Error if source overlaping with destination.
pub fn copy_nonoverlapping(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> { pub fn copy_nonoverlapping(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> {
let buffer = self.buffer.write(); let buffer = self.buffer.borrow_mut();
let read_region = self.checked_region(&buffer, src_offset, len)?; let read_region = self.checked_region(&buffer, src_offset, len)?;
let write_region = self.checked_region(&buffer, dst_offset, len)?; let write_region = self.checked_region(&buffer, dst_offset, len)?;
@ -186,7 +186,7 @@ impl MemoryInstance {
/// Clear memory region with a specified value. Semantically equivalent to `memset`. /// Clear memory region with a specified value. Semantically equivalent to `memset`.
pub fn clear(&self, offset: usize, new_val: u8, len: usize) -> Result<(), Error> { pub fn clear(&self, offset: usize, new_val: u8, len: usize) -> Result<(), Error> {
let mut buffer = self.buffer.write(); let mut buffer = self.buffer.borrow_mut();
let range = self.checked_region(&buffer, offset, len)?.range(); let range = self.checked_region(&buffer, offset, len)?.range();
for val in &mut buffer[range] { *val = new_val } for val in &mut buffer[range] { *val = new_val }

12
src/interpreter/table.rs
View File

@ -1,7 +1,7 @@
use std::u32; use std::u32;
use std::fmt; use std::fmt;
use std::rc::Rc; use std::rc::Rc;
use parking_lot::RwLock; use std::cell::RefCell;
use elements::{TableType, ResizableLimits}; use elements::{TableType, ResizableLimits};
use interpreter::Error; use interpreter::Error;
use interpreter::module::check_limits; use interpreter::module::check_limits;
@ -12,7 +12,7 @@ pub struct TableInstance<St> {
/// Table limits. /// Table limits.
limits: ResizableLimits, limits: ResizableLimits,
/// Table memory buffer. /// Table memory buffer.
buffer: RwLock<Vec<Option<Rc<FuncInstance<St>>>>>, buffer: RefCell<Vec<Option<Rc<FuncInstance<St>>>>>,
} }
@ -20,7 +20,7 @@ impl<St> fmt::Debug for TableInstance<St> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("TableInstance") f.debug_struct("TableInstance")
.field("limits", &self.limits) .field("limits", &self.limits)
.field("buffer.len", &self.buffer.read().len()) .field("buffer.len", &self.buffer.borrow().len())
.finish() .finish()
} }
} }
@ -31,7 +31,7 @@ impl<St> TableInstance<St> {
check_limits(table_type.limits())?; check_limits(table_type.limits())?;
Ok(TableInstance { Ok(TableInstance {
limits: table_type.limits().clone(), limits: table_type.limits().clone(),
buffer: RwLock::new( buffer: RefCell::new(
vec![None; table_type.limits().initial() as usize] vec![None; table_type.limits().initial() as usize]
), ),
}) })
@ -44,7 +44,7 @@ impl<St> TableInstance<St> {
/// Get the specific value in the table /// Get the specific value in the table
pub fn get(&self, offset: u32) -> Result<Rc<FuncInstance<St>>, Error> { pub fn get(&self, offset: u32) -> Result<Rc<FuncInstance<St>>, Error> {
let buffer = self.buffer.read(); let buffer = self.buffer.borrow();
let buffer_len = buffer.len(); let buffer_len = buffer.len();
let table_elem = buffer.get(offset as usize).cloned().ok_or(Error::Table(format!( let table_elem = buffer.get(offset as usize).cloned().ok_or(Error::Table(format!(
"trying to read table item with index {} when there are only {} items", "trying to read table item with index {} when there are only {} items",
@ -59,7 +59,7 @@ impl<St> TableInstance<St> {
/// Set the table element to the specified function. /// Set the table element to the specified function.
pub fn set(&self, offset: u32, value: Rc<FuncInstance<St>>) -> Result<(), Error> { pub fn set(&self, offset: u32, value: Rc<FuncInstance<St>>) -> Result<(), Error> {
let mut buffer = self.buffer.write(); let mut buffer = self.buffer.borrow_mut();
let buffer_len = buffer.len(); let buffer_len = buffer.len();
let table_elem = buffer.get_mut(offset as usize).ok_or(Error::Table(format!( let table_elem = buffer.get_mut(offset as usize).ok_or(Error::Table(format!(
"trying to update table item with index {} when there are only {} items", "trying to update table item with index {} when there are only {} items",