add

Author: coremodmc

unsafeConvert.go

@@ -8,19 +8,25 @@ import (
 	"unsafe"
 )
 
-func Bytes(v string) []byte {
+func ByteSlice(v string) []byte {
 	return unsafe.Slice(unsafe.StringData(v), len(v))
 }
 
-func BytesReflect(v string) []byte {
+func BytePointer(v string) []byte {
 	return *(*[]byte)(unsafe.Pointer(&v))
 }
 
-func String(v []byte) string {
+func ByteCopy(s string) []byte {
+	buf := make([]byte, len(s))
+	copy(buf, s)
+	return buf
+}
+
+func StringSlice(v []byte) string {
 	return unsafe.String(unsafe.SliceData(v), len(v))
 }
 
-func StringReflect(v []byte) string {
+func StringPointer(v []byte) string {
 	return *(*string)(unsafe.Pointer(&v))
 }
 
@@ -43,7 +49,7 @@ func StringReflect(v []byte) string {
 // system crashes. So before converting, please test in a virtual
 // environment whether the type you want to convert can be converted,
 // in order to avoid loss.
-func STBReflect[T ~string | ~[]byte](v T) string {
+func STBPointer[T ~string | ~[]byte](v T) string {
 	return *(*string)(unsafe.Pointer(&v))
 }
 

unsafeConvert_Benchmark_test.go

@@ -233,47 +233,110 @@ The official mailing list for discussion of the Go language is Go Nuts.
 
 Report bugs using the Go issue tracker.`
 
-func Benchmark_StringToBytes_Lite(b *testing.B) {
+func Benchmark_ByteToString_G_Lite(b *testing.B) {
 	b.ResetTimer()
 	v := "Break a leg"
 	for i := 0; i < b.N; i++ {
 		_ = []byte(v)
 	}
 }
 
-func Benchmark_StringToBytes_usC_Lite(b *testing.B) {
+func Benchmark_ByteToString_Copy_U_Lite(b *testing.B) {
 	b.ResetTimer()
 	v := "Break a leg"
 	for i := 0; i < b.N; i++ {
-		_ = unsafeConvert.Bytes(v)
+		_ = unsafeConvert.ByteCopy(v)
 	}
 }
 
-func Benchmark_StringToBytes_usC_Reflect_Lite(b *testing.B) {
+func Benchmark_ByteToString_Slice_U_Lite(b *testing.B) {
 	b.ResetTimer()
 	v := "Break a leg"
 	for i := 0; i < b.N; i++ {
-		_ = unsafeConvert.BytesReflect(v)
+		_ = unsafeConvert.ByteSlice(v)
 	}
 }
 
-func Benchmark_StringToBytes_Big(b *testing.B) {
+func Benchmark_ByteToString_Pointer_U_Lite(b *testing.B) {
+	b.ResetTimer()
+	v := "Break a leg"
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.BytePointer(v)
+	}
+}
+
+func Benchmark_ByteToString_G_Big(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = []byte(biG)
+	}
+}
+
+func Benchmark_ByteToString_Copy_U_Big(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.ByteCopy(biG)
+	}
+}
+
+func Benchmark_ByteToString_Slice_U_Big(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.ByteSlice(biG)
+	}
+}
+
+func Benchmark_BytesToString_U_Pointer_Big(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.BytePointer(biG)
+	}
+}
+
+// 
+
+func Benchmark_StringToByte_G_Lite(b *testing.B) {
+	b.ResetTimer()
+	v := []byte("Break a leg")
+	for i := 0; i < b.N; i++ {
+		_ = string(v)
+	}
+}
+
+func Benchmark_StringToByte_Slice_U_Lite(b *testing.B) {
+	b.ResetTimer()
+	v := []byte("Break a leg")
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.StringSlice(v)
+	}
+}
+
+
+func Benchmark_StringToByte_Pointer_U_Lite(b *testing.B) {
+	b.ResetTimer()
+	v := []byte("Break a leg")
+	for i := 0; i < b.N; i++ {
+		_ = unsafeConvert.StringPointer(v)
+	}
+}
+
+func Benchmark_StringToByte_G_Big(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		_ = []byte(biG)
 	}
 }
 
-func Benchmark_StringToBytes_usC_Big(b *testing.B) {
+func Benchmark_StringToByte_Slice_U_Big(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_ = unsafeConvert.Bytes(biG)
+		_ = unsafeConvert.ByteSlice(biG)
 	}
 }
 
-func Benchmark_StringToBytes_usC_Reflect_Big(b *testing.B) {
+func Benchmark_StringToBytes_U_Pointer_Big(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_ = unsafeConvert.BytesReflect(biG)
+		_ = unsafeConvert.BytePointer(biG)
 	}
 }

unsafeConvert_test.go

@@ -42,14 +42,14 @@ type Bs string
 
 func TestTsT(t *testing.T) {
 	var r Bs = "src"
-	t.Error(STBReflect(r))
+	t.Error(STBPointer(r))
 	t.Error("ok")
 }
 
 func TestString(t *testing.T) {
 	for _, want := range strings {
 		arg := []byte(want)
-		got := String(arg)
+		got := StringSlice(arg)
 		if got != want {
 			t.Errorf("String(%q) = %q but want %q",
 				arg, got, want)
@@ -71,7 +71,18 @@ func eq(a, b []byte) bool {
 func TestBytes(t *testing.T) {
 	for _, arg := range strings {
 		want := []byte(arg)
-		got := Bytes(arg)
+		got := ByteSlice(arg)
+		if !eq(got, want) {
+			t.Errorf("Bytes(%q) = %q but want %q",
+				arg, got, want)
+		}
+	}
+}
+
+func TestPoolBytes(t *testing.T) {
+	for _, arg := range strings {
+		want := []byte(arg)
+		got := ByteCopy(arg)
 		if !eq(got, want) {
 			t.Errorf("Bytes(%q) = %q but want %q",
 				arg, got, want)
@@ -80,7 +91,7 @@ func TestBytes(t *testing.T) {
 }
 
 func TestNil(t *testing.T) {
-	got := String(nil)
+	got := StringSlice(nil)
 	if got != "" {
 		t.Errorf("String(nil) = %q but want %q", got, "")
 	}
@@ -104,7 +115,7 @@ func BenchmarkString(b *testing.B) {
 		name := fmt.Sprintf("String/%d", l)
 		b.Run(name, func(b *testing.B) {
 			for n := 0; n < b.N; n++ {
-				String(arg)
+				StringSlice(arg)
 			}
 		})
 
@@ -124,7 +135,7 @@ func BenchmarkBytes(b *testing.B) {
 		name := fmt.Sprintf("Bytes/%d", l)
 		b.Run(name, func(b *testing.B) {
 			for n := 0; n < b.N; n++ {
-				Bytes(arg)
+				ByteSlice(arg)
 			}
 		})