PipelineExecutor.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_PIPELINEEXECUTOR_H
#define TALVOS_PIPELINEEXECUTOR_H

#include <atomic>
#include <condition_variable>
#include <functional>
#include <map>
#include <thread>
#include <vector>

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

namespace talvos
{

class Command;
class Device;
class DispatchCommand;
class DrawCommandBase;
class Framebuffer;
class Invocation;
class Memory;
class Object;
class PipelineStage;
class RenderPassInstance;
class Type;
class Variable;
class Workgroup;

class PipelineExecutorKey
{
  friend class Device;
  PipelineExecutorKey(){};
};

// TODO: Define proper Vec2/Vec3/Vec4/Vec<N> classes?
struct Vec4
{
  float X, Y, Z, W;
};

class PipelineExecutor
{
public:
  PipelineExecutor(PipelineExecutorKey Key, Device &Dev);

  ~PipelineExecutor();

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

  const Invocation *getCurrentInvocation() const;

  const Workgroup *getCurrentWorkgroup() const;

  const PipelineStage &getCurrentStage() const { return *CurrentStage; }

  bool isWorkerThread() const;

  void run(const DispatchCommand &Cmd);

  void run(const DrawCommandBase &Cmd);

  void signalError();

private:
  struct RenderPipelineState;

  struct VertexOutput;

  struct PointPrimitive;

  struct TrianglePrimitive;

  struct Fragment
  {
    uint32_t X;  
    uint32_t Y;  
    float Depth; 
    float InvW;  
  };

  void doWork(std::function<void()> Task);

  void runWorker();

  void runComputeWorker();

  void runTriangleFragmentWorker(TrianglePrimitive Primitive,
                                 const PipelineContext &PC,
                                 const RenderPassInstance &RPI,
                                 const VkViewport &Viewport);

  void runPointFragmentWorker(PointPrimitive Primitive,
                              const RenderPassInstance &RPI);

  void runVertexWorker(RenderPipelineState *State, uint32_t InstanceIndex);

  void finalizeVariables(const DescriptorSetMap &DSM);

  void initializeVariables(const DescriptorSetMap &DSM,
                           uint64_t PushConstantAddress);

  void buildPendingFragments(const DrawCommandBase &Cmd, int XMinFB, int XMaxFB,
                             int YMinFB, int YMaxFB);

  void processFragment(const Fragment &Frag, const RenderPassInstance &RPI,
                       std::function<void(uint32_t, uint32_t, const Variable *,
                                          const Type *, Memory *, uint64_t)>
                           GenLocData);

  void rasterizePoint(const DrawCommandBase &Cmd, const VkViewport &Viewport,
                      const VertexOutput &Vertex);

  void rasterizeTriangle(const DrawCommandBase &Cmd, const VkViewport &Viewport,
                         const VertexOutput &VA, const VertexOutput &VB,
                         const VertexOutput &VC);

  static Vec4 getPosition(const VertexOutput &Out);

  void loadVertexInput(const PipelineContext &PC, Memory *PipelineMemory,
                       uint64_t Address, uint32_t VertexIndex,
                       uint32_t InstanceIndex, uint32_t Location,
                       uint32_t Component, const Type *ElemTy) const;

  Device &Dev;

  const Command *CurrentCommand;

  const PipelineStage *CurrentStage;

  std::vector<Object> Objects;

  unsigned NumThreads;

  std::vector<std::thread> WorkerThreads;

  bool ShutDownWorkers;

  std::function<void()> CurrentTask;

  uint32_t CurrentTaskID = 0;

  std::mutex WorkerMutex;

  std::condition_variable WorkerSignal;

  std::condition_variable MasterSignal;

  std::atomic<uint32_t> NumWorkersFinished;

  std::atomic<size_t> NextWorkIndex;

  std::vector<Dim3> PendingGroups;

  std::vector<Workgroup *> RunningGroups;

  std::vector<Dim3> PendingFragments;

  Workgroup *createWorkgroup(Dim3 GroupId) const;

  // Interactive debugging functionality.
  bool Continue;    
  bool Interactive; 

  void interact();

  void printContext() const;

  std::vector<std::string> LastLine;

  static uint32_t NextBreakpoint;

  static std::map<uint32_t, uint32_t> Breakpoints;

  bool brk(const std::vector<std::string> &Args);
  bool breakpoint(const std::vector<std::string> &Args);
  bool cont(const std::vector<std::string> &Args);
  bool help(const std::vector<std::string> &Args);
  bool print(const std::vector<std::string> &Args);
  bool quit(const std::vector<std::string> &Args);
  bool step(const std::vector<std::string> &Args);
  bool swtch(const std::vector<std::string> &Args);
};

} // namespace talvos

#endif