Invocation.h

Go to the documentation of this file.

// Copyright (c) 2018 the Talvos developers. All rights reserved.
//
// This file is distributed under a three-clause BSD license. For full license
// terms please see the LICENSE file distributed with this source code.


#ifndef TALVOS_INVOCATION_H
#define TALVOS_INVOCATION_H

#include <vector>

#include "talvos/Dim3.h"
#include "talvos/Object.h"

namespace talvos
{

class Device;
class Function;
class Instruction;
class Memory;
class Module;
class PipelineStage;
class Workgroup;

class Invocation
{
public:
  enum State
  {
    READY,
    BARRIER,
    FINISHED
  };

public:
  Invocation(Device &Dev, const std::vector<Object> &InitialObjects);

  Invocation(Device &Dev, const PipelineStage &Stage,
             const std::vector<Object> &InitialObjects,
             std::shared_ptr<Memory> PipelineMemory, Workgroup *Group,
             Dim3 GlobalId);

  ~Invocation();

  // Do not allow Invocation objects to be copied.
  Invocation(const Invocation &) = delete;
  Invocation &operator=(const Invocation &) = delete;

  void clearBarrier() { AtBarrier = false; }

  void execute(const Instruction *Inst);

  const Instruction *getCurrentInstruction() const
  {
    return CurrentInstruction;
  }

  Dim3 getGlobalId() const { return GlobalId; }

  Object getObject(uint32_t Id) const;

  State getState() const;

  void step();

  bool wasDiscarded() const { return Discarded; }

