feat: improve perf for convert,add CopyUnsafe and change Equal function,make Swap extern

Author: NikoMalik

bench_test.go

@@ -7,6 +7,8 @@ import (
 	"testing"
 )
 
+const x64 = 64
+
 func ConvertSliceManual(from []int64) []int32 {
 	to := make([]int32, len(from))
 	for i, v := range from {
@@ -15,6 +17,91 @@ func ConvertSliceManual(from []int64) []int32 {
 	return to
 }
 
+func TestCopyUnsafe(t *testing.T) {
+	// Test 1: Standard case
+	source := []byte("Hello, World!")
+	destination := make([]byte, len(source))
+	n := CopyUnsafe(destination, source)
+	if n != len(source) {
+		t.Errorf("Expected %d bytes copied, got %d", len(source), n)
+	}
+	if string(destination) != string(source) {
+		t.Errorf("Expected destination %q, got %q", string(source), string(destination))
+	}
+
+	// Test 2: Different lengths (source longer than destination)
+	source = []byte("Hello, Go!")
+	destination = make([]byte, len(source)-2) // Smaller destination
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("Expected panic for size mismatch, but none occurred")
+		}
+	}()
+	_ = CopyUnsafe(destination, source)
+
+	// Test 3: Empty slices
+	source = []byte{}
+	destination = []byte{}
+	n = CopyUnsafe(destination, source)
+	if n != 0 {
+		t.Errorf("Expected 0 bytes copied, got %d", n)
+	}
+}
+
+func TestStrings(t *testing.T) {
+	// Test 1: Standard case
+	source := []byte("Hello, World!")
+
+	n := String(source)
+	if n != string(source) {
+		t.Errorf("Expected %s string copied, got %s", string(source), n)
+	}
+
+	source1 := "Hello,world!"
+
+	n1 := StringToBytes(source1)
+	if string(n1) != source1 {
+		t.Errorf("Expected %s string copied, got %s", source, n1)
+	}
+
+}
+
+func BenchmarkCopyUnsafe(b *testing.B) {
+	source := []byte("Benchmarking Unsafe Copy!")
+	destination := make([]byte, len(source))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		CopyUnsafe(destination, source)
+	}
+}
+
+func BenchmarkCopyStandart(b *testing.B) {
+	source := []byte("Benchmarking Standart Copy!")
+	destination := make([]byte, len(source))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		copy(destination, source)
+	}
+}
+
+func BenchmarkCopy_currentBytes(b *testing.B) {
+	source := []byte("Benchmarking Current Copy!")
+	destination := make([]byte, len(source))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		copy(destination[:26], source)
+	}
+}
+
+func BenchmarkCopy_currentBytes_UNSAFE(b *testing.B) {
+	source := []byte("Benchmarking Current Copy!")
+	destination := make([]byte, len(source))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		CopyUnsafe(destination[:26], source)
+	}
+}
+
 func generateTestStrings(count, minLength, maxLength int) []string {
 	var data []string
 	for i := 0; i < count; i++ {
@@ -58,13 +145,27 @@ func BenchmarkStringsBuilder(b *testing.B) {
 
 func BenchmarkString(b *testing.B) {
 	data := []byte("This is a benchmark test for String conversion.")
+	length := len(data)
 
 	b.Run("Custom String", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			_ = String(data)
 		}
 	})
 
+	b.Run("Custom string 2", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			_ = string2(data, length)
+		}
+
+	})
+
+	b.Run("Custom string 3", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			_ = string3(data)
+		}
+
+	})
 	b.Run("Standard String", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			_ = string(data)
@@ -211,15 +312,38 @@ func BenchmarkStringToBytes(b *testing.B) {
 	})
 }
 
+func TestEquals(t *testing.T) {
+	t.Run("TestEqualsTrue", func(t *testing.T) {
+		a := []byte("This is a benchmark test for Equal.....")
+		bb := []byte("This is a benchmark test for Equal.....")
+		lengthA := uintptr(len(a))
+		boole := Equal(a, bb, lengthA)
+		if boole == false {
+			t.Log("IsEqual: ", Equal(a, bb, lengthA))
+		}
+	})
+	t.Run("TestEqualsFalse", func(t *testing.T) {
+		a := []byte("This is a benchmark test for Equal.....")
+		bb := []byte("This is a benchmark test for Equal.....1")
+		lengthA := uintptr(len(a))
+		boole := Equal(a, bb, lengthA)
+		if boole == true {
+			t.Log("IsEqual: ", Equal(a, bb, lengthA))
+		}
+
+	})
+}
+
 func BenchmarkEqualTrue(b *testing.B) { // true
 	a := []byte("This is a benchmark test for Equal.....")
 	bb := []byte("This is a benchmark test for Equal.....")
+	lengthA := uintptr(len(a))
 
 	b.Run("Custom Equal", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			boole := Equal(a, bb)
+			boole := Equal(a, bb, lengthA)
 			if boole == false {
-				b.Log("IsEqual: ", Equal(a, bb))
+				b.Log("IsEqual: ", Equal(a, bb, lengthA))
 			}
 		}
 	})
