File size: 3,457 Bytes
b98ffbb |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
use std::{ptr::NonNull, sync::Arc};
use aligned_vec::{AVec, ConstAlign};
use dora_arrow_convert::{ArrowData, IntoArrow};
use dora_core::{
config::{DataId, OperatorId},
message::{ArrowTypeInfo, BufferOffset, Metadata},
};
use eyre::{Context, Result};
use shared_memory_extended::{Shmem, ShmemConf};
#[derive(Debug)]
#[non_exhaustive]
pub enum Event {
Stop,
Reload {
operator_id: Option<OperatorId>,
},
Input {
id: DataId,
metadata: Metadata,
data: ArrowData,
},
InputClosed {
id: DataId,
},
Error(String),
}
pub enum RawData {
Empty,
Vec(AVec<u8, ConstAlign<128>>),
SharedMemory(SharedMemoryData),
}
impl RawData {
pub fn into_arrow_array(self, type_info: &ArrowTypeInfo) -> Result<arrow::array::ArrayData> {
let raw_buffer = match self {
RawData::Empty => return Ok(().into_arrow().into()),
RawData::Vec(data) => {
let ptr = NonNull::new(data.as_ptr() as *mut _).unwrap();
let len = data.len();
unsafe { arrow::buffer::Buffer::from_custom_allocation(ptr, len, Arc::new(data)) }
}
RawData::SharedMemory(data) => {
let ptr = NonNull::new(data.data.as_ptr() as *mut _).unwrap();
let len = data.data.len();
unsafe { arrow::buffer::Buffer::from_custom_allocation(ptr, len, Arc::new(data)) }
}
};
buffer_into_arrow_array(&raw_buffer, type_info)
}
}
pub struct SharedMemoryData {
pub data: MappedInputData,
pub _drop: flume::Sender<()>,
}
fn buffer_into_arrow_array(
raw_buffer: &arrow::buffer::Buffer,
type_info: &ArrowTypeInfo,
) -> eyre::Result<arrow::array::ArrayData> {
if raw_buffer.is_empty() {
return Ok(arrow::array::ArrayData::new_empty(&type_info.data_type));
}
let mut buffers = Vec::new();
for BufferOffset { offset, len } in &type_info.buffer_offsets {
buffers.push(raw_buffer.slice_with_length(*offset, *len));
}
let mut child_data = Vec::new();
for child_type_info in &type_info.child_data {
child_data.push(buffer_into_arrow_array(raw_buffer, child_type_info)?)
}
arrow::array::ArrayData::try_new(
type_info.data_type.clone(),
type_info.len,
type_info
.validity
.clone()
.map(arrow::buffer::Buffer::from_vec),
type_info.offset,
buffers,
child_data,
)
.context("Error creating Arrow array")
}
impl std::fmt::Debug for RawData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Data").finish_non_exhaustive()
}
}
pub struct MappedInputData {
memory: Box<Shmem>,
len: usize,
}
impl MappedInputData {
pub(crate) unsafe fn map(shared_memory_id: &str, len: usize) -> eyre::Result<Self> {
let memory = Box::new(
ShmemConf::new()
.os_id(shared_memory_id)
.writable(false)
.open()
.wrap_err("failed to map shared memory input")?,
);
Ok(MappedInputData { memory, len })
}
}
impl std::ops::Deref for MappedInputData {
type Target = [u8];
fn deref(&self) -> &Self::Target {
unsafe { &self.memory.as_slice()[..self.len] }
}
}
unsafe impl Send for MappedInputData {}
unsafe impl Sync for MappedInputData {}
|