PnaclCoordinator: Use llc's module-splitting for pexe compilation

ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.cc

 // 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 "native_client/src/trusted/desc/nacl_desc_wrapper.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 {
 
 PnaclTranslateThread::PnaclTranslateThread() : llc_subprocess_active_(false),
                                                ld_subprocess_active_(false),
                                                done_(false),
                                                time_stats_(),
                                                manifest_(NULL),
-                                               obj_file_(NULL),
+                                               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 Manifest* manifest,
-    TempFile* obj_file,
+    const std::vector<TempFile*> *obj_files,
     TempFile* nexe_file,
     ErrorInfo* error_info,
     PnaclResources* resources,
     PnaclOptions* pnacl_options,
     PnaclCoordinator* coordinator,
-    Plugin* plugin) {
+    Plugin* plugin)  {
   PLUGIN_PRINTF(("PnaclStreamingTranslateThread::RunTranslate)\n"));
   manifest_ = manifest;
-  obj_file_ = obj_file;
+  obj_files_ = obj_files;
   nexe_file_ = nexe_file;
   coordinator_error_info_ = error_info;
   resources_ = resources;
   pnacl_options_ = pnacl_options;
   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;
@@ skipping 25 matching lines @@
   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.
+  // (count can be < the buffer size). This can be

[jvoung (off chromium), 2014/02/14 00:46:49]

 can be... ?

[Derek Schuff, 2014/02/14 01:01:51]

Done.

   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_);
@@ skipping 21 matching lines @@
 
 void WINAPI PnaclTranslateThread::DoTranslateThread(void* arg) {
   PnaclTranslateThread* translator =
       reinterpret_cast<PnaclTranslateThread*>(arg);
   translator->DoTranslate();
 }
 
 void PnaclTranslateThread::DoTranslate() {
   ErrorInfo error_info;
   SrpcParams params;
-  nacl::DescWrapper* llc_out_file = obj_file_->write_wrapper();
+  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(plugin_->wrapper_factory()->MakeInvalid());
+  }
 
   {
     nacl::MutexLocker ml(&subprocess_mu_);
     int64_t llc_start_time = NaClGetTimeOfDayMicroseconds();
     llc_subprocess_.reset(
       StartSubprocess(resources_->GetLlcUrl(), manifest_, &error_info));
     if (llc_subprocess_ == NULL) {
       TranslateFailed(ERROR_PNACL_LLC_SETUP,
                       "Compile process could not be created: " +
                       error_info.message());
       return;
     }
     llc_subprocess_active_ = true;
     time_stats_.pnacl_llc_load_time =
         (NaClGetTimeOfDayMicroseconds() - llc_start_time);
     // Run LLC.
     PluginReverseInterface* llc_reverse =
         llc_subprocess_->service_runtime()->rev_interface();
-    llc_reverse->AddTempQuotaManagedFile(obj_file_->identifier());
+    for (size_t i = 0; i < obj_files_->size(); i++) {
+      llc_reverse->AddTempQuotaManagedFile((*obj_files_)[i]->identifier());
+    }
   }
 
   int64_t compile_start_time = NaClGetTimeOfDayMicroseconds();
   bool init_success;
   std::vector<char> options = pnacl_options_->GetOptCommandline();
+  fprintf(stderr, "StreamInit split=%lu\n", obj_files_->size());
+
+  // Try to init with splitting
+  // 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
+  std::vector<char> split_args;
+  nacl::stringstream ss;
+  ss << "-split-module=" << obj_files_->size();
+  nacl::string split_arg = ss.str();
+  std::copy(split_arg.begin(), split_arg.end(), std::back_inserter(split_args));
+  split_args.push_back('\x00');
+  std::copy(options.begin(), options.end(), std::back_inserter(split_args));
+  int modules_used = static_cast<int>(obj_files_->size());
   init_success = llc_subprocess_->InvokeSrpcMethod(
-      "StreamInitWithOverrides",
-      "hC",
+      "StreamInitWithSplit",
+      "ihhhhhhhhhhhhhhhhC",
       &params,
-      llc_out_file->desc(),
-      &options[0],
-      options.size());
+      modules_used,
+      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) {
+    fprintf(stderr, "Falling back to StreamInitWithOverrides\n");
+    init_success = llc_subprocess_->InvokeSrpcMethod(
+        "StreamInitWithOverrides",
+        "hC",
+        &params,
+        llc_out_files[0]->desc(),
+        &options[0],
+        options.size());
+    modules_used = 1;
+  }
 
   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(ERROR_PNACL_LLC_INTERNAL,
                       nacl::string("Stream init failed: ") +
                       nacl::string(params.outs()[0]->arrays.str));
     } else {
       TranslateFailed(ERROR_PNACL_LLC_INTERNAL,
@@ skipping 74 matching lines @@
                  " is_shared_library=%d, soname='%s', lib_dependencies='%s')\n",
                  this, is_shared_library, soname.c_str(),
                  lib_dependencies.c_str()));
 
   // Shut down the llc subprocess.
   NaClXMutexLock(&subprocess_mu_);
   llc_subprocess_active_ = false;
   llc_subprocess_.reset(NULL);
   NaClXMutexUnlock(&subprocess_mu_);
 
