forked from 1b-agent/opencadstudio-upstream
Fix 4: shared-memory
This commit is contained in:
Sebastian authored and Hakan Seven committed
1 parent
a93d425002
commit
2b898d6f22
13 files changed
+894
-92
No files matched your search
@@ -0,0 +1,473 @@
|
||||
//! Shared-memory document view for out-of-process plugins.
|
||||
//!
|
||||
//! The host owns a memory-mapped file that contains a small, read-only,
|
||||
//! rkyv-serialized view of the active document. The plugin maps the same file
|
||||
//! read-only and reads entity/layer data directly from the mapping without
|
||||
//! copying the full `CadDocument` into its own address space.
|
||||
|
||||
use std::fs::OpenOptions;
|
||||
use std::io;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicU32, AtomicU64, AtomicU8, AtomicUsize, Ordering};
|
||||
|
||||
use acadrust::{CadDocument, EntityType, Handle};
|
||||
use memmap2::{Mmap, MmapMut};
|
||||
use rkyv::{check_archived_root, to_bytes, Archive, Deserialize, Serialize};
|
||||
|
||||
use crate::host::{DocumentReader, ReaderEntity, ReaderEntityKind, ReaderPoint};
|
||||
|
||||
/// Magic number identifying a valid control page.
|
||||
const CONTROL_MAGIC: u32 = 0x4F_43_53_44; // "OCSD"
|
||||
|
||||
/// Size of the control region at the start of the mapping. Must be enough for
|
||||
/// `ControlPage` and aligned to a typical page boundary so the snapshot segments
|
||||
/// that follow are naturally aligned for rkyv.
|
||||
const CONTROL_SIZE: usize = 4096;
|
||||
|
||||
/// Information sent to the plugin so it can open the shared mapping.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DocumentViewInfo {
|
||||
/// Absolute path to the memory-mapped file.
|
||||
pub path: String,
|
||||
/// Snapshot version at the time the view was opened.
|
||||
pub version: u64,
|
||||
}
|
||||
|
||||
/// Host-side, file-backed double buffer for the document view.
|
||||
pub struct DocumentSnapshotStore {
|
||||
path: PathBuf,
|
||||
mmap: MmapMut,
|
||||
segment_size: usize,
|
||||
current_version: u64,
|
||||
}
|
||||
|
||||
impl DocumentSnapshotStore {
|
||||
/// Create a new store for `tab`. `segment_size` is the maximum size of one
|
||||
/// snapshot buffer; the file is sized to hold two segments plus the control
|
||||
/// page.
|
||||
pub fn new(tab: usize, segment_size: usize) -> io::Result<Self> {
|
||||
let segment_size = segment_size.next_multiple_of(4096);
|
||||
static STORE_ID: AtomicUsize = AtomicUsize::new(0);
|
||||
let id = STORE_ID.fetch_add(1, Ordering::Relaxed);
|
||||
let path = Self::temp_path(tab, id);
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.open(&path)?;
|
||||
let total = CONTROL_SIZE + 2 * segment_size;
|
||||
file.set_len(total as u64)?;
|
||||
|
||||
let mut mmap = unsafe { MmapMut::map_mut(&file)? };
|
||||
let control = ControlPage::from_bytes_mut(&mut mmap);
|
||||
control.magic.store(CONTROL_MAGIC, Ordering::Relaxed);
|
||||
control.version.store(0, Ordering::Relaxed);
|
||||
control.active_segment.store(0, Ordering::Relaxed);
|
||||
control.active_len.store(0, Ordering::Relaxed);
|
||||
mmap.flush()?;
|
||||
|
||||
Ok(Self {
|
||||
path,
|
||||
mmap,
|
||||
segment_size,
|
||||
current_version: 0,
|
||||
})
|
||||
}
|
||||
|
||||
fn temp_path(tab: usize, id: usize) -> PathBuf {
|
||||
let mut path = std::env::temp_dir();
|
||||
path.push(format!(
|
||||
"ocs_plugin_doc_{}_{}_{}_{}.bin",
|
||||
std::process::id(),
|
||||
tab,
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_millis(),
|
||||
id,
|
||||
));
|
||||
path
|
||||
}
|
||||
|
||||
/// Path the plugin should open to access the mapping.
|
||||
pub fn path(&self) -> &Path {
|
||||
&self.path
|
||||
}
|
||||
|
||||
/// Serialize `doc` into the inactive segment and atomically publish it.
|
||||
pub fn publish(&mut self, doc: &CadDocument) -> io::Result<()> {
|
||||
let data = DocumentViewData::from(doc);
|
||||
let bytes = to_bytes::<_, 256>(&data).map_err(|e| {
|
||||
io::Error::new(io::ErrorKind::InvalidData, format!("rkyv serialize: {e}"))
|
||||
})?;
|
||||
if bytes.len() > self.segment_size {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::OutOfMemory,
|
||||
format!(
|
||||
"document view {} bytes exceeds segment size {}",
|
||||
bytes.len(),
|
||||
self.segment_size
|
||||
),
|
||||
));
|
||||
}
|
||||
|
||||
let inactive = {
|
||||
let control = ControlPage::from_bytes_mut(&mut self.mmap);
|
||||
let active = control.active_segment.load(Ordering::Acquire) as usize;
|
||||
1 - active
|
||||
};
|
||||
let offset = CONTROL_SIZE + inactive * self.segment_size;
|
||||
|
||||
self.mmap[offset..offset + bytes.len()].copy_from_slice(&bytes);
|
||||
let control = ControlPage::from_bytes_mut(&mut self.mmap);
|
||||
// Ensure the plugin sees the new length before it sees the new version.
|
||||
control
|
||||
.active_len
|
||||
.store(bytes.len() as u64, Ordering::Release);
|
||||
control
|
||||
.active_segment
|
||||
.store(inactive as u8, Ordering::Release);
|
||||
self.current_version = self.current_version.wrapping_add(1);
|
||||
control
|
||||
.version
|
||||
.store(self.current_version, Ordering::Release);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Current published version.
|
||||
pub fn version(&self) -> u64 {
|
||||
ControlPage::from_bytes(&self.mmap)
|
||||
.version
|
||||
.load(Ordering::Acquire)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DocumentSnapshotStore {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.path);
|
||||
}
|
||||
}
|
||||
|
||||
/// Plugin-side read-only mapping of the host's document view.
|
||||
pub struct SharedDocumentReader {
|
||||
mmap: Mmap,
|
||||
segment_size: usize,
|
||||
cached_version: u64,
|
||||
}
|
||||
|
||||
impl SharedDocumentReader {
|
||||
/// Open the file at `path` read-only and map it. The mapping may initially
|
||||
/// contain no valid snapshot; the caller should `refresh()` before use.
|
||||
pub fn open(path: &Path) -> io::Result<Self> {
|
||||
let file = OpenOptions::new().read(true).open(path)?;
|
||||
let mmap = unsafe { Mmap::map(&file)? };
|
||||
let file_len = mmap.len();
|
||||
let segment_size = if file_len > CONTROL_SIZE {
|
||||
(file_len - CONTROL_SIZE) / 2
|
||||
} else {
|
||||
0
|
||||
};
|
||||
Ok(Self {
|
||||
mmap,
|
||||
segment_size,
|
||||
cached_version: 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Check whether the host has published a newer snapshot.
|
||||
pub fn has_new_version(&self) -> bool {
|
||||
let control = ControlPage::from_bytes(&self.mmap);
|
||||
if control.magic.load(Ordering::Acquire) != CONTROL_MAGIC {
|
||||
return false;
|
||||
}
|
||||
control.version.load(Ordering::Acquire) != self.cached_version
|
||||
}
|
||||
|
||||
/// Update the cached version after the caller has re-bound to a new snapshot.
|
||||
pub fn refresh(&mut self) {
|
||||
let control = ControlPage::from_bytes(&self.mmap);
|
||||
self.cached_version = control.version.load(Ordering::Acquire);
|
||||
}
|
||||
|
||||
fn active_segment_bytes(&self) -> &[u8] {
|
||||
let control = ControlPage::from_bytes(&self.mmap);
|
||||
let active = control.active_segment.load(Ordering::Acquire) as usize;
|
||||
let len = control.active_len.load(Ordering::Acquire) as usize;
|
||||
let offset = CONTROL_SIZE + active * self.segment_size;
|
||||
if offset + len > self.mmap.len() {
|
||||
return &[];
|
||||
}
|
||||
&self.mmap[offset..offset + len]
|
||||
}
|
||||
|
||||
fn archived(&self) -> Option<&ArchivedDocumentViewData> {
|
||||
let bytes = self.active_segment_bytes();
|
||||
check_archived_root::<DocumentViewData>(bytes).ok()
|
||||
}
|
||||
}
|
||||
|
||||
impl DocumentReader for SharedDocumentReader {
|
||||
fn entity_count(&self) -> usize {
|
||||
self.archived().map(|doc| doc.entities.len()).unwrap_or(0)
|
||||
}
|
||||
|
||||
fn for_each_entity(&self, f: &mut dyn FnMut(ReaderEntity<'_>)) {
|
||||
let Some(doc) = self.archived() else { return };
|
||||
for entity in doc.entities.iter() {
|
||||
let handle = Handle::new(entity.handle);
|
||||
let kind = ReaderEntityKind::from_u8(entity.kind);
|
||||
let layer_name: &str = entity.layer_name.as_str();
|
||||
let point = entity.point.as_ref().map(|p| ReaderPoint {
|
||||
x: p.x,
|
||||
y: p.y,
|
||||
z: p.z,
|
||||
});
|
||||
f(ReaderEntity {
|
||||
handle,
|
||||
kind,
|
||||
layer_name,
|
||||
point,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn layer_name(&self, handle: Handle) -> Option<&str> {
|
||||
let doc = self.archived()?;
|
||||
let handle_val = handle.value();
|
||||
doc.layers
|
||||
.iter()
|
||||
.find(|layer| layer.handle == handle_val)
|
||||
.map(|layer| layer.name.as_str())
|
||||
}
|
||||
|
||||
fn app_id_name(&self, handle: Handle) -> Option<&str> {
|
||||
let doc = self.archived()?;
|
||||
let handle_val = handle.value();
|
||||
doc.app_ids
|
||||
.iter()
|
||||
.find(|app| app.handle == handle_val)
|
||||
.map(|app| app.name.as_str())
|
||||
}
|
||||
}
|
||||
|
||||
/// Raw control page shared between host and plugin.
|
||||
#[repr(C, align(8))]
|
||||
struct ControlPage {
|
||||
magic: AtomicU32,
|
||||
_pad0: [u8; 4],
|
||||
version: AtomicU64,
|
||||
active_len: AtomicU64,
|
||||
active_segment: AtomicU8,
|
||||
_pad1: [u8; 7],
|
||||
}
|
||||
|
||||
impl ControlPage {
|
||||
fn from_bytes(mmap: &[u8]) -> &Self {
|
||||
assert!(mmap.len() >= std::mem::size_of::<Self>());
|
||||
assert_eq!(mmap.as_ptr() as usize % std::mem::align_of::<Self>(), 0);
|
||||
unsafe { &*(mmap.as_ptr() as *const Self) }
|
||||
}
|
||||
|
||||
fn from_bytes_mut(mmap: &mut [u8]) -> &mut Self {
|
||||
assert!(mmap.len() >= std::mem::size_of::<Self>());
|
||||
assert_eq!(mmap.as_ptr() as usize % std::mem::align_of::<Self>(), 0);
|
||||
unsafe { &mut *(mmap.as_ptr() as *mut Self) }
|
||||
}
|
||||
}
|
||||
|
||||
/// Serializable document view. This is the only data type placed in shared
|
||||
/// memory, so it must contain no pointers into host memory.
|
||||
#[derive(Archive, Serialize, Deserialize, Debug, Clone)]
|
||||
#[archive(check_bytes)]
|
||||
pub struct DocumentViewData {
|
||||
pub layers: Vec<LayerView>,
|
||||
pub app_ids: Vec<AppIdView>,
|
||||
pub entities: Vec<EntityView>,
|
||||
}
|
||||
|
||||
impl From<&CadDocument> for DocumentViewData {
|
||||
fn from(doc: &CadDocument) -> Self {
|
||||
Self {
|
||||
layers: doc.layers.iter().map(LayerView::from).collect(),
|
||||
app_ids: doc.app_ids.iter().map(AppIdView::from).collect(),
|
||||
entities: doc.entities().map(EntityView::from).collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Archive, Serialize, Deserialize, Debug, Clone)]
|
||||
#[archive(check_bytes)]
|
||||
pub struct LayerView {
|
||||
pub handle: u64,
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
impl From<&acadrust::tables::Layer> for LayerView {
|
||||
fn from(layer: &acadrust::tables::Layer) -> Self {
|
||||
Self {
|
||||
handle: layer.handle.value(),
|
||||
name: layer.name.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Archive, Serialize, Deserialize, Debug, Clone)]
|
||||
#[archive(check_bytes)]
|
||||
pub struct AppIdView {
|
||||
pub handle: u64,
|
||||
pub name: String,
|
||||
}
|
||||
|
||||
impl From<&acadrust::tables::AppId> for AppIdView {
|
||||
fn from(app_id: &acadrust::tables::AppId) -> Self {
|
||||
Self {
|
||||
handle: app_id.handle.value(),
|
||||
name: app_id.name.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Archive, Serialize, Deserialize, Debug, Clone)]
|
||||
#[archive(check_bytes)]
|
||||
pub struct EntityView {
|
||||
pub handle: u64,
|
||||
pub kind: u8,
|
||||
pub layer_name: String,
|
||||
pub point: Option<PointView>,
|
||||
}
|
||||
|
||||
impl From<&EntityType> for EntityView {
|
||||
fn from(entity: &EntityType) -> Self {
|
||||
let handle = entity.common().handle.value();
|
||||
let kind = ReaderEntityKind::from_entity(entity).to_u8();
|
||||
let layer_name = entity.common().layer.clone();
|
||||
let point = match entity {
|
||||
EntityType::Point(p) => Some(PointView {
|
||||
x: p.location.x,
|
||||
y: p.location.y,
|
||||
z: p.location.z,
|
||||
}),
|
||||
_ => None,
|
||||
};
|
||||
Self {
|
||||
handle,
|
||||
kind,
|
||||
layer_name,
|
||||
point,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Archive, Serialize, Deserialize, Debug, Clone, Copy)]
|
||||
#[archive(check_bytes)]
|
||||
pub struct PointView {
|
||||
pub x: f64,
|
||||
pub y: f64,
|
||||
pub z: f64,
|
||||
}
|
||||
|
||||
impl ReaderEntityKind {
|
||||
/// Convert the simplified kind to a stable `u8` for the shared format.
|
||||
pub fn to_u8(self) -> u8 {
|
||||
match self {
|
||||
ReaderEntityKind::Point => 1,
|
||||
ReaderEntityKind::Line => 2,
|
||||
ReaderEntityKind::Circle => 3,
|
||||
ReaderEntityKind::Arc => 4,
|
||||
ReaderEntityKind::Polyline => 5,
|
||||
ReaderEntityKind::Text => 6,
|
||||
ReaderEntityKind::Other => 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode a stable `u8` back to the simplified kind.
|
||||
pub fn from_u8(value: u8) -> Self {
|
||||
match value {
|
||||
1 => ReaderEntityKind::Point,
|
||||
2 => ReaderEntityKind::Line,
|
||||
3 => ReaderEntityKind::Circle,
|
||||
4 => ReaderEntityKind::Arc,
|
||||
5 => ReaderEntityKind::Polyline,
|
||||
6 => ReaderEntityKind::Text,
|
||||
_ => ReaderEntityKind::Other,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::host::{DocumentReader, ReaderEntityKind};
|
||||
use acadrust::entities::Point;
|
||||
use acadrust::tables::Layer;
|
||||
use acadrust::{CadDocument, EntityType};
|
||||
|
||||
fn sample_doc() -> CadDocument {
|
||||
let mut doc = CadDocument::new();
|
||||
doc.layers.add(Layer::new("SURVEY")).unwrap();
|
||||
let mut point = Point::from_coords(10.0, 20.0, 5.0);
|
||||
point.common.layer = "SURVEY".to_string();
|
||||
doc.add_entity(EntityType::Point(point)).unwrap();
|
||||
doc
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_document_reader_roundtrip() {
|
||||
let doc = sample_doc();
|
||||
let mut store = DocumentSnapshotStore::new(0, 1024 * 1024).unwrap();
|
||||
store.publish(&doc).unwrap();
|
||||
|
||||
let reader = SharedDocumentReader::open(store.path()).unwrap();
|
||||
assert_eq!(reader.entity_count(), 1);
|
||||
|
||||
let mut seen = Vec::new();
|
||||
reader.for_each_entity(&mut |e| {
|
||||
seen.push((e.kind, e.layer_name.to_string(), e.point, e.handle));
|
||||
});
|
||||
assert_eq!(seen.len(), 1);
|
||||
assert_eq!(seen[0].0, ReaderEntityKind::Point);
|
||||
assert_eq!(seen[0].1, "SURVEY");
|
||||
assert_eq!(
|
||||
seen[0].2,
|
||||
Some(ReaderPoint {
|
||||
x: 10.0,
|
||||
y: 20.0,
|
||||
z: 5.0
|
||||
})
|
||||
);
|
||||
assert!(
|
||||
seen[0].3.is_valid(),
|
||||
"reader entity should expose a valid handle"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_document_reader_updates_after_publish() {
|
||||
let doc = sample_doc();
|
||||
let mut store = DocumentSnapshotStore::new(0, 1024 * 1024).unwrap();
|
||||
store.publish(&doc).unwrap();
|
||||
|
||||
let reader = SharedDocumentReader::open(store.path()).unwrap();
|
||||
assert_eq!(reader.entity_count(), 1);
|
||||
|
||||
let mut doc2 = doc;
|
||||
let mut point2 = Point::from_coords(1.0, 2.0, 3.0);
|
||||
point2.common.layer = "SURVEY".to_string();
|
||||
doc2.add_entity(EntityType::Point(point2)).unwrap();
|
||||
store.publish(&doc2).unwrap();
|
||||
|
||||
assert_eq!(reader.entity_count(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn layer_name_lookup_by_handle() {
|
||||
let doc = sample_doc();
|
||||
let mut store = DocumentSnapshotStore::new(0, 1024 * 1024).unwrap();
|
||||
store.publish(&doc).unwrap();
|
||||
|
||||
let survey = doc.layers.iter().find(|l| l.name == "SURVEY").unwrap();
|
||||
let reader = SharedDocumentReader::open(store.path()).unwrap();
|
||||
assert_eq!(reader.layer_name(survey.handle), Some("SURVEY"));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user