| /* |
| * 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 "RSScriptGroupFusion.h" |
| |
| #include "Assert.h" |
| #include "Log.h" |
| #include "bcc/BCCContext.h" |
| #include "bcc/Source.h" |
| #include "bcinfo/MetadataExtractor.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/IR/DataLayout.h" |
| #include "llvm/IR/IRBuilder.h" |
| #include "llvm/IR/Module.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using llvm::Function; |
| using llvm::Module; |
| |
| using std::string; |
| |
| namespace bcc { |
| |
| namespace { |
| |
| const Function* getInvokeFunction(const Source& source, const int slot, |
| Module* newModule) { |
| |
| bcinfo::MetadataExtractor &metadata = *source.getMetadata(); |
| const char* functionName = metadata.getExportFuncNameList()[slot]; |
| Function* func = newModule->getFunction(functionName); |
| // Materialize the function so that later the caller can inspect its argument |
| // and return types. |
| newModule->materialize(func); |
| return func; |
| } |
| |
| const Function* |
| getFunction(Module* mergedModule, const Source* source, const int slot, |
| uint32_t* signature) { |
| |
| bcinfo::MetadataExtractor &metadata = *source->getMetadata(); |
| const char* functionName = metadata.getExportForEachNameList()[slot]; |
| if (functionName == nullptr || !functionName[0]) { |
| ALOGE("Kernel fusion (module %s slot %d): failed to find kernel function", |
| source->getName().c_str(), slot); |
| return nullptr; |
| } |
| |
| if (metadata.getExportForEachInputCountList()[slot] > 1) { |
| ALOGE("Kernel fusion (module %s function %s): cannot handle multiple inputs", |
| source->getName().c_str(), functionName); |
| return nullptr; |
| } |
| |
| if (signature != nullptr) { |
| *signature = metadata.getExportForEachSignatureList()[slot]; |
| } |
| |
| const Function* function = mergedModule->getFunction(functionName); |
| |
| return function; |
| } |
| |
| // The whitelist of supported signature bits. Context or user data arguments are |
| // not currently supported in kernel fusion. To support them or any new kinds of |
| // arguments in the future, it requires not only listing the signature bits here, |
| // but also implementing additional necessary fusion logic in the getFusedFuncSig(), |
| // getFusedFuncType(), and fuseKernels() functions below. |
| constexpr uint32_t ExpectedSignatureBits = |
| bcinfo::MD_SIG_In | |
| bcinfo::MD_SIG_Out | |
| bcinfo::MD_SIG_X | |
| bcinfo::MD_SIG_Y | |
| bcinfo::MD_SIG_Z | |
| bcinfo::MD_SIG_Kernel; |
| |
| int getFusedFuncSig(const std::vector<Source*>& sources, |
| const std::vector<int>& slots, |
| uint32_t* retSig) { |
| *retSig = 0; |
| uint32_t firstSignature = 0; |
| uint32_t signature = 0; |
| auto slotIter = slots.begin(); |
| for (const Source* source : sources) { |
| const int slot = *slotIter++; |
| bcinfo::MetadataExtractor &metadata = *source->getMetadata(); |
| |
| if (metadata.getExportForEachInputCountList()[slot] > 1) { |
| ALOGE("Kernel fusion (module %s slot %d): cannot handle multiple inputs", |
| source->getName().c_str(), slot); |
| return -1; |
| } |
| |
| signature = metadata.getExportForEachSignatureList()[slot]; |
| if (signature & ~ExpectedSignatureBits) { |
| ALOGE("Kernel fusion (module %s slot %d): Unexpected signature %x", |
| source->getName().c_str(), slot, signature); |
| return -1; |
| } |
| |
| if (firstSignature == 0) { |
| firstSignature = signature; |
| } |
| |
| *retSig |= signature; |
| } |
| |
| if (!bcinfo::MetadataExtractor::hasForEachSignatureIn(firstSignature)) { |
| *retSig &= ~bcinfo::MD_SIG_In; |
| } |
| |
| if (!bcinfo::MetadataExtractor::hasForEachSignatureOut(signature)) { |
| *retSig &= ~bcinfo::MD_SIG_Out; |
| } |
| |
| return 0; |
| } |
| |
| llvm::FunctionType* getFusedFuncType(bcc::BCCContext& Context, |
| const std::vector<Source*>& sources, |
| const std::vector<int>& slots, |
| Module* M, |
| uint32_t* signature) { |
| int error = getFusedFuncSig(sources, slots, signature); |
| |
| if (error < 0) { |
| return nullptr; |
| } |
| |
| const Function* firstF = getFunction(M, sources.front(), slots.front(), nullptr); |
| |
| bccAssert (firstF != nullptr); |
| |
| llvm::SmallVector<llvm::Type*, 8> ArgTys; |
| |
| if (bcinfo::MetadataExtractor::hasForEachSignatureIn(*signature)) { |
| ArgTys.push_back(firstF->arg_begin()->getType()); |
| } |
| |
| llvm::Type* I32Ty = llvm::IntegerType::get(Context.getLLVMContext(), 32); |
| if (bcinfo::MetadataExtractor::hasForEachSignatureX(*signature)) { |
| ArgTys.push_back(I32Ty); |
| } |
| if (bcinfo::MetadataExtractor::hasForEachSignatureY(*signature)) { |
| ArgTys.push_back(I32Ty); |
| } |
| if (bcinfo::MetadataExtractor::hasForEachSignatureZ(*signature)) { |
| ArgTys.push_back(I32Ty); |
| } |
| |
| const Function* lastF = getFunction(M, sources.back(), slots.back(), nullptr); |
| |
| bccAssert (lastF != nullptr); |
| |
| llvm::Type* retTy = lastF->getReturnType(); |
| |
| return llvm::FunctionType::get(retTy, ArgTys, false); |
| } |
| |
| } // anonymous namespace |
| |
| bool fuseKernels(bcc::BCCContext& Context, |
| const std::vector<Source *>& sources, |
| const std::vector<int>& slots, |
| const std::string& fusedName, |
| Module* mergedModule) { |
| bccAssert(sources.size() == slots.size() && "sources and slots differ in size"); |
| |
| uint32_t fusedFunctionSignature; |
| |
| llvm::FunctionType* fusedType = |
| getFusedFuncType(Context, sources, slots, mergedModule, &fusedFunctionSignature); |
| |
| if (fusedType == nullptr) { |
| return false; |
| } |
| |
| Function* fusedKernel = |
| (Function*)(mergedModule->getOrInsertFunction(fusedName, fusedType)); |
| |
| llvm::LLVMContext& ctxt = Context.getLLVMContext(); |
| |
| llvm::BasicBlock* block = llvm::BasicBlock::Create(ctxt, "entry", fusedKernel); |
| llvm::IRBuilder<> builder(block); |
| |
| Function::arg_iterator argIter = fusedKernel->arg_begin(); |
| |
| llvm::Value* dataElement = nullptr; |
| if (bcinfo::MetadataExtractor::hasForEachSignatureIn(fusedFunctionSignature)) { |
| dataElement = &*(argIter++); |
| dataElement->setName("DataIn"); |
| } |
| |
| llvm::Value* X = nullptr; |
| if (bcinfo::MetadataExtractor::hasForEachSignatureX(fusedFunctionSignature)) { |
| X = &*(argIter++); |
| X->setName("x"); |
| } |
| |
| llvm::Value* Y = nullptr; |
| if (bcinfo::MetadataExtractor::hasForEachSignatureY(fusedFunctionSignature)) { |
| Y = &*(argIter++); |
| Y->setName("y"); |
| } |
| |
| llvm::Value* Z = nullptr; |
| if (bcinfo::MetadataExtractor::hasForEachSignatureZ(fusedFunctionSignature)) { |
| Z = &*(argIter++); |
| Z->setName("z"); |
| } |
| |
| auto slotIter = slots.begin(); |
| for (const Source* source : sources) { |
| int slot = *slotIter; |
| |
| uint32_t inputFunctionSignature; |
| const Function* inputFunction = |
| getFunction(mergedModule, source, slot, &inputFunctionSignature); |
| if (inputFunction == nullptr) { |
| // Either failed to find the kernel function, or the function has multiple inputs. |
| return false; |
| } |
| |
| // Don't try to fuse a non-kernel |
| if (!bcinfo::MetadataExtractor::hasForEachSignatureKernel(inputFunctionSignature)) { |
| ALOGE("Kernel fusion (module %s function %s): not a kernel", |
| source->getName().c_str(), inputFunction->getName().str().c_str()); |
| return false; |
| } |
| |
| std::vector<llvm::Value*> args; |
| |
| if (bcinfo::MetadataExtractor::hasForEachSignatureIn(inputFunctionSignature)) { |
| if (dataElement == nullptr) { |
| ALOGE("Kernel fusion (module %s function %s): expected input, but got null", |
| source->getName().c_str(), inputFunction->getName().str().c_str()); |
| return false; |
| } |
| |
| const llvm::FunctionType* funcTy = inputFunction->getFunctionType(); |
| llvm::Type* firstArgType = funcTy->getParamType(0); |
| |
| if (dataElement->getType() != firstArgType) { |
| std::string msg; |
| llvm::raw_string_ostream rso(msg); |
| rso << "Mismatching argument type, expected "; |
| firstArgType->print(rso); |
| rso << ", received "; |
| dataElement->getType()->print(rso); |
| ALOGE("Kernel fusion (module %s function %s): %s", source->getName().c_str(), |
| inputFunction->getName().str().c_str(), rso.str().c_str()); |
| return false; |
| } |
| |
| args.push_back(dataElement); |
| } else { |
| // Only the first kernel in a batch is allowed to have no input |
| if (slotIter != slots.begin()) { |
| ALOGE("Kernel fusion (module %s function %s): function not first in batch takes no input", |
| source->getName().c_str(), inputFunction->getName().str().c_str()); |
| return false; |
| } |
| } |
| |
| if (bcinfo::MetadataExtractor::hasForEachSignatureX(inputFunctionSignature)) { |
| args.push_back(X); |
| } |
| |
| if (bcinfo::MetadataExtractor::hasForEachSignatureY(inputFunctionSignature)) { |
| args.push_back(Y); |
| } |
| |
| if (bcinfo::MetadataExtractor::hasForEachSignatureZ(inputFunctionSignature)) { |
| args.push_back(Z); |
| } |
| |
| dataElement = builder.CreateCall((llvm::Value*)inputFunction, args); |
| |
| slotIter++; |
| } |
| |
| if (fusedKernel->getReturnType()->isVoidTy()) { |
| builder.CreateRetVoid(); |
| } else { |
| builder.CreateRet(dataElement); |
| } |
| |
| llvm::NamedMDNode* ExportForEachNameMD = |
| mergedModule->getOrInsertNamedMetadata("#rs_export_foreach_name"); |
| |
| llvm::MDString* nameMDStr = llvm::MDString::get(ctxt, fusedName); |
| llvm::MDNode* nameMDNode = llvm::MDNode::get(ctxt, nameMDStr); |
| ExportForEachNameMD->addOperand(nameMDNode); |
| |
| llvm::NamedMDNode* ExportForEachMD = |
| mergedModule->getOrInsertNamedMetadata("#rs_export_foreach"); |
| llvm::MDString* sigMDStr = llvm::MDString::get(ctxt, |
| llvm::utostr(fusedFunctionSignature)); |
| llvm::MDNode* sigMDNode = llvm::MDNode::get(ctxt, sigMDStr); |
| ExportForEachMD->addOperand(sigMDNode); |
| |
| return true; |
| } |
| |
| bool renameInvoke(BCCContext& Context, const Source* source, const int slot, |
| const std::string& newName, Module* module) { |
| const llvm::Function* F = getInvokeFunction(*source, slot, module); |
| std::vector<llvm::Type*> params; |
| for (auto I = F->arg_begin(), E = F->arg_end(); I != E; ++I) { |
| params.push_back(I->getType()); |
| } |
| llvm::Type* returnTy = F->getReturnType(); |
| |
| llvm::FunctionType* batchFuncTy = |
| llvm::FunctionType::get(returnTy, params, false); |
| |
| llvm::Function* newF = |
| llvm::Function::Create(batchFuncTy, |
| llvm::GlobalValue::ExternalLinkage, newName, |
| module); |
| |
| llvm::BasicBlock* block = llvm::BasicBlock::Create(Context.getLLVMContext(), |
| "entry", newF); |
| llvm::IRBuilder<> builder(block); |
| |
| llvm::Function::arg_iterator argIter = newF->arg_begin(); |
| llvm::Value* arg1 = &*(argIter++); |
| builder.CreateCall((llvm::Value*)F, arg1); |
| |
| builder.CreateRetVoid(); |
| |
| llvm::NamedMDNode* ExportFuncNameMD = |
| module->getOrInsertNamedMetadata("#rs_export_func"); |
| llvm::MDString* strMD = llvm::MDString::get(module->getContext(), newName); |
| llvm::MDNode* nodeMD = llvm::MDNode::get(module->getContext(), strMD); |
| ExportFuncNameMD->addOperand(nodeMD); |
| |
| return true; |
| } |
| |
| } // namespace bcc |