void wake_all_waiters() {
thread::Mutex::LockGuard guard(mutex_);
should_stop_ = false;
// For ourself..
pending_threads_++;
waiting_to_run_.broadcast();
}
void wake_all_waiters(THREAD) {
thread::Mutex::LockGuard guard(mutex_);
should_stop_ = false;
if(cDebugThreading) {
std::cerr << "[" << VM::current() << " WORLD waking all threads]\n";
}
if(state->run_state_ != ManagedThread::eAlone) {
rubinius::bug("A non-alone thread is trying to wake all");
}
// For ourself..
pending_threads_++;
waiting_to_run_.broadcast();
state->run_state_ = ManagedThread::eRunning;
}
virtual void perform() {
set_name("rbx.jit");
ManagedThread::set_current(ls_);
#ifndef RBX_WINDOWS
sigset_t set;
sigfillset(&set);
pthread_sigmask(SIG_SETMASK, &set, NULL);
#endif
for(;;) { // forever
BackgroundCompileRequest* req = 0;
// Lock, wait, get a request, unlock
{
thread::Mutex::LockGuard guard(mutex_);
if(pause_) {
state = cPaused;
paused_ = true;
pause_condition_.broadcast();
while(pause_) {
condition_.wait(mutex_);
}
state = cUnknown;
paused_ = false;
}
// If we've been asked to stop, do so now.
if(stop_) return;
while(pending_requests_.empty()) {
state = cIdle;
// unlock and wait...
condition_.wait(mutex_);
if(stop_) return;
}
// now locked again, shift a request
req = pending_requests_.front();
state = cRunning;
}
// This isn't ideal, but it's the safest. Keep the GC from
// running while we're building the IR.
ls_->shared().gc_dependent(ls_);
// mutex now unlock, allowing others to push more requests
//
current_req_ = req;
jit::Compiler jit(ls_);
current_compiler_ = &jit;
int spec_id = 0;
if(Class* cls = req->receiver_class()) {
spec_id = cls->class_id();
}
void* func = 0;
{
timer::Running<1000000> timer(ls_->shared().stats.jit_time_spent);
jit.compile(ls_, req);
func = jit.generate_function(ls_);
}
// We were unable to compile this function, likely
// because it's got something we don't support.
if(!func) {
if(ls_->config().jit_show_compiling) {
llvm::outs() << "[[[ JIT error in background compiling ]]]\n";
}
// If someone was waiting on this, wake them up.
if(thread::Condition* cond = req->waiter()) {
cond->signal();
}
current_req_ = 0;
current_compiler_ = 0;
pending_requests_.pop_front();
delete req;
// We don't depend on the GC here, so let it run independent
// of us.
ls_->shared().gc_independent(ls_);
continue;
}
if(show_machine_code_) {
jit.show_machine_code();
}
// If the method has had jit'ing request disabled since we started
// JIT'ing it, discard our work.
if(!req->vmmethod()->jit_disabled()) {
jit::RuntimeDataHolder* rd = jit.context().runtime_data_holder();
ls_->start_method_update();
if(!req->is_block()) {
if(spec_id) {
req->method()->add_specialized(spec_id, reinterpret_cast<executor>(func), rd);
} else {
req->method()->set_unspecialized(reinterpret_cast<executor>(func), rd);
}
} else {
req->method()->set_unspecialized(reinterpret_cast<executor>(func), rd);
}
assert(req->method()->jit_data());
ls_->end_method_update();
rd->run_write_barrier(ls_->write_barrier(), req->method());
ls_->shared().stats.jitted_methods++;
if(ls_->config().jit_show_compiling) {
llvm::outs() << "[[[ JIT finished background compiling "
<< (req->is_block() ? " (block)" : " (method)")
<< " ]]]\n";
}
}
// If someone was waiting on this, wake them up.
if(thread::Condition* cond = req->waiter()) {
cond->signal();
}
current_req_ = 0;
current_compiler_ = 0;
pending_requests_.pop_front();
delete req;
// We don't depend on the GC here, so let it run independent
// of us.
ls_->shared().gc_independent(ls_);
}
}