Time Bounded Function Calls?

[S3ckShUn21]

Right now we are using Wrench as a sandbox for user created scripts to run within the context of our application. We'd like the sandbox to be very safe for the users - so they can't accidentally brick the whole device if they write a bad script. (With an infinite loop for example)

I'm fairly certain this feature doesn't exist already, and I'm not very familiar with the inner workings of the wrench VM, so I'm mainly asking conceptually as a future feature. Would it be possible for the VM to do something like

wr_run_timeout(WRState* w, unsigned char* bytecode, int outlen, int timeout_ms)
// or
wr_callFunction_timeout(WRContext* context, WRFunction* func, int timeout_ms)

or have some way, in an external loop, to time bound the running of the function

int start_ms = now();

// Externally force the code to only run for a maximum of 1000ms
while( now() - start_ms < 1000 )
{
  // Running for a 'tick' could be some arbitrary time slice (1ms) or some number of instructions that run (10 bytecode instructions)
  WRTimeoutStatus status = wr_run_tick(...);
  if( status == WRTimeoutStatus::Complete )
  {
    break;
  }
}

The 'tick' number could be some compile time directive like stack size, or possibly set in the constructor of the context

Thanks so much!

[jingoro2112]

Sure! this can be accomplished several ways, but they all come down to the same thing. Every instruction might be the one the VM has to exit on so every instruction adds an "if()" check. Not a big deal unless you are trying to squeeze every last ounce of speed out. So I will add a countdown flag to the VM which will be compiled in if the operator wants that functionality, it will look like this: int g_instructionCounter = -1; wr_run( .... , int instructions=-1 ) { g_instructionCounter = instructions; while( g_instructionCounter ) { if ( g_instructionCounter > 0 ) { --g_instructionCounter; } // do a VM instruction } // FORCE a yield! } So an external thread can set g_instructionCounter to '0' and cause the VM thread to immediately yield (on it's next instruction) or if the countdown reaches zero on it's own then the time slice is over. That get the job done for you?

…

-Curt

On Mon, Jun 17, 2024 at 5:29 PM Cole Roof ***@***.***> wrote: Right now we are using Wrench as a sandbox for user created scripts to run within the context of our application. We'd like the sandbox to be very safe for the users - so they can't accidentally brick the whole device if they write a bad script. *(With an infinite loop for example)* I'm fairly certain this feature doesn't exist already, and I'm not very familiar with the inner workings of the wrench VM, so I'm mainly asking conceptually as a future feature. Would it be possible for the VM to do something like wr_run_timeout(WRState* w, unsigned char* bytecode, int outlen, int timeout_ms) // or wr_callFunction_timeout(WRContext* context, WRFunction* func, int timeout_ms) or have some way, in an external loop, to time bound the running of the function int start_ms = now(); // Externally force the code to only run for a maximum of 1000ms while( now() - start_ms < 1000 ) { // Running for a 'tick' could be some arbitrary time slice (1ms) or some number of instructions that run (10 bytecode instructions) wr_run_tick(...); } *The 'tick' number could be some compile time directive like stack size, or possibly set in the constructor of the context* Thanks so much! — Reply to this email directly, view it on GitHub <#36>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AALIKA3O5ID7PRIFJ336TLTZH5IMHAVCNFSM6AAAAABJOYUFHKVHI2DSMVQWIX3LMV43ERDJONRXK43TNFXW4OZWHAZTENRUHE> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[madshobye]

Would you consider the tick model instead… or as well? Tick would allow for the wrench code to run in a loop function in the Arduino environment without blocking other recurring background checks that are not interrupt based. The user would then be able to write an endless loop in wrench while the main system is unaffected. Eg

void loop() {wr_tick()}

I guess this is relevant for general execution more than function calls but could be the same concept for both.

It would fit very well with a common non-blocking pattern for Arduino libraries, watchdog timers in Esp32 etc.

[jingoro2112]

Okay I added some more functionality for you, including a basic round-robin scheduler and ticker(), I think this will do what you need?

[jingoro2112]

https://home.workshopfriends.com/wrench/www/#features

…

On Tue, Jun 18, 2024 at 1:06 AM madshobye ***@***.***> wrote: Would you consider the tick model instead… or as well? Tick would allow for the wrench code to run in a loop function in the Arduino environment without blocking other recurring background checks that are not interrupt based. The user would then be able to write an endless loop in wrench while the main system is unaffected. Eg void loop() {wr_tick()} I guess this is relevant for general execution more than function calls but could be the same concept for both. It would fit very well with a common non-blocking pattern for Arduino libraries, watchdog timers in Esp32 etc. — Reply to this email directly, view it on GitHub <#36 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AALIKAZY45QSSB2HNAJK6ZLZH656JAVCNFSM6AAAAABJOYUFHKVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMBRGU4DG> . You are receiving this because you commented.Message ID: ***@***.***>

[S3ckShUn21]

Firstly, I'd like to say how incredible it is that you've implemented this feature so quickly - I'm so appreciative of that.

I'd just like to make sure I'm understanding the feature properly, would this snippet work how I intend

(Running my scripts in series, capping each at a runtime of 5 seconds)

[S3ckShUn21]

Sorry, I think I misunderstood the yielding feature, here is a new version of my example code

//
// // Example Wrench Script
// //   All scripts will 'override' a `run` function
//
// function run( values_hashtable )
// {
//   for(;;)
//   {
//     values_hashtable["random_number"] += 1
//   }
// }
//

void run_wrench_script()
{
    // Load all the bytecode in to memory some how
    std::vector<uint8_t *> scripts;

    wr_setInstructionsPerSlice(10); // Force the VM to yeild every 10 jumps

    // Safely run all the scripts in series, with a timeout if they ran too long
    for( uint8_t *bytecode : scripts)
    {
        WRState* state = wr_newState();
	WRContext* context = wr_run(state, bytecode);

        // Start the running of my function
        WRValue* retval = wr_callFunction(context, "run");

        time_t now = now(); // assume timestamp in ms
        while( now() - now < 5000 ) // only allow to run for 5 seconds
        {
            if( retval == NULL && wr_getYeildInfo(context) )
            {
                println("The function was force yeilded");
                retval = wr_continue(context);
            }
            else
            {
                println("The function ended by itself");
                break; // We can break from the loop because the function is done
            }
        }

	wr_destroyState( w );
    }
}

[jingoro2112]

Your code had some bugs in it that I fixed up, here is a corrected example with notes. I need to modify the documentation to make clear that calling any of the overloaded wr_callFunction(...) is the equivilant of wr_continue() but I think this does kinda what you are intending:

const char exampleYield[]=
" // Example Wrench Script\n"
" //   All scripts will 'override' a `run` function	\n"
"													\n"
"function run( values_hashtable )					\n"
"{													\n"
"   for(;;)											\n"
"   {												\n"
"      values_hashtable[\"random_number\"] += 1;	\n"
"   }												\n"
" }													\n";

#include <time.h>
//------------------------------------------------------------------------------
void testYield2()
{
	WRState* state = wr_newState(); // create a state (only need to do this once)

	// make sure we only execute 10 instructions at any time
	wr_setInstructionsPerSlice( state, 10 );

	// compile a script
	unsigned char* out;
	int outLen;
	int err = wr_compile( exampleYield, strlen(exampleYield), &out, &outLen );
	if ( err )
	{
		// oops! something wrong with the code:
		printf( "err compiling [%s]\n", c_errStrings[err] );
		wr_destroyState( state );
		return;
	}

	// now that the script is compiled into bytecode (stored in
	// out/outLen) we need to "run" it, this loads it into a context.
	// for the case of your example, it won't do anything but load the
	// function signature and return, since nothing actually happens in
	// the code in global scope.
	
	WRContext* context = wr_run( state, out, outLen );
	if ( !context )
	{
		// must have been an error processing the script?
		printf( "err compiling [%s]\n", c_errStrings[(int)wr_getLastError(state)] );
		wr_destroyState( state );
		return;
	}

	time_t future = time(0) + 5;

	while( time(0) < future ) // run for 5 seconds
	{
		// the VM will automatically continue on yield, this can be
		// called multiple times.. need to make this clear in the docs..
		WRValue* retval = wr_callFunction( context, "run" ); 
		
		if ( retval )
		{
			// the function returned, so it completed, do something
			// with it...

			// and we're out
			break;
		}
		
		if ( !wr_getYieldInfo(context) )
		{
			// something went wrong! this is not yielded
			printf( "non-yield [%s]\n", c_errStrings[(int)wr_getLastError(state)] );
			break;
		}
		else
		{
			printf( "function forced to yield\n" );
		}
	}

	wr_destroyState( state );
}

which should work for PC and linux.

[jingoro2112]

oh and make sure you get latest 6.0.2 I changed some function signatures

[S3ckShUn21]

This looks exactly like what we needed! Thanks so much, this new feature is great!