`[Fix]` unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of `unsafe` #3492

nan01ab · 2024-09-18T16:36:09Z

Description

The Unsafe.NotZero(ReadOnlySpan<byte>) method in Neo.VM use long* to load data from ReadOnlySpan<byte> for better performance, but this approach may result in misaligned memory access. This approach is no problem on x86 CPUs, but it may cause bug on some RISC CPUs(for example, some ARM CPUs).

Fixes # (issue)

Type of change

Optimization (the change is only an optimization)
Style (the change is only a code style for better maintenance or standard purpose)
Bug fix (non-breaking change which fixes an issue)
New feature (non-breaking change which adds functionality)
Breaking change (fix or feature that would cause existing functionality to not work as expected)
This change requires a documentation update

Test Configuration:

Checklist:

My code follows the style guidelines of this project
I have performed a self-review of my code
I have commented my code, particularly in hard-to-understand areas
I have made corresponding changes to the documentation
My changes generate no new warnings
I have added tests that prove my fix is effective or that my feature works
New and existing unit tests pass locally with my changes
Any dependent changes have been merged and published in downstream modules

.gitignore

AnnaShaleva · 2024-09-18T18:25:38Z

src/Neo.VM/Utility.cs

+            for (; i < x.Length; i++)
+            {
+                if (x[i] != 0) return true;
+            }


There's a difference in the existing approach comparing to the old code: new code starts comparison from the head of x, and the old code started comparison from the tail of x. GetBoolean is kind of a hot-path code in the VM, thus it would be interesting to see how this bugfix affects the performance (time) of DB restore from dump for mainnet/testnet.

The old code started comparison from the head of x too.

Wouldn't this work?

foreach (var b in Span) if (b != 0) return true;

There's a difference in the existing approach comparing to the old code: new code starts comparison from the head of x, and the old code started comparison from the tail of x. GetBoolean is kind of a hot-path code in the VM, thus it would be interesting to see how this bugfix affects the performance (time) of DB restore from dump for mainnet/testnet.

There's a difference in the existing approach comparing to the old code: new code starts comparison from the head of x, and the old code started comparison from the tail of x. GetBoolean is kind of a hot-path code in the VM, thus it would be interesting to see how this bugfix affects the performance (time) of DB restore from dump for mainnet/testnet.

Now the performance has been optimized(by ContainsAnyExcept because it can use SIMD).

Intel Core i7-8750H CPU 2.20GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores .NET SDK 8.0.203 [Host] : .NET 8.0.3 (8.0.324.11423), X64 RyuJIT AVX2 DefaultJob : .NET 8.0.3 (8.0.324.11423), X64 RyuJIT AVX2 | Method | length | Mean | Error | StdDev | |------------------ |------- |---------:|----------:|----------:| | LongPointer | 10 | 4.221 ns | 0.0285 ns | 0.0222 ns | | ContainsAnyExcept | 10 | 6.324 ns | 0.0619 ns | 0.0548 ns | | LongPointer | 20 | 5.567 ns | 0.0756 ns | 0.0670 ns | | ContainsAnyExcept | 20 | 6.820 ns | 0.0935 ns | 0.0829 ns | | LongPointer | 30 | 7.218 ns | 0.0847 ns | 0.0751 ns | | ContainsAnyExcept | 30 | 6.545 ns | 0.0514 ns | 0.0429 ns |

The new implementation performs better in some cases, especially if the bytes is relatively long.

AnnaShaleva · 2024-09-18T18:26:46Z

src/Neo.VM/Types/ByteString.cs

