Heap Info - Use a single allocation for the memory usage strings

Zephiles · Zephiles · commit e0414804158f · 2020-04-10T20:33:12.000-05:00
diff --git a/ttyd-tools/rel/include/global.h b/ttyd-tools/rel/include/global.h
@@ -734,26 +734,20 @@ struct OnScreenTimerDisplayFrameCounter
 struct HeapInfoDisplay
 {
 	#define MEMORY_USAGE_LINE_BUFFER_SIZE 64
+	int32_t ArrayCount;
 	bool *DisplayHeapInfo;
-	char **MemoryUsageBuffer;
+	char *MemoryUsageBuffer;
 	char HeapCorruptionBuffer[512];
 	
 	HeapInfoDisplay()
 	{
-		int32_t NumHeaps = gc::OSAlloc::NumHeaps;
+		int32_t NumHeaps = gc::OSAlloc::NumHeaps + 1; // Add one for the smart heap
+		ArrayCount = NumHeaps;
+		DisplayHeapInfo = new bool[NumHeaps];
 		
-		DisplayHeapInfo = new bool[NumHeaps + 1]; // Add one for the smart heap
-		
-		// Add one for the smart heap, subtract 1 for not displaying the free portion of the smart heap
-		int32_t MemoryUsageArrays = ((NumHeaps + 1) * 2) - 1;
-		
-		char **tempMemoryUsageBuffer = new char *[MemoryUsageArrays];
-		MemoryUsageBuffer = tempMemoryUsageBuffer;
-		
-		for (int32_t i = 0; i < MemoryUsageArrays; i++)
-		{
-			tempMemoryUsageBuffer[i] = new char[MEMORY_USAGE_LINE_BUFFER_SIZE];
-		}
+		// Subtract 1 for not displaying the free portion of the smart heap
+		int32_t MemoryUsageArrays = (NumHeaps * 2) - 1;
+		MemoryUsageBuffer = new char[MemoryUsageArrays * MEMORY_USAGE_LINE_BUFFER_SIZE];
 	}
 	
 	~HeapInfoDisplay()
@@ -765,20 +759,6 @@ struct HeapInfoDisplay
 		
 		if (MemoryUsageBuffer)
 		{
-			int32_t NumHeaps = gc::OSAlloc::NumHeaps;
-			
-			// Add one for the smart heap, subtract 1 for not displaying the free portion of the smart heap
-			int32_t MemoryUsageArrays = ((NumHeaps + 1) * 2) - 1;
-			
-			char **tempMemoryUsageBuffer = MemoryUsageBuffer;
-			for (int32_t i = 0; i < MemoryUsageArrays; i++)
-			{
-				if (tempMemoryUsageBuffer[i])
-				{
-					delete[] (tempMemoryUsageBuffer[i]);
-				}
-			}
-			
 			delete[] (MemoryUsageBuffer);
 		}
 	}
diff --git a/ttyd-tools/rel/include/main.h b/ttyd-tools/rel/include/main.h
@@ -6,6 +6,6 @@ namespace mod {
 
 void fixRoomProblems();
 void clearHeapCorruptionBuffer();
-void clearMemoryUsageBuffers();
+void clearMemoryUsageBuffer();
 
 }
diff --git a/ttyd-tools/rel/include/menufunctions.h b/ttyd-tools/rel/include/menufunctions.h
@@ -100,7 +100,6 @@ double getStickAngle(int32_t stickXYOut[2]); // If the X and Y values are not wa
 void getStickAngleString(char *stringOut);
 char *getTimeString(char *stringOut, int64_t time);
 void updateOnScreenTimerVars();
-int32_t getTotalHeaps();
 
 // void getButtonsPressedDynamic(uint8_t *buttonArrayOut, uint32_t currentButtonCombo);
 void getButtonsPressed(uint8_t *buttonArrayOut, uint32_t currentButtonCombo);
