Panic inside vm.Run about expr HOT 9 CLOSED

The first panic is on the line:

		op := program.Bytecode[vm.ip]

https://github.com/antonmedv/expr/blob/cb1f3459dd4705b6cbaf43069925d5e2c782fd6b/vm/vm.go#L90C1-L90C32

This means that the instruction pointer points to a wrong address.

But this is strange, as a few lines above we have check:

for vm.ip < len(program.Bytecode) {
		if vm.debug {
			<-vm.step
		}

		op := program.Bytecode[vm.ip]

Very interesting.

Is it possible to add a wrapper with recover and log the executed expression?

from expr.

Also, could you make sure that you don't reuse VM in different threads?

from expr.

I added wrapper and caught the panic once again (same stacktrace).
Executed expression:

Data.Code == 'XXX' && Parameters.Date.Unix() < ToUnix('2024-01-01')

So, the environment is something like this:

type env struct {
	Data       *DataStruct
	Parameters *ParametersStruct
}

type DataStruct struct {
	Code string
}

type ParametersStruct struct {
	Date time.Time
}

func (e *env) ToUnix(rawDate string) int64 {
	t, err := time.Parse("2006-01-02", rawDate)
	if err != nil {
		panic("invalid rawDate")
	}

	return t.Unix()
}

And ToUnix function is marked as expr.ConstExpr (also there are expr.Optimize(true) and expr.AsBool() options).

I will keep my eye on it to prove that panics happen only for this expression.

I checked the code and seems highly unlikely that VM is being used in different threads.

from expr.

The code looks ok. Lets true to take a look at what program (already compiled) is executed during panic.

Please, log the program as JSON, and as program.Disassemble().

from expr.

Should getting the program as JSON be done as something like this json.Marshal(vm.Program.Source)?

from expr.

The whole program. Or some sort of other dump technics you can find out.

from expr.

@Bychin any news on the problem?

from expr.

@antonmedv so I wasn't able to reproduce the problems after a little change.

So previously I was using the VM like this:

type Evaluator struct {
	v *vm.VM
}

func (e *Evaluator) Evaluate() error {
	// reuse the same vm instance for performance gain
	v := e.v
	if v == nil {
		v = &vm.VM{}
	}

	... := v.Run(...)

	return nil
}

// WithReusableVM reuses the same vm instance for performance gain.
// It will make the engine not thread safe.
func (e *Evaluator) WithReusableVM() {
	e.v = &vm.VM{}
}

evaluator := &Evaluator{}
if reuseVM {
	evaluator.WithReusableVM() // <- this thing caused the problem
}
evaluator.Evaluate()

evaluator is used in a single thread, but as soon as I stopped reusing VM the problem was gone. I checked the code of v.Run method and I can see that the inner state of VM is cleared before the actual execution, so I don't know where to investigate next.

from expr.

I will close this issue as it not a problem any more. Feel free to create another issue if someone encounters a panic in vm.

from expr.