use std::{
pin::Pin,
sync::{
Arc,
atomic::{AtomicU64, AtomicUsize, Ordering},
},
task::{Context, Poll, Wake, Waker},
};
use futures::Stream;
use crate::sync::Mutex;
#[cfg(all(test, rig_loom))]
mod loom_models;
#[cfg(all(test, not(rig_loom)))]
mod tests;
use crate::bus::{BusDriver, Dispatcher, Recording, Registrar};
use rig_core::serve::ErasedHandler;
use rig_core::serve::ServingPolicy;
use rig_core::serve::adapters::ModelAdapter;
use rig_core::{
completion::ModelRef,
effect::{HandlerKey, Key, family},
error::ErrorReport,
};
static NEXT_AGENT: AtomicU64 = AtomicU64::new(0);
pub(crate) fn default_owner() -> String {
format!("agent#{}", NEXT_AGENT.fetch_add(1, Ordering::Relaxed))
}
pub(crate) struct AnonymousModel {
key: Key<family::Completion>,
registrar: Registrar,
}
impl AnonymousModel {
pub(crate) fn key(&self) -> &Key<family::Completion> {
&self.key
}
}
impl Drop for AnonymousModel {
fn drop(&mut self) {
self.registrar.deregister(self.key.raw());
}
}
#[derive(Clone)]
pub(crate) struct AgentBus {
dispatcher: Dispatcher,
registrar: Registrar,
owner: Arc<str>,
driver: Option<Arc<Mutex<BusDriver>>>,
wakers: Arc<WakerSet>,
anonymous_models: Arc<AtomicUsize>,
config: Option<ServingPolicy>,
}
impl std::fmt::Debug for AgentBus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AgentBus")
.field("owner", &self.owner)
.field("owns_driver", &self.driver.is_some())
.finish_non_exhaustive()
}
}
impl AgentBus {
pub(crate) fn owned(
dispatcher: Dispatcher,
registrar: Registrar,
driver: BusDriver,
owner: String,
config: ServingPolicy,
) -> Self {
Self {
dispatcher,
registrar,
owner: Arc::from(owner),
driver: Some(Arc::new(Mutex::new(driver))),
wakers: Arc::new(WakerSet::default()),
anonymous_models: Arc::new(AtomicUsize::new(0)),
config: Some(config),
}
}
pub(crate) fn config(&self) -> Option<ServingPolicy> {
self.config
}
pub(crate) fn record_to(&mut self, recorder: Recording) -> Result<(), ErrorReport> {
let Some(driver) = self.driver.as_mut() else {
return Err(ErrorReport::new(
rig_core::error::ErrorKind::Internal,
"an agent over a host's bus does not record; tap the host's driver",
));
};
let Some(driver) = Arc::get_mut(driver) else {
return Err(ErrorReport::new(
rig_core::error::ErrorKind::Internal,
"recording is enabled at build, before a clone shares the driver",
));
};
driver
.get_mut()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.record_with(recorder);
Ok(())
}
pub(crate) fn over(dispatcher: Dispatcher, registrar: Registrar, owner: String) -> Self {
Self {
dispatcher,
registrar,
owner: Arc::from(owner),
driver: None,
wakers: Arc::new(WakerSet::default()),
anonymous_models: Arc::new(AtomicUsize::new(0)),
config: None,
}
}
pub(crate) fn detached(&self) -> Self {
Self {
dispatcher: self.dispatcher.clone(),
registrar: self.registrar.clone(),
owner: self.owner.clone(),
driver: None,
wakers: Arc::new(WakerSet::default()),
anonymous_models: self.anonymous_models.clone(),
config: self.config,
}
}
pub(crate) fn dispatcher(&self) -> &Dispatcher {
&self.dispatcher
}
pub(crate) fn registrar(&self) -> &Registrar {
&self.registrar
}
pub(crate) fn owner(&self) -> &str {
&self.owner
}
pub(crate) fn raw_key(&self, suffix: &str) -> HandlerKey {
HandlerKey::from(format!("{}/{suffix}", self.owner))
}
pub(crate) fn key<F: rig_core::effect::Family>(&self, suffix: &str) -> Key<F> {
Key::new_unchecked(self.raw_key(suffix))
}
pub(crate) fn model_key(&self, label: &str) -> Key<family::Completion> {
self.key(rig_core::effect::model_key(label).as_str())
}
pub(crate) fn model_label<'k>(&self, key: &'k HandlerKey) -> Option<&'k str> {
key.as_str()
.strip_prefix(&*self.owner)
.and_then(|rest| rest.strip_prefix("/model:"))
}
pub(crate) fn register_erased(
&mut self,
key: HandlerKey,
handler: ErasedHandler,
) -> Result<(), ErrorReport> {
match self.driver.as_mut().and_then(Arc::get_mut) {
Some(driver) => driver
.get_mut()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.register_erased(key, handler),
None => self.registrar.register_erased(key, handler),
}
}
pub(crate) fn owns_driver(&self) -> bool {
self.driver.is_some()
}
pub(crate) fn register_model(
&self,
label: &ModelRef,
model: impl Into<rig_core::DynModel<rig_core::operation::Completion>>,
) -> Key<family::Completion> {
let key = self.model_key(label.as_str());
register_generated(
self.registrar
.register_typed::<family::Completion>(
key.raw().clone(),
ModelAdapter::new(label.clone(), model),
)
.map(|_| ()),
);
key
}
pub(crate) fn register_anonymous_model(
&self,
model: impl Into<rig_core::DynModel<rig_core::operation::Completion>>,
) -> Arc<AnonymousModel> {
let n = self.anonymous_models.fetch_add(1, Ordering::SeqCst);
let key = self.register_model(&ModelRef::new(format!("anonymous#{n}")), model);
Arc::new(AnonymousModel {
key,
registrar: self.registrar.clone(),
})
}
pub(crate) fn try_into_parts(self) -> Result<(Dispatcher, BusDriver), Self> {
let Some(driver) = self.driver else {
return Err(self);
};
match Arc::try_unwrap(driver) {
Ok(mutex) => Ok((
self.dispatcher,
mutex
.into_inner()
.unwrap_or_else(std::sync::PoisonError::into_inner),
)),
Err(driver) => Err(Self {
driver: Some(driver),
..self
}),
}
}
pub(crate) fn drive<S>(&self, inner: S) -> Driven<S> {
Driven {
inner: Some(inner),
driver: self.driver.clone(),
wakers: Arc::clone(&self.wakers),
slot: self.wakers.slot(),
}
}
}
#[track_caller]
pub(crate) fn register_generated(registered: Result<(), rig_core::error::ErrorReport>) {
if let Err(report) = registered {
let caller = std::panic::Location::caller();
debug_assert!(
false,
"a generated key changed family at {caller}: {report}"
);
tracing::error!(
%report,
%caller,
"a generated bus key changed family; the registration was refused"
);
}
}
pub(crate) struct Driven<S> {
inner: Option<S>,
driver: Option<Arc<Mutex<BusDriver>>>,
wakers: Arc<WakerSet>,
slot: u64,
}
impl<S> Driven<S> {
fn finish(&mut self) {
self.inner = None;
self.wakers.unregister(self.slot);
self.wakers.wake_by_ref();
}
fn settle_in_flight(&mut self, cx: &Context<'_>) {
let Some(driver) = self.driver.clone() else {
return;
};
let mut before = usize::MAX;
loop {
let in_flight = match try_lock(&driver) {
Some(guard) => guard.in_flight(),
None => return,
};
if in_flight == 0 || in_flight >= before {
return;
}
before = in_flight;
self.poll_driver(cx);
}
}
fn poll_driver(&mut self, cx: &Context<'_>) {
let Some(driver) = &self.driver else {
return;
};
self.wakers.register(self.slot, cx.waker());
if let Some(mut guard) = try_lock(driver) {
let waker = Waker::from(Arc::clone(&self.wakers));
let mut driver_cx = Context::from_waker(&waker);
let _ = Pin::new(&mut *guard).poll(&mut driver_cx);
}
}
}
fn try_lock<T>(driver: &Mutex<T>) -> Option<crate::sync::MutexGuard<'_, T>> {
match driver.try_lock() {
Ok(guard) => Some(guard),
Err(std::sync::TryLockError::Poisoned(poisoned)) => Some(poisoned.into_inner()),
Err(std::sync::TryLockError::WouldBlock) => None,
}
}
impl<S> Drop for Driven<S> {
fn drop(&mut self) {
let was_live = self.inner.take().is_some();
self.wakers.unregister(self.slot);
if !was_live {
return;
}
if let Some(driver) = &self.driver
&& let Some(mut guard) = try_lock(driver)
{
let waker = Waker::from(Arc::clone(&self.wakers));
let mut driver_cx = Context::from_waker(&waker);
let _ = Pin::new(&mut *guard).poll(&mut driver_cx);
}
self.wakers.wake_by_ref();
}
}
impl<S: Stream + Unpin> Stream for Driven<S> {
type Item = S::Item;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
let Some(inner) = &mut this.inner else {
return Poll::Ready(None);
};
match Pin::new(&mut *inner).poll_next(cx) {
Poll::Ready(Some(item)) => Poll::Ready(Some(item)),
Poll::Ready(None) => {
this.settle_in_flight(cx);
this.finish();
Poll::Ready(None)
}
Poll::Pending => {
this.poll_driver(cx);
let Some(inner) = &mut this.inner else {
return Poll::Ready(None);
};
match Pin::new(&mut *inner).poll_next(cx) {
Poll::Ready(None) => {
this.settle_in_flight(cx);
this.finish();
Poll::Ready(None)
}
other => other,
}
}
}
}
}
impl<S: Unpin> Unpin for Driven<S> {}
#[derive(Default)]
pub(crate) struct WakerSet {
slots: Mutex<Vec<(u64, Waker)>>,
next_slot: AtomicU64,
}
impl WakerSet {
fn slot(&self) -> u64 {
self.next_slot.fetch_add(1, Ordering::Relaxed)
}
fn register(&self, slot: u64, waker: &Waker) {
let mut slots = self
.slots
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
match slots.iter_mut().find(|(id, _)| *id == slot) {
Some((_, existing)) => {
if !existing.will_wake(waker) {
existing.clone_from(waker);
}
}
None => slots.push((slot, waker.clone())),
}
}
fn unregister(&self, slot: u64) {
let mut slots = self
.slots
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
slots.retain(|(id, _)| *id != slot);
}
}
impl Wake for WakerSet {
fn wake(self: Arc<Self>) {
self.wake_by_ref();
}
fn wake_by_ref(self: &Arc<Self>) {
let wakers: Vec<Waker> = self
.slots
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.iter()
.map(|(_, waker)| waker.clone())
.collect();
for waker in wakers {
waker.wake();
}
}
}