diff --git a/ttyd-tools/rel/source/draw.cpp b/ttyd-tools/rel/source/draw.cpp
@@ -3434,13 +3434,13 @@ void drawDisplaysMemoryUsageMenu()
 	
 	// Draw each option for displaying memory usage about each heap
 	bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;
-	int32_t TotalHeaps = getTotalHeaps() - 1; // Remove the smart heap from the total
+	int32_t NumHeaps = HeapInfo.ArrayCount - 1; // Remove the smart heap from the total
 	
 	int32_t tempCurrentMenuOption = static_cast<int32_t>(MenuVar.CurrentMenuOption);
 	char *tempDisplayBuffer = DisplayBuffer;
 	const char *String;
 	
-	for (int32_t i = 0; i < TotalHeaps; i++)
+	for (int32_t i = 0; i < NumHeaps; i++)
 	{
 		// Draw each heap number
 		sprintf(tempDisplayBuffer,
@@ -3458,12 +3458,12 @@ void drawDisplaysMemoryUsageMenu()
 	}
 	
 	// Draw the smart heap text
-	bool CurrentOptionCheck = tempCurrentMenuOption == TotalHeaps;
+	bool CurrentOptionCheck = tempCurrentMenuOption == NumHeaps;
 	Color = getSelectedTextColor(CurrentOptionCheck);
 	drawText("Smart Heap", PosX, PosY, Alpha, Color, Scale);
 	
 	// Draw the bool for the smart heap
-	getOnOffTextAndColor(DisplayHeapInfo[TotalHeaps], &String, &Color);
+	getOnOffTextAndColor(DisplayHeapInfo[NumHeaps], &String, &Color);
 	drawText(String, PosX + 120, PosY, Alpha, Color, Scale);
 }
 
@@ -4795,10 +4795,10 @@ void drawMemoryUsage()
 		PosY -= 20;
 	}
 	
-	char **tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;
+	char *tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;
 	bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;
 	
-	int32_t NumHeaps = getTotalHeaps() - 1; // Remove the smart heap from the total
+	int32_t NumHeaps = HeapInfo.ArrayCount - 1; // Remove the smart heap from the total
 	uint32_t MemoryUsageCounter = 0;
 	
 	// Draw the text for the main heaps
@@ -4808,15 +4808,17 @@ void drawMemoryUsage()
 		if (DisplayHeapInfo[i])
 		{
 			// Draw the used and free text
-			if (tempMemoryUsageBuffer[MemoryUsageCounter][0] != '\0')
+			uint32_t MemoryUsageBufferIndex = MemoryUsageCounter * MEMORY_USAGE_LINE_BUFFER_SIZE;
+			if (tempMemoryUsageBuffer[MemoryUsageBufferIndex] != '\0')
 			{
-				drawText(tempMemoryUsageBuffer[MemoryUsageCounter], PosX, PosY, Alpha, Color, Scale);
+				drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);
 				PosY -= 20;
 			}
 			
-			if (tempMemoryUsageBuffer[MemoryUsageCounter + 1][0] != '\0')
+			MemoryUsageBufferIndex += MEMORY_USAGE_LINE_BUFFER_SIZE;
+			if (tempMemoryUsageBuffer[MemoryUsageBufferIndex] != '\0')
 			{
-				drawText(tempMemoryUsageBuffer[MemoryUsageCounter + 1], PosX, PosY, Alpha, Color, Scale);
+				drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);
 				PosY -= 20;
 			}
 		}
@@ -4827,14 +4829,15 @@ void drawMemoryUsage()
 	if (DisplayHeapInfo[NumHeaps])
 	{
 		// Draw the used text
-		if (tempMemoryUsageBuffer[MemoryUsageCounter][0] != '\0')
+		if (tempMemoryUsageBuffer[MemoryUsageCounter] != '\0')
 		{
-			drawText(tempMemoryUsageBuffer[MemoryUsageCounter], PosX, PosY, Alpha, Color, Scale);
+			uint32_t MemoryUsageBufferIndex = MemoryUsageCounter * MEMORY_USAGE_LINE_BUFFER_SIZE;
+			drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);
 		}
 	}
 	
 	// Clear each of the memory usage buffers
