Merge branch 'perf/lhn-baselines' into perf/lhn-sort-cache

Author: Bar-Maz

src/libs/ReportActionsUtils.ts

@@ -672,7 +672,6 @@ function setSortedReportActionsCacheMaxSize(newSize: number): void {
         sortedReportActionsCacheMaxSize = newSize;
     }
 
-    // Immediately evict if current caches are above the new limit.
     evictOldestCacheEntries(sortedReportActionsCacheAscending);
     evictOldestCacheEntries(sortedReportActionsCacheDescending);
 }

src/libs/SidebarUtils.ts

@@ -274,9 +274,7 @@ function getReportsToDisplayInLHN(
 ) {
     const isInFocusMode = priorityMode === CONST.PRIORITY_MODE.GSD;
     const allReportsDictValues = reports ?? {};
-    // Adjust the size of the sorted report actions cache to roughly match
-    // the current number of reports, while still respecting the global cap
-    // inside ReportActionsUtils to guard against excessive memory usage.
+
     setSortedReportActionsCacheMaxSize(Object.keys(allReportsDictValues).length);
     const reportsToDisplay: ReportsToDisplayInLHN = {};
 

tests/perf-test/ReportActionsUtils.perf-test.ts

@@ -1,7 +1,13 @@
 import {getLastClosedReportAction} from '@selectors/ReportAction';
 import Onyx from 'react-native-onyx';
 import {measureFunction} from 'reassure';
-import {getLastVisibleAction, getLastVisibleMessage, getMostRecentIOURequestActionID, getSortedReportActionsForDisplay} from '@libs/ReportActionsUtils';
+import {
+    getLastVisibleAction,
+    getLastVisibleMessage,
+    getMostRecentIOURequestActionID,
+    getSortedReportActions,
+    getSortedReportActionsForDisplay,
+} from '@libs/ReportActionsUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type {ReportActions} from '@src/types/onyx/ReportAction';
@@ -35,6 +41,7 @@ const reportActions = createCollection<ReportAction>(
 );
 
 const reportId = '1';
+const ACTIONS_COUNT_CACHE = 100;
 
 describe('ReportActionsUtils', () => {
     beforeAll(() => {
@@ -140,4 +147,33 @@ describe('ReportActionsUtils', () => {
         await waitForBatchedUpdates();
         await measureFunction(() => getLastClosedReportAction(reportActions));
     });
+
+    test('[ReportActionsUtils] getSortedReportActions cache hit performance', async () => {
+        const reportActionsForCache = createCollection<ReportAction>(
+            (item) => `${item.reportActionID}`,
+            (index) => createRandomReportAction(index),
+            ACTIONS_COUNT_CACHE,
+        );
+        const actionsArray = Object.values(reportActionsForCache);
+
+        await measureFunction(() => getSortedReportActions(actionsArray, true), {
+            runs: 20,
+            warmupRuns: 5,
+        });
+    });
+
+    test('[ReportActionsUtils] getSortedReportActions cache hit with different array references', async () => {
+        const reportActionsForCache = createCollection<ReportAction>(
+            (item) => `${item.reportActionID}`,
+            (index) => createRandomReportAction(index),
+            ACTIONS_COUNT_CACHE,
+        );
+        const actionsArray = Object.values(reportActionsForCache);
+        const newArrayRef = [...actionsArray];
+
+        await measureFunction(() => getSortedReportActions(newArrayRef, true), {
+            runs: 20,
+            warmupRuns: 5,
+        });
+    });
 });

tests/perf-test/ReportActionsUtilsCache.perf-test.ts

@@ -384,26 +384,6 @@ describe('SidebarUtils', () => {
         });
     });
 
-    test('[SidebarUtils LHN] scaling – 2000 reports', async () => {
-        const dataSet = createLHNReportsWithActions(2000);
-        await Onyx.multiSet({
-            ...dataSet.reports,
-            ...dataSet.reportActions,
-            ...dataSet.reportNameValuePairs,
-        } as Parameters<typeof Onyx.multiSet>[0]);
-        await waitForBatchedUpdates();
-
-        await measureFunction(() => {
-            for (const reportKey of Object.keys(dataSet.reports)) {
-                const reportID = reportKey.replace(ONYXKEYS.COLLECTION.REPORT, '');
-                const actions = dataSet.reportActions[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`];
-                if (actions) {
-                    getSortedReportActionsForDisplay(actions, true);
-                }
-            }
-        });
-    }, 600000);
-
     test('[SidebarUtils LHN] cache usage verification – allSortedReportActions cache', async () => {
         await waitForBatchedUpdates();
         await new Promise((resolve) => {