Home | History | Annotate | Download | only in Renderscript 
      1 /*
      2  * Copyright 2012, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "bcc/Renderscript/RSCompilerDriver.h"
     18 
     19 #include <llvm/IR/Module.h>
     20 #include <llvm/Support/CommandLine.h>
     21 #include <llvm/Support/Path.h>
     22 #include <llvm/Support/raw_ostream.h>
     23 
     24 #include "bcinfo/BitcodeWrapper.h"
     25 
     26 #include "bcc/Compiler.h"
     27 #include "bcc/Renderscript/RSExecutable.h"
     28 #include "bcc/Renderscript/RSScript.h"
     29 #include "bcc/Support/CompilerConfig.h"
     30 #include "bcc/Support/TargetCompilerConfigs.h"
     31 #include "bcc/Source.h"
     32 #include "bcc/Support/FileMutex.h"
     33 #include "bcc/Support/Log.h"
     34 #include "bcc/Support/InputFile.h"
     35 #include "bcc/Support/Initialization.h"
     36 #include "bcc/Support/Sha1Util.h"
     37 #include "bcc/Support/OutputFile.h"
     38 
     39 #ifdef HAVE_ANDROID_OS
     40 #include <cutils/properties.h>
     41 #endif
     42 #include <utils/String8.h>
     43 #include <utils/StopWatch.h>
     44 
     45 using namespace bcc;
     46 
     47 RSCompilerDriver::RSCompilerDriver(bool pUseCompilerRT) :
     48     mConfig(NULL), mCompiler(), mCompilerRuntime(NULL), mDebugContext(false),
     49     mEnableGlobalMerge(true) {
     50   init::Initialize();
     51   // Chain the symbol resolvers for compiler_rt and RS runtimes.
     52   if (pUseCompilerRT) {
     53     mCompilerRuntime = new CompilerRTSymbolResolver();
     54     mResolver.chainResolver(*mCompilerRuntime);
     55   }
     56   mResolver.chainResolver(mRSRuntime);
     57 }
     58 
     59 RSCompilerDriver::~RSCompilerDriver() {
     60   delete mCompilerRuntime;
     61   delete mConfig;
     62 }
     63 
     64 RSExecutable *
     65 RSCompilerDriver::loadScript(const char *pCacheDir, const char *pResName,
     66                              const char *pBitcode, size_t pBitcodeSize) {
     67   //android::StopWatch load_time("bcc: RSCompilerDriver::loadScript time");
     68   if ((pCacheDir == NULL) || (pResName == NULL)) {
     69     ALOGE("Missing pCacheDir and/or pResName");
     70     return NULL;
     71   }
     72 
     73   if ((pBitcode == NULL) || (pBitcodeSize <= 0)) {
     74     ALOGE("No bitcode supplied! (bitcode: %p, size of bitcode: %zu)",
     75           pBitcode, pBitcodeSize);
     76     return NULL;
     77   }
     78 
     79   RSInfo::DependencyTableTy dep_info;
     80   uint8_t bitcode_sha1[20];
     81   Sha1Util::GetSHA1DigestFromBuffer(bitcode_sha1, pBitcode, pBitcodeSize);
     82 
     83   // {pCacheDir}/{pResName}.o
     84   llvm::SmallString<80> output_path(pCacheDir);
     85   llvm::sys::path::append(output_path, pResName);
     86   llvm::sys::path::replace_extension(output_path, ".o");
     87 
     88   dep_info.push(std::make_pair(output_path.c_str(), bitcode_sha1));
     89 
     90   //===--------------------------------------------------------------------===//
     91   // Acquire the read lock for reading the Script object file.
     92   //===--------------------------------------------------------------------===//
     93   FileMutex<FileBase::kReadLock> read_output_mutex(output_path.c_str());
     94 
     95   if (read_output_mutex.hasError() || !read_output_mutex.lock()) {
     96     ALOGE("Unable to acquire the read lock for %s! (%s)", output_path.c_str(),
     97           read_output_mutex.getErrorMessage().c_str());
     98     return NULL;
     99   }
    100 
    101   //===--------------------------------------------------------------------===//
    102   // Read the output object file.
    103   //===--------------------------------------------------------------------===//
    104   InputFile *object_file = new (std::nothrow) InputFile(output_path.c_str());
    105 
    106   if ((object_file == NULL) || object_file->hasError()) {
    107       //      ALOGE("Unable to open the %s for read! (%s)", output_path.c_str(),
    108       //            object_file->getErrorMessage().c_str());
    109     delete object_file;
    110     return NULL;
    111   }
    112 
    113   //===--------------------------------------------------------------------===//
    114   // Acquire the read lock on object_file for reading its RS info file.
    115   //===--------------------------------------------------------------------===//
    116   android::String8 info_path = RSInfo::GetPath(output_path.c_str());
    117 
    118   if (!object_file->lock()) {
    119     ALOGE("Unable to acquire the read lock on %s for reading %s! (%s)",
    120           output_path.c_str(), info_path.string(),
    121           object_file->getErrorMessage().c_str());
    122     delete object_file;
    123     return NULL;
    124   }
    125 
    126  //===---------------------------------------------------------------------===//
    127   // Open and load the RS info file.
    128   //===--------------------------------------------------------------------===//
    129   InputFile info_file(info_path.string());
    130   RSInfo *info = RSInfo::ReadFromFile(info_file, dep_info);
    131 
    132   // Release the lock on object_file.
    133   object_file->unlock();
    134 
    135   if (info == NULL) {
    136     delete object_file;
    137     return NULL;
    138   }
    139 
    140   //===--------------------------------------------------------------------===//
    141   // Create the RSExecutable.
    142   //===--------------------------------------------------------------------===//
    143   RSExecutable *result = RSExecutable::Create(*info, *object_file, mResolver);
    144   if (result == NULL) {
    145     delete object_file;
    146     delete info;
    147     return NULL;
    148   }
    149 
    150   return result;
    151 }
    152 
    153 #if defined(DEFAULT_ARM_CODEGEN)
    154 extern llvm::cl::opt<bool> EnableGlobalMerge;
    155 #endif
    156 
    157 bool RSCompilerDriver::setupConfig(const RSScript &pScript) {
    158   bool changed = false;
    159 
    160   const llvm::CodeGenOpt::Level script_opt_level =
    161       static_cast<llvm::CodeGenOpt::Level>(pScript.getOptimizationLevel());
    162 
    163   if (mConfig != NULL) {
    164     // Renderscript bitcode may have their optimization flag configuration
    165     // different than the previous run of RS compilation.
    166     if (mConfig->getOptimizationLevel() != script_opt_level) {
    167       mConfig->setOptimizationLevel(script_opt_level);
    168       changed = true;
    169     }
    170   } else {
    171     // Haven't run the compiler ever.
    172     mConfig = new (std::nothrow) DefaultCompilerConfig();
    173     if (mConfig == NULL) {
    174       // Return false since mConfig remains NULL and out-of-memory.
    175       return false;
    176     }
    177     mConfig->setOptimizationLevel(script_opt_level);
    178 #if defined(DEFAULT_ARM_CODEGEN)
    179     EnableGlobalMerge = mEnableGlobalMerge;
    180 #endif
    181     changed = true;
    182   }
    183 
    184 #if defined(DEFAULT_ARM_CODEGEN)
    185   // NEON should be disable when full-precision floating point is required.
    186   assert((pScript.getInfo() != NULL) && "NULL RS info!");
    187   if (pScript.getInfo()->getFloatPrecisionRequirement() == RSInfo::FP_Full) {
    188     // Must be ARMCompilerConfig.
    189     ARMCompilerConfig *arm_config = static_cast<ARMCompilerConfig *>(mConfig);
    190     changed |= arm_config->enableNEON(/* pEnable */false);
    191   }
    192 #endif
    193 
    194   return changed;
    195 }
    196 
    197 Compiler::ErrorCode
    198 RSCompilerDriver::compileScript(RSScript &pScript,
    199                                 const char* pScriptName,
    200                                 const char *pOutputPath,
    201                                 const char *pRuntimePath,
    202                                 const RSInfo::DependencyTableTy &pDeps,
    203                                 bool pSkipLoad, bool pDumpIR) {
    204   //android::StopWatch compile_time("bcc: RSCompilerDriver::compileScript time");
    205   RSInfo *info = NULL;
    206 
    207   //===--------------------------------------------------------------------===//
    208   // Extract RS-specific information from source bitcode.
    209   //===--------------------------------------------------------------------===//
    210   // RS info may contains configuration (such as #optimization_level) to the
    211   // compiler therefore it should be extracted before compilation.
    212   info = RSInfo::ExtractFromSource(pScript.getSource(), pDeps);
    213   if (info == NULL) {
    214     return Compiler::kErrInvalidSource;
    215   }
    216 
    217   //===--------------------------------------------------------------------===//
    218   // Associate script with its info
    219   //===--------------------------------------------------------------------===//
    220   // This is required since RS compiler may need information in the info file
    221   // to do some transformation (e.g., expand foreach-able function.)
    222   pScript.setInfo(info);
    223 
    224   //===--------------------------------------------------------------------===//
    225   // Link RS script with Renderscript runtime.
    226   //===--------------------------------------------------------------------===//
    227   if (!RSScript::LinkRuntime(pScript, pRuntimePath)) {
    228     ALOGE("Failed to link script '%s' with Renderscript runtime!", pScriptName);
    229     return Compiler::kErrInvalidSource;
    230   }
    231 
    232   {
    233     // FIXME(srhines): Windows compilation can't use locking like this, but
    234     // we also don't need to worry about concurrent writers of the same file.
    235 #ifndef USE_MINGW
    236     //===------------------------------------------------------------------===//
    237     // Acquire the write lock for writing output object file.
    238     //===------------------------------------------------------------------===//
    239     FileMutex<FileBase::kWriteLock> write_output_mutex(pOutputPath);
    240 
    241     if (write_output_mutex.hasError() || !write_output_mutex.lock()) {
    242       ALOGE("Unable to acquire the lock for writing %s! (%s)",
    243             pOutputPath, write_output_mutex.getErrorMessage().c_str());
    244       return Compiler::kErrInvalidSource;
    245     }
    246 #endif
    247 
    248     // Open the output file for write.
    249     OutputFile output_file(pOutputPath,
    250                            FileBase::kTruncate | FileBase::kBinary);
    251 
    252     if (output_file.hasError()) {
    253         ALOGE("Unable to open %s for write! (%s)", pOutputPath,
    254               output_file.getErrorMessage().c_str());
    255       return Compiler::kErrInvalidSource;
    256     }
    257 
    258     // Setup the config to the compiler.
    259     bool compiler_need_reconfigure = setupConfig(pScript);
    260 
    261     if (mConfig == NULL) {
    262       ALOGE("Failed to setup config for RS compiler to compile %s!",
    263             pOutputPath);
    264       return Compiler::kErrInvalidSource;
    265     }
    266 
    267     if (compiler_need_reconfigure) {
    268       Compiler::ErrorCode err = mCompiler.config(*mConfig);
    269       if (err != Compiler::kSuccess) {
    270         ALOGE("Failed to config the RS compiler for %s! (%s)",pOutputPath,
    271               Compiler::GetErrorString(err));
    272         return Compiler::kErrInvalidSource;
    273       }
    274     }
    275 
    276     OutputFile *ir_file = NULL;
    277     llvm::raw_fd_ostream *IRStream = NULL;
    278     if (pDumpIR) {
    279       android::String8 path(pOutputPath);
    280       path.append(".ll");
    281       ir_file = new OutputFile(path.string(), FileBase::kTruncate);
    282       IRStream = ir_file->dup();
    283     }
    284 
    285     // Run the compiler.
    286     Compiler::ErrorCode compile_result = mCompiler.compile(pScript,
    287                                                            output_file, IRStream);
    288 
    289     if (ir_file) {
    290       ir_file->close();
    291       delete ir_file;
    292     }
    293 
    294     if (compile_result != Compiler::kSuccess) {
    295       ALOGE("Unable to compile the source to file %s! (%s)", pOutputPath,
    296             Compiler::GetErrorString(compile_result));
    297       return Compiler::kErrInvalidSource;
    298     }
    299   }
    300 
    301   // No need to produce an RSExecutable in this case.
    302   // TODO: Error handling in this case is nonexistent.
    303   if (pSkipLoad) {
    304     return Compiler::kSuccess;
    305   }
    306 
    307   {
    308     android::String8 info_path = RSInfo::GetPath(pOutputPath);
    309     OutputFile info_file(info_path.string(), FileBase::kTruncate);
    310 
    311     if (info_file.hasError()) {
    312       ALOGE("Failed to open the info file %s for write! (%s)",
    313             info_path.string(), info_file.getErrorMessage().c_str());
    314       return Compiler::kErrInvalidSource;
    315     }
    316 
    317     FileMutex<FileBase::kWriteLock> write_info_mutex(info_path.string());
    318     if (write_info_mutex.hasError() || !write_info_mutex.lock()) {
    319       ALOGE("Unable to acquire the lock for writing %s! (%s)",
    320             info_path.string(), write_info_mutex.getErrorMessage().c_str());
    321       return Compiler::kErrInvalidSource;
    322     }
    323 
    324     // Perform the write.
    325     if (!info->write(info_file)) {
    326       ALOGE("Failed to sync the RS info file %s!", info_path.string());
    327       return Compiler::kErrInvalidSource;
    328     }
    329   }
    330 
    331   return Compiler::kSuccess;
    332 }
    333 
    334 bool RSCompilerDriver::build(BCCContext &pContext,
    335                              const char *pCacheDir,
    336                              const char *pResName,
    337                              const char *pBitcode,
    338                              size_t pBitcodeSize,
    339                              const char *pRuntimePath,
    340                              RSLinkRuntimeCallback pLinkRuntimeCallback,
    341                              bool pDumpIR) {
    342     //  android::StopWatch build_time("bcc: RSCompilerDriver::build time");
    343   //===--------------------------------------------------------------------===//
    344   // Check parameters.
    345   //===--------------------------------------------------------------------===//
    346   if ((pCacheDir == NULL) || (pResName == NULL)) {
    347     ALOGE("Invalid parameter passed to RSCompilerDriver::build()! (cache dir: "
    348           "%s, resource name: %s)", ((pCacheDir) ? pCacheDir : "(null)"),
    349                                     ((pResName) ? pResName : "(null)"));
    350     return false;
    351   }
    352 
    353   if ((pBitcode == NULL) || (pBitcodeSize <= 0)) {
    354     ALOGE("No bitcode supplied! (bitcode: %p, size of bitcode: %u)",
    355           pBitcode, static_cast<unsigned>(pBitcodeSize));
    356     return false;
    357   }
    358 
    359   //===--------------------------------------------------------------------===//
    360   // Prepare dependency information.
    361   //===--------------------------------------------------------------------===//
    362   RSInfo::DependencyTableTy dep_info;
    363   uint8_t bitcode_sha1[20];
    364   Sha1Util::GetSHA1DigestFromBuffer(bitcode_sha1, pBitcode, pBitcodeSize);
    365 
    366   //===--------------------------------------------------------------------===//
    367   // Construct output path.
    368   // {pCacheDir}/{pResName}.o
    369   //===--------------------------------------------------------------------===//
    370   llvm::SmallString<80> output_path(pCacheDir);
    371   llvm::sys::path::append(output_path, pResName);
    372   llvm::sys::path::replace_extension(output_path, ".o");
    373 
    374   dep_info.push(std::make_pair(output_path.c_str(), bitcode_sha1));
    375 
    376   //===--------------------------------------------------------------------===//
    377   // Load the bitcode and create script.
    378   //===--------------------------------------------------------------------===//
    379   Source *source = Source::CreateFromBuffer(pContext, pResName,
    380                                             pBitcode, pBitcodeSize);
    381   if (source == NULL) {
    382     return false;
    383   }
    384 
    385   RSScript *script = new (std::nothrow) RSScript(*source);
    386   if (script == NULL) {
    387     ALOGE("Out of memory when create Script object for '%s'! (output: %s)",
    388           pResName, output_path.c_str());
    389     delete source;
    390     return false;
    391   }
    392 
    393   script->setLinkRuntimeCallback(pLinkRuntimeCallback);
    394 
    395   // Read information from bitcode wrapper.
    396   bcinfo::BitcodeWrapper wrapper(pBitcode, pBitcodeSize);
    397   script->setCompilerVersion(wrapper.getCompilerVersion());
    398   script->setOptimizationLevel(static_cast<RSScript::OptimizationLevel>(
    399                                    wrapper.getOptimizationLevel()));
    400 
    401   //===--------------------------------------------------------------------===//
    402   // Compile the script
    403   //===--------------------------------------------------------------------===//
    404   Compiler::ErrorCode status = compileScript(*script, pResName,
    405                                              output_path.c_str(),
    406                                              pRuntimePath, dep_info, false,
    407                                              pDumpIR);
    408 
    409   // Script is no longer used. Free it to get more memory.
    410   delete script;
    411 
    412   if (status != Compiler::kSuccess) {
    413     return false;
    414   }
    415 
    416   return true;
    417 }
    418 
    419 
    420 bool RSCompilerDriver::build(RSScript &pScript, const char *pOut,
    421                              const char *pRuntimePath) {
    422   RSInfo::DependencyTableTy dep_info;
    423   RSInfo *info = RSInfo::ExtractFromSource(pScript.getSource(), dep_info);
    424   if (info == NULL) {
    425     return false;
    426   }
    427   pScript.setInfo(info);
    428 
    429   // Embed the info string directly in the ELF, since this path is for an
    430   // offline (host) compilation.
    431   pScript.setEmbedInfo(true);
    432 
    433   Compiler::ErrorCode status = compileScript(pScript, pOut, pOut, pRuntimePath,
    434                                              dep_info, true);
    435   if (status != Compiler::kSuccess) {
    436     return false;
    437   }
    438 
    439   return true;
    440 }
    441 
    442