diff options
Diffstat (limited to '')
| -rw-r--r-- | src/testdir/test_memory_usage.vim | 165 |
1 files changed, 165 insertions, 0 deletions
diff --git a/src/testdir/test_memory_usage.vim b/src/testdir/test_memory_usage.vim new file mode 100644 index 0000000..13e7eec --- /dev/null +++ b/src/testdir/test_memory_usage.vim @@ -0,0 +1,165 @@ +" Tests for memory usage. + +source check.vim +CheckFeature terminal +CheckNotGui + +" Skip tests on Travis CI ASAN build because it's difficult to estimate memory +" usage. +CheckNotAsan + +source shared.vim + +func s:pick_nr(str) abort + return substitute(a:str, '[^0-9]', '', 'g') * 1 +endfunc + +if has('win32') + if !executable('wmic') + throw 'Skipped: wmic program missing' + endif + func s:memory_usage(pid) abort + let cmd = printf('wmic process where processid=%d get WorkingSetSize', a:pid) + return s:pick_nr(system(cmd)) / 1024 + endfunc +elseif has('unix') + if !executable('ps') + throw 'Skipped: ps program missing' + endif + func s:memory_usage(pid) abort + return s:pick_nr(system('ps -o rss= -p ' . a:pid)) + endfunc +else + throw 'Skipped: not win32 or unix' +endif + +" Wait for memory usage to level off. +func s:monitor_memory_usage(pid) abort + let proc = {} + let proc.pid = a:pid + let proc.hist = [] + let proc.max = 0 + + func proc.op() abort + " Check the last 200ms. + let val = s:memory_usage(self.pid) + if self.max < val + let self.max = val + endif + call add(self.hist, val) + if len(self.hist) < 20 + return 0 + endif + let sample = remove(self.hist, 0) + return len(uniq([sample] + self.hist)) == 1 + endfunc + + call WaitFor({-> proc.op()}, 10000) + return {'last': get(proc.hist, -1), 'max': proc.max} +endfunc + +let s:term_vim = {} + +func s:term_vim.start(...) abort + let self.buf = term_start([GetVimProg()] + a:000) + let self.job = term_getjob(self.buf) + call WaitFor({-> job_status(self.job) ==# 'run'}) + let self.pid = job_info(self.job).process + + " running an external command may fail once in a while + let g:test_is_flaky = 1 +endfunc + +func s:term_vim.stop() abort + call term_sendkeys(self.buf, ":qall!\<CR>") + call WaitFor({-> job_status(self.job) ==# 'dead'}) + exe self.buf . 'bwipe!' +endfunc + +func s:vim_new() abort + return copy(s:term_vim) +endfunc + +func Test_memory_func_capture_vargs() + " Case: if a local variable captures a:000, funccall object will be free + " just after it finishes. + let testfile = 'Xtest.vim' + let lines =<< trim END + func s:f(...) + let x = a:000 + endfunc + for _ in range(10000) + call s:f(0) + endfor + END + call writefile(lines, testfile, 'D') + + let vim = s:vim_new() + call vim.start('--clean', '-c', 'set noswapfile', testfile) + let before = s:monitor_memory_usage(vim.pid).last + + call term_sendkeys(vim.buf, ":so %\<CR>") + call WaitFor({-> term_getcursor(vim.buf)[0] == 1}) + let after = s:monitor_memory_usage(vim.pid) + + " Estimate the limit of max usage as 2x initial usage. + " The lower limit can fluctuate a bit, use 97%. + call assert_inrange(before * 97 / 100, 2 * before, after.max) + + " In this case, garbage collecting is not needed. + " The value might fluctuate a bit, allow for 3% tolerance below and 5% above. + " Based on various test runs. + let lower = after.last * 97 / 100 + let upper = after.last * 105 / 100 + call assert_inrange(lower, upper, after.max) + + call vim.stop() +endfunc + +func Test_memory_func_capture_lvars() + " Case: if a local variable captures l: dict, funccall object will not be + " free until garbage collector runs, but after that memory usage doesn't + " increase so much even when rerun Xtest.vim since system memory caches. + let testfile = 'Xtest.vim' + let lines =<< trim END + func s:f() + let x = l: + endfunc + for _ in range(10000) + call s:f() + endfor + END + call writefile(lines, testfile, 'D') + + let vim = s:vim_new() + call vim.start('--clean', '-c', 'set noswapfile', testfile) + let before = s:monitor_memory_usage(vim.pid).last + + call term_sendkeys(vim.buf, ":so %\<CR>") + call WaitFor({-> term_getcursor(vim.buf)[0] == 1}) + let after = s:monitor_memory_usage(vim.pid) + + " Rerun Xtest.vim. + for _ in range(3) + call term_sendkeys(vim.buf, ":so %\<CR>") + call WaitFor({-> term_getcursor(vim.buf)[0] == 1}) + let last = s:monitor_memory_usage(vim.pid).last + endfor + + " The usage may be a bit less than the last value, use 80%. + " Allow for 20% tolerance at the upper limit. That's very permissive, but + " otherwise the test fails sometimes. On Cirrus CI with FreeBSD we need to + " be even much more permissive. + if has('bsd') + let multiplier = 19 + else + let multiplier = 12 + endif + let lower = before * 8 / 10 + let upper = (after.max + (after.last - before)) * multiplier / 10 + call assert_inrange(lower, upper, last) + + call vim.stop() +endfunc + +" vim: shiftwidth=2 sts=2 expandtab |