Some notes:

• A vector is a value, not dissimilar to an int, as a result, it is illogical to change a value, you can change a variable containing a value, but the value itself is immutable. As a result, the Set method should be Set(vec M128[T], offset int, value T) M128[T].

• In addition, the most basic operation on a vector is to load/store them, so there should be Store(dst []T, offset int, vec M128[T]) and Load(src []T, offset int) M128[T].

// The value of offset must be a multiple of 8 and less than unsafe. Sizeof(M128)

I'm not sure I understand this. You say that the total length of M128 is always 128 bits, so we know that unsafe.Sizeof(M128) is 16. So if offset has to be a multiple of 8 then it can only be 0 or 8. Is that what you mean?

// The value of offset must be a multiple of 8 and less than unsafe. Sizeof(M128)

I'm not sure I understand this. You say that the total length of M128 is always 128 bits, so we know that unsafe.Sizeof(M128) is 16. So if offset has to be a multiple of 8 then it can only be 0 or 8. Is that what you mean?

This is the imperfection of the proposal, and I have revised it to the following statement:

The value of offset must be a multiple of unsafe.Sizeof(T) and less than unsafe.Sizeof(M128)

Some notes:

• A vector is a value, not dissimilar to an int, as a result, it is illogical to change a value, you can change a variable containing a value, but the value itself is immutable. As a result, the Set method should be Set(vec M128[T], offset int, value T) M128[T].
• In addition, the most basic operation on a vector is to load/store them, so there should be Store(dst []T, offset int, vec M128[T]) and Load(src []T, offset int) M128[T].

1. M128 represents n data of type T, and the total length of M128 is 128 bits，

func (mem *M128[T])Set(offect int8，value T)

This is just changing one of these n T-type data

2.Regarding the API for loading and storing, taking storage as an example:

Store(dst []T, offset int, vec M128[T])

Can be written as:

for i:=int8(0);i<len(dst);i++{
vec.Set(int8(unsafe.Sizeof(T))*i+int8(offset),dst[i])
}

It seems that this can be regarded as a syntactic sugar that calls the Set or Get method continuously.

Some notes:

• A vector is a value, not dissimilar to an int, as a result, it is illogical to change a value, you can change a variable containing a value, but the value itself is immutable. As a result, the Set method should be Set(vec M128[T], offset int, value T) M128[T].
• In addition, the most basic operation on a vector is to load/store them, so there should be Store(dst []T, offset int, vec M128[T]) and Load(src []T, offset int) M128[T].

1. M128 represents n data of type T, and the total length of M128 is 128 bits，

func (mem *M128[T])Set(offect int8，value T)

This is just changing one of these n T-type data

2.Regarding the API for loading and storing, taking storage as an example:

Store(dst []T, offset int, vec M128[T])

Can be written as:

for i:=int8(0);i<len(dst);i++{
vec.Set(int8(unsafe.Sizeof(T))*i+int8(offset),dst[i])
}

It seems that this can be regarded as a syntactic sugar that calls the Set or Get method continuously.

Rethinking
In order to avoid the need to use the unsafe package when calling Set continuously, the proposal has added
// Store sets M128 data to dst starting from offset
// The value of offset must be a multiple of unsafe.Sizeof(T) and less than unsafe.Sizeof(M128)
// offset+len(dst)*unsafe.Sizeof(T) must be less than unsafe.Sizeof(M128)
func (mem *M128[T])Store(dst []T, offset int)

@merykitty，I don't quite understand the semantics of Load (src [] T, offset int) M128[T] you wrote. If you use src data to generate M128[T], this is the function of Store.

1, In vector world, to change an element, you take a vector, and return a new vector with one element changed. This is similar to how you flip a bit in an int: x = y ^ mask, this leaves y unchanged and returns a new int which has some bits flipped, this new int is stored into the variable x. That's why the function I propose is func Set(vec m128[T], offset int, value T) m128[T]. The signature of a corresponding C++ intrinsics is __m256i _mm256_insert_epi32(__m256i a, __int32 i, const int index), and this is also how the machine work: vpinsrd dst, src, val, idx puts into dst a vector similar to src with the element at idx changed to val.

2, How do you use Store to load a vector when you need a vector to invoke Store? Please provide a simple example for example addition of 2 slices into a third one using this api.

2, How do you use Store to load a vector when you need a vector to invoke Store? Please provide a simple example for example addition of 2 slices into a third one using this api.

It seems that I misunderstood your expression. I thought Load was reading [] T from M128, but what you wanted to express seems to be loading [] T into M128

1, In vector world, to change an element, you take a vector, and return a new vector with one element changed. This is similar to how you flip a bit in an int: x = y ^ mask, this leaves y unchanged and returns a new int which has some bits flipped, this new int is stored into the variable x. That's why the function I propose is func Set(vec m128[T], offset int, value T) m128[T]. The signature of a corresponding C++ intrinsics is __m256i _mm256_insert_epi32(__m256i a, __int32 i, const int index), and this is also how the machine work: vpinsrd dst, src, val, idx puts into dst a vector similar to src with the element at idx changed to val.

M128 [T] is just a 128 bit continuous memory that can be used for SIMD operations, storing n data of type T.

func (mem *M128[T])Set(offect int8，value T)Equivalent to the following code:

if offset>unsafe.Sizeof(M128)||offset%unsafe.Sizeof(T)!=0{//Check if the offset is greater than unsafe. Sizeof (M128) or not a multiple of unsafe. Sizeof (T)
//panic or runtime.throw
}
ptr:=unsafe.Pointer(mem)
ptr=unsafe.Add(ptr,offset)
*(*T)(ptr)=value

After consideration, the proposal proposes to add 2 APIs for loading or storing M128 [T] using [] T:

// Store copies all data from src into the memory of unsafe.Add(unsafe.Pointer(mem),offset)
// The value of offset must be a multiple of unsafe.Sizeof(T) and less than unsafe.Sizeof(M128).
// offset+len(src)*unsafe.Sizeof(T) must be less than unsafe.Sizeof(M128).
func (mem *M128[T])Store(offset int8,src []T)

// Load sets dst to the M128 data starting with offset
// The value of offset must be a multiple of unsafe.Sizeof(T) and less than unsafe.Sizeof(M128).
// offset+len(dst)*unsafe.Sizeof(T) must be less than unsafe.Sizeof(M128).
func (mem *M128[T])Load(offset int8, dst []T)

Should this issue be added to the review minutes?