Do not value copy structs when encountering struct pointers about expr HOT 7 CLOSED

Awesome! Can you create PR for this? If you also can provide a benchmark, it will be really interesting to see the performance increase.

from expr.

PR #54

Only a ~10000x performance improvement on my contrived example : )

from expr.

I actually realized this problem is a general pattern in the runtime code. There is a difference between a reflect.Value and putting that value into an interface, a reflect.Value is a way of accessing the pre-existing memory, where putting something into an interface is going to make a copy.

So another example in the code, if you have an embedded struct:

type Foo struct {
  Bar struct {
    Field int
  }
}

When you do 'Bar.Field', fetch will return a copy of Bar, not a pointer to the original Bar. So if we do something like my previous example and stick a big chunk of memory in the Bar structure, it's going to value copy all of Bar. Now that can be pretty easily fixed in the case of above (when Run() was called with an environment as a pointer), because then Bar's value will be addressable (CanAddr() is true) and you could create an interface of (type, *Bar) instead of (type, Bar) by returning value.Addr() instead of value. But I didn't look how it would work for other types, I guess slices are fine since the slice itself can be value copied (and what the slice points to isn't copy), but for fixed sized arrays, etc, I imagine the code now will value copy the entire array for an index operation like 'a[0]'. The additional problem is CanAddr() will be false if you passed a value to Run() instead of a pointer, but at least this is something callers can easily control.

Basically I feel like it should be a principle of expr (for a few important reasons) to be zero-copy of the environment (when a caller calls Run() with a value and not a pointer, they create a copy at their callsite of course, but that doesn't really have anything to do with expr). Right now it seems like expr is copying all over the place.

from expr.

I tried making a patch for this but it's actually a bit harder than it seems, because I thought perhaps I could just return a *struct and a slice instead of an array in fetch(), but then the problem comes to method/functions calls when the arguments are pointers and they expected values, etc, and it seems pretty ugly to try to map that back at call sites, etc. I think the real solution is probably working in reflect.Value's instead of interface{}.

from expr.

See #56

from expr.

I think the real solution is probably working in reflect.Value's instead of interface{}.

I also was thinking about it.

from expr.

#60

Easiest thing to do without a big change is just allow to opt in to the zero copy behaviour

from expr.