Optional Fetcher

[gitperson1980]

In some circumstances with certain structs and as needed, would it be possible to create provisions to use fetcher?

[antonmedv]

Can you please explain a little bit more?

As vm.Fetcher was removed in latest Expr versions. It’s still possible to do the same logic using the ast.Patch functionality.

I will write a doc on how to do it.

[gitperson1980]

type Bar struct{
   D int
}

type Foo struct {
	A int
	B bool
	Mp map[string]*Bar   // has elements  MP1 MP2 MP3 MP4 MP5 MP6   MP1-3 is call heavily and would like to cache it as pointers as below
	mp1 *Bar   //lower case to avoid export in serialization but cannot be accessed by expr
	mp2 *Bar   //lower case to avoid export in serialization
	mp3 *Bar   //lower case to avoid export in serialization
}

FooExample = Foo{A: 1, B: true, Mp: make(map[string]*Bar)}
FooExample.Mp["MP1"]= Bar{}
FooExample.Mp["MP2"]= Bar{}
FooExample.Mp["MP3"]= Bar{}
FooExample.Mp["MP4"]= Bar{}
FooExample.Mp["MP5"]= Bar{}
FooExample.mp1=FooExample.Mp["MP1"]    //cache the most used
FooExample.mp2=FooExample.Mp["MP2"]    //cache the most used
FooExample.mp3=FooExample.Mp["MP3"]    //cache the most used

FooExample.mp1.D   // direct and avoids the overhead of a map lookup

[antonmedv]

call heavily and would like to cache it as pointers as below

Expose MP1 and no map lookup will be done.

[gitperson1980]

I cannot expose it as I don't want MP1-3 added in a gob serialization routine in another process and increase the size of the serialized output with duplicate information. This is why it is lowercase. However it can be accessed by a fetcher.

What might be nice is to be able to fetch if fetcher exists/defined else fall though to standard fetch.

func (v *Foo) Fetch(i interface{}) interface{} {
	var string_i string
	if s, ok := i.(string); ok {
		string_i = s
	} else {
		string_i = fmt.Sprint(i)
	}
	switch string_i {
	case "mp1":
		return v.mp1
	case "mp2":
		return v.mp2
	case "mp3":
		return v.mp3
	}
	return nil
}

[antonmedv]

I see. What about losing a separate structure for Env?

[gitperson1980]

I don't understand the above suggestion. But if you mean use a mostly duplicate structure in Env .. then that would mean duplicated effort and size for the object that is very large in size and complexity. It would require a great deal of coordination to keep them in sync and introduce error and performance overhead.

Adding an optional fetcher within the new optimized paradigm would help immensely to do some optimization tricks for the end user. And I don't mean just this example. Case/Switch is cheap especially if you have nested structs with their own fetchers.

What would be nice is a combo fetch from fetcher when it is defined and a fall through to standard processing when it is not defined or when the fetcher returns nil. It would afford great latitude for the end user to optimize according to his needs.

[antonmedv]

Something like this:

env := Env {
    Map: &BigMap,
    MP1: BigMap["MP1"],
}

And use ast.Patcher to convert this

MP1 + MP100

to this

MP1 + Fetch("MP100")

[gitperson1980]

There would be a lot of re-definitions into Env and I would have to do that every time I introduce a different Foo into the Env - which is often. That would cause a lot of map access every time I setup Env with a different Foo and negate the caching benefit which is done only once when it is done in Foo itself.

[antonmedv]

I did not get it. My suggested approach should be even faster than old Fetcher.

If you don't what this optimization and what old Fetcher style behavior, use ast.Patch to replace all vars to some fetcher func:

Fetch("MP1") + Fetch("MP100")

[gitperson1980]

Not that your suggestions are bad... an optional fetcher provides quick and dirty mods to the end user where he chooses to deploy it prudently in concert with your recent optimizations. ast.Patch is brilliant and I do use it but is cumbersome to use en-masse with large amount of variables. It's a better option to use to enhance language constructs as a whole vs alter/intercept how large amount of variables are accessed.

[antonmedv]

So what do you suggest?

[gitperson1980]

I would benefit from a hybrid fetcher functionality as:

func Fetch(from, i interface{}) interface{} {
  if fetcher, ok := from.(Fetcher); ok {
        value := fetcher.Fetch(i)
        if value != nil {
           return value
        }
  }
// from here
// fall through to standard processing
}

Same for:

func FetchField(from interface{}, field *Field) interface{} {

for i, x := range field.Path{
         // traverse path using fetcher(s) where fetchers are defined
         // else use standard offset index processing
        }
  }
}

[gitperson1980]

in v1.9.0 I had hacked the runtime to eliminate the " if fetcher, ok := from.(Fetcher); ok {", as below, check and called fetcher by default as all items had it defined - some had the default of nil where it was not needed. Is there a way to define an interface{} Fetcher() that returns nil when not implemented? This way no check is needed but you still get a nil rejection.

or use a runtime function parameter (useFetcher bool)

if useFetcher {                                        // non Fetcher users do not pay penalty just a minor compare penalty.
if fetcher, ok := from.(Fetcher); ok {
      value:=from.(Fetcher).Fetch(i)
}else {
...

v1.9.0 old hack:

rntime.go 

func fetch(from, i interface{}, nilsafe bool) interface{} {
   //if fetcher, ok := from.(Fetcher); ok {
      //value := fetcher.Fetch(i)

      value:=from.(Fetcher).Fetch(i)
      if value != nil {
         return value
      }
      if !nilsafe {
         panic(fmt.Sprintf("cannot fetch %v from %T", i, from))
      }
      return nil

[antonmedv]

One idea I have is to do this check on compile step. And add additional opcode: OpLoadFetch & OpFetchFetcher.

This was we can eliminate the check completely. Can you implement such op codes?

[gitperson1980]

One idea I have is to do this check on compile step. And add additional opcode: OpLoadFetch & OpFetchFetcher.

This was we can eliminate the check completely. Can you implement such op codes?

Compile time check is brilliant.

I can certainly try to hack something together for your final approval. Can you distinguish the 2 with some explanation?
OpLoadFetch & OpFetchFetcher.

[antonmedv]

They are really similar. OpLoad* are for loading from env vars. OpFetch* are for loading form top of the stack vm.pop().

[gitperson1980]

I will give it a go.

[gitperson1980]

runtime.go

type Fetcher interface {
	Fetch(interface{}) interface{}
}

func FetchFetcher(from, i interface{}) interface{} {
	value:=from.(Fetcher).Fetch(i)             //bareback,  as its been vetted to have a fetcher at compile time.
	if value != nil {
		return value
	}
	panic(fmt.Sprintf("cannot fetch %v from %T", i, from))
	//return nil
}

vm.go:

		case OpFetchFetcher:
			b := vm.pop()
			a := vm.pop()
			vm.push(runtime.FetchFetcher(a, b))	

[antonmedv]

It’s not implemented currently. One way to do, it is the aperture which should be superior to the future interface.

[mdmcconnell]

I'm afraid I did not understand - what is the aperture? I do not remember seeing this concept in expr docs or code.

[antonmedv]

Yeah, looks like my iPhone stations get us run

[mdmcconnell]

Looks like possibly an auto-complete issue here. I will maintain approach of trying to patch the tree with a CallNode on nodes that implement the certain interface. But what are the required members for the CallNode and its Callee MemberNode? With only ast.CallNode{ Callee: &ast.MemberNode{Node: *node, Name: "Method"}, I am getting "panic: undefined node type ()". Same as https://go.dev/play/p/wkZtzPYBKF-

[mdmcconnell]

Eventually answered my own question in #368