RSCompilerDriver.cpp revision b10c3a7d91556ef31ce91ef018fee4722b783960
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 45using namespace bcc; 46 47RSCompilerDriver::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 59RSCompilerDriver::~RSCompilerDriver() { 60 delete mCompilerRuntime; 61 delete mConfig; 62} 63 64RSExecutable * 65RSCompilerDriver::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) 154extern llvm::cl::opt<bool> EnableGlobalMerge; 155#endif 156 157bool 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 197Compiler::ErrorCode 198RSCompilerDriver::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 // Acquire the write lock for writing output object file. 234 FileMutex<FileBase::kWriteLock> write_output_mutex(pOutputPath); 235 236 if (write_output_mutex.hasError() || !write_output_mutex.lock()) { 237 ALOGE("Unable to acquire the lock for writing %s! (%s)", 238 pOutputPath, write_output_mutex.getErrorMessage().c_str()); 239 return Compiler::kErrInvalidSource; 240 } 241 242 // Open the output file for write. 243 OutputFile output_file(pOutputPath, FileBase::kTruncate); 244 245 if (output_file.hasError()) { 246 ALOGE("Unable to open %s for write! (%s)", pOutputPath, 247 output_file.getErrorMessage().c_str()); 248 return Compiler::kErrInvalidSource; 249 } 250 251 // Setup the config to the compiler. 252 bool compiler_need_reconfigure = setupConfig(pScript); 253 254 if (mConfig == NULL) { 255 ALOGE("Failed to setup config for RS compiler to compile %s!", 256 pOutputPath); 257 return Compiler::kErrInvalidSource; 258 } 259 260 if (compiler_need_reconfigure) { 261 Compiler::ErrorCode err = mCompiler.config(*mConfig); 262 if (err != Compiler::kSuccess) { 263 ALOGE("Failed to config the RS compiler for %s! (%s)",pOutputPath, 264 Compiler::GetErrorString(err)); 265 return Compiler::kErrInvalidSource; 266 } 267 } 268 269 OutputFile *ir_file = NULL; 270 llvm::raw_fd_ostream *IRStream = NULL; 271 if (pDumpIR) { 272 android::String8 path(pOutputPath); 273 path.append(".ll"); 274 ir_file = new OutputFile(path.string(), FileBase::kTruncate); 275 IRStream = ir_file->dup(); 276 } 277 278 // Run the compiler. 279 Compiler::ErrorCode compile_result = mCompiler.compile(pScript, 280 output_file, IRStream); 281 282 if (ir_file) { 283 ir_file->close(); 284 delete ir_file; 285 } 286 287 if (compile_result != Compiler::kSuccess) { 288 ALOGE("Unable to compile the source to file %s! (%s)", pOutputPath, 289 Compiler::GetErrorString(compile_result)); 290 return Compiler::kErrInvalidSource; 291 } 292 } 293 294 // No need to produce an RSExecutable in this case. 295 // TODO: Error handling in this case is nonexistent. 296 if (pSkipLoad) { 297 return Compiler::kSuccess; 298 } 299 300 { 301 android::String8 info_path = RSInfo::GetPath(pOutputPath); 302 OutputFile info_file(info_path.string(), FileBase::kTruncate); 303 304 if (info_file.hasError()) { 305 ALOGE("Failed to open the info file %s for write! (%s)", 306 info_path.string(), info_file.getErrorMessage().c_str()); 307 return Compiler::kErrInvalidSource; 308 } 309 310 FileMutex<FileBase::kWriteLock> write_info_mutex(info_path.string()); 311 if (write_info_mutex.hasError() || !write_info_mutex.lock()) { 312 ALOGE("Unable to acquire the lock for writing %s! (%s)", 313 info_path.string(), write_info_mutex.getErrorMessage().c_str()); 314 return Compiler::kErrInvalidSource; 315 } 316 317 // Perform the write. 318 if (!info->write(info_file)) { 319 ALOGE("Failed to sync the RS info file %s!", info_path.string()); 320 return Compiler::kErrInvalidSource; 321 } 322 } 323 324 return Compiler::kSuccess; 325} 326 327bool RSCompilerDriver::build(BCCContext &pContext, 328 const char *pCacheDir, 329 const char *pResName, 330 const char *pBitcode, 331 size_t pBitcodeSize, 332 const char *pRuntimePath, 333 RSLinkRuntimeCallback pLinkRuntimeCallback, 334 bool pDumpIR) { 335 // android::StopWatch build_time("bcc: RSCompilerDriver::build time"); 336 //===--------------------------------------------------------------------===// 337 // Check parameters. 338 //===--------------------------------------------------------------------===// 339 if ((pCacheDir == NULL) || (pResName == NULL)) { 340 ALOGE("Invalid parameter passed to RSCompilerDriver::build()! (cache dir: " 341 "%s, resource name: %s)", ((pCacheDir) ? pCacheDir : "(null)"), 342 ((pResName) ? pResName : "(null)")); 343 return false; 344 } 345 346 if ((pBitcode == NULL) || (pBitcodeSize <= 0)) { 347 ALOGE("No bitcode supplied! (bitcode: %p, size of bitcode: %u)", 348 pBitcode, static_cast<unsigned>(pBitcodeSize)); 349 return false; 350 } 351 352 //===--------------------------------------------------------------------===// 353 // Prepare dependency information. 354 //===--------------------------------------------------------------------===// 355 RSInfo::DependencyTableTy dep_info; 356 uint8_t bitcode_sha1[20]; 357 Sha1Util::GetSHA1DigestFromBuffer(bitcode_sha1, pBitcode, pBitcodeSize); 358 359 //===--------------------------------------------------------------------===// 360 // Construct output path. 361 // {pCacheDir}/{pResName}.o 362 //===--------------------------------------------------------------------===// 363 llvm::SmallString<80> output_path(pCacheDir); 364 llvm::sys::path::append(output_path, pResName); 365 llvm::sys::path::replace_extension(output_path, ".o"); 366 367 dep_info.push(std::make_pair(output_path.c_str(), bitcode_sha1)); 368 369 //===--------------------------------------------------------------------===// 370 // Load the bitcode and create script. 371 //===--------------------------------------------------------------------===// 372 Source *source = Source::CreateFromBuffer(pContext, pResName, 373 pBitcode, pBitcodeSize); 374 if (source == NULL) { 375 return false; 376 } 377 378 RSScript *script = new (std::nothrow) RSScript(*source); 379 if (script == NULL) { 380 ALOGE("Out of memory when create Script object for '%s'! (output: %s)", 381 pResName, output_path.c_str()); 382 delete source; 383 return false; 384 } 385 386 script->setLinkRuntimeCallback(pLinkRuntimeCallback); 387 388 // Read information from bitcode wrapper. 389 bcinfo::BitcodeWrapper wrapper(pBitcode, pBitcodeSize); 390 script->setCompilerVersion(wrapper.getCompilerVersion()); 391 script->setOptimizationLevel(static_cast<RSScript::OptimizationLevel>( 392 wrapper.getOptimizationLevel())); 393 394 //===--------------------------------------------------------------------===// 395 // Compile the script 396 //===--------------------------------------------------------------------===// 397 Compiler::ErrorCode status = compileScript(*script, pResName, 398 output_path.c_str(), 399 pRuntimePath, dep_info, false, 400 pDumpIR); 401 402 // Script is no longer used. Free it to get more memory. 403 delete script; 404 405 if (status != Compiler::kSuccess) { 406 return false; 407 } 408 409 return true; 410} 411 412 413bool RSCompilerDriver::build(RSScript &pScript, const char *pOut, 414 const char *pRuntimePath) { 415 RSInfo::DependencyTableTy dep_info; 416 RSInfo *info = RSInfo::ExtractFromSource(pScript.getSource(), dep_info); 417 if (info == NULL) { 418 return false; 419 } 420 pScript.setInfo(info); 421 422 // Embed the info string directly in the ELF, since this path is for an 423 // offline (host) compilation. 424 pScript.setEmbedInfo(true); 425 426 Compiler::ErrorCode status = compileScript(pScript, pOut, pOut, pRuntimePath, 427 dep_info, true); 428 if (status != Compiler::kSuccess) { 429 return false; 430 } 431 432 return true; 433} 434 435