Mirror of the Vim source from https://github.com/vim/vim
|89001c986b21||2022-05-18 19:15:06||Bram Moolenaar||tip Added tag v8.2.4976 for changeset 8f599b6d9f54c6b4dfff9ba...|
|8f599b6d9f54||2022-05-18 19:15:04||Bram Moolenaar||v8.2.4976 patch 8.2.4976: Coverity complains about not restoring a ...|
|d43069214fa6||2022-05-18 04:15:04||Bram Moolenaar||Added tag v8.2.4975 for changeset f3f45218f923e791fa8e35e...|
|f3f45218f923||2022-05-18 04:15:03||Bram Moolenaar||v8.2.4975 patch 8.2.4975: recursive command line loop may cause a c...|
|02398ff5b522||2022-05-18 02:00:04||Bram Moolenaar||Added tag v8.2.4974 for changeset 6a7d94628b5a6388ced039e...|
|6a7d94628b5a||2022-05-18 02:00:03||Bram Moolenaar||v8.2.4974 patch 8.2.4974: ":so" command may read after end of buffe...|
|26d0d6f9b368||2022-05-18 00:15:05||Bram Moolenaar||Added tag v8.2.4973 for changeset 11609f025219de61f30e5ca...|
|11609f025219||2022-05-18 00:15:03||Bram Moolenaar||v8.2.4973 patch 8.2.4973: Vim9: type error for list unpack mentions...|
|7630685d3e43||2022-05-17 23:15:03||Bram Moolenaar||Added tag v8.2.4972 for changeset 2644e49d51471e8f264e02d...|
|2644e49d5147||2022-05-17 23:15:02||Bram Moolenaar||v8.2.4972 patch 8.2.4972: Vim9: compilation fails when using dict m...|
|default||89001c986b21||2022-05-18 19:15:06||Bram Moolenaar||Added tag v8.2.4976 for cha...|
|vim||930405b6b960||2015-08-19 04:52:11||Bram Moolenaar||Close invalid branch 'vim'|
|vim72||cb0592df6c86||2015-08-19 04:52:12||Bram Moolenaar||Close unused branch 'vim72'|
|vim73||c26ccfcf5989||2015-08-19 04:52:12||Bram Moolenaar||Close old branch 'vim73'|
This is an experimental side of Vim. It explores ways of making Vim script faster and better.
WARNING: The Vim9 script features are still under development, anything can break!
The third item on the poll results of 2018, after popup windows and text properties, is faster Vim script. So how do we do that?
I have been throwing some ideas around, and soon came to the conclusion that the current way functions are called and executed, with dictionaries for the arguments and local variables, is never going to be very fast. We're lucky if we can make it twice as fast. The overhead of a function call and executing every line is just too high.
So what then? We can only make something fast by having a new way of defining a function, with similar but different properties of the old way: * Arguments are only available by name, not through the a: dictionary or the a:000 list. * Local variables are not available in an l: dictionary. * A few more things that slow us down, such as exception handling details.
I Implemented a "proof of concept" and measured the time to run a simple for loop with an addition (Justin used this example in his presentation, full code is below):
let sum = 0 for i in range(1, 2999999) let sum += i endfor
|how||time in sec|
That looks very promising! It's just one example, but it shows how much we can gain, and also that Vim script can be faster than builtin interfaces.
LuaJit is much faster at Lua-only instructions. In practice the script would not do something useless as counting but change the text. For example, reindent all the lines:
let totallen = 0 for i in range(1, 100000) call setline(i, ' ' .. getline(i)) let totallen += len(getline(i)) endfor
|how||time in sec|
[These times were measured on a different system by Dominique Pelle]
The differences are smaller, but Vim 9 script is clearly the fastest. Using LuaJIT is only a little bit faster than plain Lua here, clearly the call back to the Vim code is costly.
How does Vim9 script work? The function is first compiled into a sequence of instructions. Each instruction has one or two parameters and a stack is used to store intermediate results. Local variables are also on the stack, space is reserved during compilation. This is a fairly normal way of compilation into an intermediate format, specialized for Vim, e.g. each stack item is a typeval_T. And one of the instructions is "execute Ex command", for commands that are not compiled.
Attempts have been made to implement functionality with built-in script languages such as Python, Perl, Lua, Tcl and Ruby. This never gained much foothold, for various reasons.
Instead of using script language support in Vim: * Encourage implementing external tools in any language and communicate with them. The job and channel support already makes this possible. Really any language can be used, also Java and Go, which are not available built-in. * No priority for the built-in language interfaces. They will have to be kept for backwards compatibility, but many users won't need a Vim build with these interfaces. * Improve the Vim script language, it is used to communicate with the external tool and implements the Vim side of the interface. Also, it can be used when an external tool is undesired.
Altogether this creates a clear situation: Vim with the +eval feature will be sufficient for most plugins, while some plugins require installing a tool that can be written in any language. No confusion about having Vim but the plugin not working because some specific language is missing. This is a good long term goal.
Rationale: Why is it better to run a tool separately from Vim than using a built-in interface and interpreter? Take for example something that is written in Python: * The built-in interface uses the embedded python interpreter. This is less well maintained than the python command. Building Vim with it requires installing developer packages. If loaded dynamically there can be a version mismatch. * When running the tool externally the standard python command can be used, which is quite often available by default or can be easily installed. * The built-in interface has an API that is unique for Vim with Python. This is an extra API to learn. * A .py file can be compiled into a .pyc file and execute much faster. * Inside Vim multi-threading can cause problems, since the Vim core is single threaded. In an external tool there are no such problems. * The Vim part is written in .vim files, the Python part is in .py files, this is nicely separated. * Disadvantage: An interface needs to be made between Vim and Python. JSON is available for this, and it's fairly easy to use. But it still requires implementing asynchronous communication.
To make Vim faster a new way of defining a function needs to be added. While we are doing that, since the lines in this function won't be fully backwards compatible anyway, we can also make Vim script easier to use. In other words: "less weird". Making it work more like modern programming languages will help. No surprises.
A good example is how in a function the arguments are prefixed with "a:". No other language I know does that, so let's drop it.
Taking this one step further is also dropping "s:" for script-local variables; everything at the script level is script-local by default. Since this is not backwards compatible it requires a new script style: Vim9 script!
To avoid having more variations, the syntax inside a compiled function is the same as in Vim9 script. Thus you have legacy syntax and Vim9 syntax.
def MyFunction(arg: number): number var local = 1 var todo = arg const ADD = 88 while todo > 0 local += ADD todo -= 1 endwhile return local enddef
between files. Vim currently uses the
:source command, which has several
* In the sourced script, is not clear what it provides. By default all
functions are global and can be used elsewhere.
* In a script that sources other scripts, it is not clear what function comes
from what sourced script. Finding the implementation is a hassle.
* Prevention of loading the whole script twice must be manually implemented.
We can use the
make this much better. For example, in script "myfunction.vim" define a
function and export it:
vim9script " Vim9 script syntax used here var local = 'local variable is not exported, script-local' export def MyFunction() " exported function ... def LocalFunction() " not exported, script-local ...
And in another script import the function:
vim9script " Vim9 script syntax used here import MyFunction from 'myfunction.vim'
These are ideas, this will take time to design, discuss and implement. Eventually this will lead to Vim 9!
Vim was build with -O2.
func VimOld() let sum = 0 for i in range(1, 2999999) let sum += i endfor return sum endfunc func Python() py3 << END sum = 0 for i in range(1, 3000000): sum += i END return py3eval('sum') endfunc func Lua() lua << END sum = 0 for i = 1, 2999999 do sum = sum + i end END return luaeval('sum') endfunc def VimNew(): number var sum = 0 for i in range(1, 2999999) sum += i endfor return sum enddef let start = reltime() echo VimOld() echo 'Vim old: ' .. reltimestr(reltime(start)) let start = reltime() echo Python() echo 'Python: ' .. reltimestr(reltime(start)) let start = reltime() echo Lua() echo 'Lua: ' .. reltimestr(reltime(start)) let start = reltime() echo VimNew() echo 'Vim new: ' .. reltimestr(reltime(start))
def VimNew(): number var totallen = 0 for i in range(1, 100000) setline(i, ' ' .. getline(i)) totallen += len(getline(i)) endfor return totallen enddef func VimOld() let totallen = 0 for i in range(1, 100000) call setline(i, ' ' .. getline(i)) let totallen += len(getline(i)) endfor return totallen endfunc func Lua() lua << END b = vim.buffer() totallen = 0 for i = 1, 100000 do b[i] = " " .. b[i] totallen = totallen + string.len(b[i]) end END return luaeval('totallen') endfunc func Python() py3 << END cb = vim.current.buffer totallen = 0 for i in range(0, 100000): cb[i] = ' ' + cb[i] totallen += len(cb[i]) END return py3eval('totallen') endfunc new call setline(1, range(100000)) let start = reltime() echo VimOld() echo 'Vim old: ' .. reltimestr(reltime(start)) bwipe! new call setline(1, range(100000)) let start = reltime() echo Python() echo 'Python: ' .. reltimestr(reltime(start)) bwipe! new call setline(1, range(100000)) let start = reltime() echo Lua() echo 'Lua: ' .. reltimestr(reltime(start)) bwipe! new call setline(1, range(100000)) let start = reltime() echo VimNew() echo 'Vim new: ' .. reltimestr(reltime(start)) bwipe!