ShMemory.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef SHMEMORY_HPP
#define SHMEMORY_HPP

#include <list>
#include <map>
#include <utility>
#include <string>
#include "ShDllExport.hpp"
#include "ShRefCount.hpp"
#include "ShMemoryDep.hpp"

namespace SH {

class ShStorage;

class
SH_DLLEXPORT ShMemory : public ShRefCountable {
public:
  virtual ~ShMemory();

  int timestamp() const;

  ShPointer<ShStorage> findStorage(const std::string& id);

  template<typename Functor>
  ShPointer<ShStorage> findStorage(const std::string& id, const Functor& f);

  void removeStorage(const ShPointer<ShStorage>& storage);

  void add_dep(ShMemoryDep* dep);

  void flush();

protected:
  ShMemory();
  
private:
  void updateTimestamp(int timestamp);

  void addStorage(const ShPointer<ShStorage>& storage);

  typedef std::list< ShPointer<ShStorage> > StorageList;
  StorageList m_storages;
  int m_timestamp;

  std::list<ShMemoryDep*> dependencies;

  friend class ShStorage;

  ShMemory& operator=(const ShMemory& other);
  ShMemory(const ShMemory& other);
};

typedef ShPointer<ShMemory> ShMemoryPtr;
typedef ShPointer<const ShMemory> ShMemoryCPtr;

class
SH_DLLEXPORT ShTransfer {
public:
  virtual ~ShTransfer() {}

  virtual bool transfer(const ShStorage* from, ShStorage* to) = 0;

  virtual int cost() = 0;

protected:
  ShTransfer(const std::string& from, const std::string& to);

private:
  
  ShTransfer(const ShTransfer& other);
  ShTransfer& operator=(const ShTransfer& other);
};

class
SH_DLLEXPORT ShStorage : public ShRefCountable {
public:
  ShStorage();
  virtual ~ShStorage();

  int timestamp() const;
  void setTimestamp(int timestamp);
  const ShMemory* memory() const;
  ShMemory* memory();

  void sync();

  void dirty();
  
  // Mark an upcoming write to this storage.
  void dirtyall();
  
  virtual std::string id() const = 0;
  
  static int cost(ShStorage* from, ShStorage* to);

  static bool transfer(ShStorage* from, ShStorage* to);

  static void addTransfer(const std::string& from,
                          const std::string& to,
                          ShTransfer* transfer);

  void orphan();
  
protected:
  ShStorage(ShMemory* memory);

private:
  ShMemory* m_memory;
  int m_timestamp;

  typedef std::map<std::pair<std::string, std::string>, ShTransfer*> TransferMap;
  static TransferMap* m_transfers;

  ShStorage(const ShStorage& other);
  ShStorage& operator=(const ShStorage& other);
};

typedef ShPointer<ShStorage> ShStoragePtr;
typedef ShPointer<const ShStorage> ShStorageCPtr;

class
SH_DLLEXPORT ShHostStorage : public ShStorage {
public:
  ShHostStorage(ShMemory* memory, int length); 
  ShHostStorage(ShMemory* memory, int length, void* data); 

  ~ShHostStorage();

  std::string id() const;

  int length() const;

  const void* data() const;
  void* data();
  
private:
  int m_length; 
  void* m_data; 

  bool m_managed; 

  // NOT IMPLEMENTED
  ShHostStorage& operator=(const ShHostStorage& other);
  ShHostStorage(const ShHostStorage& other);
};

typedef ShPointer<ShHostStorage> ShHostStoragePtr;
typedef ShPointer<const ShHostStorage> ShHostStorageCPtr;

class
SH_DLLEXPORT ShHostMemory : public ShMemory {
public:
  ShHostMemory(int length);
  ShHostMemory(int length, void* data);

  ~ShHostMemory();

  ShHostStoragePtr hostStorage();
  ShPointer<const ShHostStorage> hostStorage() const;

private:
  ShHostStoragePtr m_hostStorage;
  // NOT IMPLEMENTED
  ShHostMemory& operator=(const ShHostMemory& other);
  ShHostMemory(const ShHostMemory& other);
};

typedef ShPointer<ShHostMemory> ShHostMemoryPtr;
typedef ShPointer<const ShHostMemory> ShHostMemoryCPtr;

template<typename Functor>
ShPointer<ShStorage> ShMemory::findStorage(const std::string& id, const Functor& f)
{
  for (StorageList::iterator I = m_storages.begin(); I != m_storages.end(); ++I) {
    if ((*I)->id() == id && f(*I)) return *I;
  }
  return 0;
}

}

#endif

---