-	clearMemoryUsageBuffers();
+	clearMemoryUsageBuffer();
 }
 
 void drawNpcNameToPtrError()
diff --git a/ttyd-tools/rel/source/main.cpp b/ttyd-tools/rel/source/main.cpp
@@ -467,18 +467,13 @@ void clearHeapCorruptionBuffer()
 	clearMemory(HeapInfo.HeapCorruptionBuffer, sizeof(HeapInfo.HeapCorruptionBuffer));
 }
 
-void clearMemoryUsageBuffers()
+void clearMemoryUsageBuffer()
 {
-	int32_t TotalHeaps = gc::OSAlloc::NumHeaps;
+	int32_t ArrayCount = HeapInfo.ArrayCount;
 	
-	// Add one for the smart heap, subtract 1 for not displaying the free portion of the smart heap
-	int32_t MemoryUsageArrays = ((TotalHeaps + 1) * 2) - 1;
-	
-	char **tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;
-	for (int32_t i = 0; i < MemoryUsageArrays; i++)
-	{
-		clearMemory(tempMemoryUsageBuffer[i], MEMORY_USAGE_LINE_BUFFER_SIZE);
-	}
+	// Subtract 1 for not displaying the free portion of the smart heap
+	int32_t MemoryUsageArrays = (ArrayCount * 2) - 1;
+	clearMemory(HeapInfo.MemoryUsageBuffer, MemoryUsageArrays * MEMORY_USAGE_LINE_BUFFER_SIZE);
 }
 
 void addTextToHeapCorruptionBuffer(char *text)
@@ -615,7 +610,7 @@ void handleStandardHeapChunkResults(void *addressWithError,
 			Chunks);
 		
 		// Add the text to the memory usage buffer
-		strncpy(HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex], 
+		strncpy(&HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex * MEMORY_USAGE_LINE_BUFFER_SIZE], 
 			tempDisplayBuffer, MEMORY_USAGE_LINE_BUFFER_SIZE - 1);
 	}
 }
@@ -676,7 +671,7 @@ void handleSmartHeapChunkResults(void *addressWithError,
 			Chunks);
 		
 		// Add the text to the memory usage buffer
-		strncpy(HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex], 
+		strncpy(&HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex * MEMORY_USAGE_LINE_BUFFER_SIZE], 
 			tempDisplayBuffer, MEMORY_USAGE_LINE_BUFFER_SIZE - 1);
 	}
 }
