configmgr: implement a single item cache for node lookup.

Saves 13.5m cycles on a headless start, 1.3%.

Change-Id: I73f0dd8a523f84c765a217ee95aea9bcc3db1b5d

configmgr/source/nodemap.cxx

@@ -32,16 +32,20 @@ namespace configmgr {
 void NodeMap::cloneInto(NodeMap * target) const
 {
     assert(target != 0 && target->empty());
-    NodeMapImpl clone(aImpl);
+    NodeMapImpl clone(maImpl);
     for (NodeMapImpl::iterator i(clone.begin()); i != clone.end(); ++i) {
         i->second = i->second->clone(true);
     }
-    std::swap(clone, target->aImpl);
+    std::swap(clone, target->maImpl);
+    target->clearCache();
 }
 
 rtl::Reference< Node > NodeMap::findNode(int layer, OUString const & name) const
 {
-    const_iterator i(aImpl.find(name));
+    const_iterator i;
+    if (maCache == end() || maCache->first != name)
+        maCache = const_cast< NodeMap *>(this)->maImpl.find(name);
+    i = maCache;
     return i == end() || i->second->getLayer() > layer
         ? rtl::Reference< Node >() : i->second;
 }

configmgr/source/nodemap.hxx

@@ -30,34 +30,41 @@ namespace configmgr {
 typedef std::map< OUString, rtl::Reference< Node > > NodeMapImpl;
 class NodeMap
 {
-    NodeMapImpl aImpl;
+    NodeMapImpl maImpl;
+
     NodeMap(const NodeMap &rMap) :
-        aImpl(rMap.aImpl) {}
+        maImpl(rMap.maImpl) { clearCache(); }
 
   public:
     typedef NodeMapImpl::iterator iterator;
     typedef NodeMapImpl::const_iterator const_iterator;
     typedef NodeMapImpl::value_type value_type;
 
-     NodeMap() {}
+     NodeMap() { clearCache(); }
     ~NodeMap() {}
-    void clear() { aImpl.clear(); }
-    bool empty() const { return aImpl.empty(); }
-    void erase(const iterator &it) { aImpl.erase(it); }
-    void erase(const OUString &aStr) { aImpl.erase(aStr); }
-    iterator find(const OUString &aStr) { return aImpl.find( aStr ); }
+    bool empty() const { return maImpl.empty(); }
+    iterator find(const OUString &aStr) { return maImpl.find( aStr ); }
+
+    const_iterator find(const OUString &aStr) const { return maImpl.find( aStr ); }
+    iterator begin() { return maImpl.begin(); }
+    const_iterator begin() const { return maImpl.begin(); }
 
-    const_iterator find(const OUString &aStr) const { return aImpl.find( aStr ); }
-    rtl::Reference<Node> &operator[](const OUString &aStr) { return aImpl[aStr]; }
-    iterator begin() { return aImpl.begin(); }
-    const_iterator begin() const { return aImpl.begin(); }
+    iterator end() { return maImpl.end(); }
+    const_iterator end() const { return maImpl.end(); }
 
-    iterator end() { return aImpl.end(); }
-    const_iterator end() const { return aImpl.end(); }
-    std::pair<iterator,bool> insert(const value_type &vt) { return aImpl.insert(vt); }
+    rtl::Reference<Node> &operator[](const OUString &aStr) { return maImpl[aStr]; clearCache(); }
+    std::pair<iterator,bool> insert(const value_type &vt) { return maImpl.insert(vt); clearCache(); }
+    void clear() { maImpl.clear(); clearCache(); }
+    void erase(const iterator &it) { maImpl.erase(it); clearCache(); }
+    void erase(const OUString &aStr) { maImpl.erase(aStr); clearCache(); }
 
     rtl::Reference< Node > findNode(int layer, OUString const & name) const;
     void cloneInto(NodeMap * target) const;
+
+private:
+    // We get a large number of repeated identical lookups.
+    mutable const_iterator maCache;
+    void clearCache() { maCache = maImpl.end(); }
 };
 
 }