Merge "Mark whether a script is threadable"
diff --git a/bcinfo/MetadataExtractor.cpp b/bcinfo/MetadataExtractor.cpp
index acc6915..4d868c8 100644
--- a/bcinfo/MetadataExtractor.cpp
+++ b/bcinfo/MetadataExtractor.cpp
@@ -60,6 +60,7 @@
// synced with slang_rs_metadata.h)
static const llvm::StringRef ObjectSlotMetadataName = "#rs_object_slots";
+static const llvm::StringRef ThreadableMetadataName = "#rs_is_threadable";
MetadataExtractor::MetadataExtractor(const char *bitcode, size_t bitcodeSize)
: mModule(nullptr), mBitcode(bitcode), mBitcodeSize(bitcodeSize),
@@ -68,7 +69,8 @@
mExportForEachNameList(nullptr), mExportForEachSignatureList(nullptr),
mExportForEachInputCountList(nullptr), mPragmaCount(0),
mPragmaKeyList(nullptr), mPragmaValueList(nullptr), mObjectSlotCount(0),
- mObjectSlotList(nullptr), mRSFloatPrecision(RS_FP_Full) {
+ mObjectSlotList(nullptr), mRSFloatPrecision(RS_FP_Full),
+ mIsThreadable(true) {
BitcodeWrapper wrapper(bitcode, bitcodeSize);
mCompilerVersion = wrapper.getCompilerVersion();
mOptimizationLevel = wrapper.getOptimizationLevel();
@@ -82,7 +84,8 @@
mExportForEachNameList(nullptr), mExportForEachSignatureList(nullptr),
mExportForEachInputCountList(nullptr), mPragmaCount(0),
mPragmaKeyList(nullptr), mPragmaValueList(nullptr), mObjectSlotCount(0),
- mObjectSlotList(nullptr), mRSFloatPrecision(RS_FP_Full) {
+ mObjectSlotList(nullptr), mRSFloatPrecision(RS_FP_Full),
+ mIsThreadable(true) {
mCompilerVersion = RS_VERSION; // Default to the actual current version.
mOptimizationLevel = 3;
}
@@ -425,6 +428,36 @@
}
+void MetadataExtractor::readThreadableFlag(
+ const llvm::NamedMDNode *ThreadableMetadata) {
+
+ // Scripts are threadable by default. If we read a valid metadata value for
+ // 'ThreadableMetadataName' and it is set to 'no', we mark script as non
+ // threadable. All other exception paths retain the default value.
+
+ mIsThreadable = true;
+ if (ThreadableMetadata == nullptr)
+ return;
+
+ llvm::MDNode *mdNode = ThreadableMetadata->getOperand(0);
+ if (mdNode == nullptr)
+ return;
+
+ llvm::Value *mdValue = mdNode->getOperand(0);
+ if (mdValue == nullptr)
+ return;
+
+ const char *value = createStringFromValue(mdValue);
+ if (value == nullptr)
+ return;
+
+ if (strcmp(value, "no") == 0)
+ mIsThreadable = false;
+ return;
+
+}
+
+
bool MetadataExtractor::extract() {
if (!(mBitcode && mBitcodeSize) && !mModule) {
ALOGE("Invalid/empty bitcode/module");
@@ -463,6 +496,8 @@
mModule->getNamedMetadata(PragmaMetadataName);
const llvm::NamedMDNode *ObjectSlotMetadata =
mModule->getNamedMetadata(ObjectSlotMetadataName);
+ const llvm::NamedMDNode *ThreadableMetadata =
+ mModule->getNamedMetadata(ThreadableMetadataName);
if (!populateVarNameMetadata(ExportVarMetadata)) {
@@ -488,6 +523,8 @@
return false;
}
+ readThreadableFlag(ThreadableMetadata);
+
return true;
}
diff --git a/include/bcc/Renderscript/RSTransforms.h b/include/bcc/Renderscript/RSTransforms.h
index 9fe418b..647ac4d 100644
--- a/include/bcc/Renderscript/RSTransforms.h
+++ b/include/bcc/Renderscript/RSTransforms.h
@@ -32,9 +32,9 @@
llvm::ModulePass * createRSEmbedInfoPass();
+llvm::ModulePass * createRSScreenFunctionsPass();
-llvm::ModulePass *
-createRSScreenFunctionsPass();
+llvm::ModulePass * createRSIsThreadablePass();
} // end namespace bcc
diff --git a/include/bcinfo/MetadataExtractor.h b/include/bcinfo/MetadataExtractor.h
index 6d53a29..3648889 100644
--- a/include/bcinfo/MetadataExtractor.h
+++ b/include/bcinfo/MetadataExtractor.h
@@ -61,6 +61,9 @@
enum RSFloatPrecision mRSFloatPrecision;
+ // Flag to mark that script is threadable. True by default.
+ bool mIsThreadable;
+
// Helper functions for extraction
bool populateVarNameMetadata(const llvm::NamedMDNode *VarNameMetadata);
bool populateFuncNameMetadata(const llvm::NamedMDNode *FuncNameMetadata);
@@ -68,6 +71,7 @@
const llvm::NamedMDNode *Signatures);
bool populateObjectSlotMetadata(const llvm::NamedMDNode *ObjectSlotMetadata);
void populatePragmaMetadata(const llvm::NamedMDNode *PragmaMetadata);
+ void readThreadableFlag(const llvm::NamedMDNode *ThreadableMetadata);
uint32_t calculateNumInputs(const llvm::Function *Function,
uint32_t Signature);
@@ -269,6 +273,11 @@
static bool hasForEachSignatureKernel(uint32_t sig) {
return sig & 0x20;
}
+
+ bool isThreadable() {
+ return mIsThreadable;
+ }
+
};
} // namespace bcinfo
diff --git a/lib/Core/Compiler.cpp b/lib/Core/Compiler.cpp
index c88ecc3..a2ebab5 100644
--- a/lib/Core/Compiler.cpp
+++ b/lib/Core/Compiler.cpp
@@ -197,6 +197,14 @@
// This has to come after LTO, since we don't want to examine functions that
// are never actually called.
passes.add(createRSScreenFunctionsPass());
+ passes.add(createRSIsThreadablePass());
+
+ // RSEmbedInfoPass needs to come after we have scanned for non-threadable
+ // functions.
+ // Script passed to RSCompiler must be a RSScript.
+ RSScript &script = static_cast<RSScript &>(pScript);
+ if (script.getEmbedInfo())
+ passes.add(createRSEmbedInfoPass());
// Add passes to the pass manager to emit machine code through MC layer.
if (mTarget->addPassesToEmitMC(passes, mc_context, pResult,
@@ -356,14 +364,9 @@
}
bool Compiler::addExpandForEachPass(Script &pScript, llvm::PassManager &pPM) {
- // Script passed to RSCompiler must be a RSScript.
- RSScript &script = static_cast<RSScript &>(pScript);
-
// Expand ForEach on CPU path to reduce launch overhead.
bool pEnableStepOpt = true;
pPM.add(createRSForEachExpandPass(pEnableStepOpt));
- if (script.getEmbedInfo())
- pPM.add(createRSEmbedInfoPass());
return true;
}
diff --git a/lib/Renderscript/Android.mk b/lib/Renderscript/Android.mk
index 3280909..251b32c 100644
--- a/lib/Renderscript/Android.mk
+++ b/lib/Renderscript/Android.mk
@@ -32,6 +32,7 @@
RSMetadata.cpp \
RSScript.cpp \
RSInvokeHelperPass.cpp \
+ RSIsThreadablePass.cpp \
RSScreenFunctionsPass.cpp \
RSStubsWhiteList.cpp \
RSScriptGroupFusion.cpp
diff --git a/lib/Renderscript/RSEmbedInfo.cpp b/lib/Renderscript/RSEmbedInfo.cpp
index 0d7f360..0ae97a2 100644
--- a/lib/Renderscript/RSEmbedInfo.cpp
+++ b/lib/Renderscript/RSEmbedInfo.cpp
@@ -83,6 +83,7 @@
const uint32_t *objectSlotList = me.getObjectSlotList();
const char **pragmaKeyList = me.getPragmaKeyList();
const char **pragmaValueList = me.getPragmaValueList();
+ bool isThreadable = me.isThreadable();
size_t i;
// We use a simple text format here that the compatibility library can
@@ -118,6 +119,7 @@
s << pragmaKeyList[i] << " - "
<< pragmaValueList[i] << "\n";
}
+ s << "isThreadable: " << ((isThreadable) ? "yes" : "no") << "\n";
s.flush();
return str;
diff --git a/lib/Renderscript/RSIsThreadablePass.cpp b/lib/Renderscript/RSIsThreadablePass.cpp
new file mode 100644
index 0000000..33de8fc
--- /dev/null
+++ b/lib/Renderscript/RSIsThreadablePass.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2015, 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 "bcc/Renderscript/RSTransforms.h"
+#include "bcc/Support/Log.h"
+
+#include <cstdlib>
+
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/Metadata.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Function.h>
+#include <llvm/Pass.h>
+
+namespace { // anonymous namespace
+
+// Create a Module pass that screens all the global functions in the module and
+// check if any non-threadable function is callable. If so, we mark the
+// Module as non-threadable by adding a metadata flag '#rs_is_threadable'
+
+class RSIsThreadablePass : public llvm::ModulePass {
+private:
+ static char ID;
+
+ std::vector<std::string> nonThreadableFns = {
+ "_Z22rsgBindProgramFragment19rs_program_fragment",
+ "_Z19rsgBindProgramStore16rs_program_store",
+ "_Z20rsgBindProgramVertex17rs_program_vertex",
+ "_Z20rsgBindProgramRaster17rs_program_raster",
+ "_Z14rsgBindSampler19rs_program_fragmentj10rs_sampler",
+ "_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation",
+ "_Z15rsgBindConstant19rs_program_fragmentj13rs_allocation",
+ "_Z15rsgBindConstant17rs_program_vertexj13rs_allocation",
+ "_Z36rsgProgramVertexLoadProjectionMatrixPK12rs_matrix4x4",
+ "_Z31rsgProgramVertexLoadModelMatrixPK12rs_matrix4x4",
+ "_Z33rsgProgramVertexLoadTextureMatrixPK12rs_matrix4x4",
+ "_Z35rsgProgramVertexGetProjectionMatrixP12rs_matrix4x4",
+ "_Z31rsgProgramFragmentConstantColor19rs_program_fragmentffff",
+ "_Z11rsgGetWidthv",
+ "_Z12rsgGetHeightv",
+ "_Z11rsgDrawRectfffff",
+ "_Z11rsgDrawQuadffffffffffff",
+ "_Z20rsgDrawQuadTexCoordsffffffffffffffffffff",
+ "_Z24rsgDrawSpriteScreenspacefffff",
+ "_Z11rsgDrawMesh7rs_mesh",
+ "_Z11rsgDrawMesh7rs_meshj",
+ "_Z11rsgDrawMesh7rs_meshjjj",
+ "_Z25rsgMeshComputeBoundingBox7rs_meshPfS0_S0_S0_S0_S0_",
+ "_Z11rsgDrawPath7rs_path",
+ "_Z13rsgClearColorffff",
+ "_Z13rsgClearDepthf",
+ "_Z11rsgDrawTextPKcii",
+ "_Z11rsgDrawText13rs_allocationii",
+ "_Z14rsgMeasureTextPKcPiS1_S1_S1_",
+ "_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_",
+ "_Z11rsgBindFont7rs_font",
+ "_Z12rsgFontColorffff",
+ "_Z18rsgBindColorTarget13rs_allocationj",
+ "_Z18rsgBindDepthTarget13rs_allocation",
+ "_Z19rsgClearColorTargetj",
+ "_Z19rsgClearDepthTargetv",
+ "_Z24rsgClearAllRenderTargetsv",
+ "_Z7rsGetDtv",
+ "_Z5colorffff",
+ "_Z9rsgFinishv",
+ };
+
+ bool isPresent(std::vector<std::string> &list, std::string name) {
+ auto lower = std::lower_bound(list.begin(),
+ list.end(),
+ name);
+
+ if (lower != list.end() && name.compare(*lower) == 0)
+ return true;
+ return false;
+ }
+
+public:
+ RSIsThreadablePass()
+ : ModulePass (ID) {
+ std::sort(nonThreadableFns.begin(), nonThreadableFns.end());
+ }
+
+ virtual void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
+ AU.setPreservesAll();
+ }
+
+ bool runOnModule(llvm::Module &M) override {
+ bool threadable = true;
+
+ auto &FunctionList(M.getFunctionList());
+ for (auto &F: FunctionList) {
+ if (isPresent(nonThreadableFns, F.getName().str())) {
+ threadable = false;
+ break;
+ }
+ }
+
+ llvm::LLVMContext &context = M.getContext();
+ llvm::MDString *val =
+ llvm::MDString::get(context, (threadable) ? "yes" : "no");
+ llvm::NamedMDNode *node =
+ M.getOrInsertNamedMetadata("#rs_is_threadable");
+ node->addOperand(llvm::MDNode::get(context, val));
+
+ return false;
+ }
+
+};
+
+}
+
+char RSIsThreadablePass::ID = 0;
+
+namespace bcc {
+
+llvm::ModulePass *
+createRSIsThreadablePass () {
+ return new RSIsThreadablePass();
+}
+
+}
