Introduce RSCompilerDriver.
RSCompilerDriver hosts a Compiler. It brings all things together.
Given a RSScript and its output path, RSCompilerDriver::build()
either loads the object file from the previous built or runs the
compiler to get one.
diff --git a/lib/ExecutionEngine/RSCompilerDriver.cpp b/lib/ExecutionEngine/RSCompilerDriver.cpp
new file mode 100644
index 0000000..ceb4f93
--- /dev/null
+++ b/lib/ExecutionEngine/RSCompilerDriver.cpp
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2012, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "RSCompilerDriver.h"
+
+#include "CompilerConfig.h"
+#include "TargetCompilerConfigs.h"
+#include "DebugHelper.h"
+#include "FileMutex.h"
+#include "InputFile.h"
+#include "Initialization.h"
+#include "OutputFile.h"
+#include "RSExecutable.h"
+
+#include <cutils/properties.h>
+#include <utils/String8.h>
+
+using namespace bcc;
+
+namespace {
+
+bool is_force_recompile() {
+ char buf[PROPERTY_VALUE_MAX];
+
+ property_get("debug.rs.forcerecompile", buf, "0");
+ if ((::strcmp(buf, "1") == 0) || (::strcmp(buf, "true") == 0)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+} // end anonymous namespace
+
+RSCompilerDriver::RSCompilerDriver() : mConfig(NULL), mCompiler() {
+ init::Initialize();
+ // Chain the symbol resolvers for BCC runtimes and RS runtimes.
+ mResolver.chainResolver(mBCCRuntime);
+ mResolver.chainResolver(mRSRuntime);
+}
+
+RSCompilerDriver::~RSCompilerDriver() {
+ delete mConfig;
+}
+
+RSExecutable *RSCompilerDriver::loadScriptCache(const RSScript &pScript,
+ const std::string &pOutputPath){
+ RSExecutable *result = NULL;
+
+ if (is_force_recompile())
+ return NULL;
+
+ //===--------------------------------------------------------------------===//
+ // Acquire the read lock for reading output object file.
+ //===--------------------------------------------------------------------===//
+ FileMutex<FileBase::kReadLock> read_output_mutex(pOutputPath);
+
+ if (read_output_mutex.hasError() || !read_output_mutex.lock()) {
+ ALOGE("Unable to acquire the read lock for %s! (%s)", pOutputPath.c_str(),
+ read_output_mutex.getErrorMessage().c_str());
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Read the output object file.
+ //===--------------------------------------------------------------------===//
+ InputFile *output_file = new (std::nothrow) InputFile(pOutputPath);
+
+ if ((output_file == NULL) || output_file->hasError()) {
+ ALOGE("Unable to open the %s for read! (%s)", pOutputPath.c_str(),
+ output_file->getErrorMessage().c_str());
+ delete output_file;
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Acquire the read lock on output_file for reading its RS info file.
+ //===--------------------------------------------------------------------===//
+ android::String8 info_path = RSInfo::GetPath(*output_file);
+
+ if (!output_file->lock()) {
+ ALOGE("Unable to acquire the read lock on %s for reading %s! (%s)",
+ pOutputPath.c_str(), info_path.string(),
+ output_file->getErrorMessage().c_str());
+ delete output_file;
+ return NULL;
+ }
+
+ //===---------------------------------------------------------------------===//
+ // Open and load the RS info file.
+ //===--------------------------------------------------------------------===//
+ InputFile info_file(info_path.string());
+ RSInfo *info = RSInfo::ReadFromFile(info_file,
+ pScript.getSourceDependencies());
+
+ // Release the lock on output_file.
+ output_file->unlock();
+
+ if (info == NULL) {
+ delete output_file;
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Create the RSExecutable.
+ //===--------------------------------------------------------------------===//
+ result = RSExecutable::Create(*info, *output_file, mResolver);
+ if (result == NULL) {
+ delete output_file;
+ delete info;
+ return NULL;
+ }
+
+ // TODO: Dirty hack for libRS. This can be removed once RSExecutable is public
+ // to libRS.
+ if (!result->isThreadable()) {
+ mRSRuntime.getAddress("__clearThreadable");
+ }
+
+ return result;
+}
+
+bool RSCompilerDriver::setupConfig(const RSScript &pScript) {
+ bool changed = false;
+
+ const llvm::CodeGenOpt::Level script_opt_level =
+ static_cast<llvm::CodeGenOpt::Level>(pScript.getOptimizationLevel());
+
+ if (mConfig != NULL) {
+ // Renderscript bitcode may have their optimization flag configuration
+ // different than the previous run of RS compilation.
+ if (mConfig->getOptimizationLevel() != script_opt_level) {
+ mConfig->setOptimizationLevel(script_opt_level);
+ changed = true;
+ }
+ } else {
+ // Haven't run the compiler ever.
+ mConfig = new (std::nothrow) DefaultCompilerConfig();
+ if (mConfig == NULL) {
+ // Return false since mConfig remains NULL and out-of-memory.
+ return false;
+ }
+ mConfig->setOptimizationLevel(script_opt_level);
+ changed = true;
+ }
+
+#if defined(DEFAULT_ARM_CODEGEN)
+ // NEON should be disable when full-precision floating point is required.
+ assert((pScript.getInfo() != NULL) && "NULL RS info!");
+ if (pScript.getInfo()->getFloatPrecisionRequirement() == RSInfo::Full) {
+ // Must be ARMCompilerConfig.
+ ARMCompilerConfig *arm_config = static_cast<ARMCompilerConfig *>(mConfig);
+ changed |= arm_config->enableNEON(/* pEnable */false);
+ }
+#endif
+
+ return changed;
+}
+
+RSExecutable *RSCompilerDriver::compileScript(RSScript &pScript,
+ const std::string &pOutputPath) {
+ RSExecutable *result = NULL;
+ RSInfo *info = NULL;
+
+ //===--------------------------------------------------------------------===//
+ // Extract RS-specific information from source bitcode.
+ //===--------------------------------------------------------------------===//
+ // RS info may contains configuration (such as #optimization_level) to the
+ // compiler therefore it should be extracted before compilation.
+ info = RSInfo::ExtractFromSource(pScript.getSource(),
+ pScript.getSourceDependencies());
+ if (info == NULL) {
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Associate script with its info
+ //===--------------------------------------------------------------------===//
+ // This is required since RS compiler may need information in the info file
+ // to do some transformation (e.g., expand foreach-able function.)
+ pScript.setInfo(info);
+
+ //===--------------------------------------------------------------------===//
+ // Acquire the write lock for writing output object file.
+ //===--------------------------------------------------------------------===//
+ FileMutex<FileBase::kWriteLock> write_output_mutex(pOutputPath);
+
+ if (write_output_mutex.hasError() || !write_output_mutex.lock()) {
+ ALOGE("Unable to acquire the lock for writing %s! (%s)",
+ pOutputPath.c_str(), write_output_mutex.getErrorMessage().c_str());
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Open the output file for write.
+ //===--------------------------------------------------------------------===//
+ OutputFile *output_file = new (std::nothrow) OutputFile(pOutputPath);
+
+ if ((output_file == NULL) || output_file->hasError()) {
+ ALOGE("Unable to open the %s for write! (%s)", pOutputPath.c_str(),
+ output_file->getErrorMessage().c_str());
+ delete info;
+ delete output_file;
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Setup the config to the compiler.
+ //===--------------------------------------------------------------------===//
+ bool compiler_need_reconfigure = setupConfig(pScript);
+
+ if (mConfig == NULL) {
+ ALOGE("Failed to setup config for RS compiler to compile %s!",
+ pOutputPath.c_str());
+ delete info;
+ delete output_file;
+ return NULL;
+ }
+
+ // Compiler need to re-config if it's haven't run the config() yet or the
+ // configuration it referenced is changed.
+ if (compiler_need_reconfigure) {
+ Compiler::ErrorCode err = mCompiler.config(*mConfig);
+ if (err != Compiler::kSuccess) {
+ ALOGE("Failed to config the RS compiler for %s! (%s)",pOutputPath.c_str(),
+ Compiler::GetErrorString(err));
+ delete info;
+ delete output_file;
+ return NULL;
+ }
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Run the compiler.
+ //===--------------------------------------------------------------------===//
+ Compiler::ErrorCode compile_result = mCompiler.compile(pScript, *output_file);
+ if (compile_result != Compiler::kSuccess) {
+ ALOGE("Unable to compile the source to file %s! (%s)", pOutputPath.c_str(),
+ Compiler::GetErrorString(compile_result));
+ delete info;
+ delete output_file;
+ return NULL;
+ }
+
+ //===--------------------------------------------------------------------===//
+ // Create the RSExecutable.
+ //===--------------------------------------------------------------------===//
+ result = RSExecutable::Create(*info, *output_file, mResolver);
+ if (result == NULL) {
+ delete info;
+ delete output_file;
+ return NULL;
+ }
+
+ // TODO: Dirty hack for libRS. This can be removed once RSExecutable is public
+ // to libRS.
+ result->setThreadable(mRSRuntime.getAddress("__isThreadable") != NULL);
+
+ //===--------------------------------------------------------------------===//
+ // Write out the RS info file.
+ //===--------------------------------------------------------------------===//
+ // Note that write failure only results in a warning since the source is
+ // successfully compiled and loaded.
+ if (!result->syncInfo(/* pForce */true)) {
+ ALOGW("%s was successfully compiled and loaded but its RS info file failed "
+ "to write out!", pOutputPath.c_str());
+ }
+
+ return result;
+}
+
+RSExecutable *RSCompilerDriver::build(RSScript &pScript,
+ const std::string &pOutputPath) {
+ RSExecutable *result = loadScriptCache(pScript, pOutputPath);
+
+ if (result != NULL) {
+ // Cache hit
+ return result;
+ }
+
+ return compileScript(pScript, pOutputPath);
+}
diff --git a/lib/ExecutionEngine/RSCompilerDriver.h b/lib/ExecutionEngine/RSCompilerDriver.h
new file mode 100644
index 0000000..8bc9298
--- /dev/null
+++ b/lib/ExecutionEngine/RSCompilerDriver.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BCC_EXECUTION_ENGINE_RS_COMPILER_DRIVER_H
+#define BCC_EXECUTION_ENGINE_RS_COMPILER_DRIVER_H
+
+#include <string>
+
+#include "BCCRuntimeSymbolResolver.h"
+#include "RSCompiler.h"
+#include "SymbolResolvers.h"
+#include "SymbolResolverProxy.h"
+
+namespace bcc {
+
+class CompilerConfig;
+class RSExecutable;
+class RSScript;
+
+class RSCompilerDriver {
+private:
+ CompilerConfig *mConfig;
+ RSCompiler mCompiler;
+
+ BCCRuntimeSymbolResolver mBCCRuntime;
+ LookupFunctionSymbolResolver<void*> mRSRuntime;
+ SymbolResolverProxy mResolver;
+
+ RSExecutable *loadScriptCache(const RSScript &pScript,
+ const std::string &pOutputPath);
+
+ // Setup the compiler config for the given script. Return true if mConfig has
+ // been changed and false if it remains unchanged.
+ bool setupConfig(const RSScript &pScript);
+
+ RSExecutable *compileScript(RSScript &pScript,
+ const std::string &pOutputPath);
+
+public:
+ RSCompilerDriver();
+ ~RSCompilerDriver();
+
+ inline void setRSRuntimeLookupFunction(
+ LookupFunctionSymbolResolver<>::LookupFunctionTy pLookupFunc)
+ { mRSRuntime.setLookupFunction(pLookupFunc); }
+ inline void setRSRuntimeLookupContext(void *pContext)
+ { mRSRuntime.setContext(pContext); }
+
+ // FIXME: This method accompany with loadScriptCache and compileScript should
+ // all be const-methods. They're not now because the getAddress() in
+ // SymbolResolverInterface is not a const-method.
+ RSExecutable *build(RSScript &pScript,
+ const std::string &pOutputPath);
+};
+
+} // end namespace bcc
+
+#endif // BCC_EXECUTION_ENGINE_RS_COMPILER_DRIVER_H