perf: tasks are now fully async

This commit is contained in:
Folke Lemaitre 2024-06-26 14:28:53 +02:00
parent 36952153ec
commit 0614ca6ca6
No known key found for this signature in database
GPG Key ID: 41F8B1FBACAE2040
2 changed files with 87 additions and 68 deletions

View File

@ -105,7 +105,7 @@ M.defaults = {
-- leave nil, to automatically select a browser depending on your OS.
-- If you want to use a specific browser, you can define it here
browser = nil, ---@type string?
throttle = 20, -- how frequently should the ui process render events
throttle = 1000 / 30, -- how frequently should the ui process render events
custom_keys = {
-- You can define custom key maps here. If present, the description will
-- be shown in the help menu.

View File

@ -4,7 +4,45 @@ local Process = require("lazy.manage.process")
---@field skip? fun(plugin:LazyPlugin, opts?:TaskOptions):any?
---@field run fun(task:LazyTask, opts:TaskOptions)
---@alias LazyTaskState fun():boolean?
---@alias LazyTaskState {task:LazyTask, thread:thread}
local Scheduler = {}
---@type LazyTaskState[]
Scheduler._queue = {}
Scheduler._executor = assert(vim.loop.new_check())
Scheduler._running = false
function Scheduler.step()
Scheduler._running = true
local budget = 1 * 1e6
local start = vim.loop.hrtime()
local count = #Scheduler._queue
local i = 0
while #Scheduler._queue > 0 and vim.loop.hrtime() - start < budget do
---@type LazyTaskState
local state = table.remove(Scheduler._queue, 1)
state.task:_step(state.thread)
if coroutine.status(state.thread) ~= "dead" then
table.insert(Scheduler._queue, state)
end
i = i + 1
if i >= count then
break
end
end
Scheduler._running = false
if #Scheduler._queue == 0 then
return Scheduler._executor:stop()
end
end
---@param state LazyTaskState
function Scheduler.add(state)
table.insert(Scheduler._queue, state)
if not Scheduler._executor:is_active() then
Scheduler._executor:start(vim.schedule_wrap(Scheduler.step))
end
end
---@class LazyTask
---@field plugin LazyPlugin
@ -13,11 +51,11 @@ local Process = require("lazy.manage.process")
---@field status string
---@field error? string
---@field warn? string
---@field private _task fun(task:LazyTask)
---@field private _running LazyPluginState[]
---@field private _task fun(task:LazyTask, opts:TaskOptions)
---@field private _started? number
---@field private _ended? number
---@field private _opts TaskOptions
---@field private _threads thread[]
local Task = {}
---@class TaskOptions: {[string]:any}
@ -32,18 +70,17 @@ function Task.new(plugin, name, task, opts)
__index = Task,
})
self._opts = opts or {}
self._running = {}
self._threads = {}
self._task = task
self._started = nil
self.plugin = plugin
self.name = name
self.output = ""
self.status = ""
plugin._.tasks = plugin._.tasks or {}
---@param other LazyTask
plugin._.tasks = vim.tbl_filter(function(other)
return other.name ~= name or other:is_running()
end, plugin._.tasks)
end, plugin._.tasks or {})
table.insert(plugin._.tasks, self)
return self
end
@ -52,27 +89,26 @@ function Task:has_started()
return self._started ~= nil
end
function Task:has_ended()
return self._ended ~= nil
end
function Task:is_done()
return self:has_started() and not self:is_running()
return self:has_started() and self:has_ended()
end
function Task:is_running()
return self:has_started() and self._ended == nil
return self:has_started() and not self:has_ended()
end
function Task:start()
if vim.in_fast_event() then
return vim.schedule(function()
self:start()
end)
end
assert(not self:has_started(), "task already started")
assert(not self:has_ended(), "task already done")
self._started = vim.uv.hrtime()
---@type boolean, string|any
local ok, err = pcall(self._task, self, self._opts)
if not ok then
self.error = err or "failed"
end
self:_check()
self:async(function()
self._task(self, self._opts)
end)
end
---@param msg string|string[]
@ -102,36 +138,33 @@ end
---@param fn async fun()
function Task:async(fn)
local co = coroutine.create(fn)
local check = vim.uv.new_check()
check:start(vim.schedule_wrap(function()
table.insert(self._threads, co)
Scheduler.add({ task = self, thread = co })
end
---@param co thread
function Task:_step(co)
local status = coroutine.status(co)
if status == "dead" then
check:stop()
self:_check()
elseif status == "suspended" then
if status == "suspended" then
local ok, res = coroutine.resume(co)
if not ok then
error(res)
self:notify_error(tostring(res))
elseif res then
self.status = res
self.output = self.output .. "\n" .. res
vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
self:notify(tostring(res))
end
end
end))
table.insert(self._running, function()
return check:is_active()
end)
end
---@private
function Task:_check()
for _, state in ipairs(self._running) do
if state() then
for _, t in ipairs(self._threads) do
if coroutine.status(t) ~= "dead" then
return
end
end
self:_done()
end
---@private
function Task:_done()
assert(self:has_started(), "task not started")
assert(not self:has_ended(), "task already done")
self._ended = vim.uv.hrtime()
if self._opts.on_done then
self._opts.on_done(self)
@ -147,29 +180,13 @@ function Task:time()
if not self:has_started() then
return 0
end
if not self:is_done() then
if not self:has_ended() then
return (vim.uv.hrtime() - self._started) / 1e6
end
return (self._ended - self._started) / 1e6
end
---@param fn fun()
function Task:schedule(fn)
local done = false
table.insert(self._running, function()
return not done
end)
vim.schedule(function()
---@type boolean, string|any
local ok, err = pcall(fn)
if not ok then
self.error = err or "failed"
end
done = true
self:_check()
end)
end
---@async
---@param cmd string
---@param opts? ProcessOpts
function Task:spawn(cmd, opts)
@ -178,6 +195,7 @@ function Task:spawn(cmd, opts)
local on_exit = opts.on_exit
function opts.on_line(line)
self:notify(line)
self.status = line
if on_line then
pcall(on_line, line)
@ -185,6 +203,7 @@ function Task:spawn(cmd, opts)
vim.api.nvim_exec_autocmds("User", { pattern = "LazyRender", modeline = false })
end
local running = true
---@param output string
function opts.on_exit(ok, output)
self.output = self.output .. output
@ -194,12 +213,12 @@ function Task:spawn(cmd, opts)
if on_exit then
pcall(on_exit, ok, output)
end
self:_check()
running = false
end
Process.spawn(cmd, opts)
while running do
coroutine.yield()
end
local proc = Process.spawn(cmd, opts)
table.insert(self._running, function()
return proc and not proc:is_closing()
end)
end
---@param tasks (LazyTask?)[]