-  if(!RunLdSubprocess(is_shared_library, soname, lib_dependencies)) {
+  if(!RunLdSubprocess(modules_used, is_shared_library, soname, lib_dependencies)) {
     return;
   }
   core->CallOnMainThread(0, report_translate_finished_, PP_OK);
 }
 
-bool PnaclTranslateThread::RunLdSubprocess(int is_shared_library,
+bool PnaclTranslateThread::RunLdSubprocess(int modules_used,
+                                           int is_shared_library,
                                            const nacl::string& soname,
                                            const nacl::string& lib_dependencies
                                            ) {
   ErrorInfo error_info;
   SrpcParams params;
-  // Reset object file for reading first.
-  if (!obj_file_->Reset()) {
-    TranslateFailed(ERROR_PNACL_LD_SETUP,
-                    "Link process could not reset object file");
-    return false;
+
+  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(ERROR_PNACL_LD_SETUP,
+                      "Link process could not reset object file");
+      return false;
+    }
+    ld_in_files.push_back((*obj_files_)[i]->read_wrapper());
   }
-  nacl::DescWrapper* ld_in_file = obj_file_->read_wrapper();
+  for (; i < PnaclCoordinator::kMaxTranslatorObjectFiles; i++) {
+    ld_in_files.push_back(plugin_->wrapper_factory()->MakeInvalid());
+  }
+
   nacl::DescWrapper* ld_out_file = nexe_file_->write_wrapper();
 
   {
     // Create LD process
     nacl::MutexLocker ml(&subprocess_mu_);
     int64_t ld_start_time = NaClGetTimeOfDayMicroseconds();
     ld_subprocess_.reset(
       StartSubprocess(resources_->GetLdUrl(), manifest_, &error_info));
     if (ld_subprocess_ == NULL) {
       TranslateFailed(ERROR_PNACL_LD_SETUP,
                       "Link process could not be created: " +
                       error_info.message());
       return false;
     }
     ld_subprocess_active_ = true;
     time_stats_.pnacl_ld_load_time =
         (NaClGetTimeOfDayMicroseconds() - ld_start_time);
     PluginReverseInterface* ld_reverse =
         ld_subprocess_->service_runtime()->rev_interface();
     ld_reverse->AddTempQuotaManagedFile(nexe_file_->identifier());
   }
 
   int64_t link_start_time = NaClGetTimeOfDayMicroseconds();
   // Run LD.
-  if (!ld_subprocess_->InvokeSrpcMethod("RunWithDefaultCommandLine",
-                                       "hhiss",
-                                       &params,
-                                       ld_in_file->desc(),
-                                       ld_out_file->desc(),
-                                       is_shared_library,
-                                       soname.c_str(),
-                                       lib_dependencies.c_str())) {
+  bool success;
+  // If we ran LLC with module splitting, we can't fall back here.
+  if (modules_used > 1) {
+    success = ld_subprocess_->InvokeSrpcMethod("RunWithSplit",
+                                               "ihhhhhhhhhhhhhhhhh",
+                                               &params,
+                                               modules_used,
+                                               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());
+  } else {
+    success = ld_subprocess_->InvokeSrpcMethod("RunWithDefaultCommandLine",
+                                               "hhiss",
+                                               &params,
+                                               ld_in_files[0]->desc(),
+                                               ld_out_file->desc(),
+                                               is_shared_library,
+                                               soname.c_str(),
+                                               lib_dependencies.c_str());
+  }
+  if (!success) {
     TranslateFailed(ERROR_PNACL_LD_INTERNAL,
                     "link failed.");
     return false;
   }
   time_stats_.pnacl_link_time =
       NaClGetTimeOfDayMicroseconds() - link_start_time;
   PLUGIN_PRINTF(("PnaclCoordinator: link (translator=%p) succeeded\n",
                  this));
   // Shut down the ld subprocess.
   NaClXMutexLock(&subprocess_mu_);
@@ skipping 43 matching lines @@
   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