void initialize() {
save_stack_info();
initialize_util_module();
initialize_numerics_module();
initialize_sexpr_module();
initialize_kernel_module();
initialize_inductive_module();
initialize_quotient_module();
init_default_print_fn();
initialize_library_module();
initialize_tactic_module();
initialize_definitional_module();
initialize_frontend_lean_module();
register_modules();
}
void initialize() {
save_stack_info();
initialize_util_module();
initialize_numerics_module();
initialize_sexpr_module();
initialize_kernel_module();
initialize_inductive_module();
initialize_quotient_module();
init_default_print_fn();
initialize_library_core_module();
initialize_vm_core_module();
initialize_library_module();
initialize_compiler_module();
initialize_tactic_module();
initialize_constructions_module();
initialize_equations_compiler_module();
initialize_inductive_compiler_module();
initialize_frontend_lean_module();
initialize_vm_module();
}
void check_stack(char const * component_name) {
if (!g_stack_info_init)
save_stack_info(false);
if (get_used_stack_size() + LEAN_MIN_STACK_SPACE > g_stack_size)
throw stack_space_exception(component_name);
}
void mt_task_queue::spawn_worker() {
lean_always_assert(!m_shutting_down);
auto this_worker = std::make_shared<worker_info>();
m_workers.push_back(this_worker);
m_required_workers--;
this_worker->m_thread.reset(new lthread([this, this_worker]() {
save_stack_info(false);
unique_lock<mutex> lock(m_mutex);
while (true) {
if (m_shutting_down) {
break;
}
if (m_required_workers < 0) {
scoped_add<int> inc_required(m_required_workers, +1);
scoped_add<unsigned> inc_sleeping(m_sleeping_workers, +1);
if (m_wake_up_worker.wait_for(lock, g_worker_max_idle_time,
[&] { return m_required_workers >= 1 || m_shutting_down; })) {
continue;
} else {
break;
}
}
if (m_queue.empty()) {
if (m_queue_added.wait_for(lock, g_worker_max_idle_time,
[&] { return !m_queue.empty() || m_shutting_down; })) {
continue;
} else {
break;
}
}
auto t = dequeue();
if (get_state(t).load() != task_state::Queued) continue;
get_state(t) = task_state::Running;
reset_heartbeat();
{
flet<gtask> _(this_worker->m_current_task, t);
scoped_current_task scope_cur_task(&t);
notify_queue_changed();
lock.unlock();
execute(t);
lock.lock();
}
reset_heartbeat();
handle_finished(t);
notify_queue_changed();
}
// We need to run the finalizers while the lock is held,
// otherwise we risk a race condition at the end of the program.
// We would finalize in the thread, while we call the finalize() function.
run_thread_finalizers();
run_post_thread_finalizers();
m_workers.erase(std::find(m_workers.begin(), m_workers.end(), this_worker));
m_required_workers++;
m_shut_down_cv.notify_all();
}));
}
