Runtime Const Generics
Runtime Const Generics - Lemmy.World
Hello, I was playing around with rust and wondered if I could use const generics for toggling debug code on and off to avoid any runtime cost while still being able to toggle the DEBUG flag during runtime. I came up with a nifty solution that requires a single dynamic dispatch many programs have anyways. It works by rewriting the vtable. It’s a zero cost bool! Is this technique worth it? Probably not. It’s funny though. Repo: https://github.com/raldone01/runtime_const_generics_rs/tree/v1.0.0 [https://github.com/raldone01/runtime_const_generics_rs/tree/v1.0.0] Full source code below: rust use std::mem::transmute; use std::sync::atomic::AtomicU32; use std::sync::atomic::Ordering; use replace_with::replace_with_or_abort; trait GameObject { fn run(&mut self); fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject; } trait GameObjectBoxExt { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject>; } impl GameObjectBoxExt for dyn GameObject { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> { unsafe { let selv = Box::into_raw(self); let selv = (&mut *selv).set_debug(flag); return Box::from_raw(selv); } } } static ID_CNT: AtomicU32 = AtomicU32::new(0); struct Node3D<const DEBUG: bool = false> { id: u32, cnt: u32, } impl Node3D { const TYPE_NAME: &str = "Node3D"; fn new() -> Self { let id = ID_CNT.fetch_add(1, Ordering::Relaxed); let selv = Self { id, cnt: 0 }; return selv; } } impl<const DEBUG: bool> GameObject for Node3D<DEBUG> { fn run(&mut self) { println!("Hello {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id); if DEBUG { println!("Debug {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id); } self.cnt += 1; } fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject { unsafe { match flag { true => transmute::<_, &mut Node3D<true>>(self) as &mut dyn GameObject, false => transmute::<_, &mut Node3D<false>>(self) as &mut dyn GameObject, } } } } struct Node2D<const DEBUG: bool = false> { id: u32, cnt: u32, } impl Node2D { const TYPE_NAME: &str = "Node2D"; fn new() -> Self { let id = ID_CNT.fetch_add(1, Ordering::Relaxed); let selv = Self { id, cnt: 0 }; return selv; } } impl<const DEBUG: bool> GameObject for Node2D<DEBUG> { fn run(&mut self) { println!("Hello {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id); if DEBUG { println!("Debug {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id); } self.cnt += 1; } fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject { unsafe { match flag { true => transmute::<_, &mut Node2D<true>>(self) as &mut dyn GameObject, false => transmute::<_, &mut Node2D<false>>(self) as &mut dyn GameObject, } } } } fn main() { let mut objects = Vec::new(); for _ in 0..10 { objects.push(Box::new(Node3D::new()) as Box<dyn GameObject>); objects.push(Box::new(Node2D::new()) as Box<dyn GameObject>); } for o in 0..3 { for (i, object) in objects.iter_mut().enumerate() { let debug = (o + i) % 2 == 0; replace_with_or_abort(object, |object| object.set_debug(debug)); object.run(); } } } Note if anyone gets the following to work without unsafe, maybe by using the replace_with crate I would be very happy: rust impl GameObjectBoxExt for dyn GameObject { fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> { unsafe { let selv = Box::into_raw(self); let selv = (&mut *selv).set_debug(flag); return Box::from_raw(selv); } } I am curious to hear your thoughts.