@@ -85,7 +85,7 @@ internal bool Equals(StackItem? other, ref uint limits)
        public override bool GetBoolean()
        {
            if (Size > Integer.MaxSize) throw new InvalidCastException();
-            return Unsafe.NotZero(GetSpan());
+            return GetSpan().NotZero();


The implementation is quite straightforward, but GetBoolean is frequently-used in VM, thus we have to check mainnet/testnet networks for compatibility. There should be no issues, but let's do it just in case.

@superboyiii could you check it?

shargon · 2024-09-18T19:22:37Z

src/Neo.VM/Types/ByteString.cs

@@ -85,7 +85,7 @@ internal bool Equals(StackItem? other, ref uint limits)
        public override bool GetBoolean()
        {
            if (Size > Integer.MaxSize) throw new InvalidCastException();
-            return Unsafe.NotZero(GetSpan());
+            return GetSpan().NotZero();


@superboyiii could you check it?

.gitignore

cschuchardt88 · 2024-09-19T08:41:35Z

src/Neo.VM/Utility.cs

@@ -27,6 +27,23 @@ static Utility()
            StrictUTF8.EncoderFallback = EncoderFallback.ExceptionFallback;
        }

+        public static bool NotZero(this ReadOnlySpan<byte> x)


This needs to be moved to the extensions library. For ReadOnlySpans.cs

This needs to be moved to the extensions library. For ReadOnlySpans.cs

Move it with the rest of the content together?

Just that extension method

cschuchardt88 · 2024-09-19T08:45:16Z

src/Neo.VM/Utility.cs

+            for (; i < x.Length; i++)
+            {
+                if (x[i] != 0) return true;
+            }


Wouldn't this work?

foreach (var b in Span) if (b != 0) return true;

shargon · 2024-09-19T13:41:04Z

src/Neo.VM/Utility.cs

+            int i;
+            for (i = 0; i + 7 < x.Length; i += 8)
+            {
+                if ((x[i] | x[i + 1] | x[i + 2] | x[i + 3] | x[i + 4] | x[i + 5] | x[i + 6] | x[i + 7]) != 0)


This won't be faster as previous version

This won't be faster as previous version

This won't be faster as previous version

The performance has been optimized,

shargon · 2024-09-19T13:42:30Z

src/Neo.VM/Unsafe.cs

-        {
-            int len = x.Length;
-            if (len == 0) return false;
-            fixed (byte* xp = x)


could you explain more how this could be wrong in different platform? could you write a unit test for it?

Align of long is 8, and align of byte is 1, so byte* may not be aligned to 8.

fix: unalignment load in ReadOnlySpan<byte>.NotZero

7cf2e7f

nan01ab changed the title ~~fix: unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>)~~ [fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) Sep 18, 2024

nan01ab changed the title ~~[fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>)~~ [Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) Sep 18, 2024

Jim8y added the waiting for review label Sep 18, 2024

AnnaShaleva reviewed Sep 18, 2024

View reviewed changes

shargon reviewed Sep 18, 2024

View reviewed changes

Update .gitignore

37f78c8

cschuchardt88 reviewed Sep 19, 2024

View reviewed changes

shargon reviewed Sep 19, 2024

View reviewed changes

shargon requested changes Sep 19, 2024

View reviewed changes

use SequenceEqual to compare bytes for better performace

2031460

nan01ab changed the title ~~[Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>)~~ [Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of unsafe Sep 19, 2024

nan01ab added 4 commits September 20, 2024 01:39

use ContainsAnyExcept to get better performace and simply code

a4ef07d

use ContainsAnyExcept to get better performance and simply code

6315b28

use ContainsAnyExcept to get better performance and simply code

cf362b7

fix comment

d3fc7d2

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

`[Fix]` unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of `unsafe` #3492

`[Fix]` unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of `unsafe` #3492

nan01ab commented Sep 18, 2024 •

edited

Loading

AnnaShaleva Sep 18, 2024 •

edited

Loading

nan01ab Sep 18, 2024

cschuchardt88 Sep 19, 2024

nan01ab Sep 19, 2024 •

edited

Loading

AnnaShaleva Sep 18, 2024

shargon Sep 18, 2024

shargon Sep 18, 2024

cschuchardt88 Sep 19, 2024

nan01ab Sep 19, 2024

cschuchardt88 Sep 20, 2024

cschuchardt88 Sep 19, 2024

shargon Sep 19, 2024

nan01ab Sep 19, 2024

shargon Sep 19, 2024

nan01ab Sep 19, 2024

[Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of unsafe #3492

Are you sure you want to change the base?

[Fix] unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of unsafe #3492

Conversation

nan01ab commented Sep 18, 2024 • edited Loading

Description

Type of change

Checklist:

AnnaShaleva Sep 18, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nan01ab Sep 19, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

`[Fix]` unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of `unsafe` #3492

`[Fix]` unalignment memory load in Neo.VM Unsafe.NotZero(ReadOnlySpan<byte>) and remove the use of `unsafe` #3492

nan01ab commented Sep 18, 2024 •

edited

Loading

AnnaShaleva Sep 18, 2024 •

edited

Loading

nan01ab Sep 19, 2024 •

edited

Loading