perf: niche rkyv values

Author: MaxOhn

bathbot-model/src/osekai.rs

@@ -9,8 +9,11 @@ use std::{
 use eyre::{Result, WrapErr};
 use form_urlencoded::Serializer as FormSerializer;
 use rkyv::{
-    bytecheck::CheckBytes, string::ArchivedString, with::Niche, Archive, Archived,
-    Deserialize as RkyvDeserialize, Portable, Serialize,
+    bytecheck::CheckBytes,
+    niche::niching::{NaN, Null},
+    string::ArchivedString,
+    with::NicheInto,
+    Archive, Archived, Deserialize as RkyvDeserialize, Portable, Serialize,
 };
 use rosu_v2::{
     model::GameMode,
@@ -27,6 +30,7 @@ use twilight_interactions::command::{CommandOption, CreateOption};
 use super::deser;
 use crate::{
     rkyv_util::{time::DateRkyv, DerefAsString},
+    rosu_v2::mode::GameModeNiche,
     RankingKind,
 };
 
@@ -202,18 +206,20 @@ pub struct OsekaiMedal {
     #[serde(with = "deser::u32_string")]
     pub ordering: u32,
     #[serde(rename = "Frequency", with = "deser::option_f32_string")]
+    #[rkyv(with = NicheInto<NaN>)]
     pub rarity: Option<f32>,
     pub name: Box<str>,
     #[serde(rename = "Link")]
     icon_url_suffix: Box<str>,
     pub description: Box<str>,
     #[serde(rename = "Gamemode", deserialize_with = "maybe_osekai_mode")]
+    #[rkyv(with = NicheInto<GameModeNiche>)]
     pub mode: Option<GameMode>,
     pub grouping: MedalGroup,
-    #[rkyv(with = Niche)]
+    #[rkyv(with = NicheInto<Null>)]
     solution: Option<Box<str>>,
-    #[rkyv(with = Niche)]
     #[serde(deserialize_with = "medal_mods")]
+    #[rkyv(with = NicheInto<Null>)]
     pub mods: Option<Box<str>>,
     #[serde(rename = "Supports_Lazer", deserialize_with = "stringified_bool_int")]
     pub supports_lazer: bool,
@@ -810,6 +816,7 @@ pub struct OsekaiRarityEntry {
     #[serde(rename = "possessionRate", with = "deser::f32_string")]
     pub possession_percent: f32,
     #[serde(rename = "gameMode", deserialize_with = "maybe_osekai_mode")]
+    #[rkyv(with = NicheInto<GameModeNiche>)]
     pub mode: Option<GameMode>,
 }
 

bathbot-model/src/rkyv_util/as_non_zero.rs

@@ -1,27 +1,24 @@
 use std::num::{NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8};
 
 use rkyv::{
-    niche::option_nonzero::{
-        ArchivedOptionNonZeroU16, ArchivedOptionNonZeroU32, ArchivedOptionNonZeroU64,
-        ArchivedOptionNonZeroU8,
-    },
+    niche::{niched_option::NichedOption, niching::Zero},
     rancor::Fallible,
     with::{ArchiveWith, DeserializeWith, SerializeWith},
-    Place,
+    Archived, Place,
 };
 
 pub struct AsNonZero;
 
 macro_rules! impl_as_non_zero {
-    ($ar:ty, $nz:ty, $ne:ty) => {
+    ($nz:ty, $ne:ty) => {
         impl ArchiveWith<Option<$ne>> for AsNonZero {
-            type Archived = $ar;
+            type Archived = NichedOption<Archived<$nz>, Zero>;
             type Resolver = ();
 
             #[inline]
             fn resolve_with(field: &Option<$ne>, _: Self::Resolver, out: Place<Self::Archived>) {
                 let opt = field.and_then(<$nz>::new);
-                <$ar>::resolve_from_option(opt, out);
+                NichedOption::resolve_from_option(opt.as_ref(), Some(()), out);
             }
         }
 
@@ -35,10 +32,12 @@ macro_rules! impl_as_non_zero {
             }
         }
 
-        impl<D: Fallible + ?Sized> DeserializeWith<$ar, Option<$ne>, D> for AsNonZero {
+        impl<D: Fallible + ?Sized>
+            DeserializeWith<NichedOption<Archived<$nz>, Zero>, Option<$ne>, D> for AsNonZero
+        {
             #[inline]
             fn deserialize_with(
-                field: &$ar,
+                field: &NichedOption<Archived<$nz>, Zero>,
                 _: &mut D,
             ) -> Result<Option<$ne>, <D as Fallible>::Error> {
                 Ok(field.as_ref().copied().map(<$nz>::from).map(<$nz>::get))
@@ -47,7 +46,7 @@ macro_rules! impl_as_non_zero {
     };
 }
 
-impl_as_non_zero!(ArchivedOptionNonZeroU8, NonZeroU8, u8);
-impl_as_non_zero!(ArchivedOptionNonZeroU16, NonZeroU16, u16);
-impl_as_non_zero!(ArchivedOptionNonZeroU32, NonZeroU32, u32);
-impl_as_non_zero!(ArchivedOptionNonZeroU64, NonZeroU64, u64);
+impl_as_non_zero!(NonZeroU8, u8);
+impl_as_non_zero!(NonZeroU16, u16);
+impl_as_non_zero!(NonZeroU32, u32);
+impl_as_non_zero!(NonZeroU64, u64);

bathbot-model/src/rkyv_util/time.rs

@@ -1,6 +1,7 @@
 use rkyv::{
     bytecheck::CheckBytes,
     munge::munge,
+    niche::niching::Niching,
     rancor::{Fallible, Source},
     rend::u64_le,
     traits::NoUndef,
@@ -11,7 +12,7 @@ use time::{error::ComponentRange, Date, OffsetDateTime};
 
 pub struct DateTimeRkyv;
 
-#[derive(Copy, Clone, CheckBytes, Portable)]
+#[derive(Copy, Clone, CheckBytes, Portable, PartialEq, Eq)]
 #[bytecheck(crate = rkyv::bytecheck)]
 #[repr(C)]
 pub struct ArchivedDateTime {
@@ -24,7 +25,7 @@ pub struct ArchivedDateTime {
 unsafe impl NoUndef for ArchivedDateTime {}
 
 impl ArchivedDateTime {
-    pub fn new(datetime: OffsetDateTime) -> Self {
+    pub const fn new(datetime: OffsetDateTime) -> Self {
         let unix_timestamp_nanos = datetime.unix_timestamp_nanos();
 
         Self {
@@ -73,6 +74,16 @@ impl<D: Fallible<Error: Source>> DeserializeWith<ArchivedDateTime, OffsetDateTim
     }
 }
 
+impl Niching<ArchivedDateTime> for DateTimeRkyv {
+    unsafe fn is_niched(niched: *const ArchivedDateTime) -> bool {
+        unsafe { *niched == ArchivedDateTime::new(OffsetDateTime::UNIX_EPOCH) }
+    }
+
+    fn resolve_niched(out: Place<ArchivedDateTime>) {
+        Self::resolve_with(&OffsetDateTime::UNIX_EPOCH, (), out);
+    }
+}
+
 pub struct DateRkyv;
 
 impl DateRkyv {

bathbot-model/src/rosu_v2/grade.rs

@@ -2,7 +2,12 @@ use rkyv::{Archive, Deserialize, Serialize};
 use rosu_v2::model::Grade;
 
 #[derive(Archive, Serialize, Deserialize)]
-#[rkyv(remote = Grade, archived = ArchivedGrade, resolver = GradeResolver, derive(Copy, Clone))]
+#[rkyv(
+    remote = Grade,
+    archived = ArchivedGrade,
+    resolver = GradeResolver,
+    derive(Copy, Clone),
+)]
 pub enum GradeRkyv {
     F,
     D,

bathbot-model/src/rosu_v2/mod.rs

@@ -1,3 +1,4 @@
 pub mod grade;
+pub mod mode;
 pub mod ranking;
 pub mod user;

bathbot-model/src/rosu_v2/mode.rs

@@ -0,0 +1,18 @@
+use rkyv::{niche::niching::Niching, Archive, Place};
+use rosu_mods::GameMode;
+
+pub struct GameModeNiche;
+
+impl GameModeNiche {
+    const NICHED: u8 = u8::MAX;
+}
+
+impl Niching<GameMode> for GameModeNiche {
+    unsafe fn is_niched(niched: *const GameMode) -> bool {
+        unsafe { *niched as u8 == Self::NICHED }
+    }
+
+    fn resolve_niched(out: Place<GameMode>) {
+        Self::NICHED.resolve((), unsafe { out.cast_unchecked() });
+    }
+}

bathbot-model/src/rosu_v2/ranking.rs

@@ -1,4 +1,8 @@
-use rkyv::{with::Map, Archive, Serialize};
+use rkyv::{
+    niche::niching::NaN,
+    with::{Map, MapNiche},
+    Archive, Serialize,
+};
 use rosu_v2::prelude::{CountryCode, Rankings, User, UserStatistics, Username};
 
 use super::user::UserStatisticsRkyv;
@@ -23,6 +27,6 @@ pub struct RankingsUserRkyv {
     pub user_id: u32,
     #[rkyv(with = DerefAsString)]
     pub username: Username,
-    #[rkyv(with = Map<UserStatisticsRkyv>)]
+    #[rkyv(with = MapNiche<UserStatisticsRkyv, NaN>)]
     pub statistics: Option<UserStatistics>,
 }

bathbot-model/src/rosu_v2/user.rs

@@ -5,10 +5,11 @@ use ::rosu_v2::model::user::{
 use bathbot_util::osu::UserStats;
 use rkyv::{
     munge::munge,
+    niche::niching::{NaN, Niching},
     rancor::{Fallible, Source},
     rend::u32_le,
     ser::{Allocator, Writer},
-    with::{ArchiveWith, InlineAsBox, Map, SerializeWith},
+    with::{ArchiveWith, InlineAsBox, Map, MapNiche, SerializeWith},
     Archive, Deserialize, Place, Serialize,
 };
 use rosu_v2::prelude::{CountryCode, DailyChallengeUserStatistics, GameMode, Username};
@@ -72,13 +73,16 @@ impl From<MedalCompactRkyv> for MedalCompact {
 }
 
 #[derive(Archive, Serialize)]
-#[rkyv(remote = DailyChallengeUserStatistics, archived = ArchivedDailyChallengeUserStatistics)]
+#[rkyv(
+    remote = DailyChallengeUserStatistics,
+    archived = ArchivedDailyChallengeUserStatistics,
+)]
 pub struct DailyChallengeUserStatisticsRkyv {
     pub daily_streak_best: u32,
     pub daily_streak_current: u32,
-    #[rkyv(with = Map<DateTimeRkyv>)]
+    #[rkyv(with = MapNiche<DateTimeRkyv, DateTimeRkyv>)]
     pub last_update: Option<OffsetDateTime>,
-    #[rkyv(with = Map<DateTimeRkyv>)]
+    #[rkyv(with = MapNiche<DateTimeRkyv, DateTimeRkyv>)]
     pub last_weekly_streak: Option<OffsetDateTime>,
     pub playcount: u32,
     pub top_10p_placements: u32,
@@ -113,6 +117,17 @@ pub struct TeamRkyv {
     pub short_name: String,
 }
 
+impl Niching<ArchivedTeam> for TeamRkyv {
+    unsafe fn is_niched(niched: *const ArchivedTeam) -> bool {
+        unsafe { (*niched).id == 0 }
+    }
+
+    fn resolve_niched(out: Place<ArchivedTeam>) {
+        munge!(let ArchivedTeam { id, .. } = out);
+        0_u32.resolve((), id);
+    }
+}
+
 #[derive(Clone, Archive, Serialize)]
 pub struct User {
     pub avatar_url: Box<str>,
@@ -122,7 +137,7 @@ pub struct User {
     pub join_date: OffsetDateTime,
     #[rkyv(with = UserKudosuRkyv)]
     pub kudosu: UserKudosu,
-    #[rkyv(with = Map<DateTimeRkyv>)]
+    #[rkyv(with = MapNiche<DateTimeRkyv, DateTimeRkyv>)]
     pub last_visit: Option<OffsetDateTime>,
     pub mode: GameMode,
     pub user_id: u32,
@@ -134,7 +149,7 @@ pub struct User {
     pub follower_count: u32,
     pub graveyard_mapset_count: u32,
     pub guest_mapset_count: u32,
-    #[rkyv(with = Map<UserHighestRankRkyv>)]
+    #[rkyv(with = MapNiche<UserHighestRankRkyv, DateTimeRkyv>)]
     pub highest_rank: Option<UserHighestRank>,
     pub loved_mapset_count: u32,
     pub mapping_follower_count: u32,
@@ -145,14 +160,14 @@ pub struct User {
     #[rkyv(with = Map<MonthlyCountRkyv>)]
     pub replays_watched_counts: Vec<MonthlyCount>,
     pub scores_first_count: u32,
-    #[rkyv(with = Map<UserStatisticsRkyv>)]
+    #[rkyv(with = MapNiche<UserStatisticsRkyv, NaN>)]
     pub statistics: Option<UserStatistics>,
     pub pending_mapset_count: u32,
     #[rkyv(with = Map<MedalCompactRkyv>)]
     pub medals: Vec<MedalCompact>,
     #[rkyv(with = DailyChallengeUserStatisticsRkyv)]
     pub daily_challenge: DailyChallengeUserStatistics,
-    #[rkyv(with = Map<TeamRkyv>)]
+    #[rkyv(with = MapNiche<TeamRkyv, TeamRkyv>)]
     pub team: Option<Team>,
 }
 
@@ -194,7 +209,11 @@ impl ArchiveWith<UserExtended> for User {
         DerefAsString::resolve_with(&user.country_code, resolver.country_code, country_code);
         DateTimeRkyv::resolve_with(&user.join_date, resolver.join_date, join_date);
         UserKudosuRkyv::resolve_with(&user.kudosu, resolver.kudosu, kudosu);
-        Map::<DateTimeRkyv>::resolve_with(&user.last_visit, resolver.last_visit, last_visit);
+        MapNiche::<DateTimeRkyv, DateTimeRkyv>::resolve_with(
+            &user.last_visit,
+            resolver.last_visit,
+            last_visit,
+        );
         user.mode.resolve(resolver.mode, mode);
         user.user_id.resolve(resolver.user_id, user_id);
         DerefAsString::resolve_with(&user.username, resolver.username, username);
@@ -214,7 +233,7 @@ impl ArchiveWith<UserExtended> for User {
             resolver.guest_mapset_count,
             guest_mapset_count,
         );
-        Map::<UserHighestRankRkyv>::resolve_with(
+        MapNiche::<UserHighestRankRkyv, DateTimeRkyv>::resolve_with(
             &user.highest_rank,
             resolver.highest_rank,
             highest_rank,
@@ -259,14 +278,18 @@ impl ArchiveWith<UserExtended> for User {
             resolver.replays_watched_counts,
             replays_watched_counts,
         );
-        Map::<UserStatisticsRkyv>::resolve_with(&user.statistics, resolver.statistics, statistics);
+        MapNiche::<UserStatisticsRkyv, NaN>::resolve_with(
+            &user.statistics,
+            resolver.statistics,
+            statistics,
+        );
         MapUnwrapOrDefault::<MedalCompactRkyv>::resolve_with(&user.medals, resolver.medals, medals);
         DailyChallengeUserStatisticsRkyv::resolve_with(
             &user.daily_challenge_stats,
             resolver.daily_challenge,
             daily_challenge,
         );
-        Map::<TeamRkyv>::resolve_with(&user.team, resolver.team, team);
+        MapNiche::<TeamRkyv, TeamRkyv>::resolve_with(&user.team, resolver.team, team);
     }
 }
 
@@ -279,12 +302,15 @@ impl<S: Fallible<Error: Source> + Writer + Allocator + ?Sized> SerializeWith<Use
             country_code: DerefAsString::serialize_with(&user.country_code, serializer)?,
             join_date: DateTimeRkyv::serialize_with(&user.join_date, serializer)?,
             kudosu: UserKudosuRkyv::serialize_with(&user.kudosu, serializer)?,
-            last_visit: Map::<DateTimeRkyv>::serialize_with(&user.last_visit, serializer)?,
+            last_visit: MapNiche::<DateTimeRkyv, DateTimeRkyv>::serialize_with(
+                &user.last_visit,
+                serializer,
+            )?,
             mode: user.mode.serialize(serializer)?,
             user_id: user.user_id.serialize(serializer)?,
             username: DerefAsString::serialize_with(&user.username, serializer)?,
             badges: MapUnwrapOrDefault::<BadgeRkyv>::serialize_with(&user.badges, serializer)?,
-            highest_rank: Map::<UserHighestRankRkyv>::serialize_with(
+            highest_rank: MapNiche::<UserHighestRankRkyv, DateTimeRkyv>::serialize_with(
                 &user.highest_rank,
                 serializer,
             )?,
@@ -329,7 +355,10 @@ impl<S: Fallible<Error: Source> + Writer + Allocator + ?Sized> SerializeWith<Use
                 &user.replays_watched_counts,
                 serializer,
             )?,
-            statistics: Map::<UserStatisticsRkyv>::serialize_with(&user.statistics, serializer)?,
+            statistics: MapNiche::<UserStatisticsRkyv, NaN>::serialize_with(
+                &user.statistics,
+                serializer,
+            )?,
             medals: MapUnwrapOrDefault::<MedalCompactRkyv>::serialize_with(
                 &user.medals,
                 serializer,
@@ -338,7 +367,7 @@ impl<S: Fallible<Error: Source> + Writer + Allocator + ?Sized> SerializeWith<Use
                 &user.daily_challenge_stats,
                 serializer,
             )?,
-            team: Map::<TeamRkyv>::serialize_with(&user.team, serializer)?,
+            team: MapNiche::<TeamRkyv, TeamRkyv>::serialize_with(&user.team, serializer)?,
         })
     }
 }
@@ -381,7 +410,7 @@ impl From<UserExtended> for User {
 #[rkyv(remote = UserHighestRank, archived = ArchivedUserHighestRank, derive(Clone))]
 pub struct UserHighestRankRkyv {
     pub rank: u32,
-    #[rkyv(with = DateTimeRkyv)]
+    #[rkyv(with = DateTimeRkyv, niche = DateTimeRkyv)]
     pub updated_at: OffsetDateTime,
 }
 
@@ -430,6 +459,7 @@ pub struct UserStatisticsRkyv {
     pub grade_counts: GradeCounts,
     #[rkyv(with = UserLevelRkyv)]
     pub level: UserLevel,
+    #[rkyv(niche = NaN)]
     pub accuracy: f32,
     pub country_rank: u32,
     pub global_rank: u32,