1 /* Copyright 2017 The TensorFlow Authors. All Rights Reserved. 2 3 Licensed under the Apache License, Version 2.0 (the "License"); 4 you may not use this file except in compliance with the License. 5 You may obtain a copy of the License at 6 7 http://www.apache.org/licenses/LICENSE-2.0 8 9 Unless required by applicable law or agreed to in writing, software 10 distributed under the License is distributed on an "AS IS" BASIS, 11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 See the License for the specific language governing permissions and 13 limitations under the License. 14 ==============================================================================*/ 15 16 #include "tensorflow/compiler/xla/service/llvm_ir/kernel_support_library.h" 17 18 #include "tensorflow/compiler/xla/service/llvm_ir/llvm_loop.h" 19 #include "tensorflow/compiler/xla/service/llvm_ir/llvm_util.h" 20 21 namespace xla { 22 void KernelSupportLibrary::For( 23 tensorflow::StringPiece name, llvm::Value* start, llvm::Value* end, 24 llvm::Value* step, 25 const std::function<void(llvm::Value*, bool)>& for_body_generator) { 26 If(ir_builder_->CreateICmpSLT(start, end), [&]() { 27 for_body_generator(start, /*is_first_iteration=*/true); 28 For(name, ir_builder_->CreateAdd(start, step), end, step, 29 [&](llvm::Value* iv) { for_body_generator(iv, false); }); 30 }); 31 } 32 33 void KernelSupportLibrary::For( 34 tensorflow::StringPiece name, llvm::Value* start, llvm::Value* end, 35 llvm::Value* step, bool peel_first_iteration, 36 const std::function<void(llvm::Value*, llvm::Value*)>& for_body_generator) { 37 if (peel_first_iteration) { 38 For(name, start, end, step, true, 39 [&](llvm::Value* indvar, bool is_first_iteration) { 40 for_body_generator(indvar, ir_builder_->getInt1(is_first_iteration)); 41 }); 42 } else { 43 std::unique_ptr<llvm_ir::ForLoop> loop = llvm_ir::ForLoop::EmitForLoop( 44 name, start, end, step, ir_builder_, 45 /*prevent_unrolling=*/prevent_unrolling_, 46 /*prevent_vectorization=*/prevent_vectorization_); 47 ir_builder_->SetInsertPoint(&loop->GetBodyBasicBlock()->back()); 48 for_body_generator(loop->GetIndVarValue(), 49 /*is_first_iteration=*/ir_builder_->CreateICmpEQ( 50 loop->GetIndVarValue(), start)); 51 llvm_ir::SetToLastInsertPoint(loop->GetExitBasicBlock(), ir_builder_); 52 } 53 } 54 55 void KernelSupportLibrary::If( 56 llvm::Value* condition, const std::function<void()>& true_block_generator, 57 const std::function<void()>& false_block_generator) { 58 llvm_ir::LlvmIfData if_data = 59 llvm_ir::EmitIfThenElse(condition, "", ir_builder_); 60 ir_builder_->SetInsertPoint(&if_data.true_block->back()); 61 true_block_generator(); 62 ir_builder_->SetInsertPoint(&if_data.false_block->back()); 63 false_block_generator(); 64 llvm_ir::SetToLastInsertPoint(if_data.after_block, ir_builder_); 65 } 66 67 void KernelSupportLibrary::EmitAndCallOutlinedKernel( 68 bool enable_fast_math, bool optimize_for_size, 69 llvm::IRBuilder<>* ir_builder, tensorflow::StringPiece kernel_name, 70 KernelSupportLibrary::ArgumentVector arguments, 71 const std::function<void(KernelSupportLibrary::ArgumentVector)>& 72 kernel_body_generator) { 73 llvm::Module* module = ir_builder->GetInsertBlock()->getModule(); 74 llvm::Function* function = 75 module->getFunction(llvm_ir::AsStringRef(kernel_name)); 76 77 int64 null_arg_idx = -1; 78 std::vector<llvm::Value*> sanitized_args; 79 sanitized_args.reserve(arguments.size()); 80 for (int64 i = 0, e = arguments.size(); i < e; i++) { 81 if (arguments[i]) { 82 sanitized_args.push_back(arguments[i]); 83 } else { 84 CHECK_EQ(null_arg_idx, -1); 85 null_arg_idx = i; 86 } 87 } 88 89 if (!function) { 90 VLOG(2) << "Generating kernel for " << kernel_name; 91 std::vector<llvm::Type*> arg_types; 92 std::transform(sanitized_args.begin(), sanitized_args.end(), 93 std::back_inserter(arg_types), 94 [](llvm::Value* arg) { return arg->getType(); }); 95 96 auto* function_type = llvm::FunctionType::get( 97 ir_builder->getVoidTy(), arg_types, /*isVarArg=*/false); 98 99 function = llvm_ir::CreateFunction( 100 function_type, llvm::GlobalValue::InternalLinkage, 101 /*enable_fast_math=*/enable_fast_math, 102 /*optimize_for_size=*/optimize_for_size, kernel_name, module); 103 104 llvm::IRBuilder<>::InsertPointGuard guard(*ir_builder); 105 106 auto* entry_bb = 107 llvm::BasicBlock::Create(ir_builder->getContext(), "entry", function); 108 auto* return_inst = llvm::ReturnInst::Create(ir_builder->getContext(), 109 /*retVal=*/nullptr, entry_bb); 110 // Set the insert point to before return_inst. 111 ir_builder->SetInsertPoint(return_inst); 112 113 std::vector<llvm::Value*> arg_values; 114 /* 115 * clang on OSX doesn't like std::transform or range for loop here. 116 * See https://github.com/tensorflow/tensorflow/issues/15196 117 */ 118 for (llvm::Function::arg_iterator arg = function->arg_begin(), 119 arg_e = function->arg_end(); 120 arg != arg_e; ++arg) { 121 arg_values.push_back(arg); 122 } 123 if (null_arg_idx != -1) { 124 arg_values.insert(arg_values.begin() + null_arg_idx, nullptr); 125 } 126 kernel_body_generator(arg_values); 127 } else { 128 VLOG(3) << "Re-using kernel for " << kernel_name; 129 } 130 131 ir_builder->CreateCall(function, llvm_ir::AsArrayRef(sanitized_args)); 132 } 133 134 } // namespace xla 135
