Mercurial > octave
changeset 32358:8f4bc20584ed
Rename VM-related functions to start with __vm
* Rename all VM-related functions that don't already start with __vm
to start with __vm. This helps with TAB autocompletion after typing
the common prefix.
| author | Arun Giridhar <arungiridhar@gmail.com> |
|---|---|
| date | Thu, 28 Sep 2023 19:32:56 -0400 |
| parents | 523613891d2f |
| children | 9865d2a1b49b |
| files | doc/interpreter/vectorize.txi etc/NEWS.9.md libinterp/corefcn/compile.cc libinterp/parse-tree/pt-bytecode-vm.cc libinterp/parse-tree/pt-bytecode.h scripts/help/vm.m test/compile-bench/bench-octave/bench.m test/compile-bench/bench-octave/bench_valgrind.m test/compile/bytecode.tst test/compile/shutup_operator_test/bytecode_disp.tst |
| diffstat | 10 files changed, 199 insertions(+), 201 deletions(-) [+] |
line wrap: on
line diff
--- a/doc/interpreter/vectorize.txi Wed Sep 27 18:17:36 2023 +0200 +++ b/doc/interpreter/vectorize.txi Thu Sep 28 19:32:56 2023 -0400 @@ -636,22 +636,22 @@ code. Octave versions 9 onwards have the VM built-in by default. At its simplest, the only thing a user needs is to run the single command -@code{__enable_vm_eval__ (1)} on starting Octave, and the rest of the user's +@code{__vm_enable__ (1)} on starting Octave, and the rest of the user's session is as before, except that some code will likely run faster. If you find yourself doing this frequently, you can also add the following code to your Octave startup file (`.octaverc` or similar): @example @group -if (exist ("__enable_vm_eval__") == 5) # built-in function exists - __enable_vm_eval__ (1); +if (exist ("__vm_enable__") == 5) # built-in function exists + __vm_enable__ (1); end @end group @end example -The full calling form for @code{__enable_vm_eval__} is: +The full calling form for @code{__vm_enable__} is: -@DOCSTRING(__enable_vm_eval__) +@DOCSTRING(__vm_enable__) A more comprehensive list of VM-related functions is given by the @code{vm} command. @@ -663,7 +663,7 @@ VM compilation for specific functions as the user needs. In general, these might be done for frequently called functions ("hotspots"). -@DOCSTRING(__compile__) +@DOCSTRING(__vm_compile__) @DOCSTRING(__vm_clear_cache__)
--- a/etc/NEWS.9.md Wed Sep 27 18:17:36 2023 +0200 +++ b/etc/NEWS.9.md Thu Sep 28 19:32:56 2023 -0400 @@ -4,14 +4,12 @@ ### General improvements - Octave now has an experimental virtual machine (VM) for just-in-time (JIT) -evaluation of m-code. This VM can be enabled by the end user with the -command `__enable_vm_eval__ (1)` as long as the configuration option -`--disable-vm-evaluator` was *not* used when building Octave. Speedups from 2X -to 40X have been observed for different kinds of m-code. This feature is -considered experimental for now. M-code that cannot be handled by the VM yet -falls back automatically to the existing interpreter. User tests of the VM -evaluator are encouraged. To learn more about VM commands, type `vm` -or `help vm` at the Octave prompt. +evaluation of m-code. Speedups from 2X to 40X have been observed for different +kinds of m-code. This feature is considered experimental for now. M-code +that cannot be handled by the VM yet falls back automatically to the existing +interpreter. User tests of the VM evaluator are encouraged. To learn more +about VM commands, type `vm` or `help vm` at the Octave prompt, or refer the +Octave manual section 19.6 on the VM. - `oruntests`: The current directory now changes to the directory containing the files with the tests for the duration of the test. This
--- a/libinterp/corefcn/compile.cc Wed Sep 27 18:17:36 2023 +0200 +++ b/libinterp/corefcn/compile.cc Thu Sep 28 19:32:56 2023 -0400 @@ -38,6 +38,11 @@ OCTAVE_BEGIN_NAMESPACE(octave) +// If TRUE, use VM evaluator rather than tree walker. +// FIXME: Use OCTAVE_ENABLE_VM_EVALUATOR define to set it to true when +// the VM has been tested properly. +bool V__vm_enable__ = false; + // Cleverly hidden in pt-bytecode-vm.cc to prevent inlining here extern "C" void dummy_mark_1 (void); extern "C" void dummy_mark_2 (void); @@ -299,7 +304,7 @@ error ("Function not a user function or script: %s", fn_name.c_str ()); } - if (!ufn->is_compiled () && V__enable_vm_eval__ && !ov.is_anonymous_function ()) + if (!ufn->is_compiled () && V__vm_enable__ && !ov.is_anonymous_function ()) compile_user_function (*ufn, 0); else if (!ufn->is_compiled ()) error ("Function not compiled: %s", fn_name.c_str ()); @@ -314,11 +319,11 @@ return octave_value {true}; } -DEFMETHOD (__compile__, interp, args, , +DEFMETHOD (__vm_compile__, interp, args, , doc: /* -*- texinfo -*- -@deftypefn {} {@var{success} =} __compile__ (@var{fn_name}) -@deftypefnx {} {@var{success} =} __compile__ (@var{fn_name}, "clear") -@deftypefnx {} {@var{success} =} __compile__ (@var{fn_name}, "print") +@deftypefn {} {@var{success} =} __vm_compile__ (@var{fn_name}) +@deftypefnx {} {@var{success} =} __vm_compile__ (@var{fn_name}, "clear") +@deftypefnx {} {@var{success} =} __vm_compile__ (@var{fn_name}, "print") Compile the specified function to bytecode. @@ -417,23 +422,18 @@ return octave_value {true}; } -// If TRUE, use VM evaluator rather than tree walker. -// FIXME: Use OCTAVE_ENABLE_VM_EVALUATOR define to set it to true when -// the VM has been tested properly. -bool V__enable_vm_eval__ = false; - -DEFUN (__enable_vm_eval__, args, nargout, +DEFUN (__vm_enable__, args, nargout, doc: /* -*- texinfo -*- -@deftypefn {} {@var{val} =} __enable_vm_eval__ () -@deftypefnx {} {@var{old_val} =} __enable_vm_eval__ (@var{new_val}) -@deftypefnx {} {@var{old_val} =} __enable_vm_eval__ (@var{new_val}, "local") +@deftypefn {} {@var{val} =} __vm_enable__ () +@deftypefnx {} {@var{old_val} =} __vm_enable__ (@var{new_val}) +@deftypefnx {} {@var{old_val} =} __vm_enable__ (@var{new_val}, "local") Query or set whether Octave automatically compiles functions to bytecode and executes them in a virtual machine (VM). Note that the virtual machine feature is experimental. The default value is currently false, while the VM is still experimental. -Users need to explicitly call @code{__enable_vm_eval__ (1)} to enable it. +Users need to explicitly call @code{__vm_enable__ (1)} to enable it. In future, this will be set to the value of the OCTAVE_ENABLE_VM_EVALUATOR flag that was set when building Octave. @@ -447,16 +447,16 @@ setting is restored when exiting the function. Once compiled to bytecode, the function will always be evaluated by the -VM no matter the state of @qcode{"__enable_vm_eval__"}, until the bytecode is +VM no matter the state of @qcode{"__vm_enable__"}, until the bytecode is cleared, by e.g. @qcode{"clear all"} or an modification to the function's m-file. -@seealso{__compile__} +@seealso{__vm_compile__} @end deftypefn */) { - return set_internal_variable (V__enable_vm_eval__, args, nargout, - "__enable_vm_eval__"); + return set_internal_variable (V__vm_enable__, args, nargout, + "__vm_enable__"); } OCTAVE_END_NAMESPACE(octave)
--- a/libinterp/parse-tree/pt-bytecode-vm.cc Wed Sep 27 18:17:36 2023 +0200 +++ b/libinterp/parse-tree/pt-bytecode-vm.cc Thu Sep 28 19:32:56 2023 -0400 @@ -7406,7 +7406,7 @@ if (fn->is_compiled ()) return true; - if (V__enable_vm_eval__ && !fn->m_compilation_failed) + if (V__vm_enable__ && !fn->m_compilation_failed) { try {
--- a/libinterp/parse-tree/pt-bytecode.h Wed Sep 27 18:17:36 2023 +0200 +++ b/libinterp/parse-tree/pt-bytecode.h Thu Sep 28 19:32:56 2023 -0400 @@ -325,7 +325,7 @@ }; // If TRUE, use VM evaluator rather than tree walker. -extern bool V__enable_vm_eval__; +extern bool V__vm_enable__; OCTAVE_END_NAMESPACE(octave)
--- a/scripts/help/vm.m Wed Sep 27 18:17:36 2023 +0200 +++ b/scripts/help/vm.m Thu Sep 28 19:32:56 2023 -0400 @@ -33,10 +33,10 @@ ## The VM commands available in Octave are ## ## @table @code -## @item __enable_vm_eval__ +## @item __vm_enable__ ## The main VM user function. Switch on or off the VM as a whole. ## -## @item __compile__ +## @item __vm_compile__ ## Another VM user function. Compiles a specified function to bytecode. ## ## @item __vm_clear_cache__ @@ -55,7 +55,7 @@ ## ## @noindent ## -## @seealso{__enable_vm_eval__, __compile__, __vm_clear_cache__, +## @seealso{__vm_enable__, __vm_compile__, __vm_clear_cache__, ## __vm_is_executing__, __vm_print_trace__, __vm_profile__} ## @end deftypefn
--- a/test/compile-bench/bench-octave/bench.m Wed Sep 27 18:17:36 2023 +0200 +++ b/test/compile-bench/bench-octave/bench.m Thu Sep 28 19:32:56 2023 -0400 @@ -28,8 +28,8 @@ end % For compatibility with older releases and Matlab - if ~exist("__compile__") - __compile__ = @(varargin) true; + if ~exist("__vm_compile__") + __vm_compile__ = @(varargin) true; end if ~exist("__dummy_mark_1__") __dummy_mark_1__ = @() true; @@ -112,7 +112,7 @@ tic; [ccttot0, cctuser0, cctsys0] = cputime; if !no_compile - if ! __compile__ (name) + if ! __vm_compile__ (name) warning ("Could not compile %s, skipping ...", name) continue; end
--- a/test/compile-bench/bench-octave/bench_valgrind.m Wed Sep 27 18:17:36 2023 +0200 +++ b/test/compile-bench/bench-octave/bench_valgrind.m Thu Sep 28 19:32:56 2023 -0400 @@ -37,7 +37,7 @@ % logfilename, octbin, bench folder, benchname filter cmd_template = ["valgrind --tool=callgrind --callgrind-out-file=%s --separate-recs=10 " ... "--dump-instr=yes --collect-jumps=yes \"--dump-after=dummy_mark_1\" " ... - " %s -W --eval \"__enable_vm_eval__ (1); cd %s; bench('reg','%s','n_factor', %d);exit(0)\""]; + " %s -W --eval \"__vm_enable__ (1); cd %s; bench('reg','%s','n_factor', %d);exit(0)\""]; logfilename1 = ["callgrind.out.log_mark_", name, "_", num2str(i), "_", name, ".log"]; logfilename2 = ["callgrind.out.log_ref1_", name, "_", num2str(i), "_", name, ".log"];
--- a/test/compile/bytecode.tst Wed Sep 27 18:17:36 2023 +0200 +++ b/test/compile/bytecode.tst Thu Sep 28 19:32:56 2023 -0400 @@ -33,25 +33,25 @@ ## Test binary expressions %!test -%! __enable_vm_eval__ (0, "local"); % Disable the vm for the tree_walker run +%! __vm_enable__ (0, "local"); % Disable the vm for the tree_walker run %! %! clear all % We want all compiled functions to be cleared so that we can run the tree_walker %! %! key = "10 -10 24 0.041666666666666664 1 -5.0915810909090906 13 1 0 1 0 truthy1 1 falsy3 falsy4 truthy5 1 truthy7 truthy8 1 falsy9 falsy11 0 1 0 1 0 0 1 1 0 1 0 1 1 1 0 1 0 1 0 0 0 0 1 1 1 1 1 1 1 1 "; %! -%! __compile__ bytecode_binops clear; +%! __vm_compile__ bytecode_binops clear; %! bytecode_binops (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! % We wanna know the function compiles, so do a explicit compile -%! assert (__compile__ ("bytecode_binops")); +%! assert (__vm_compile__ ("bytecode_binops")); %! bytecode_binops (); %! assert (__prog_output_assert__ (key)); ## Test subfunctions %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 2 2 11 30 10 30 5 0 0 double 1 2 1 2 double 30 11 5 0 0 double 1 2 1 2 double 11 11 12 13 1 1 double 14 1 1 double 11 11 5 13 1 1 double 14 1 1 double 11 3 3 3 2 2 2 313 ret32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ret32:1 ret32:ret32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 take32:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 1 18 59 64 "; %! a = 313; @@ -59,261 +59,261 @@ %! % externally scoped variables work %! h = @() __printf_assert__ ("%d ", a); %! -%! __compile__ bytecode_subfuncs clear; +%! __vm_compile__ bytecode_subfuncs clear; %! bytecode_subfuncs (h); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_subfuncs")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_subfuncs")); %! bytecode_subfuncs (h); %! assert (__prog_output_assert__ (key)); ## Test if:s %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "0 1 2 3 4 5 6 7 8 1 2 yay1 3 5 7 8 1 yay1 3 4 yay2 5 6 7 yay3 "; %! -%! __compile__ bytecode_if clear; +%! __vm_compile__ bytecode_if clear; %! bytecode_if (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_if")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_if")); %! bytecode_if (); %! assert (__prog_output_assert__ (key)); ## Test for:s %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 2 3 4 4 1 3 5 5 1 4 4 4 3 2 1 1 0.200 0.300 0.400 0.400 0.300 0.200 0.100 0.000 0.000 NaN NaN NaN 1 4 2 2 16 4 3 3 256 3 2 1 double 1 3 size 2 size 1 2 4 size 2 size 1 double q size 1 size 1 w size 1 size 1 e size 1 size 1 char single single 5 1 11 2 12 key:a val:1 1val:1 key:b val:1 3val:2 4val:2 2key:c val:string "; %! -%! __compile__ bytecode_for clear; +%! __vm_compile__ bytecode_for clear; %! bytecode_for (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_for")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_for")); %! bytecode_for (); %! assert (__prog_output_assert__ (key)); ## Test while %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "5 4 3 2 1 3 5 4 4 3 3 4 1 2 1 3 2 8 3 1 3 "; %! -%! __compile__ bytecode_while clear; +%! __vm_compile__ bytecode_while clear; %! bytecode_while (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_while")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_while")); %! bytecode_while (); %! assert (__prog_output_assert__ (key)); ## Test assign %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 3 1 1 2 3 2 3 2 2 6 18 2.000000 2.000000 3.000000 4.000000 5.000000 1 4 double 729.000000 324.000000 182.250000 116.640000 4 1 double 37.000000 81.000000 54.000000 118.000000 2 2 double "; %! -%! __compile__ bytecode_assign clear; +%! __vm_compile__ bytecode_assign clear; %! bytecode_assign (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_assign")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_assign")); %! bytecode_assign (); %! assert (__prog_output_assert__ (key)); ## Test unary %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "-1 4 1 2 3 4 1 3 2 4 0 0 "; %! -%! __compile__ bytecode_unary clear; +%! __vm_compile__ bytecode_unary clear; %! bytecode_unary (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_unary")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_unary")); %! bytecode_unary (); %! assert (__prog_output_assert__ (key)); ## Test range %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 2 3 1 3 5 1 3 5 1 1.1 1.2 1.3 1.4 1 0.9 0.8 0.7 7 7 1 8 10 8 10 8 9 10 11 8 9 10 11 10 8 10 8 -10 -9 -8 -7 -10 -9 -8 -7 "; %! -%! __compile__ bytecode_range clear; +%! __vm_compile__ bytecode_range clear; %! bytecode_range (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_range")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_range")); %! bytecode_range (); %! assert (__prog_output_assert__ (key)); ## Test multi assign %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "3 4 2 2 1 2 3 4 1 2 3 4 1 1 3 2 3 4 1 1 1 2 3 4 1 1 1 2 3 4 1 2 3 "; %! -%! __compile__ bytecode_multi_assign clear; +%! __vm_compile__ bytecode_multi_assign clear; %! bytecode_multi_assign (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_multi_assign")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_multi_assign")); %! bytecode_multi_assign (); %! assert (__prog_output_assert__ (key)); ## Test subsasgn %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! clear functions % persistent variables in bytecode_subsasgn %! key = "3 5 9 8 11 13 1 2 3 4 5 6 77 88 99 1010 1 2 3 987 987 6 77 88 99 1010 0 0 0 0 0 13 double 3 2 4 2 3 cell 1 3 6 7 2 3 1 4 5 1 3 5 2 4 6 7 7 7 7 7 7 1 2 3 1 3 3 2 3 2 3 1 3 1 2 3 4 4 4 3 4 5 6 1 5 3 4 1 5 -1 4 1 5 -1 8 3 3 3 3 3 3 3 3 1 1 3 1 "; %! -%! __compile__ bytecode_subsasgn clear; +%! __vm_compile__ bytecode_subsasgn clear; %! bytecode_subsasgn (); %! assert (__prog_output_assert__ (key), "bytecode_subsasgn failed uncompiled"); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_subsasgn")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_subsasgn")); %! bytecode_subsasgn (); %! assert (__prog_output_assert__ (key), "bytecode_subsasgn failed compiled"); ## Test end %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 3 2 4 1 5 6 7 2 2 5 5 6 6 1 2 3 4 5 2 2 2 3 3 4 fs 2 3 1 foo oo "; %! -%! __compile__ bytecode_end clear; +%! __vm_compile__ bytecode_end clear; %! bytecode_end (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_end")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_end")); %! bytecode_end (); %! assert (__prog_output_assert__ (key)); ## Test matrix %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 2 3 4 1 4 1 2 3 4 4 1 1 3 2 4 2 2 1 3 1 3 2 4 2 4 4 2 0 0 a b c d 7 15 10 22 2 2 30 1 1 1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16 4 4 1 1 1 0.0333333 0.0666667 0.1 0.133333 0.0666667 0.133333 0.2 0.266667 0.1 0.2 0.3 0.4 0.133333 0.266667 0.4 0.533333 4 4 1 0 0 1 2 2 30 1 1 10 14 14 20 2 2 0.0333333 0.0666667 0.1 0.133333 0.0666667 0.133333 0.2 0.266667 0.1 0.2 0.3 0.4 0.133333 0.266667 0.4 0.533333 4 4 2.5 -0.5 2 0 2 2 2 6 4 8 2 2 2 3 4 5 3 4 5 6 4 5 6 7 5 6 7 8 4 4 3 4 5 6 1 4 3 4 5 6 1 4 -1 0 1 2 1 4 2 4 6 8 1 4 0.5 1 1.5 2 1 4 0.5 1 1.5 2 1 4 1 4 9 16 1 4 1 1 1 1 1 4 1 1 1 1 1 4 1 4 27 256 1 4 1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16 4 4 1 0.5 0.333333 0.25 2 1 0.666667 0.5 3 1.5 1 0.75 4 2 1.33333 1 4 4 1 2 3 4 0.5 1 1.5 2 0.333333 0.666667 1 1.33333 0.25 0.5 0.75 1 4 4 1 4 27 256 4 1 qzwxeca s d zzxxccz x c 1 258 33264 258 1 33264 "; %! -%! __compile__ bytecode_matrix clear; +%! __vm_compile__ bytecode_matrix clear; %! bytecode_matrix (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_matrix")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_matrix")); %! bytecode_matrix (); %! assert (__prog_output_assert__ (key)); ## Test return %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 baaar bääär baaaaz bääääz bååååz booz 1 1 2 1 1 1 2 1 silly silly "; %! -%! __compile__ bytecode_return clear; +%! __vm_compile__ bytecode_return clear; %! bytecode_return (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_return")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_return")); %! bytecode_return (); %! assert (__prog_output_assert__ (key)); ## Test word list command %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "A B C QWE "; %! -%! __compile__ bytecode_wordlistcmd clear; +%! __vm_compile__ bytecode_wordlistcmd clear; %! bytecode_wordlistcmd (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_wordlistcmd")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_wordlistcmd")); %! bytecode_wordlistcmd (); %! assert (__prog_output_assert__ (key)); ## Test do until %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "5 3 5 5 4 4 3 4 1 2 1 3 2 12 3 0 3 "; %! -%! __compile__ bytecode_dountil clear; +%! __vm_compile__ bytecode_dountil clear; %! bytecode_dountil (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_dountil")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_dountil")); %! bytecode_dountil (); %! assert (__prog_output_assert__ (key)); ## Test cell %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "a b a b 1 2 b c b c 1 2 char b c c d b d c e 2 2 b d f h j l c e g i k m 6 2 1 2 2 3 1 3 2 4 1 3 1 2 1 3 2 4 2 2 double qwe 1 3 char 1 2 "; %! -%! __compile__ bytecode_cell clear; +%! __vm_compile__ bytecode_cell clear; %! bytecode_cell (); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_cell")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_cell")); %! bytecode_cell (); %! assert (__prog_output_assert__ (key)); ## Test varargin %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 3 1 2 1 1 1 1 1 2 3 4 1 4 4 0 0 0 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 0 0 1 0 0 0 2 1 1 1 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 2 1 2 4 1 2 0 0 2 1 nob 0 0 1 noa nob 0 0 0 2 1 2 4 1 2 3 4 3 3 2 1 0 "; %! -%! __compile__ bytecode_varargin clear; +%! __vm_compile__ bytecode_varargin clear; %! bytecode_varargin (1,2,3); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_varargin")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_varargin")); %! bytecode_varargin (1,2,3); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "0 0 1 1 1 1 1 2 3 4 1 4 4 0 0 0 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 0 0 1 0 0 0 2 1 1 1 1 2 3 4 1 3 4 2 3 4 1 3 3 2 2 3 4 1 4 4 1 2 1 2 4 1 2 0 0 2 1 nob 0 0 1 noa nob 0 0 0 2 1 2 4 1 2 3 4 1 3 2 1 0 "; %! -%! __compile__ bytecode_varargin clear; +%! __vm_compile__ bytecode_varargin clear; %! bytecode_varargin (1); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_varargin")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_varargin")); %! bytecode_varargin (1); %! assert (__prog_output_assert__ (key)); ## Test global variables %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "double 0 0 1 1 1 1 1 2 2 2 400 100 0 1 3 double 1 1 1 2 double 1 2 1 1 11 eclass:double 1 1 3 4 double 1 2 400 100 1 1 1 1 3 4 1 1 5 6 1 1 1 2 double 1 2 1 2 double 1 2 1 1 3 4 eclass:double 1 2 3 4 double 1 2 0 0 1 1 3 4 1 1 5 6 1 0 2 double 2 double 11 2 6 4 5 double 1 5 11 double 1 1 22 double 1 1 33 double 1 1 3 double 1 1 4 double 1 1 10 double 1 1 2 3 double 1 2 3 double 1 1 2 double 1 1 55 double 1 1 7 double 1 1 0 11 12 4 11 12 4 "; %! -%! __compile__ bytecode_global_1 clear; +%! __vm_compile__ bytecode_global_1 clear; %! clear global a; %! clear global b; %! clear global q @@ -324,8 +324,8 @@ %! assert (length(who('global','a'))); %! assert (length(who('global','b'))); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_global_1")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_global_1")); %! clear global a; %! clear global b; %! clear global q; @@ -346,37 +346,37 @@ ## Test switch %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "yay yay2 yay3 yay4 yay5 yay6 yay7 yay8 1 2 3 3 1 3 3 4 4 1 3 3 4 4 2 yoo 2 3 3 1:1 for-end:12:2 3:3 for-end:3breaking:4 "; %! -%! __compile__ bytecode_switch clear; +%! __vm_compile__ bytecode_switch clear; %! bytecode_switch; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_switch")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_switch")); %! bytecode_switch; %! assert (__prog_output_assert__ (key)); ## Test eval (dynamic stack frames) %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "3.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 5.000000 4.000000 2.000000 3.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 4.000000 1.000000 1.000000 double 5.000000 4.000000 2.000000 1:11.000000 2:22.000000 3:33.000000 4:3.000000 5:22.000000 6:3.000000 7:3.000000 3 3 2 2 3.000000 3.000000 "; %! -%! __compile__ bytecode_eval_1 clear; +%! __vm_compile__ bytecode_eval_1 clear; %! bytecode_eval_1; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_eval_1")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_eval_1")); %! bytecode_eval_1; %! assert (__prog_output_assert__ (key)); ## Test evalin and assignin %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! % We want to test all combinations of compiled and uncompiled evalin_1 and 2. %! @@ -385,28 +385,28 @@ %! caller_a = 2; %! %! -%! __compile__ bytecode_evalin_1 clear; -%! __compile__ bytecode_evalin_2 clear; +%! __vm_compile__ bytecode_evalin_1 clear; +%! __vm_compile__ bytecode_evalin_2 clear; %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_evalin_1")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_evalin_1")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! %! -%! __compile__ bytecode_evalin_1 clear; -%! __compile__ bytecode_evalin_2 clear; -%! assert (__compile__ ("bytecode_evalin_1")); -%! assert (__compile__ ("bytecode_evalin_2")); +%! __vm_compile__ bytecode_evalin_1 clear; +%! __vm_compile__ bytecode_evalin_2 clear; +%! assert (__vm_compile__ ("bytecode_evalin_1")); +%! assert (__vm_compile__ ("bytecode_evalin_2")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! -%! __compile__ bytecode_evalin_1 clear; -%! __compile__ bytecode_evalin_2 clear; -%! assert (__compile__ ("bytecode_evalin_2")); +%! __vm_compile__ bytecode_evalin_1 clear; +%! __vm_compile__ bytecode_evalin_2 clear; +%! assert (__vm_compile__ ("bytecode_evalin_2")); %! bytecode_evalin_1 (); %! assert (__prog_output_assert__ (key)); %! @@ -414,9 +414,9 @@ ## Test error messages %!test %! ## Interpreter reference -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all -%! __compile__ bytecode_errors clear; +%! __vm_compile__ bytecode_errors clear; %! fail ("bytecode_errors (0)", ... %! "'qweqwe' undefined near line 9, column 6"); %! fail ("bytecode_errors (1)", ... @@ -436,9 +436,9 @@ %! fail ("bytecode_errors (8)", ... %! 'operator \+: nonconformant arguments \(op1 is 1x3, op2 is 1x2\)'); %! -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! ## Bytecode running the same errors -%! __compile__ bytecode_errors; +%! __vm_compile__ bytecode_errors; %! fail ("bytecode_errors (0)", ... %! "'qweqwe' undefined near line 9, column 6"); %! fail ("bytecode_errors (1)", ... @@ -460,153 +460,153 @@ ## Test try catch %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "yay yay2 yay3 ooo yay2 yay3 ooo2 ooo2 yay3 yay4 Nested error yay5 yay6 In catch yay7 qwe yay8 Error in subfunction yay9 'asd' undefined near line 87, column 11 yay10 operator *: nonconformant arguments (op1 is 1x2, op2 is 1x3) yay11 yoyo yay12 foo yay12 foo yay12 foo yay13 foo yay13 foo yay13 foo "; %! -%! __compile__ bytecode_trycatch clear; +%! __vm_compile__ bytecode_trycatch clear; %! bytecode_trycatch; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_trycatch")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_trycatch")); %! bytecode_trycatch; %! assert (__prog_output_assert__ (key)); ## Test unwind protect %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "yay1 yay2 yay3 e1 subyyay1 subyyay2 subyyay3 subyyay4 subyyay5 subyyay6 subyyay7 subyyay8 subyyay9 subyyay10 subyyay11 subyyay12 subyyay13 subyyay14 subyyay15 subyyay16 subyyay17 subyyay18 yay4 yay5 yay6 "; -%! __compile__ bytecode_unwind clear; +%! __vm_compile__ bytecode_unwind clear; %! bytecode_unwind; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_unwind")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_unwind")); %! bytecode_unwind; %! assert (__prog_output_assert__ (key)); ## Test persistant %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! clear functions % clear persistent variables in bytecode_persistant %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; %! -%! __compile__ bytecode_persistant clear; +%! __vm_compile__ bytecode_persistant clear; %! bytecode_persistant; %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); %! %! clear all; -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; -%! assert (__compile__ ("bytecode_persistant")); +%! assert (__vm_compile__ ("bytecode_persistant")); %! bytecode_persistant; %! %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (0, "local"); -%! __compile__ bytecode_persistant clear; +%! __vm_enable__ (0, "local"); +%! __vm_compile__ bytecode_persistant clear; %! clear all; %! key = "a:3 b: double 0 0 0 c:3 c:4 a:4 b:1 double 1 1 0 c:5 c:6 "; %! bytecode_persistant; -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_persistant")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_persistant")); %! %! bytecode_persistant; %! assert (__prog_output_assert__ (key)); ## Test structs %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 2 double 1 1 struct 3 4 "; -%! __compile__ bytecode_struct clear; +%! __vm_compile__ bytecode_struct clear; %! bytecode_struct; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_struct")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_struct")); %! bytecode_struct; %! assert (__prog_output_assert__ (key)); ## Test indexing chained objects and strange indexing %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 2 3 3 2 cell 1 1 3 3 2 3 22 double 33 3 4 matlab.lang.MemoizedFunction 2 "; -%! __compile__ bytecode_index_obj clear; +%! __vm_compile__ bytecode_index_obj clear; %! bytecode_index_obj; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_index_obj")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_index_obj")); %! bytecode_index_obj; %! assert (__prog_output_assert__ (key)); ## Test varargout %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "7 8 1 1 2 1 0 0 0 1 0 1 0 0 0 1 0 "; -%! __compile__ bytecode_varargout clear; +%! __vm_compile__ bytecode_varargout clear; %! bytecode_varargout; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_varargout")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_varargout")); %! bytecode_varargout; %! assert (__prog_output_assert__ (key)); ## Test inputname %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "a a b + 1 a a b b aa aa bb bb aa + 1 bb * 3 a + 1 b * 3 aa aa bb bb aa + 1 bb * 3 a a b b a + 1 b * 3 "; -%! __compile__ bytecode_inputname clear; +%! __vm_compile__ bytecode_inputname clear; %! a = 9; b = 8; %! bytecode_inputname (a, b + 1); %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_inputname")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_inputname")); %! bytecode_inputname (a, b + 1); %! assert (__prog_output_assert__ (key)); ## Test ans %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "2 5 1 1 1 "; -%! __compile__ bytecode_ans clear; +%! __vm_compile__ bytecode_ans clear; %! bytecode_ans; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_ans")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_ans")); %! bytecode_ans; %! assert (__prog_output_assert__ (key)); ## Test using classdef %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! global cdef_foo_ctor_cnt; clear global cdef_foo_ctor_cnt; %! global cdef_foo_dtor_cnt; clear global cdef_foo_dtor_cnt; %! key = ". 1 f1 . 2 f3 3 f2 . sumf2f3 2 . . call14 f4 . a a_1 . 5 f8 . 6 f10 7 f9 . sumf9f10 2 . . call18 f11 . 2 2 3 4 4 4 3 2 2 3 . 9 sumf9f10 10 f12 11 f13 12 f14 13 sumf2f3 14 f5 15 f6 16 f7 "; -%! __compile__ bytecode_cdef_use clear; +%! __vm_compile__ bytecode_cdef_use clear; %! bytecode_cdef_use (); %! assert (__prog_output_assert__ (key)); %! global cdef_foo_ctor_cnt; global cdef_foo_dtor_cnt; %! assert (cdef_foo_ctor_cnt == cdef_foo_dtor_cnt); % Check, as many ctor and dtor executions %! -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! global cdef_foo_ctor_cnt; clear global cdef_foo_ctor_cnt; %! global cdef_foo_dtor_cnt; clear global cdef_foo_dtor_cnt; -%! assert (__compile__ ("bytecode_cdef_use")); +%! assert (__vm_compile__ ("bytecode_cdef_use")); %! bytecode_cdef_use (); %! assert (__prog_output_assert__ (key)); %! global cdef_foo_ctor_cnt; global cdef_foo_dtor_cnt; @@ -619,18 +619,18 @@ ## Test anonymous function handles %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "1 2 12 3 4 4 4 1 2 3 1 2 3 1 2 1 2 11 12 11 12 1 4 4 1 1 1 2 1 2 1 2 3 1 2 3 1 3 1 3 9 0 1 fooo ~101 103 ~101 103 ~110 123 ~101 123 ~010 123 ~000 123 ~011 123 "; -%! __compile__ bytecode_anon_handles clear; +%! __vm_compile__ bytecode_anon_handles clear; %! bytecode_anon_handles; %! %! global __assert_printf__; %! %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_anon_handles")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_anon_handles")); %! bytecode_anon_handles; %! global __assert_printf__; %! assert (__prog_output_assert__ (key)); @@ -639,23 +639,23 @@ ## m-file %!test %! clear all -%! __enable_vm_eval__ (1, "local"); -%! __compile__ wrongname_fn clear; -%! assert (__compile__ ("wrongname_fn")); +%! __vm_enable__ (1, "local"); +%! __vm_compile__ wrongname_fn clear; +%! assert (__vm_compile__ ("wrongname_fn")); %! %! assert (wrongname_fn (77) == 78); ## Test some misc stuff %!test %! clear all -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! %! bytecode_misc; % asserts inernally ## Leak check %!test %! clear all -%! __enable_vm_eval__ (1, "local"); +%! __vm_enable__ (1, "local"); %! %! c = 2; %! d = 3; @@ -668,15 +668,15 @@ ## Test scripts %!test -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all %! key = "0 1 3 4 5 3 "; -%! __compile__ bytecode_scripts clear; +%! __vm_compile__ bytecode_scripts clear; %! bytecode_scripts; %! assert (__prog_output_assert__ (key)); %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_scripts")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_scripts")); %! bytecode_scripts; %! assert (__prog_output_assert__ (key)); @@ -685,16 +685,16 @@ %! global cdef_bar_cnt %! cdef_bar_cnt = 0; %! -%! __enable_vm_eval__ (0, "local"); +%! __vm_enable__ (0, "local"); %! clear all -%! __compile__ bytecode_nested clear; +%! __vm_compile__ bytecode_nested clear; %! % These tests uses asserts in themself %! bytecode_nested; %! %! cdef_bar_cnt = 0; %! -%! __enable_vm_eval__ (1, "local"); -%! assert (__compile__ ("bytecode_nested")); +%! __vm_enable__ (1, "local"); +%! assert (__vm_compile__ ("bytecode_nested")); %! bytecode_nested; %! %! assert (cdef_bar_cnt == 0);
--- a/test/compile/shutup_operator_test/bytecode_disp.tst Wed Sep 27 18:17:36 2023 +0200 +++ b/test/compile/shutup_operator_test/bytecode_disp.tst Thu Sep 28 19:32:56 2023 -0400 @@ -9,10 +9,10 @@ %! % double's display. Is this a bug ??? %! clear classes %! key = "ans = 1 . ans = 5 . . ans = 0 . ans = 8 . ans = 3 . x = 3 . x = 1 y = 2 . x = 1 . . x = 1 . y = 2 . x = 1 "; -%! __compile__ bytecode_disp clear; +%! __vm_compile__ bytecode_disp clear; %! bytecode_disp; %! assert (__prog_output_assert__ (key)); %! -%! assert (__compile__ ("bytecode_disp")); +%! assert (__vm_compile__ ("bytecode_disp")); %! bytecode_disp; %! assert (__prog_output_assert__ (key));