| //===- LoopGeneratorsKMP.h - IR helper to create loops ----------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file contains functions to create scalar and OpenMP parallel loops |
| // as LLVM-IR. |
| // |
| //===----------------------------------------------------------------------===// |
| #ifndef POLLY_LOOP_GENERATORS_KMP_H |
| #define POLLY_LOOP_GENERATORS_KMP_H |
| |
| #include "polly/CodeGen/IRBuilder.h" |
| #include "polly/CodeGen/LoopGenerators.h" |
| #include "polly/Support/ScopHelper.h" |
| #include "llvm/ADT/SetVector.h" |
| |
| namespace polly { |
| using llvm::GlobalValue; |
| using llvm::GlobalVariable; |
| |
| /// This ParallelLoopGenerator subclass handles the generation of parallelized |
| /// code, utilizing the LLVM OpenMP library. |
| class ParallelLoopGeneratorKMP final : public ParallelLoopGenerator { |
| public: |
| /// Create a parallel loop generator for the current function. |
| ParallelLoopGeneratorKMP(PollyIRBuilder &Builder, const DataLayout &DL) |
| : ParallelLoopGenerator(Builder, DL) { |
| SourceLocationInfo = createSourceLocation(); |
| } |
| |
| protected: |
| /// The source location struct of this loop. |
| /// ident_t = type { i32, i32, i32, i32, i8* } |
| GlobalValue *SourceLocationInfo; |
| |
| /// Convert the combination of given chunk size and scheduling type (which |
| /// might have been set via the command line) into the corresponding |
| /// scheduling type. This may result (e.g.) in a 'change' from |
| /// "static chunked" scheduling to "static non-chunked" (regarding the |
| /// provided and returned scheduling types). |
| /// |
| /// @param ChunkSize The chunk size, set via command line or its default. |
| /// @param Scheduling The scheduling, set via command line or its default. |
| /// |
| /// @return The corresponding OMPGeneralSchedulingType. |
| OMPGeneralSchedulingType |
| getSchedType(int ChunkSize, OMPGeneralSchedulingType Scheduling) const; |
| |
| /// Returns True if 'LongType' is 64bit wide, otherwise: False. |
| bool is64BitArch(); |
| |
| public: |
| // The functions below may be used if one does not want to generate a |
| // specific OpenMP parallel loop, but generate individual parts of it |
| // (e.g. the subfunction definition). |
| |
| /// Create a runtime library call to spawn the worker threads. |
| /// |
| /// @param SubFn The subfunction which holds the loop body. |
| /// @param SubFnParam The parameter for the subfunction (basically the struct |
| /// filled with the outside values). |
| /// @param LB The lower bound for the loop we parallelize. |
| /// @param UB The upper bound for the loop we parallelize. |
| /// @param Stride The stride of the loop we parallelize. |
| void createCallSpawnThreads(Value *SubFn, Value *SubFnParam, Value *LB, |
| Value *UB, Value *Stride); |
| |
| void deployParallelExecution(Function *SubFn, Value *SubFnParam, Value *LB, |
| Value *UB, Value *Stride) override; |
| |
| Function *prepareSubFnDefinition(Function *F) const override; |
| |
| std::tuple<Value *, Function *> createSubFn(Value *Stride, AllocaInst *Struct, |
| SetVector<Value *> UsedValues, |
| ValueMapT &VMap) override; |
| |
| /// Create a runtime library call to get the current global thread number. |
| /// |
| /// @return A Value ref which holds the current global thread number. |
| Value *createCallGlobalThreadNum(); |
| |
| /// Create a runtime library call to request a number of threads. |
| /// Which will be used in the next OpenMP section (by the next fork). |
| /// |
| /// @param GlobalThreadID The global thread ID. |
| /// @param NumThreads The number of threads to use. |
| void createCallPushNumThreads(Value *GlobalThreadID, Value *NumThreads); |
| |
| /// Create a runtime library call to prepare the OpenMP runtime. |
| /// For dynamically scheduled loops, saving the loop arguments. |
| /// |
| /// @param GlobalThreadID The global thread ID. |
| /// @param LB The loop's lower bound. |
| /// @param UB The loop's upper bound. |
| /// @param Inc The loop increment. |
| /// @param ChunkSize The chunk size of the parallel loop. |
| void createCallDispatchInit(Value *GlobalThreadID, Value *LB, Value *UB, |
| Value *Inc, Value *ChunkSize); |
| |
| /// Create a runtime library call to retrieve the next (dynamically) |
| /// allocated chunk of work for this thread. |
| /// |
| /// @param GlobalThreadID The global thread ID. |
| /// @param IsLastPtr Pointer to a flag, which is set to 1 if this is |
| /// the last chunk of work, or 0 otherwise. |
| /// @param LBPtr Pointer to the lower bound for the next chunk. |
| /// @param UBPtr Pointer to the upper bound for the next chunk. |
| /// @param StridePtr Pointer to the stride for the next chunk. |
| /// |
| /// @return A Value which holds 1 if there is work to be done, 0 otherwise. |
| Value *createCallDispatchNext(Value *GlobalThreadID, Value *IsLastPtr, |
| Value *LBPtr, Value *UBPtr, Value *StridePtr); |
| |
| /// Create a runtime library call to prepare the OpenMP runtime. |
| /// For statically scheduled loops, saving the loop arguments. |
| /// |
| /// @param GlobalThreadID The global thread ID. |
| /// @param IsLastPtr Pointer to a flag, which is set to 1 if this is |
| /// the last chunk of work, or 0 otherwise. |
| /// @param LBPtr Pointer to the lower bound for the next chunk. |
| /// @param UBPtr Pointer to the upper bound for the next chunk. |
| /// @param StridePtr Pointer to the stride for the next chunk. |
| /// @param ChunkSize The chunk size of the parallel loop. |
| void createCallStaticInit(Value *GlobalThreadID, Value *IsLastPtr, |
| Value *LBPtr, Value *UBPtr, Value *StridePtr, |
| Value *ChunkSize); |
| |
| /// Create a runtime library call to mark the end of |
| /// a statically scheduled loop. |
| /// |
| /// @param GlobalThreadID The global thread ID. |
| void createCallStaticFini(Value *GlobalThreadID); |
| |
| /// Create the current source location. |
| /// |
| /// TODO: Generates only(!) dummy values. |
| GlobalVariable *createSourceLocation(); |
| }; |
| } // end namespace polly |
| #endif |