Memory.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_MEMORY_H
#define TALVOS_MEMORY_H

#include <cstdint>
#include <cstring>
#include <mutex>
#include <vector>

namespace talvos
{

class Device;

enum class MemoryScope
{
  Device,
  Workgroup,
  Invocation
};

class Memory
{
public:
  Memory(Device &D, MemoryScope Scope);

  ~Memory();

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

  uint64_t allocate(uint64_t NumBytes);

  template <typename T>
  T atomic(uint64_t Address, uint32_t Opcode, uint32_t Scope,
           uint32_t Semantics, T Value = 0);

  uint32_t atomicCmpXchg(uint64_t Address, uint32_t Scope,
                         uint32_t EqualSemantics, uint32_t UnequalSemantics,
                         uint32_t Value, uint32_t Comparator);

  void dump() const;

  void dump(uint64_t Address) const;

  MemoryScope getScope() const { return Scope; }

  void load(uint8_t *Result, uint64_t Address, uint64_t NumBytes) const;

  uint8_t *map(uint64_t Base, uint64_t Offset, uint64_t NumBytes);

  void release(uint64_t Address);

  void store(uint64_t Address, uint64_t NumBytes, const uint8_t *Data);

  void unmap(uint64_t Base);

  static void copy(uint64_t DstAddress, Memory &DstMem, uint64_t SrcAddress,
                   const Memory &SrcMem, uint64_t NumBytes);

  static const char *scopeToString(MemoryScope Scope)
  {
    switch (Scope)
    {
    case MemoryScope::Device:
      return "Device";
    case MemoryScope::Workgroup:
      return "Workgroup";
    case MemoryScope::Invocation:
      return "Invocation";
    default:
      return "<invalid>";
    }
  }

private:
  Device &Dev; 

  MemoryScope Scope; 

  std::mutex Mutex; 

  static const uint32_t NUM_ATOMIC_MUTEXES = 100;

  std::mutex AtomicMutexes[NUM_ATOMIC_MUTEXES];

  struct Buffer
  {
    uint64_t NumBytes; 
    uint8_t *Data;     
  };
  std::vector<Buffer> Buffers;       
  std::vector<uint64_t> FreeBuffers; 

  bool isAccessValid(uint64_t Address, uint64_t NumBytes) const;
};

} // namespace talvos

#endif