@@ -233,6 +357,15 @@ func BenchmarkEqualTrue(b *testing.B) { // true
 
 		}
 	})
+
+	b.Run("TEST GENERIC EQUAL", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			boole := String(a) == String(bb)
+			if boole == false {
+				b.Fatal("GenericEqual: ", Equal(a, bb, lengthA))
+			}
+		}
+	})
 }
 
 func BenchmarkConvertSlice(b *testing.B) {

utils.go

@@ -10,6 +10,18 @@ import (
 	"github.com/NikoMalik/low-level-functions/constants"
 )
 
+//go:linkname memmove runtime.memmove
+func memmove(dst, src unsafe.Pointer, n uintptr)
+
+// constants in make for  standart copy is more faster,but if no constant we can use CopyUnsafe()
+// make([]byte, len(src)) not constant make([]byte, 0) constant
+//
+//go:nocheckptr
+func CopyUnsafe(dst []byte, src []byte) int {
+	memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(&src[0]), uintptr(len(src)))
+	return len(src)
+}
+
 //go:nosplit
 //go:nocheckptr
 func Noescape(up unsafe.Pointer) unsafe.Pointer {
@@ -32,16 +44,24 @@ func (err *ErrorSizeUnmatch) Error() string {
 }
 
 func String(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+func string2(b []byte, length int) string {
+	return *(*string)(unsafe.Pointer(&struct {
+		*byte
+		int
+	}{(*byte)(unsafe.Pointer(&b[0])), length}))
+}
+
+// too slow
+func string3(b []byte) string {
 
 	return unsafe.String(unsafe.SliceData(b), len(b))
 }
 
 func StringToBytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(&struct {
-		string
-		Cap int
-	}{s, len(s)},
-	))
+	return *(*[]byte)(unsafe.Pointer(&s))
 }
 
 func CopyString(s string) string {
@@ -60,7 +80,7 @@ func ConvertSlice[TFrom, TTo any](from []TFrom) ([]TTo, error) {
 	minSize := unsafe.Sizeof(zeroValTo)
 
 	if minSize > maxSize {
-		swap(&minSize, &maxSize)
+		Swap(&minSize, &maxSize)
 	}
 
 	if unsafe.Sizeof(zeroValFrom) == minSize {
@@ -97,7 +117,7 @@ func ConvertSlice[TFrom, TTo any](from []TFrom) ([]TTo, error) {
 }
 
 //go:noinline
-func swap[T any](a, b *T) {
+func Swap[T any](a, b *T) {
 	tmp := *a
 	*a = *b
 	*b = tmp
@@ -235,11 +255,8 @@ func MakeNoZeroCapString(l int, c int) []string {
 //go:linkname memequal runtime.memequal
 func memequal(a, b unsafe.Pointer, size uintptr) bool
 
-func Equal(a, b []byte) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	return memequal(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), uintptr(len(a)))
+func Equal(a, b []byte, length uintptr) bool {
+	return memequal(unsafe.Pointer(&a[0]), unsafe.Pointer(&b[0]), length)
 
 }
 
@@ -269,7 +286,7 @@ func IsNil(v any) bool {
 //
 // Returns:
 // - bool: True if the variables point to the same memory location, false otherwise.
-func IsEqual(v1, v2 any) bool {
+func IsEqual[T any](v1, v2 T) bool {
 	// Get the memory address of the variables using unsafe.Pointer.
 	// The & operator returns the memory address of a variable.
 	// The unsafe.Pointer type is used to store and manipulate untyped memory.
@@ -315,6 +332,7 @@ func GetItem[T any](slice []T, idx int) T { // experimental same performance as
 	return *(*T)(ptr)
 }
 
+//go:nocheckptr
 func GetItemWithoutCheck[T any](slice []T, idx int) T { // clears the checks for idx and make it faster but not safe
 
 	ptr := unsafe.Pointer(uintptr(unsafe.Pointer(&slice[0])) + uintptr(idx)*unsafe.Sizeof(slice[0]))