@@ -685,16 +680,16 @@ void checkHeaps()
 {
 	// Clear the heap buffers to be safe
 	clearHeapCorruptionBuffer();
-	clearMemoryUsageBuffers();
+	clearMemoryUsageBuffer();
 	
 	void *AddressWithError;
 	uint32_t MemoryUsageCounter = 0;
 	
 	// Check the standard heaps
 	gc::OSAlloc::HeapInfo *HeapArray = gc::OSAlloc::HeapArray;
-	int32_t TotalHeaps = gc::OSAlloc::NumHeaps;
+	int32_t NumHeaps = gc::OSAlloc::NumHeaps;
 	
-	for (int32_t i = 0; i < TotalHeaps; i++)
+	for (int32_t i = 0; i < NumHeaps; i++)
 	{
 		const gc::OSAlloc::HeapInfo *heap = &HeapArray[i];
 		
@@ -735,12 +730,12 @@ void checkHeaps()
 	// Draw the memory usage details
 	// Make sure at least one heap is being drawn
 	bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;
-	for (int32_t i = 0; i <= TotalHeaps; i++)
+	for (int32_t i = 0; i <= NumHeaps; i++)
 	{
 		if (DisplayHeapInfo[i])
 		{
 			drawFunctionOnDebugLayerWithOrder(drawMemoryUsage, 5.f);
-			return;
+			break;
 		}
 	}
 }
diff --git a/ttyd-tools/rel/source/menu.cpp b/ttyd-tools/rel/source/menu.cpp
@@ -2608,7 +2608,7 @@ void menuCheckButton()
 				case A:
 				{
 					// Make sure the selected option is valid
-					if (tempCurrentMenuOption >= static_cast<uint32_t>(getTotalHeaps()))
+					if (tempCurrentMenuOption >= static_cast<uint32_t>(HeapInfo.ArrayCount))
 					{
 						break;
 					}
diff --git a/ttyd-tools/rel/source/menufunctions.cpp b/ttyd-tools/rel/source/menufunctions.cpp
@@ -4195,12 +4195,6 @@ void updateOnScreenTimerVars()
 	OnScreenTimer.PreviousFrameTime = CurrentFrameTime;
 }
 
-int32_t getTotalHeaps()
-{
-	int32_t TotalHeaps = gc::OSAlloc::NumHeaps;
-	return TotalHeaps + 1; // Add one to include the smart heap at the end
-}
-
 /*void getButtonsPressedDynamic(uint8_t *buttonArrayOut, uint32_t currentButtonCombo)
 {
 	uint32_t Counter = 0;
@@ -4981,7 +4975,7 @@ void adjustBattlesStatusSelection(uint32_t button)
 
 void adjustDisplaysMemoryUsageSelection(uint32_t button)
 {
-	uint32_t TotalMenuOptions = static_cast<uint32_t>(getTotalHeaps());
+	uint32_t TotalMenuOptions = static_cast<uint32_t>(HeapInfo.ArrayCount);
 	uint32_t MaxOptionsPerRow = 1;
 	uint32_t MaxOptionsPerPage = TotalMenuOptions;
 	uint8_t tempPage[1];

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,6 @@ namespace mod {`
`6`	`6`
`7`	`7`	`void fixRoomProblems();`
`8`	`8`	`void clearHeapCorruptionBuffer();`
`9`		`-void clearMemoryUsageBuffers();`
	`9`	`+void clearMemoryUsageBuffer();`
`10`	`10`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3434,13 +3434,13 @@ void drawDisplaysMemoryUsageMenu()`
`3434`	`3434`
`3435`	`3435`	`// Draw each option for displaying memory usage about each heap`
`3436`	`3436`	`bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;`
`3437`		`- int32_t TotalHeaps = getTotalHeaps() - 1; // Remove the smart heap from the total`
	`3437`	`+ int32_t NumHeaps = HeapInfo.ArrayCount - 1; // Remove the smart heap from the total`
`3438`	`3438`
`3439`	`3439`	`int32_t tempCurrentMenuOption = static_cast<int32_t>(MenuVar.CurrentMenuOption);`
`3440`	`3440`	`char *tempDisplayBuffer = DisplayBuffer;`
`3441`	`3441`	`const char *String;`
`3442`	`3442`
`3443`		`- for (int32_t i = 0; i < TotalHeaps; i++)`
	`3443`	`+ for (int32_t i = 0; i < NumHeaps; i++)`
`3444`	`3444`	`{`
`3445`	`3445`	`// Draw each heap number`
`3446`	`3446`	`sprintf(tempDisplayBuffer,`
`@@ -3458,12 +3458,12 @@ void drawDisplaysMemoryUsageMenu()`
`3458`	`3458`	`}`
`3459`	`3459`
`3460`	`3460`	`// Draw the smart heap text`
`3461`		`- bool CurrentOptionCheck = tempCurrentMenuOption == TotalHeaps;`
	`3461`	`+ bool CurrentOptionCheck = tempCurrentMenuOption == NumHeaps;`
`3462`	`3462`	`Color = getSelectedTextColor(CurrentOptionCheck);`
`3463`	`3463`	`drawText("Smart Heap", PosX, PosY, Alpha, Color, Scale);`
`3464`	`3464`
`3465`	`3465`	`// Draw the bool for the smart heap`
`3466`		`- getOnOffTextAndColor(DisplayHeapInfo[TotalHeaps], &String, &Color);`
	`3466`	`+ getOnOffTextAndColor(DisplayHeapInfo[NumHeaps], &String, &Color);`
`3467`	`3467`	`drawText(String, PosX + 120, PosY, Alpha, Color, Scale);`
`3468`	`3468`	`}`
`3469`	`3469`
`@@ -4795,10 +4795,10 @@ void drawMemoryUsage()`
`4795`	`4795`	`PosY -= 20;`
`4796`	`4796`	`}`
`4797`	`4797`
`4798`		`- char **tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;`
	`4798`	`+ char *tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;`
`4799`	`4799`	`bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;`
`4800`	`4800`
`4801`		`- int32_t NumHeaps = getTotalHeaps() - 1; // Remove the smart heap from the total`
	`4801`	`+ int32_t NumHeaps = HeapInfo.ArrayCount - 1; // Remove the smart heap from the total`
`4802`	`4802`	`uint32_t MemoryUsageCounter = 0;`
`4803`	`4803`
`4804`	`4804`	`// Draw the text for the main heaps`
`@@ -4808,15 +4808,17 @@ void drawMemoryUsage()`
`4808`	`4808`	`if (DisplayHeapInfo[i])`
`4809`	`4809`	`{`
`4810`	`4810`	`// Draw the used and free text`
`4811`		`- if (tempMemoryUsageBuffer[MemoryUsageCounter][0] != '\0')`
	`4811`	`+ uint32_t MemoryUsageBufferIndex = MemoryUsageCounter * MEMORY_USAGE_LINE_BUFFER_SIZE;`
	`4812`	`+ if (tempMemoryUsageBuffer[MemoryUsageBufferIndex] != '\0')`
`4812`	`4813`	`{`
`4813`		`- drawText(tempMemoryUsageBuffer[MemoryUsageCounter], PosX, PosY, Alpha, Color, Scale);`
	`4814`	`+ drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);`
`4814`	`4815`	`PosY -= 20;`
`4815`	`4816`	`}`
`4816`	`4817`
`4817`		`- if (tempMemoryUsageBuffer[MemoryUsageCounter + 1][0] != '\0')`
	`4818`	`+ MemoryUsageBufferIndex += MEMORY_USAGE_LINE_BUFFER_SIZE;`
	`4819`	`+ if (tempMemoryUsageBuffer[MemoryUsageBufferIndex] != '\0')`
`4818`	`4820`	`{`
`4819`		`- drawText(tempMemoryUsageBuffer[MemoryUsageCounter + 1], PosX, PosY, Alpha, Color, Scale);`
	`4821`	`+ drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);`
`4820`	`4822`	`PosY -= 20;`
`4821`	`4823`	`}`
`4822`	`4824`	`}`
`@@ -4827,14 +4829,15 @@ void drawMemoryUsage()`
`4827`	`4829`	`if (DisplayHeapInfo[NumHeaps])`
`4828`	`4830`	`{`
`4829`	`4831`	`// Draw the used text`
`4830`		`- if (tempMemoryUsageBuffer[MemoryUsageCounter][0] != '\0')`
	`4832`	`+ if (tempMemoryUsageBuffer[MemoryUsageCounter] != '\0')`
`4831`	`4833`	`{`
`4832`		`- drawText(tempMemoryUsageBuffer[MemoryUsageCounter], PosX, PosY, Alpha, Color, Scale);`
	`4834`	`+ uint32_t MemoryUsageBufferIndex = MemoryUsageCounter * MEMORY_USAGE_LINE_BUFFER_SIZE;`
	`4835`	`+ drawText(&tempMemoryUsageBuffer[MemoryUsageBufferIndex], PosX, PosY, Alpha, Color, Scale);`
`4833`	`4836`	`}`
`4834`	`4837`	`}`
`4835`	`4838`
`4836`	`4839`	`// Clear each of the memory usage buffers`
`4837`		`- clearMemoryUsageBuffers();`
	`4840`	`+ clearMemoryUsageBuffer();`
`4838`	`4841`	`}`
`4839`	`4842`
`4840`	`4843`	`void drawNpcNameToPtrError()`
Original file line number	Diff line number	Diff line change
`@@ -467,18 +467,13 @@ void clearHeapCorruptionBuffer()`
`467`	`467`	`clearMemory(HeapInfo.HeapCorruptionBuffer, sizeof(HeapInfo.HeapCorruptionBuffer));`
`468`	`468`	`}`
`469`	`469`
`470`		`-void clearMemoryUsageBuffers()`
	`470`	`+void clearMemoryUsageBuffer()`
`471`	`471`	`{`
`472`		`- int32_t TotalHeaps = gc::OSAlloc::NumHeaps;`
	`472`	`+ int32_t ArrayCount = HeapInfo.ArrayCount;`
`473`	`473`
`474`		`- // Add one for the smart heap, subtract 1 for not displaying the free portion of the smart heap`
`475`		`- int32_t MemoryUsageArrays = ((TotalHeaps + 1) * 2) - 1;`
`476`		`-`
`477`		`- char **tempMemoryUsageBuffer = HeapInfo.MemoryUsageBuffer;`
`478`		`- for (int32_t i = 0; i < MemoryUsageArrays; i++)`
`479`		`- {`
`480`		`- clearMemory(tempMemoryUsageBuffer[i], MEMORY_USAGE_LINE_BUFFER_SIZE);`
`481`		`- }`
	`474`	`+ // Subtract 1 for not displaying the free portion of the smart heap`
	`475`	`+ int32_t MemoryUsageArrays = (ArrayCount * 2) - 1;`
	`476`	`+ clearMemory(HeapInfo.MemoryUsageBuffer, MemoryUsageArrays * MEMORY_USAGE_LINE_BUFFER_SIZE);`
`482`	`477`	`}`
`483`	`478`
`484`	`479`	`void addTextToHeapCorruptionBuffer(char *text)`
`@@ -615,7 +610,7 @@ void handleStandardHeapChunkResults(void *addressWithError,`
`615`	`610`	`Chunks);`
`616`	`611`
`617`	`612`	`// Add the text to the memory usage buffer`
`618`		`- strncpy(HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex],`
	`613`	`+ strncpy(&HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex * MEMORY_USAGE_LINE_BUFFER_SIZE],`
`619`	`614`	`tempDisplayBuffer, MEMORY_USAGE_LINE_BUFFER_SIZE - 1);`
`620`	`615`	`}`
`621`	`616`	`}`
`@@ -676,7 +671,7 @@ void handleSmartHeapChunkResults(void *addressWithError,`
`676`	`671`	`Chunks);`
`677`	`672`
`678`	`673`	`// Add the text to the memory usage buffer`
`679`		`- strncpy(HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex],`
	`674`	`+ strncpy(&HeapInfo.MemoryUsageBuffer[memoryUsageBufferIndex * MEMORY_USAGE_LINE_BUFFER_SIZE],`
`680`	`675`	`tempDisplayBuffer, MEMORY_USAGE_LINE_BUFFER_SIZE - 1);`
`681`	`676`	`}`
`682`	`677`	`}`
`@@ -685,16 +680,16 @@ void checkHeaps()`
`685`	`680`	`{`
`686`	`681`	`// Clear the heap buffers to be safe`
`687`	`682`	`clearHeapCorruptionBuffer();`
`688`		`- clearMemoryUsageBuffers();`
	`683`	`+ clearMemoryUsageBuffer();`
`689`	`684`
`690`	`685`	`void *AddressWithError;`
`691`	`686`	`uint32_t MemoryUsageCounter = 0;`
`692`	`687`
`693`	`688`	`// Check the standard heaps`
`694`	`689`	`gc::OSAlloc::HeapInfo *HeapArray = gc::OSAlloc::HeapArray;`
`695`		`- int32_t TotalHeaps = gc::OSAlloc::NumHeaps;`
	`690`	`+ int32_t NumHeaps = gc::OSAlloc::NumHeaps;`
`696`	`691`
`697`		`- for (int32_t i = 0; i < TotalHeaps; i++)`
	`692`	`+ for (int32_t i = 0; i < NumHeaps; i++)`
`698`	`693`	`{`
`699`	`694`	`const gc::OSAlloc::HeapInfo *heap = &HeapArray[i];`
`700`	`695`
`@@ -735,12 +730,12 @@ void checkHeaps()`
`735`	`730`	`// Draw the memory usage details`
`736`	`731`	`// Make sure at least one heap is being drawn`
`737`	`732`	`bool *DisplayHeapInfo = HeapInfo.DisplayHeapInfo;`
`738`		`- for (int32_t i = 0; i <= TotalHeaps; i++)`
	`733`	`+ for (int32_t i = 0; i <= NumHeaps; i++)`
`739`	`734`	`{`
`740`	`735`	`if (DisplayHeapInfo[i])`
`741`	`736`	`{`
`742`	`737`	`drawFunctionOnDebugLayerWithOrder(drawMemoryUsage, 5.f);`
`743`		`- return;`
	`738`	`+ break;`
`744`	`739`	`}`
`745`	`740`	`}`
`746`	`741`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2608,7 +2608,7 @@ void menuCheckButton()`
`2608`	`2608`	`case A:`
`2609`	`2609`	`{`
`2610`	`2610`	`// Make sure the selected option is valid`
`2611`		`- if (tempCurrentMenuOption >= static_cast<uint32_t>(getTotalHeaps()))`
	`2611`	`+ if (tempCurrentMenuOption >= static_cast<uint32_t>(HeapInfo.ArrayCount))`
`2612`	`2612`	`{`
`2613`	`2613`	`break;`
`2614`	`2614`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4195,12 +4195,6 @@ void updateOnScreenTimerVars()`
`4195`	`4195`	`OnScreenTimer.PreviousFrameTime = CurrentFrameTime;`
`4196`	`4196`	`}`
`4197`	`4197`
`4198`		`-int32_t getTotalHeaps()`
`4199`		`-{`
`4200`		`- int32_t TotalHeaps = gc::OSAlloc::NumHeaps;`
`4201`		`- return TotalHeaps + 1; // Add one to include the smart heap at the end`
`4202`		`-}`
`4203`		`-`
`4204`	`4198`	`/void getButtonsPressedDynamic(uint8_t buttonArrayOut, uint32_t currentButtonCombo)`
`4205`	`4199`	`{`
`4206`	`4200`	`uint32_t Counter = 0;`
`@@ -4981,7 +4975,7 @@ void adjustBattlesStatusSelection(uint32_t button)`
`4981`	`4975`
`4982`	`4976`	`void adjustDisplaysMemoryUsageSelection(uint32_t button)`
`4983`	`4977`	`{`
`4984`		`- uint32_t TotalMenuOptions = static_cast<uint32_t>(getTotalHeaps());`
	`4978`	`+ uint32_t TotalMenuOptions = static_cast<uint32_t>(HeapInfo.ArrayCount);`
`4985`	`4979`	`uint32_t MaxOptionsPerRow = 1;`
`4986`	`4980`	`uint32_t MaxOptionsPerPage = TotalMenuOptions;`
`4987`	`4981`	`uint8_t tempPage[1];`