  void executeAccessChain(const Instruction *Inst);
  void executeAll(const Instruction *Inst);
  void executeAny(const Instruction *Inst);
  void executeAtomicCompareExchange(const Instruction *Inst);
  template <typename T> void executeAtomicOp(const Instruction *Inst);
  void executeBitcast(const Instruction *Inst);
  void executeBitwiseAnd(const Instruction *Inst);
  void executeBitwiseOr(const Instruction *Inst);
  void executeBitwiseXor(const Instruction *Inst);
  void executeBranch(const Instruction *Inst);
  void executeBranchConditional(const Instruction *Inst);
  void executeCompositeConstruct(const Instruction *Inst);
  void executeCompositeExtract(const Instruction *Inst);
  void executeCompositeInsert(const Instruction *Inst);
  void executeControlBarrier(const Instruction *Inst);
  void executeConvertFToS(const Instruction *Inst);
  void executeConvertFToU(const Instruction *Inst);
  void executeConvertSToF(const Instruction *Inst);
  void executeConvertUToF(const Instruction *Inst);
  void executeCopyMemory(const Instruction *Inst);
  void executeCopyObject(const Instruction *Inst);
  void executeDot(const Instruction *Inst);
  void executeExtInst(const Instruction *Inst);
  void executeFAdd(const Instruction *Inst);
  void executeFConvert(const Instruction *Inst);
  void executeFDiv(const Instruction *Inst);
  void executeFMod(const Instruction *Inst);
  void executeFMul(const Instruction *Inst);
  void executeFNegate(const Instruction *Inst);
  void executeFOrdEqual(const Instruction *Inst);
  void executeFOrdGreaterThan(const Instruction *Inst);
  void executeFOrdGreaterThanEqual(const Instruction *Inst);
  void executeFOrdLessThan(const Instruction *Inst);
  void executeFOrdLessThanEqual(const Instruction *Inst);
  void executeFOrdNotEqual(const Instruction *Inst);
  void executeFRem(const Instruction *Inst);
  void executeFSub(const Instruction *Inst);
  void executeFunctionCall(const Instruction *Inst);
  void executeFUnordEqual(const Instruction *Inst);
  void executeFUnordGreaterThan(const Instruction *Inst);
  void executeFUnordGreaterThanEqual(const Instruction *Inst);
  void executeFUnordLessThan(const Instruction *Inst);
  void executeFUnordLessThanEqual(const Instruction *Inst);
  void executeFUnordNotEqual(const Instruction *Inst);
  void executeIAdd(const Instruction *Inst);
  void executeIEqual(const Instruction *Inst);
  void executeImage(const Instruction *Inst);
  void executeImageQuerySize(const Instruction *Inst);
  void executeImageRead(const Instruction *Inst);
  void executeImageSampleExplicitLod(const Instruction *Inst);
  void executeImageWrite(const Instruction *Inst);
  void executeIMul(const Instruction *Inst);
  void executeINotEqual(const Instruction *Inst);
  void executeIsInf(const Instruction *Inst);
  void executeIsNan(const Instruction *Inst);
  void executeISub(const Instruction *Inst);
  void executeKill(const Instruction *Inst);
  void executeLoad(const Instruction *Inst);
  void executeLogicalAnd(const Instruction *Inst);
  void executeLogicalEqual(const Instruction *Inst);
  void executeLogicalNot(const Instruction *Inst);
  void executeLogicalNotEqual(const Instruction *Inst);
  void executeLogicalOr(const Instruction *Inst);
  void executeMatrixTimesScalar(const Instruction *Inst);
  void executeMatrixTimesVector(const Instruction *Inst);
  void executeNot(const Instruction *Inst);
  void executePhi(const Instruction *Inst);
  void executeReturn(const Instruction *Inst);
  void executeReturnValue(const Instruction *Inst);
  void executeSampledImage(const Instruction *Inst);
  void executeSConvert(const Instruction *Inst);
  void executeSDiv(const Instruction *Inst);
  void executeSelect(const Instruction *Inst);
  void executeSGreaterThan(const Instruction *Inst);
  void executeSGreaterThanEqual(const Instruction *Inst);
  void executeShiftLeftLogical(const Instruction *Inst);
  void executeShiftRightArithmetic(const Instruction *Inst);
  void executeShiftRightLogical(const Instruction *Inst);
  void executeSLessThan(const Instruction *Inst);
  void executeSLessThanEqual(const Instruction *Inst);
  void executeSMod(const Instruction *Inst);
  void executeSNegate(const Instruction *Inst);
  void executeSRem(const Instruction *Inst);
  void executeStore(const Instruction *Inst);
  void executeSwitch(const Instruction *Inst);
  void executeUConvert(const Instruction *Inst);
  void executeUDiv(const Instruction *Inst);
  void executeUGreaterThan(const Instruction *Inst);
  void executeUGreaterThanEqual(const Instruction *Inst);
  void executeULessThan(const Instruction *Inst);
  void executeULessThanEqual(const Instruction *Inst);
  void executeUMod(const Instruction *Inst);
  void executeUndef(const Instruction *Inst);
  void executeUnreachable(const Instruction *Inst);
  void executeVariable(const Instruction *Inst);
  void executeVectorExtractDynamic(const Instruction *Inst);
  void executeVectorInsertDynamic(const Instruction *Inst);
  void executeVectorShuffle(const Instruction *Inst);
  void executeVectorTimesMatrix(const Instruction *Inst);
  void executeVectorTimesScalar(const Instruction *Inst);

private:
  std::shared_ptr<const Module> CurrentModule;

  const Function *CurrentFunction;       
  const Instruction *CurrentInstruction; 
  uint32_t CurrentBlock;                 
  uint32_t PreviousBlock;                
  bool AtBarrier;                        
  bool Discarded;                        

  struct StackEntry
  {
    // The instruction, block, and function to return to.
    const Instruction *CallInst; 
    const Function *CallFunc;    
    uint32_t CallBlock;          

    std::vector<uint64_t> Allocations;
  };

  std::vector<StackEntry> CallStack; 

  std::vector<Object> Objects; 

  Device &Dev;           
  Workgroup *Group;      
  Dim3 GlobalId;         
  Memory *PrivateMemory; 

  std::shared_ptr<Memory> PipelineMemory;

  std::vector<std::pair<uint32_t, Object>> PhiTemps;

  template <typename OpTy, unsigned N, unsigned Offset = 2, typename F>
  void executeOp(const Instruction *Inst, const F &Op);
  template <unsigned N, unsigned Offset = 2, typename F>
  void executeOpFP(const Instruction *Inst, const F &&Op);
  template <unsigned N, unsigned Offset = 2, typename F>
  void executeOpSInt(const Instruction *Inst, const F &&Op);
  template <unsigned N, unsigned Offset = 2, typename F>
  void executeOpUInt(const Instruction *Inst, const F &&Op);

  Memory &getMemory(uint32_t StorageClass);

  void moveToBlock(uint32_t Id);
};

} // namespace talvos

#endif