Visit "Any" types in payload visitor

[cretz]

What changed?

• Added WellKnownAnyVisitor to VisitPayloadsOptions with default for visiting any
• Updated generator to make sure "Any" types are visited

Closes temporalio/sdk-go#1622

[cretz]

This file has some whitespace changes (this was using spaces which was looking bad even though the final generated source was always go fmt'd anyways)

[cretz]

Does everyone agree with this assumption?

[tdeebswihart]

Can we benchmark that assumption? I'd like to see numbers personally

[cretz]

We can get numbers. Can you define the parameters of the benchmarks for the numbers you are wanting to see? Do you want the only way we use "any" today (update requests that have barely anything in them) or benchmarking this with more possibilities in "any"? And do you have recommend sizes of payloads? Meaning do you want to benchmark an update with 4K byte inputs or just 5 bytes (or a bunch of other values)?

Also, it should be noted that this utility is mostly used for payload manipulation which almost always mutates the payloads no matter what making this check-never-mutated piece moot. So that has to be factored in as well. Knowing that, can you clarify if you have concerns about the always-marshal approach since it may be a almost-always-marshal approach anyways?

[tdeebswihart]

If that's the context around this assumption, then we should encode that in the code so it's obvious next time looks at an undocumented assumption :)

[cretz]

It was not meant to be the context around the assumption. I definitely made the assumption regardless of that context and don't really want to choose one or the other based too much on expected frequency/usage. I just added that context in case you had concerns with the expected frequency/usage. I can provide benchmark numbers, I just need some context around which numbers/scenarios you want to see.

[cretz]

Interesting results here. So here are some basic benchmarks:

func Benchmark_AnyCloneEqualCheck(b *testing.B) {
	anyMsg, _ := anypb.New(&update.Request{Input: &update.Input{Args: &common.Payloads{
		Payloads: []*common.Payload{{Data: []byte("orig-val")}},
	}}})
	for i := 0; i < b.N; i++ {
		child, _ := anyMsg.UnmarshalNew()
		childOrig := proto.Clone(child)
		// Do visitor stuff...
		proto.Equal(childOrig, child)
	}
}

func Benchmark_AnyMarshalReMarshal(b *testing.B) {
	anyMsg, _ := anypb.New(&update.Request{Input: &update.Input{Args: &common.Payloads{
		Payloads: []*common.Payload{{Data: []byte("orig-val")}},
	}}})
	for i := 0; i < b.N; i++ {
		child, err := anyMsg.UnmarshalNew()
		require.NoError(b, err)
		// Do visitor stuff...
		_ = anyMsg.MarshalFrom(child)
	}
}

Running this (on Windows at least) shows that the current unmarshal-remarshal way is at least 3x faster every time I try:

Benchmark_AnyCloneEqualCheck
Benchmark_AnyCloneEqualCheck-20           464596              2538 ns/op
Benchmark_AnyMarshalReMarshal
Benchmark_AnyMarshalReMarshal-20         1717684               810.9 ns/op

(similar results even if I move anymsg creation into the loop)

Gonna merge based on this info...

[tdeebswihart]

Excellent! Thank you for doing this; this is all I wanted to see: analysis to support our assumptions 😄

[cretz]

There could be a need in the future to expose this for users to delegate to, but we will wait until that need to expose it