Did some benchmarking of nailpit's markov chain impl, and I'm quite surprised. 20-22 million tokens per second after being trained on the full Moby Dick text. I think iocaine does around 10 million tokens per second currently?
There's potential improvements still, but that will be a whole effort...
![A streaming encryption encoder done as a shitpost:
/// A Neko that produces milk, for other Nekos to consume.
pub struct NekoMilkProducer<Sec: NekoSec> {
stream: NekoState<Sec>,
}
impl<Sec: NekoSec> NekoMilkProducer<Sec> {
pub fn new(
mut stream: NekoState<Sec>,
key: &NekoKey<Sec>,
nonce: &NekoNonce<Sec>,
ad: &[u8],
) -> Self {
stream.key(key);
stream.nonce(nonce);
stream.ad(ad);
stream.permutation_p12(ops::RESET);
stream.begin_op(ops::ENCRYPTION);
Self { stream }
}
/// Produce milk, by taking a slice of bytes and encrypting them.
pub fn produce(&mut self, data: &mut [u8]) {
NekoOperateMut::absorb_and_set(&mut self.stream, data);
}
/// Neko is now tired of producing milk, so make the Neko provide a
/// seal/tag of authenticity, so that the milk can be certified as 100%
/// Neko made.
pub fn finalize(mut self) -> NekoTag {
self.stream.create_mac()
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:usjm3ynnir6y4inkcdovrfei/bafkreib2g2ie4f3fkfjzrx4nxnp63cw6iy3ff3lm3vvugm25gqpguu5uii)
![Implement of a custom PacketPool for a Bluetooth LE controller
pub const MTU: usize = 251;
pub const DATA_MTU: usize = MTU - 6;
pub struct AllocPacketPool;
#[repr(transparent)]
pub struct PacketBuf(Box<[u8; MTU]>);
impl PacketPool for AllocPacketPool {
type Packet = PacketBuf;
const MTU: usize = MTU;
fn allocate() -> Option<Self::Packet> {
// Directly allocate on the heap, with no stack usage for
// initialising the buffer.
let buf = Box::new_zeroed();
// SAFETY: A zeroed buffer is a valid state for PacketBuf.
Some(PacketBuf(unsafe { buf.assume_init() }))
}
fn capacity() -> usize {
32
}
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:usjm3ynnir6y4inkcdovrfei/bafkreihcr4wzff3fbxkvgkv2wsdkhooszlcdg7bcecyhsnqt7lwbgubddq)
