Do not serialize structures for static signer

[roman-khimov]

It can be optimized out, see https://github.com/nspcc-dev/neofs-sdk-go/pull/398#discussion_r1172312597

[smallhive]

It is obvious, that StaticSigner faster and cheaper then regular signer. Despite it we shouldn't have two different methods like Calculate and CalculateLazy. It may lead to misunderstanding to customer, which func should be use to calculate signature.

Instead it I suggest to change Calculate func interface from

func (x *Signature) Calculate(signer Signer, data []byte) error

to

func (x *Signature) Calculate(signer Signer, dataSrc func() []byte) error {

Of course, it leads to some changes in code, but removes misunderstanding. This changed variant has the same performance:

$ go test -bench=. -benchmem
goos: linux
goarch: amd64
pkg: github.com/nspcc-dev/neofs-sdk-go/container
cpu: Intel(R) Core(TM) i7-10875H CPU @ 2.30GHz
BenchmarkCalculate-16                      27002             43873 ns/op            5396 B/op         76 allocs/op
BenchmarkCalculateLazy-16                  27144             44347 ns/op            5396 B/op         76 allocs/op
BenchmarkCalculateLazyStatic-16          1535890               887.0 ns/op           272 B/op          4 allocs/op
BenchmarkCalculateLazySingle-16            27273             46403 ns/op            5396 B/op         76 allocs/op
PASS
ok      github.com/nspcc-dev/neofs-sdk-go/container     6.896s

Description:

• BenchmarkCalculate - current signer function
• BenchmarkCalculateLazy - checks if signer is Static and do all staff or call regualar Calculate
• BenchmarkCalculateLazyStatic - working only with StaticSigner, just for information
• BenchmarkCalculateLazySingle - Our target function

Conslusion:

• Use single function Calculate
• Change its interface
• Update the code
• Enjoy dramatical speed increasing with StaticSigner situations

[roman-khimov]

Passing a function means creating some lambda function in 99% of use cases which is just not fun. How about

type MarshalledStably interface {
    StableMarshal([]byte) []byte
}
func (x *Signature) Calculate(signer Signer, data []byte) error {}
func (x *Signature) CalculateMarshalled(signer Signer, smth MarshalledStably) error {}

IIRC we calculate signatures for something with StableMarshal() in 99% of the cases.

[smallhive]

Do you mean left current Calculate as is, append new CalculateMarshalled where we will implement Lazy functionality? I don't mind, even more - I like this approach.

[roman-khimov]

Yeah, generic Calculate can be useful anyway, but marshalled one can be lazy or not depending on the implementation. Static signer will obviously optimize it.

[notimetoname]

Passing a function means creating some lambda function in 99% of use cases which is just not fun.

@roman-khimov, do you mean readability or other reasons?

[roman-khimov]

Mostly that. Performance-wise there will also be a difference, but a tiny one.