Device.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_DEVICE_H
#define TALVOS_DEVICE_H

#include <condition_variable>
#include <memory>
#include <mutex>
#include <vector>

namespace talvos
{

class Command;
class Instruction;
class Invocation;
class Memory;
class PipelineExecutor;
class Plugin;
class Workgroup;

class Device
{
public:
  Device();
  ~Device();

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

  Memory &getGlobalMemory() { return *GlobalMemory; }

  PipelineExecutor &getPipelineExecutor() { return *Executor; }

  bool isThreadSafe() const;

  void notifyFenceSignaled();

  void reportError(const std::string &Error, bool Fatal = false);

  void reportAtomicAccess(const Memory *Mem, uint64_t Address,
                          uint64_t NumBytes, uint32_t Opcode, uint32_t Scope,
                          uint32_t Semantics);
  void reportCommandBegin(const Command *Cmd);
  void reportCommandComplete(const Command *Cmd);
  void reportInstructionExecuted(const Invocation *Invoc,
                                 const Instruction *Inst);
  void reportInvocationBegin(const Invocation *Invoc);
  void reportInvocationComplete(const Invocation *Invoc);
  void reportMemoryLoad(const Memory *Mem, uint64_t Address, uint64_t NumBytes);
  void reportMemoryMap(const Memory *Mem, uint64_t Base, uint64_t Offset,
                       uint64_t NumBytes);
  void reportMemoryStore(const Memory *Mem, uint64_t Address, uint64_t NumBytes,
                         const uint8_t *Data);
  void reportMemoryUnmap(const Memory *Mem, uint64_t Base);
  void reportWorkgroupBegin(const Workgroup *Group);
  void reportWorkgroupBarrier(const Workgroup *Group);
  void reportWorkgroupComplete(const Workgroup *Group);

  bool waitForFences(const std::vector<const bool *> &Fences, bool WaitAll,
                     uint64_t Timeout) const;

private:
  Memory *GlobalMemory; 

  std::vector<std::pair<void *, Plugin *>> Plugins;

  PipelineExecutor *Executor;

  size_t MaxErrors;

  mutable std::mutex FenceMutex;

  mutable std::condition_variable FenceSignaled;
};

} // namespace talvos

#endif