int r = EMBRYO_PROGRAM_OK;
int err;
int args = 0;
+ int instruct = 0;
char *file = NULL;
char *func = NULL;
}
}
r = EMBRYO_PROGRAM_OK;
+ fn = EMBRYO_FUNCTION_MAIN;
if (func)
{
fn = embryo_program_function_find(ep, func);
- if (fn != EMBRYO_FUNCTION_NONE)
- {
- while ((r = embryo_program_run(ep, fn)) == EMBRYO_PROGRAM_SLEEP);
- }
- else
+ if (fn == EMBRYO_FUNCTION_NONE)
{
printf("Unable to find public function %s()\n"
"Executing main() instead\n", func);
- while ((r = embryo_program_run(ep, EMBRYO_FUNCTION_MAIN)) == EMBRYO_PROGRAM_SLEEP);
+ fn = EMBRYO_FUNCTION_MAIN;
}
}
- else
+ embryo_program_max_cycle_run_set(ep, 100000000);
+ for (;;)
{
- while ((r = embryo_program_run(ep, EMBRYO_FUNCTION_MAIN)) == EMBRYO_PROGRAM_SLEEP);
+ r = embryo_program_run(ep, fn);
+ if (r == EMBRYO_PROGRAM_SLEEP)
+ {
+ fn = EMBRYO_FUNCTION_CONT;
+ printf("SLEEP INSTRUCTION!\n");
+ continue;
+ }
+ else if (r == EMBRYO_PROGRAM_TOOLONG)
+ {
+ fn = EMBRYO_FUNCTION_CONT;
+ instruct++;
+ printf("Executed %i00 million instructions!\n", instruct);
+ continue;
+ }
+ else
+ break;
}
embryo_program_vm_pop(ep);
if (r == EMBRYO_PROGRAM_FAIL)
/** An invalid cell reference */
#define EMBRYO_CELL_NONE 0x7fffffff
/* program run return values */
-#define EMBRYO_PROGRAM_OK 1
-#define EMBRYO_PROGRAM_SLEEP 2
-#define EMBRYO_PROGRAM_BUSY 3
-#define EMBRYO_PROGRAM_FAIL 0
+#define EMBRYO_PROGRAM_OK 1
+#define EMBRYO_PROGRAM_SLEEP 2
+#define EMBRYO_PROGRAM_BUSY 3
+#define EMBRYO_PROGRAM_TOOLONG 4
+#define EMBRYO_PROGRAM_FAIL 0
typedef unsigned int Embryo_UCell;
typedef int Embryo_Cell;
int embryo_program_recursion_get(Embryo_Program *ep);
int embryo_program_run(Embryo_Program *ep, Embryo_Function func);
Embryo_Cell embryo_program_return_value_get(Embryo_Program *ep);
+ void embryo_program_max_cycle_run_set(Embryo_Program *ep, int max);
+ int embryo_program_max_cycle_run_get(Embryo_Program *ep);
int embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell);
int embryo_parameter_string_push(Embryo_Program *ep, char *str);
int embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num);
* @return @c EMBRYO_PROGRAM_OK on success. @c EMBRYO_PROGRAM_SLEEP if the
* program is halted by the Small @c sleep call.
* @c EMBRYO_PROGRAM_FAIL if there is an error.
+ * @c EMBRYO_PROGRAM_TOOLONG if the program executes for longer than
+ * it is allowed to in abstract machine instruction count.
* @ingroup Embryo_Run_Group
*/
int
unsigned char op;
Embryo_Cell offs;
int num;
+ int max_run_cycles;
+ int cycle_count;
#ifdef EMBRYO_EXEC_JUMPTABLE
/* we limit the jumptable to 256 elements. why? above we forced "op" to be
* a unsigned char - that means 256 max values. we limit opcode overflow
/* track recursion depth */
ep->run_count++;
-
+
+ max_run_cycles = ep->max_run_cycles;
/* start running */
- for (;;)
+ for (cycle_count = 0;;)
{
+ if (max_run_cycles > 0)
+ {
+ if (cycle_count >= max_run_cycles)
+ {
+ TOOLONG(ep);
+ }
+ cycle_count++;
+ }
op = (Embryo_Opcode)*cip++;
SWITCH(op);
CASE(EMBRYO_OP_LOAD_PRI);
#endif
SWITCHEND;
}
+ ep->max_run_cycles = max_run_cycles;
ep->run_count--;
-
ep->hea = hea_start;
-
return EMBRYO_PROGRAM_OK;
}
}
/**
+ * Sets the maximum number of abstract machine cycles any given program run
+ * can execute before being put to sleep and returning.
+ *
+ * @param ep The given program.
+ * @param max The number of machine cycles as a limit.
+ *
+ * This sets the maximum number of abstract machine (virtual machine)
+ * instructions that a single run of an embryo function (even if its main)
+ * can use before embryo embryo_program_run() reutrns with the value
+ * EMBRYO_PROGRAM_TOOLONG. If the function fully executes within this number
+ * of cycles, embryo_program_run() will return as normal with either
+ * EMBRYO_PROGRAM_OK, EMBRYO_PROGRAM_FAIL or EMBRYO_PROGRAM_SLEEP. If the
+ * run exceeds this instruction count, then EMBRYO_PROGRAM_TOOLONG will be
+ * returned indicating the program exceeded its run count. If the app wishes
+ * to continue running this anyway - it is free to process its own events or
+ * whatever it wants and continue the function by calling
+ * embryo_program_run(program, EMBRYO_FUNCTION_CONT); which will start the
+ * run again until the instruction count is reached. This can keep being done
+ * to allow the calling program to still be able to control things outside the
+ * embryo function being called. If the maximum run cycle count is 0 then the
+ * program is allowed to run forever only returning when it is done.
+ *
+ * It is important to note that abstract machine cycles are NOT the same as
+ * the host machine cpu cycles. They are not fixed in runtime per cycle, so
+ * this is more of a helper tool than a way to HARD-FORCE a script to only
+ * run for a specific period of time. If the cycle count is set to something
+ * low like 5000 or 1000, then every 1000 (or 5000) cycles control will be
+ * returned to the calling process where it can check a timer to see if a
+ * physical runtime limit has been elapsed and then abort runing further
+ * assuming a "runaway script" or keep continuing the script run. This
+ * limits resolution to only that many cycles which do not take a determined
+ * amount of time to execute, as this varies from cpu to cpu and also depends
+ * on how loaded the system is. Making the max cycle run too low will
+ * impact performance requiring the abstract machine to do setup and teardown
+ * cycles too often comapred to cycles actually executed.
+ *
+ * Also note it does NOT include nested abstract machines. IF this abstract
+ * machine run calls embryo script that calls a native function that in turn
+ * calls more embryo script, then the 2nd (and so on) levels are not included
+ * in this run count. They can set their own max instruction count values
+ * separately.
+ *
+ * The default max cycle run value is 0 in any program until set with this
+ * function.
+ *
+ * @ingroup Embryo_Run_Group
+ */
+void
+embryo_program_max_cycle_run_set(Embryo_Program *ep, int max)
+{
+ if (!ep) return;
+ if (max < 0) max = 0;
+ ep->max_run_cycles = max;
+}
+
+/**
+ * Retreives the maximum number of abstract machine cycles a program is allowed
+ * to run.
+ * @param ep The given program.
+ * @return The number of cycles a run cycle is allowed to run for this
+ * program.
+ *
+ * This returns the value set by embryo_program_max_cycle_run_set(). See
+ * embryo_program_max_cycle_run_set() for more information.
+ *
+ * @ingroup Embryo_Run_Group
+ */
+int
+embryo_program_max_cycle_run_get(Embryo_Program *ep)
+{
+ if (!ep) return 0;
+ return ep->max_run_cycles;
+}
+
+/**
* @defgroup Embryo_Parameter_Group Function Parameter Functions
*
* Functions that set parameters for the next function that is called.
#define EMBRYO_MAGIC 0xf1e0 /* magic byte pattern */
#define EMBRYO_FLAG_COMPACT 0x04 /* compact encoding */
#define EMBRYO_FLAG_RELOC 0x8000 /* jump/call addresses relocated */
-#define GETPARAM(v) (v = *(Embryo_Cell *)cip++)
-#define PUSH(v) (stk -= sizeof(Embryo_Cell), *(Embryo_Cell *)(data + (int)stk) = v)
-#define POP(v) (v = *(Embryo_Cell *)(data + (int)stk), stk += sizeof(Embryo_Cell))
-#define ABORT(ep,v) {(ep)->stk = reset_stk; (ep)->hea = reset_hea; ep->run_count--; ep->error = v; return 0;}
-#define OK(ep,v) {(ep)->stk = reset_stk; (ep)->hea = reset_hea; ep->run_count--; ep->error = v; return 1;}
-#define STKMARGIN ((Embryo_Cell)(16 * sizeof(Embryo_Cell)))
-#define CHKMARGIN() if ((hea + STKMARGIN) > stk) {ep->error = EMBRYO_ERROR_STACKERR; return 0;}
-#define CHKSTACK() if (stk > ep->stp) {ep->run_count--; ep->error = EMBRYO_ERROR_STACKLOW; return 0;}
-#define CHKHEAP() if (hea < ep->hlw) {ep->run_count--; ep->error = EMBRYO_ERROR_HEAPLOW; return 0;}
-#define CHKMEM(x) if ((((x) >= hea) && ((x) < stk)) || ((Embryo_UCell)(x) >= (Embryo_UCell)ep->stp)) ABORT(ep, EMBRYO_ERROR_MEMACCESS);
+#define GETPARAM(v) (v = *(Embryo_Cell *)cip++)
+#define PUSH(v) (stk -= sizeof(Embryo_Cell), *(Embryo_Cell *)(data + (int)stk) = v)
+#define POP(v) (v = *(Embryo_Cell *)(data + (int)stk), stk += sizeof(Embryo_Cell))
+#define ABORT(ep,v) {(ep)->stk = reset_stk; (ep)->hea = reset_hea; (ep)->run_count--; ep->error = v; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_FAIL;}
+#define OK(ep,v) {(ep)->stk = reset_stk; (ep)->hea = reset_hea; (ep)->run_count--; ep->error = v; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_OK;}
+#define TOOLONG(ep) {(ep)->pri = pri; (ep)->cip = (Embryo_Cell)((unsigned char *)cip - code); (ep)->alt = alt; (ep)->frm = frm; (ep)->stk = stk; (ep)->hea = hea; (ep)->reset_stk = reset_stk; (ep)->reset_hea = reset_hea; (ep)->run_count--; (ep)->max_run_cycles = max_run_cycles; return EMBRYO_PROGRAM_TOOLONG;}
+#define STKMARGIN ((Embryo_Cell)(16 * sizeof(Embryo_Cell)))
+#define CHKMARGIN() if ((hea + STKMARGIN) > stk) {ep->error = EMBRYO_ERROR_STACKERR; return 0;}
+#define CHKSTACK() if (stk > ep->stp) {ep->run_count--; ep->error = EMBRYO_ERROR_STACKLOW; return 0;}
+#define CHKHEAP() if (hea < ep->hlw) {ep->run_count--; ep->error = EMBRYO_ERROR_HEAPLOW; return 0;}
+#define CHKMEM(x) if ((((x) >= hea) && ((x) < stk)) || ((Embryo_UCell)(x) >= (Embryo_UCell)ep->stp)) ABORT(ep, EMBRYO_ERROR_MEMACCESS);
typedef struct _Embryo_Param Embryo_Param;
typedef struct _Embryo_Header Embryo_Header;
int run_count;
+ int max_run_cycles;
+
void *data;
};
projects / platform / upstream / efl.git / commitdiff