Repository navigation
Add support for dynamic memory allocation on stack (localloc support) #191
+329
−11
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,44 @@ | ||
| using System; | ||
| using System.Runtime.CompilerServices; | ||
|
|
||
| public class S390xInstructionTest | ||
| { | ||
| public static int Main() | ||
| { | ||
| int result = s390xHw(); | ||
| Console.WriteLine(result == 0 ? "PASS" : "FAIL: " + result); | ||
| return result == 0 ? 0 : 1; | ||
| } | ||
|
|
||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| static int Consume(Span<byte> s) | ||
| { | ||
| return s.Length; | ||
| } | ||
|
|
||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| static int FlushTest(int n) | ||
| { | ||
| Span<byte> buf = stackalloc byte[n]; | ||
| buf[0] = 0xAA; | ||
| buf[n - 1] = 0xBB; | ||
| return buf.Length; // Returns n | ||
| } | ||
|
|
||
| public static int s390xHw() | ||
| { | ||
| int r; | ||
|
|
||
| // 1. Test FlushTest buffer length returns | ||
| r = FlushTest(5); | ||
| if (r != 5) return 1; | ||
|
|
||
| r = FlushTest(40); | ||
| if (r != 40) return 2; | ||
|
|
||
| r = FlushTest(400); | ||
| if (r != 400) return 3; | ||
|
|
||
| return 0; // PASS | ||
| } | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,161 @@ | ||
| using System; | ||
| using System.Runtime.CompilerServices; | ||
|
|
||
| #pragma warning disable CA2014 // Suppress warning for stackalloc inside loop | ||
|
|
||
| public class S390xInstructionTest | ||
| { | ||
| public static int Main() | ||
| { | ||
| int result = s390xHw(); | ||
| Console.WriteLine(result == 0 ? "PASS" : "FAIL: " + result); | ||
| return result == 0 ? 0 : 1; | ||
| } | ||
|
|
||
| public static int s390xHw() | ||
| { | ||
| // 1. Test Constant Size Allocation (<= 64B) | ||
| if (!TestConstantAllocation()) | ||
| return 101; | ||
|
|
||
| // 2. Test Dynamic Size Allocation (5B, 127B, 1024B) | ||
| if (!TestDynamicAllocation(5) || !TestDynamicAllocation(127) || !TestDynamicAllocation(1024)) | ||
| return 102; | ||
|
|
||
| // 3. Test Zero-Size Allocation (0B) | ||
| if (!TestZeroSizeAllocation()) | ||
| return 103; | ||
|
|
||
| // 4. Test Multiple Allocations in a Single Method | ||
| if (!TestMultipleAllocations()) | ||
| return 104; | ||
|
|
||
| // 5. Test localloc in a Loop with Child Calls | ||
| if (!TestLocallocInLoop()) | ||
| return 105; | ||
|
|
||
| // All tests passed | ||
| return 0; | ||
| } | ||
|
|
||
| // ========================================================================= | ||
| // Test 1: Constant Size Allocation (Unrolled & Zero-Initialized) | ||
| // ========================================================================= | ||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static unsafe bool TestConstantAllocation() | ||
| { | ||
| byte* buf = stackalloc byte[16]; | ||
|
|
||
| // Verify zero-init | ||
| for (int i = 0; i < 16; i++) | ||
| { | ||
| if (buf[i] != 0) return false; | ||
| buf[i] = (byte)(i + 1); | ||
| } | ||
|
|
||
| // Verify written data | ||
| for (int i = 0; i < 16; i++) | ||
| { | ||
| if (buf[i] != (byte)(i + 1)) return false; | ||
| } | ||
|
|
||
| return true; | ||
| } | ||
|
|
||
| // ========================================================================= | ||
| // Test 2: Dynamic (Variable) Size Allocation with Loop Zeroing | ||
| // ========================================================================= | ||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static unsafe bool TestDynamicAllocation(int size) | ||
| { | ||
| byte* buf = stackalloc byte[size]; | ||
|
|
||
| // Verify zero-init | ||
| for (int i = 0; i < size; i++) | ||
| { | ||
| if (buf[i] != 0) return false; | ||
| } | ||
|
|
||
| // Write pattern | ||
| for (int i = 0; i < size; i++) | ||
| { | ||
| buf[i] = (byte)(i & 0xFF); | ||
| } | ||
|
|
||
| // Verify pattern | ||
| for (int i = 0; i < size; i++) | ||
| { | ||
| if (buf[i] != (byte)(i & 0xFF)) return false; | ||
| } | ||
|
|
||
| return true; | ||
| } | ||
|
|
||
| // ========================================================================= | ||
| // Test 3: Zero-Size Allocation (Bailout path returning NULL) | ||
| // ========================================================================= | ||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static unsafe bool TestZeroSizeAllocation() | ||
| { | ||
| int zero = 0; | ||
| byte* pDynamicZero = stackalloc byte[zero]; | ||
| byte* pConstZero = stackalloc byte[0]; | ||
|
|
||
| return (pDynamicZero == null) && (pConstZero == null); | ||
| } | ||
|
|
||
| // ========================================================================= | ||
| // Test 4: Multiple localloc Calls in a Single Method | ||
| // ========================================================================= | ||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static unsafe bool TestMultipleAllocations() | ||
| { | ||
| int localBefore = 0x12345678; | ||
|
|
||
| byte* buf1 = stackalloc byte[32]; | ||
| byte* buf2 = stackalloc byte[64]; | ||
| byte* buf3 = stackalloc byte[128]; | ||
|
|
||
| int localAfter = 0x76543210; | ||
|
|
||
| for (int i = 0; i < 32; i++) buf1[i] = 0xAA; | ||
| for (int i = 0; i < 64; i++) buf2[i] = 0xBB; | ||
| for (int i = 0; i < 128; i++) buf3[i] = 0xCC; | ||
|
|
||
| for (int i = 0; i < 32; i++) if (buf1[i] != 0xAA) return false; | ||
| for (int i = 0; i < 64; i++) if (buf2[i] != 0xBB) return false; | ||
| for (int i = 0; i < 128; i++) if (buf3[i] != 0xCC) return false; | ||
|
|
||
| if (localBefore != 0x12345678 || localAfter != 0x76543210) return false; | ||
|
|
||
| return true; | ||
| } | ||
|
|
||
| // ========================================================================= | ||
| // Test 5: localloc in a Loop with Child Calls (RSA / Outgoing Arg Safety) | ||
| // ========================================================================= | ||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static int HelperFunction(int a, int b, int c, int d, int e, int f) | ||
| { | ||
| return a + b + c + d + e + f; | ||
| } | ||
|
|
||
| [MethodImpl(MethodImplOptions.NoInlining)] | ||
| private static unsafe bool TestLocallocInLoop() | ||
| { | ||
| for (int iter = 1; iter <= 10; iter++) | ||
| { | ||
| int size = iter * 16; | ||
| byte* buf = stackalloc byte[size]; | ||
|
|
||
| buf[0] = (byte)iter; | ||
| buf[size - 1] = (byte)(iter * 2); | ||
|
|
||
| int sum = HelperFunction(buf[0], buf[size - 1], 1, 2, 3, 4); | ||
| if (sum != (iter + (iter * 2) + 10)) return false; | ||
|
|
||
| if (buf[0] != (byte)iter || buf[size - 1] != (byte)(iter * 2)) return false; | ||
| } | ||
| return true; | ||
| } | ||
| } |
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Uh oh!
There was an error while loading. Please reload this page.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
if the amount is 0, why do we even load something?
where is this targetReg is referenced is what I'm trying to understand?
Uh oh!
There was an error while loading. Please reload this page.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Initially, I had the same thing in mind to bypass the 0 size condition but if this block is being call multiple times, there would redundant backchaining happening for zero size. (Just to remain in as sync with other archs).
For the load part, we do need so that we are sure there is no previous value we are taking in, targetReg is whatever register LSRA allocates to us, that might have previous values. The node must always leave a defined value in targetReg.
Without the lgfi targetReg, 0, the register would hold prev stale values in it, and the parent node would read that stale value as the stackalloc result. Also once we know its size 0, we return early and dont want to do the long way of backchaining.
If we scrap this altogether, we dont need lgfi at all, we can do this but I preferred to keep the zeroing case in the constant logic.