Ticket #695: ro_695_r2.patch

graphics/SkeletonAnimManager.cpp

@@ -41 +41 @@
 // CSkeletonAnimManager destructor
 CSkeletonAnimManager::~CSkeletonAnimManager()
 {
-    typedef std::map<VfsPath,CSkeletonAnimDef*>::iterator Iter;
+    typedef boost::unordered_map<VfsPath,CSkeletonAnimDef*>::iterator Iter;
     for (Iter i = m_Animations.begin(); i != m_Animations.end(); ++i)
         delete i->second;
 }
@@ -54 +54 @@
     VfsPath name = fs::change_extension(pathname, L"");
 
     // Find if it's already been loaded
-    std::map<VfsPath, CSkeletonAnimDef*>::iterator iter = m_Animations.find(name);
+    boost::unordered_map<VfsPath, CSkeletonAnimDef*>::iterator iter = m_Animations.find(name);
     if (iter != m_Animations.end())
         return iter->second;
 

graphics/TextureManager.h

@@ -121 +121 @@
 {
     friend class CTextureManagerImpl;
     friend struct TextureCacheCmp;
+    friend struct TPequal_to;
+    friend struct TPhash;
 
 public:
     /**
@@ -151 +153 @@
     // easily tweaked in an Options menu? e.g. the caller just specifies
     // "terrain texture mode" and we combine it with the user's options.
     // That'd let us dynamically change texture properties easily.
-    //
+    //std::size_t hash_value(const CTexturePtr& a)
     // enum EQualityMode
     // {
     //   NONE,
@@ -180 +182 @@
 {
     friend class CTextureManagerImpl;
     friend struct TextureCacheCmp;
+    friend struct TPequal_to;
+    friend struct TPhash;
 
     // Only the texture manager can create these
     explicit CTexture(Handle handle, const CTextureProperties& props, CTextureManagerImpl* textureManager);
@@ -187 +191 @@
     NONCOPYABLE(CTexture);
 
 public:
+
     ~CTexture();
 
     /**

graphics/SkeletonAnimManager.h

@@ -25 +25 @@
 #include <map>
 #include <set>
 #include "lib/file/vfs/vfs_path.h"
+#include <boost/unordered_map.hpp>
 
 class CColladaManager;
 class CSkeletonAnimDef;
@@ -47 +48 @@
 
 private:
     // map of all known animations. Value is NULL if it failed to load.
-    std::map<VfsPath, CSkeletonAnimDef*> m_Animations;
+    boost::unordered_map<VfsPath, CSkeletonAnimDef*> m_Animations;
 
     CColladaManager& m_ColladaManager;
 };

graphics/TextureManager.cpp

@@ -31 +31 @@
 #include "ps/Filesystem.h"
 
 #include <iomanip>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+#include <boost/functional/hash.hpp>
 
-// Comparison functor that operates over texture properties, or
-// over the properties of a CTexturePtr (ignoring the mutable state like Handle).
-struct TextureCacheCmp
+struct TPhash
+     : std::unary_function<CTextureProperties, std::size_t>,
+     std::unary_function<CTexturePtr, std::size_t>
 {
-    bool operator()(const CTexturePtr& a, const CTexturePtr& b) const
+    std::size_t operator()(CTextureProperties const& a) const
     {
-        return (*this)(a->m_Properties, b->m_Properties);
+        std::size_t seed = 0;
+        boost::hash_combine(seed, a.m_Path.string());
+        boost::hash_combine(seed, a.m_Filter);
+        boost::hash_combine(seed, a.m_Wrap);
+        boost::hash_combine(seed, a.m_Aniso);
+        return seed;
     }
-
-    bool operator()(const CTextureProperties& a, const CTextureProperties& b) const
+    std::size_t operator()(CTexturePtr const& a) const
     {
-        if (a.m_Path < b.m_Path)
-            return true;
-        if (b.m_Path < a.m_Path)
-            return false;
-
-        if (a.m_Filter < b.m_Filter)
-            return true;
-        if (b.m_Filter < a.m_Filter)
-            return false;
-
-        if (a.m_Wrap < b.m_Wrap)
-            return true;
-        if (b.m_Wrap < a.m_Wrap)
-            return false;
-
-        if (a.m_Aniso < b.m_Aniso)
-            return true;
-        if (b.m_Aniso < a.m_Aniso)
-            return false;
-
-        return false;
+        return (*this)(a->m_Properties);
     }
 };
+struct TPequal_to
+    : std::binary_function<CTextureProperties, CTextureProperties, bool>,
+    std::binary_function<CTexturePtr, CTexturePtr, bool>
+{   
+    bool operator()(CTextureProperties const& a, CTextureProperties const& b) const
+    {
+        return a.m_Path == b.m_Path && a.m_Filter == b.m_Filter
+            && a.m_Wrap == b.m_Wrap && a.m_Aniso == b.m_Aniso;
+    }
+    bool operator()(CTexturePtr const& a, CTexturePtr const& b) const
+    {
+        return (*this)(a->m_Properties, b->m_Properties);
+    }
+};
 
+
 class CTextureManagerImpl
 {
     friend class CTexture;
@@ -479 +481 @@
     CTexturePtr m_ErrorTexture;
 
     // Cache of all loaded textures
-    typedef std::set<CTexturePtr, TextureCacheCmp> TextureCache;
+    typedef boost::unordered_set<CTexturePtr, TPhash, TPequal_to > TextureCache;
     TextureCache m_TextureCache;
     // TODO: we ought to expire unused textures from the cache eventually
 
     // Store the set of textures that need to be reloaded when the given file
     // (a source file or settings.xml) is modified
-    typedef std::map<VfsPath, std::set<boost::weak_ptr<CTexture> > > HotloadFilesMap;
+    typedef boost::unordered_map<VfsPath, std::set<boost::weak_ptr<CTexture> > > HotloadFilesMap;
     HotloadFilesMap m_HotloadFiles;
 
     // Cache for the conversion settings files
-    typedef std::map<VfsPath, shared_ptr<CTextureConverter::SettingsFile> > SettingsFilesMap;
+    typedef boost::unordered_map<VfsPath, shared_ptr<CTextureConverter::SettingsFile> > SettingsFilesMap;
     SettingsFilesMap m_SettingsFiles;
 };
 
-
 CTexture::CTexture(Handle handle, const CTextureProperties& props, CTextureManagerImpl* textureManager) :
     m_Handle(handle), m_BaseColour(0), m_State(UNLOADED), m_Properties(props), m_TextureManager(textureManager)
 {

lib/file/vfs/vfs_path.h

@@ -23 +23 @@
 #ifndef INCLUDED_VFS_PATH
 #define INCLUDED_VFS_PATH
 
+#include <boost/functional/hash.hpp>
+
 struct VfsPathTraits;
 
 /**
@@ -43 +45 @@
 
 typedef std::vector<VfsPath> VfsPaths;
 
+std::size_t hash_value(VfsPath const& b);
+
 struct VfsPathTraits
 {
     typedef std::wstring internal_string_type;

lib/file/vfs/vfs_path.cpp

@@ -22 +22 @@
 
 #include "precompiled.h"
 #include "lib/file/vfs/vfs_path.h"
+
+#include <iostream>
+#include <string>
+
+std::size_t hash_value(VfsPath const& b)
+{
+    boost::hash<std::wstring> hasher;
+    return hasher(b.string());
+}
+

lib/cache_adt.h

@@ -32 +32 @@
 #include <list>
 #include <map>
 #include <queue> // std::priority_queue
+#include <boost/unordered_map.hpp>
 
 /*
 Cache for items of variable size and value/"cost".
@@ -306 +307 @@
     }
 
 protected:
-    // note: hash_map is probably better in terms of locality
-    // (relevant when iterating over all items in remove_least_valuable),
-    // but would require a hash comparator for VfsPath.
-    class Map : public std::map<Key, Entry>
+    class Map : public boost::unordered_map<Key, Entry>
     {
     public:
         static Entry& entry_from_it(typename Map::iterator it) { return it->second; }