S.R.CS.Unsafe: Aligned vs Unaligned method name suffix

[ektrah]

The new Intel Intrinsic APIs (dotnet/corefx#23489) follow the convention of using the suffix Aligned for methods that require alignment. E.g.:

public static unsafe Vector256<byte> Load(byte* address)
public static unsafe Vector256<byte> LoadAligned(byte* address)

The System.Runtime.CompilerServices.Unsafe class currently does the opposite. E.g.:

public unsafe static T Read<T>(void* source)
public unsafe static T ReadUnaligned<T>(void* source)

Should the Unsafe class switch?

Benefit: ease of use. Methods without a suffix feel like the "default"; methods with a suffix feel like special cases that can be ignored most of the time. Unaligned access is a much better default than aligned access.

 public static partial class Unsafe
 {
     public static ref T AddByteOffset<T>(ref T source, System.IntPtr byteOffset)
     public static ref T Add<T>(ref T source, int elementOffset)
     public static void* Add<T>(void* source, int elementOffset)
     public static ref T Add<T>(ref T source, System.IntPtr elementOffset)
     public static bool AreSame<T>(ref T left, ref T right)
     public static void* AsPointer<T>(ref T value)
     public static ref T AsRef<T>(void* source)
     public static T As<T>(object o) where T : class
     public static ref TTo As<TFrom, TTo>(ref TFrom source)
     public static System.IntPtr ByteOffset<T>(ref T origin, ref T target)
-    public static void CopyBlock(ref byte destination, ref byte source, uint byteCount)
-    public static void CopyBlock(void* destination, void* source, uint byteCount)
+    public static void CopyBlockAligned(ref byte destination, ref byte source, uint byteCount)
+    public static void CopyBlockAligned(void* destination, void* source, uint byteCount)
-    public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount)
-    public static void CopyBlockUnaligned(void* destination, void* source, uint byteCount)
+    public static void CopyBlock(ref byte destination, ref byte source, uint byteCount)
+    public static void CopyBlock(void* destination, void* source, uint byteCount)
     public static void Copy<T>(void* destination, ref T source)
     public static void Copy<T>(ref T destination, void* source)
-    public static void InitBlock(ref byte startAddress, byte value, uint byteCount)
-    public static void InitBlock(void* startAddress, byte value, uint byteCount)
+    public static void InitBlockAligned(ref byte startAddress, byte value, uint byteCount)
+    public static void InitBlockAligned(void* startAddress, byte value, uint byteCount)
-    public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
-    public static void InitBlockUnaligned(void* startAddress, byte value, uint byteCount)
+    public static void InitBlock(ref byte startAddress, byte value, uint byteCount)
+    public static void InitBlock(void* startAddress, byte value, uint byteCount)
-    public static T Read<T>(void* source)
+    public static T ReadAligned<T>(void* source)
-    public static T ReadUnaligned<T>(void* source)
-    public static T ReadUnaligned<T>(ref byte source)
+    public static T Read<T>(void* source)
+    public static T Read<T>(ref byte source)
     public static int SizeOf<T>()
     public static ref T SubtractByteOffset<T>(ref T source, System.IntPtr byteOffset)
     public static ref T Subtract<T>(ref T source, int elementOffset)
     public static void* Subtract<T>(void* source, int elementOffset)
     public static ref T Subtract<T>(ref T source, System.IntPtr elementOffset)
-    public static void Write<T>(void* destination, T value)
+    public static void WriteAligned<T>(void* destination, T value)
-    public static void WriteUnaligned<T>(void* destination, T value)
-    public static void WriteUnaligned<T>(ref byte destination, T value)
+    public static void Write<T>(void* destination, T value)
+    public static void Write<T>(ref byte destination, T value)
 }

[jkotas]

The Unsafe class with these names shipped stable version already. Changing them would be a breaking change.

Also, I do not think that it make sense. There are 3 kinds of alignment:

• Unaligned. Corresponds to Unsafe.ReadUnaligned/WriteUnaligned methods.
• Default: This is platform specific. For example, the default alignment for long* is 4 byte on x86, but it is 8 byte on arm or x64. It is the alignment expected by Unsafe.Read/Write methods.
• More than default: Corresponds to Aligned flavor in the recently introduced intrinsic. You have to manually guarantee the alignment (e.g. if the memory is allocated on GC heap, you have to pin it).