Avoid too many copies in string encoder/decoder

[evt]

Closes #12

[fasmat]

@dshulyak I got the following results running the benchmarks in unsafe_test.go:

go test -v -benchmem -bench="^Benchmark_" -run="^$" -gcflags=-N .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
Benchmark_UnsafeBytesToString
Benchmark_UnsafeBytesToString-6         530076894                2.265 ns/op           0 B/op          0 allocs/op
Benchmark_SafeBytesToString
Benchmark_SafeBytesToString-6           417205314                2.864 ns/op           0 B/op          0 allocs/op
Benchmark_UnsafeStringToBytes
Benchmark_UnsafeStringToBytes-6         348893032                3.448 ns/op           0 B/op          0 allocs/op
Benchmark_SafeStringToBytes
Benchmark_SafeStringToBytes-6           419229655                2.861 ns/op           0 B/op          0 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 5.968s

I'm not sure if we should use the unsafe variants avoiding additional allocations, the go runtime will try to avoid allocations anyway if it can. In the case of Bytes2String we are ~ 30% faster, but in the case of String2Bytes we are ~ 20% slower than the safe way to do it.

What is your opinion?

PS.: Results with optimization:

go test -v -benchmem -bench="^Benchmark_" -run="^$" .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
Benchmark_UnsafeBytesToString
Benchmark_UnsafeBytesToString-6         1000000000               0.3178 ns/op          0 B/op          0 allocs/op
Benchmark_SafeBytesToString
Benchmark_SafeBytesToString-6           518009090                2.318 ns/op           0 B/op          0 allocs/op
Benchmark_UnsafeStringToBytes
Benchmark_UnsafeStringToBytes-6         1000000000               0.4386 ns/op          0 B/op          0 allocs/op
Benchmark_SafeStringToBytes
Benchmark_SafeStringToBytes-6           512238043                2.330 ns/op           0 B/op          0 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 3.713s

I'm not sure how accurate this is, the go compiler/runtime might just completely optimize the benchmark away. Either way according to the Benchmark all versions with and without optimizations trigger 0 allocations per operation.

[fasmat]

Using a io.StringWriter when possible improves encoding slightly when using optimizations:

go test -v -benchmem -bench="^BenchmarkEnc" -run="^$" .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
BenchmarkEncodeStrings_WithStringWriter
BenchmarkEncodeStrings_WithStringWriter-6               39392080                32.31 ns/op           74 B/op          0 allocs/op
BenchmarkEncodeStrings_WithWriterForStrings
BenchmarkEncodeStrings_WithWriterForStrings-6           53234829                51.74 ns/op           40 B/op          0 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 7.676s

without optimization there is almost no difference:

go test -v -benchmem -bench="^BenchmarkEnc" -run="^$" -gcflags=-N .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
BenchmarkEncodeStrings_WithStringWriter
BenchmarkEncodeStrings_WithStringWriter-6               24001058                56.67 ns/op           62 B/op          0 allocs/op
BenchmarkEncodeStrings_WithWriterForStrings
BenchmarkEncodeStrings_WithWriterForStrings-6           25614274                54.75 ns/op           41 B/op          0 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 6.168s

[fasmat]

I updated the benchmarks in a way that hopefully prevents go from optimizing the allocation away. These are the new results:

go test -v -benchmem -bench="^Benchmark_" -run="^$" -gcflags=-N .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
Benchmark_UnsafeBytesToString
Benchmark_UnsafeBytesToString-6         539234050                2.224 ns/op           0 B/op          0 allocs/op
Benchmark_SafeBytesToString
Benchmark_SafeBytesToString-6           98168997                12.29 ns/op           16 B/op          1 allocs/op
Benchmark_UnsafeStringToBytes
Benchmark_UnsafeStringToBytes-6         350045876                3.431 ns/op           0 B/op          0 allocs/op
Benchmark_SafeStringToBytes
Benchmark_SafeStringToBytes-6           70134423                14.63 ns/op           16 B/op          1 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 6.225s

go test -v -benchmem -bench="^BenchmarkEnc" -run="^$" -gcflags=-N .

goos: linux
goarch: arm64
pkg: github.com/spacemeshos/go-scale
BenchmarkEncodeStrings_WithStringWriter
BenchmarkEncodeStrings_WithStringWriter-6                4509775               312.8 ns/op            69 B/op          0 allocs/op
BenchmarkEncodeStrings_WithWriterForStrings
BenchmarkEncodeStrings_WithWriterForStrings-6            7346796               156.6 ns/op            36 B/op          0 allocs/op
PASS
ok      github.com/spacemeshos/go-scale 4.976s