pub struct LockedIoUring { /* private fields */ }Expand description
Un IoUring partagé entre threads derrière un verrou interne
(Send + Sync). Le verrou sérialise les accès userspace au SQ/CQ/slab ; le
protocole d’ordering userspace↔kernel du Temps 1 reste inchangé dessous.
Avertissement (Principe 5) : le verrou est un point de contention —
sous forte charge multi-thread il sérialise tout. À réserver aux cas simples
ou peu sollicités ; pour la performance, préférer le thread-per-core (§2,
RingPool). Verrou unique d’abord (Principe 7) ; un affinage
(soumission/complétion séparées) n’est envisagé qu’après mesure.
Sûreté : Send + Sync par construction — IoUring est Send, donc
FutexMutex<IoUring> est Send + Sync :
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<air_sys_syscall::io_uring::LockedIoUring>();alors qu’un IoUring nu n’est pas Sync (partage refusé par typage) :
fn assert_sync<T: Sync>() {}
assert_sync::<air_sys_syscall::io_uring::IoUring>(); // ERREUR : IoUring: !SyncImplementations§
Source§impl LockedIoUring
impl LockedIoUring
Sourcepub fn new(entries: NonZeroU32) -> Result<Self, Errno>
pub fn new(entries: NonZeroU32) -> Result<Self, Errno>
Raccourci : LockedIoUring::from_builder(IoUringBuilder::new(entries)).
§Errors
Voir IoUringBuilder::build.
Sourcepub fn from_builder(builder: IoUringBuilder) -> Result<Self, Errno>
pub fn from_builder(builder: IoUringBuilder) -> Result<Self, Errno>
Sourcepub fn with_lock<R>(&self, f: impl FnOnce(&mut IoUring) -> R) -> R
pub fn with_lock<R>(&self, f: impl FnOnce(&mut IoUring) -> R) -> R
Exécute f sur le ring sous-jacent sous le verrou (accès exclusif
sérialisé). C’est la primitive complète : toute opération d’IoUring
(les ~50 submit_*, les accesseurs de complétion) est accessible ainsi en
&self, sans recopier 50 forwarders. Les méthodes nommées ci-dessous en
sont de simples raccourcis pour les cas les plus fréquents.
Le verrou est sans empoisonnement ([FutexMutex] n’implémente pas le
poisoning) : un panic d’un autre thread sous le verrou ne le rend pas
inutilisable (cohérent avec la future synchro sans poisoning d’air-thread).
Sourcepub fn submit_read(
&self,
fd: BorrowedFd<'_>,
buffer: Vec<u8>,
offset: Option<u64>,
) -> Result<SubmissionToken, Errno>
pub fn submit_read( &self, fd: BorrowedFd<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>
Sourcepub fn submit_write(
&self,
fd: BorrowedFd<'_>,
buffer: Vec<u8>,
offset: Option<u64>,
) -> Result<SubmissionToken, Errno>
pub fn submit_write( &self, fd: BorrowedFd<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>
Sourcepub fn submit_nop(&self) -> Result<SubmissionToken, Errno>
pub fn submit_nop(&self) -> Result<SubmissionToken, Errno>
Sourcepub fn submit_and_wait(&self, want: u32) -> Result<u32, Errno>
pub fn submit_and_wait(&self, want: u32) -> Result<u32, Errno>
submit_and_wait (Temps 1) sous le verrou.
Attention : l’attente bloque avec le verrou tenu — un seul thread attend à la fois. Pour de l’attente concurrente, préférer le thread-per-core.
§Errors
Voir IoUring::submit_and_wait.
Sourcepub fn wait_completion(&self) -> Result<Completion, Errno>
pub fn wait_completion(&self) -> Result<Completion, Errno>
Sourcepub fn try_completion(&self) -> Option<Completion>
pub fn try_completion(&self) -> Option<Completion>
try_completion (Temps 1) sous le verrou.