ShMemory.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2006 Serious Hack Inc.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#ifndef SHMEMORY_HPP
#define SHMEMORY_HPP

#include <list>
#include <map>
#include <utility>
#include <string>
#include "ShDllExport.hpp"
#include "ShRefCount.hpp"
#include "ShMemoryDep.hpp"
#include "ShStorageType.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);
  template<typename Functor>
  ShPointer<ShStorage> findStorage(const std::string& id, Functor& f);

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

  void add_dep(ShMemoryDep* dep);

  void flush();
  
  void freeze(bool state);

protected:
  ShMemory();

private:
  int increment_timestamp();

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

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

  bool m_frozen;
  int m_frozenTimestamp;

  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(const ShStorage* from, const ShStorage* to) = 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;
  
  const ShMemory* memory() const;
  ShMemory* memory();

  void sync() const;

  void dirty();
  
  void dirtyall();
  
  virtual std::string id() const = 0;
  
  static int cost(const ShStorage* from, const ShStorage* to);

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

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

  void orphan();
  
  ShValueType value_type() const { return m_value_type; }

  void value_type(ShValueType value_type);

  int value_size() const { return m_value_size; }

protected:
  ShStorage(ShMemory* memory, ShValueType value_type);
  
  ShValueType m_value_type; // type index expected of data on host
  int m_value_size; // size of one element

private:
  ShMemory* m_memory;
  int m_timestamp;

  void setTimestamp(int 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, std::size_t length, ShValueType storage_type); 
  ShHostStorage(ShMemory* memory, std::size_t length, void* data, ShValueType storage_type); 

  ~ShHostStorage();

  std::string id() const;

  std::size_t length() const;

  const void* data() const;
  void* data();
  
private:
  std::size_t 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(std::size_t length, ShValueType value_type);
  ShHostMemory(std::size_t length, void* data, ShValueType value_type);

  ~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, Functor& f)
{
  for (StorageList::iterator I = m_storages.begin(); I != m_storages.end(); ++I) {
    if ((*I)->id() == id && f(*I)) return *I;
  }
  return 0;
}

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

---