// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.h" #include <iterator> #include "native_client/src/trusted/desc/nacl_desc_wrapper.h" #include "ppapi/cpp/var.h" #include "ppapi/native_client/src/trusted/plugin/plugin.h" #include "ppapi/native_client/src/trusted/plugin/plugin_error.h" #include "ppapi/native_client/src/trusted/plugin/pnacl_resources.h" #include "ppapi/native_client/src/trusted/plugin/srpc_params.h" #include "ppapi/native_client/src/trusted/plugin/temporary_file.h" #include "ppapi/native_client/src/trusted/plugin/utility.h" namespace plugin { namespace { template <typename Val> nacl::string MakeCommandLineArg(const char* key, const Val val) { nacl::stringstream ss; ss << key << val; return ss.str(); } void GetLlcCommandLine(Plugin* plugin, std::vector<char>* split_args, size_t obj_files_size, int32_t opt_level, bool is_debug, const nacl::string &architecture_attributes) { typedef std::vector<nacl::string> Args; Args args; // TODO(dschuff): This CL override is ugly. Change llc to default to // using the number of modules specified in the first param, and // ignore multiple uses of -split-module args.push_back(MakeCommandLineArg("-split-module=", obj_files_size)); args.push_back(MakeCommandLineArg("-O=", opt_level)); if (is_debug) args.push_back("-bitcode-format=llvm"); if (!architecture_attributes.empty()) args.push_back("-mattr=" + architecture_attributes); for (Args::const_iterator arg(args.begin()); arg != args.end(); ++arg) { std::copy(arg->begin(), arg->end(), std::back_inserter(*split_args)); split_args->push_back('\x00'); } } } // namespace PnaclTranslateThread::PnaclTranslateThread() : llc_subprocess_active_(false), ld_subprocess_active_(false), subprocesses_aborted_(false), done_(false), compile_time_(0), obj_files_(NULL), nexe_file_(NULL), coordinator_error_info_(NULL), resources_(NULL), coordinator_(NULL), plugin_(NULL) { NaClXMutexCtor(&subprocess_mu_); NaClXMutexCtor(&cond_mu_); NaClXCondVarCtor(&buffer_cond_); } void PnaclTranslateThread::RunTranslate( const pp::CompletionCallback& finish_callback, const std::vector<TempFile*>* obj_files, TempFile* nexe_file, nacl::DescWrapper* invalid_desc_wrapper, ErrorInfo* error_info, PnaclResources* resources, PP_PNaClOptions* pnacl_options, const nacl::string &architecture_attributes, PnaclCoordinator* coordinator, Plugin* plugin) { PLUGIN_PRINTF(("PnaclStreamingTranslateThread::RunTranslate)\n")); obj_files_ = obj_files; nexe_file_ = nexe_file; invalid_desc_wrapper_ = invalid_desc_wrapper; coordinator_error_info_ = error_info; resources_ = resources; pnacl_options_ = pnacl_options; architecture_attributes_ = architecture_attributes; coordinator_ = coordinator; plugin_ = plugin; // Invoke llc followed by ld off the main thread. This allows use of // blocking RPCs that would otherwise block the JavaScript main thread. report_translate_finished_ = finish_callback; translate_thread_.reset(new NaClThread); if (translate_thread_ == NULL) { TranslateFailed(PP_NACL_ERROR_PNACL_THREAD_CREATE, "could not allocate thread struct."); return; } const int32_t kArbitraryStackSize = 128 * 1024; if (!NaClThreadCreateJoinable(translate_thread_.get(), DoTranslateThread, this, kArbitraryStackSize)) { TranslateFailed(PP_NACL_ERROR_PNACL_THREAD_CREATE, "could not create thread."); translate_thread_.reset(NULL); } } // Called from main thread to send bytes to the translator. void PnaclTranslateThread::PutBytes(std::vector<char>* bytes, int count) { PLUGIN_PRINTF(("PutBytes (this=%p, bytes=%p, size=%" NACL_PRIuS ", count=%d)\n", this, bytes, bytes ? bytes->size() : 0, count)); size_t buffer_size = 0; // If we are done (error or not), Signal the translation thread to stop. if (count <= PP_OK) { NaClXMutexLock(&cond_mu_); done_ = true; NaClXCondVarSignal(&buffer_cond_); NaClXMutexUnlock(&cond_mu_); return; } CHECK(bytes != NULL); // Ensure that the buffer we send to the translation thread is the right size // (count can be < the buffer size). This can be done without the lock. buffer_size = bytes->size(); bytes->resize(count); NaClXMutexLock(&cond_mu_); data_buffers_.push_back(std::vector<char>()); bytes->swap(data_buffers_.back()); // Avoid copying the buffer data. NaClXCondVarSignal(&buffer_cond_); NaClXMutexUnlock(&cond_mu_); // Ensure the buffer we send back to the coordinator is the expected size bytes->resize(buffer_size); } void WINAPI PnaclTranslateThread::DoTranslateThread(void* arg) { PnaclTranslateThread* translator = reinterpret_cast<PnaclTranslateThread*>(arg); translator->DoTranslate(); } void PnaclTranslateThread::DoTranslate() { ErrorInfo error_info; SrpcParams params; std::vector<nacl::DescWrapper*> llc_out_files; size_t i; for (i = 0; i < obj_files_->size(); i++) llc_out_files.push_back((*obj_files_)[i]->write_wrapper()); for (; i < PnaclCoordinator::kMaxTranslatorObjectFiles; i++) llc_out_files.push_back(invalid_desc_wrapper_); pp::Core* core = pp::Module::Get()->core(); int64_t llc_start_time = NaClGetTimeOfDayMicroseconds(); PP_FileHandle llc_file_handle = resources_->TakeLlcFileHandle(); // On success, ownership of llc_file_handle is transferred. NaClSubprocess* llc_subprocess = plugin_->LoadHelperNaClModule( resources_->GetLlcUrl(), llc_file_handle, &error_info); if (llc_subprocess == NULL) { if (llc_file_handle != PP_kInvalidFileHandle) CloseFileHandle(llc_file_handle); TranslateFailed(PP_NACL_ERROR_PNACL_LLC_SETUP, "Compile process could not be created: " + error_info.message()); return; } GetNaClInterface()->LogTranslateTime( "NaCl.Perf.PNaClLoadTime.LoadCompiler", NaClGetTimeOfDayMicroseconds() - llc_start_time); { nacl::MutexLocker ml(&subprocess_mu_); // If we received a call to AbortSubprocesses() before we had a chance to // set llc_subprocess_, shut down and clean up the subprocess started here. if (subprocesses_aborted_) { llc_subprocess->service_runtime()->Shutdown(); delete llc_subprocess; return; } llc_subprocess_.reset(llc_subprocess); llc_subprocess = NULL; llc_subprocess_active_ = true; } int64_t compile_start_time = NaClGetTimeOfDayMicroseconds(); bool init_success; std::vector<char> split_args; GetLlcCommandLine(plugin_, &split_args, obj_files_->size(), pnacl_options_->opt_level, pnacl_options_->is_debug, architecture_attributes_); init_success = llc_subprocess_->InvokeSrpcMethod( "StreamInitWithSplit", "ihhhhhhhhhhhhhhhhC", ¶ms, static_cast<int>(obj_files_->size()), llc_out_files[0]->desc(), llc_out_files[1]->desc(), llc_out_files[2]->desc(), llc_out_files[3]->desc(), llc_out_files[4]->desc(), llc_out_files[5]->desc(), llc_out_files[6]->desc(), llc_out_files[7]->desc(), llc_out_files[8]->desc(), llc_out_files[9]->desc(), llc_out_files[10]->desc(), llc_out_files[11]->desc(), llc_out_files[12]->desc(), llc_out_files[13]->desc(), llc_out_files[14]->desc(), llc_out_files[15]->desc(), &split_args[0], split_args.size()); if (!init_success) { if (llc_subprocess_->srpc_client()->GetLastError() == NACL_SRPC_RESULT_APP_ERROR) { // The error message is only present if the error was returned from llc TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL, nacl::string("Stream init failed: ") + nacl::string(params.outs()[0]->arrays.str)); } else { TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL, "Stream init internal error"); } return; } PLUGIN_PRINTF(("PnaclCoordinator: StreamInit successful\n")); // llc process is started. while(!done_ || data_buffers_.size() > 0) { NaClXMutexLock(&cond_mu_); while(!done_ && data_buffers_.size() == 0) { NaClXCondVarWait(&buffer_cond_, &cond_mu_); } PLUGIN_PRINTF(("PnaclTranslateThread awake (done=%d, size=%" NACL_PRIuS ")\n", done_, data_buffers_.size())); if (data_buffers_.size() > 0) { std::vector<char> data; data.swap(data_buffers_.front()); data_buffers_.pop_front(); NaClXMutexUnlock(&cond_mu_); PLUGIN_PRINTF(("StreamChunk\n")); if (!llc_subprocess_->InvokeSrpcMethod("StreamChunk", "C", ¶ms, &data[0], data.size())) { if (llc_subprocess_->srpc_client()->GetLastError() != NACL_SRPC_RESULT_APP_ERROR) { // If the error was reported by the translator, then we fall through // and call StreamEnd, which returns a string describing the error, // which we can then send to the Javascript console. Otherwise just // fail here, since the translator has probably crashed or asserted. TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL, "Compile stream chunk failed. " "The PNaCl translator has probably crashed."); return; } break; } else { PLUGIN_PRINTF(("StreamChunk Successful\n")); core->CallOnMainThread( 0, coordinator_->GetCompileProgressCallback(data.size()), PP_OK); } } else { NaClXMutexUnlock(&cond_mu_); } } PLUGIN_PRINTF(("PnaclTranslateThread done with chunks\n")); // Finish llc. if (!llc_subprocess_->InvokeSrpcMethod("StreamEnd", std::string(), ¶ms)) { PLUGIN_PRINTF(("PnaclTranslateThread StreamEnd failed\n")); if (llc_subprocess_->srpc_client()->GetLastError() == NACL_SRPC_RESULT_APP_ERROR) { // The error string is only present if the error was sent back from llc. TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL, params.outs()[3]->arrays.str); } else { TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL, "Compile StreamEnd internal error"); } return; } compile_time_ = NaClGetTimeOfDayMicroseconds() - compile_start_time; GetNaClInterface()->LogTranslateTime("NaCl.Perf.PNaClLoadTime.CompileTime", compile_time_); // Shut down the llc subprocess. NaClXMutexLock(&subprocess_mu_); llc_subprocess_active_ = false; llc_subprocess_.reset(NULL); NaClXMutexUnlock(&subprocess_mu_); if(!RunLdSubprocess()) { return; } core->CallOnMainThread(0, report_translate_finished_, PP_OK); } bool PnaclTranslateThread::RunLdSubprocess() { ErrorInfo error_info; SrpcParams params; std::vector<nacl::DescWrapper*> ld_in_files; size_t i; for (i = 0; i < obj_files_->size(); i++) { // Reset object file for reading first. if (!(*obj_files_)[i]->Reset()) { TranslateFailed(PP_NACL_ERROR_PNACL_LD_SETUP, "Link process could not reset object file"); return false; } ld_in_files.push_back((*obj_files_)[i]->read_wrapper()); } for (; i < PnaclCoordinator::kMaxTranslatorObjectFiles; i++) ld_in_files.push_back(invalid_desc_wrapper_); nacl::DescWrapper* ld_out_file = nexe_file_->write_wrapper(); int64_t ld_start_time = NaClGetTimeOfDayMicroseconds(); PP_FileHandle ld_file_handle = resources_->TakeLdFileHandle(); // On success, ownership of ld_file_handle is transferred. nacl::scoped_ptr<NaClSubprocess> ld_subprocess( plugin_->LoadHelperNaClModule(resources_->GetLlcUrl(), ld_file_handle, &error_info)); if (ld_subprocess.get() == NULL) { if (ld_file_handle != PP_kInvalidFileHandle) CloseFileHandle(ld_file_handle); TranslateFailed(PP_NACL_ERROR_PNACL_LD_SETUP, "Link process could not be created: " + error_info.message()); return false; } GetNaClInterface()->LogTranslateTime( "NaCl.Perf.PNaClLoadTime.LoadLinker", NaClGetTimeOfDayMicroseconds() - ld_start_time); { nacl::MutexLocker ml(&subprocess_mu_); // If we received a call to AbortSubprocesses() before we had a chance to // set llc_subprocess_, shut down and clean up the subprocess started here. if (subprocesses_aborted_) { ld_subprocess->service_runtime()->Shutdown(); return false; } DCHECK(ld_subprocess_.get() == NULL); ld_subprocess_.swap(ld_subprocess); ld_subprocess_active_ = true; } int64_t link_start_time = NaClGetTimeOfDayMicroseconds(); // Run LD. bool success = ld_subprocess_->InvokeSrpcMethod( "RunWithSplit", "ihhhhhhhhhhhhhhhhh", ¶ms, static_cast<int>(obj_files_->size()), ld_in_files[0]->desc(), ld_in_files[1]->desc(), ld_in_files[2]->desc(), ld_in_files[3]->desc(), ld_in_files[4]->desc(), ld_in_files[5]->desc(), ld_in_files[6]->desc(), ld_in_files[7]->desc(), ld_in_files[8]->desc(), ld_in_files[9]->desc(), ld_in_files[10]->desc(), ld_in_files[11]->desc(), ld_in_files[12]->desc(), ld_in_files[13]->desc(), ld_in_files[14]->desc(), ld_in_files[15]->desc(), ld_out_file->desc()); if (!success) { TranslateFailed(PP_NACL_ERROR_PNACL_LD_INTERNAL, "link failed."); return false; } GetNaClInterface()->LogTranslateTime( "NaCl.Perf.PNaClLoadTime.LinkTime", NaClGetTimeOfDayMicroseconds() - link_start_time); PLUGIN_PRINTF(("PnaclCoordinator: link (translator=%p) succeeded\n", this)); // Shut down the ld subprocess. NaClXMutexLock(&subprocess_mu_); ld_subprocess_active_ = false; ld_subprocess_.reset(NULL); NaClXMutexUnlock(&subprocess_mu_); return true; } void PnaclTranslateThread::TranslateFailed( PP_NaClError err_code, const nacl::string& error_string) { PLUGIN_PRINTF(("PnaclTranslateThread::TranslateFailed (error_string='%s')\n", error_string.c_str())); pp::Core* core = pp::Module::Get()->core(); if (coordinator_error_info_->message().empty()) { // Only use our message if one hasn't already been set by the coordinator // (e.g. pexe load failed). coordinator_error_info_->SetReport(err_code, nacl::string("PnaclCoordinator: ") + error_string); } core->CallOnMainThread(0, report_translate_finished_, PP_ERROR_FAILED); } void PnaclTranslateThread::AbortSubprocesses() { PLUGIN_PRINTF(("PnaclTranslateThread::AbortSubprocesses\n")); NaClXMutexLock(&subprocess_mu_); if (llc_subprocess_ != NULL && llc_subprocess_active_) { llc_subprocess_->service_runtime()->Shutdown(); llc_subprocess_active_ = false; } if (ld_subprocess_ != NULL && ld_subprocess_active_) { ld_subprocess_->service_runtime()->Shutdown(); ld_subprocess_active_ = false; } subprocesses_aborted_ = true; NaClXMutexUnlock(&subprocess_mu_); nacl::MutexLocker ml(&cond_mu_); done_ = true; // Free all buffered bitcode chunks data_buffers_.clear(); NaClXCondVarSignal(&buffer_cond_); } PnaclTranslateThread::~PnaclTranslateThread() { PLUGIN_PRINTF(("~PnaclTranslateThread (translate_thread=%p)\n", this)); AbortSubprocesses(); if (translate_thread_ != NULL) NaClThreadJoin(translate_thread_.get()); PLUGIN_PRINTF(("~PnaclTranslateThread joined\n")); NaClCondVarDtor(&buffer_cond_); NaClMutexDtor(&cond_mu_); NaClMutexDtor(&subprocess_mu_); } } // namespace plugin