[TieredStorage] Handles reduced-offset and offset conversion

accounts-db/src/account_info.rs

@@ -156,7 +156,7 @@ impl AccountInfo {
         }
     }
 
-    fn get_reduced_offset(offset: usize) -> OffsetReduced {
+    pub fn get_reduced_offset(offset: usize) -> OffsetReduced {
         (offset / ALIGN_BOUNDARY_OFFSET) as OffsetReduced
     }
 
@@ -174,7 +174,7 @@ impl AccountInfo {
         )
     }
 
-    fn reduced_offset_to_offset(reduced_offset: OffsetReduced) -> Offset {
+    pub fn reduced_offset_to_offset(reduced_offset: OffsetReduced) -> Offset {
         (reduced_offset as Offset) * ALIGN_BOUNDARY_OFFSET
     }
 

accounts-db/src/accounts_file.rs

@@ -1,5 +1,6 @@
 use {
     crate::{
+        account_info::AccountInfo,
         account_storage::meta::{
             StorableAccountsWithHashesAndWriteVersions, StoredAccountInfo, StoredAccountMeta,
         },
@@ -120,14 +121,21 @@ impl AccountsFile {
     /// Return (account metadata, next_index) pair for the account at the
     /// specified `index` if any.  Otherwise return None.   Also return the
     /// index of the next entry.
-    pub fn get_account(&self, index: usize) -> Option<(StoredAccountMeta<'_>, usize)> {
+    pub fn get_account(&self, offset: usize) -> Option<(StoredAccountMeta<'_>, usize)> {
         match self {
             Self::AppendVec(av) => av.get_account(index),
+            // The get_account API here uses usize "offset", which AccountsDB
+            // assumes it is an multiple of 8.
+            //
+            // On the other hand, TieredHot uses IndexOffset in get_account(),
+            // which is equivalent to the reduced-offset concept in AccountsDB.
+            // As a result, we need to convert it to reduced_offset, but returns
+            // usize offset in the return value.
             Self::TieredStorage(ts) => ts
                 .reader()?
-                .get_account(IndexOffset(index as u32))
+                .get_account(IndexOffset(AccountInfo::get_reduced_offset(offset)))
                 .ok()?
-                .map(|(metas, index_offset)| (metas, index_offset.0 as usize)),
+                .map(|(metas, index_offset)| (metas, AccountInfo::reduced_offset_to_offset(index_offset.0))),
         }
     }
 
@@ -142,7 +150,10 @@ impl AccountsFile {
                 let Some(reader) = ts.reader() else {
                     return Err(MatchAccountOwnerError::UnableToLoad);
                 };
-                reader.account_matches_owners(IndexOffset(offset as u32), owners)
+                reader.account_matches_owners(
+                    IndexOffset(AccountInfo::get_reduced_offset(offset)),
+                    owners,
+                )
             }
         }
     }
@@ -166,7 +177,7 @@ impl AccountsFile {
             Self::AppendVec(av) => av.accounts(offset),
             Self::TieredStorage(ts) => ts
                 .reader()
-                .and_then(|reader| reader.accounts(IndexOffset(offset as u32)).ok())
+                .and_then(|reader| reader.accounts(IndexOffset(AccountInfo::get_reduced_offset(offset))).ok())
                 .unwrap_or_default(),
         }
     }
@@ -191,11 +202,19 @@ impl AccountsFile {
     ) -> Option<Vec<StoredAccountInfo>> {
         match self {
             Self::AppendVec(av) => av.append_accounts(accounts, skip),
-            // Currently we only support HOT_FORMAT.  If we later want to use
-            // a different format, then we will need a way to pass-in it.
-            // TODO: consider adding function like write_accounts_to_hot_storage() or something
-            // to hide implementation detail.
-            Self::TieredStorage(ts) => ts.write_accounts(accounts, skip, &HOT_FORMAT).ok(),
+            Self::TieredStorage(ts) => ts
+                .write_accounts(accounts, skip, &HOT_FORMAT)
+                .map(|mut infos| {
+                    infos.iter_mut().for_each(|info| {
+                        // A conversion is needed here as TieredStorage uses
+                        // IndexOffset (which is equivalent to reduced-offset)
+                        // while AccountsDb uses usize non-reduced offset that
+                        // assumes the offset must be a multiple of 8.
+                        info.offset = AccountInfo::reduced_offset_to_offset(info.offset as u32);
+                    });
+                    infos
+                })
+                .ok(),
         }
     }
 }