Introduce select0/1 cache in LOUDS.

The common usage of LOUDS includes:
  i) traversal downward from the root (select0 is computed),
 ii) traversal upward to the root (select1 is computed).
In both cases, nodes close to the root are accessed.  Therefore, caching
select0/1 values for such nodes improves traversal speed.

BUG=
TEST=unittest
REF_BUG=21859420
REF_CL=96271561

Author: Noriyuki Takahashi

src/dictionary/system/system_dictionary.cc

@@ -80,6 +80,11 @@ namespace {
 
 const int kMinTokenArrayBlobSize = 4;
 
+const size_t kKeyTrieSelect0CacheSize = 4 * 1024;
+const size_t kKeyTrieSelect1CacheSize = 4 * 1024;
+const size_t kValueTrieSelect0CacheSize = 1 * 1024;
+const size_t kValueTrieSelect1CacheSize = 16 * 1024;
+
 // Expansion table format:
 // "<Character to expand>[<Expanded character 1><Expanded character 2>...]"
 //
@@ -500,7 +505,9 @@ bool SystemDictionary::OpenDictionaryFile(bool enable_reverse_lookup_index) {
 
   const uint8 *key_image = reinterpret_cast<const uint8 *>(
       dictionary_file_->GetSection(codec_->GetSectionNameForKey(), &len));
-  if (!key_trie_.Open(key_image)) {
+  if (!key_trie_.Open(key_image,
+                      kKeyTrieSelect0CacheSize,
+                      kKeyTrieSelect1CacheSize)) {
     LOG(ERROR) << "cannot open key trie";
     return false;
   }
@@ -509,7 +516,9 @@ bool SystemDictionary::OpenDictionaryFile(bool enable_reverse_lookup_index) {
 
   const uint8 *value_image = reinterpret_cast<const uint8 *>(
       dictionary_file_->GetSection(codec_->GetSectionNameForValue(), &len));
-  if (!value_trie_.Open(value_image)) {
+  if (!value_trie_.Open(value_image,
+                        kValueTrieSelect0CacheSize,
+                        kValueTrieSelect1CacheSize)) {
     LOG(ERROR) << "can not open value trie";
     return false;
   }

src/mozc_version_template.txt

@@ -1,6 +1,6 @@
 MAJOR=2
 MINOR=17
-BUILD=2259
+BUILD=2261
 REVISION=102
 # NACL_DICTIONARY_VERSION is the target version of the system dictionary to be
 # downloaded by NaCl Mozc.

src/storage/louds/louds.cc

@@ -0,0 +1,92 @@
+// Copyright 2010-2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "storage/louds/louds.h"
+
+namespace mozc {
+namespace storage {
+namespace louds {
+
+Louds::Louds() : select0_cache_size_(0), select1_cache_size_(0) {}
+
+Louds::~Louds() {}
+
+void Louds::Init(const uint8 *image, int length,
+                 size_t select0_cache_size, size_t select1_cache_size) {
+  index_.Init(image, length);
+
+  // Cap the cache sizes.
+  if (select0_cache_size > index_.GetNum0Bits()) {
+    select0_cache_size = index_.GetNum0Bits();
+  }
+  if (select1_cache_size > index_.GetNum1Bits()) {
+    select1_cache_size = index_.GetNum1Bits();
+  }
+
+  // Initialize Select0 and Select1 cache for speed.  In LOUDS traversal, nodes
+  // close to the root are frequently accessed.  Thus, we precompute select0 and
+  // select1 values for such nodes.  Since node IDs are assigned in BFS order,
+  // the nodes close to the root are assigned smaller IDs.  Hence, a simple
+  // array can be used for the mapping from ID to cached value.
+  select0_cache_size_ = select0_cache_size;
+  select1_cache_size_ = select1_cache_size;
+  const size_t cache_size = select0_cache_size + select1_cache_size;
+  if (cache_size == 0) {
+    return;
+  }
+  select_cache_.reset(new int[cache_size]);
+
+  if (select0_cache_size > 0) {
+    // Precompute Select0(i) + 1 for i in (0, select0_cache_size).
+    select_cache_[0] = 0;
+    for (size_t i = 1; i < select0_cache_size; ++i) {
+      select_cache_[i] = index_.Select0(i) + 1;
+    }
+  }
+
+  if (select1_cache_size > 0) {
+    // Precompute Select1(i) for i in (0, select1_cache_size).
+    select1_cache_ptr_ = select_cache_.get() + select0_cache_size;
+    select1_cache_ptr_[0] = 0;
+    for (size_t i = 1; i < select1_cache_size; ++i) {
+      select1_cache_ptr_[i] = index_.Select1(i);
+    }
+  }
+}
+
+void Louds::Reset() {
+  index_.Reset();
+  select_cache_.reset(nullptr);
+  select0_cache_size_ = 0;
+  select1_cache_size_ = 0;
+}
+
+}  // namespace louds
+}  // namespace storage
+}  // namespace mozc

src/storage/louds/louds.gyp

@@ -32,10 +32,14 @@
     # Implementation of a Trie data structure based on LOUDS and its builder.
     {
       'target_name': 'louds',
-      'type': 'none',
+      'type': 'static_library',
       'toolsets': ['target', 'host'],
       'sources': [
-        'louds.h',
+        'louds.cc',
+      ],
+      'dependencies': [
+        '../../base/base.gyp:base',
+        'simple_succinct_bit_vector_index',
       ],
     },
     {

src/storage/louds/louds.h

@@ -30,6 +30,8 @@
 #ifndef MOZC_STORAGE_LOUDS_LOUDS_H_
 #define MOZC_STORAGE_LOUDS_LOUDS_H_
 
+#include <memory>
+
 #include "base/port.h"
 #include "storage/louds/simple_succinct_bit_vector_index.h"
 
@@ -57,7 +59,8 @@ namespace louds {
 //  Node:  0   1    2  3    4  5
 // LOUDS:  10  110  0  110  0  0
 //
-// This class provides basic APIs to traverse a tree structure.
+// This class provides basic APIs to traverse a tree structure.  Performance
+// critical methods are inlined.
 class Louds {
  public:
   // Represents and stores location (tree node) for tree traversal.  By storing
@@ -86,26 +89,34 @@ class Louds {
     friend class Louds;
   };
 
-  Louds() {}
-  ~Louds() {}
+  Louds();
+  ~Louds();
+
+  // Initializes this LOUDS from bit array.  To improve the performance of
+  // downward traversal (i.e., from root to leaves), set |select0_cache_size| to
+  // a larger value.  On the other hand, to improve the performance of upward
+  // traversal (i.e., from leaves to the root), set |select1_cache_size| to a
+  // larger value.
+  void Init(const uint8 *image, int length,
+            size_t select0_cache_size, size_t select1_cache_size);
 
-  // Initializes this LOUDS from bit array.
+  // Initializes this LOUDS from bit array without cache.
   void Init(const uint8 *image, int length) {
-    index_.Init(image, length);
+    Init(image, length, 0, 0);
   }
 
   // Explicitly clears the internal bit array.
-  void Reset() {
-    index_.Reset();
-  }
+  void Reset();
 
   // APIs for traversal (all the methods are inline for performance).
 
   // Initializes a Node instance from node ID.
   // Note: to get the root node, just allocate a default Node instance.
   void InitNodeFromNodeId(int node_id, Node *node) const {
     node->node_id_ = node_id;
-    node->edge_index_ = index_.Select1(node->node_id_);
+    node->edge_index_ = node_id < select1_cache_size_
+                            ? select1_cache_ptr_[node_id]
+                            : index_.Select1(node_id);
   }
 
   // Returns true if the given node is the root.
@@ -121,7 +132,9 @@ class Louds {
   //   * node 4 -> invalid node
   // REQUIRES: |node| is valid.
   void MoveToFirstChild(Node *node) const {
-    node->edge_index_ = index_.Select0(node->node_id_) + 1;
+    node->edge_index_ = node->node_id_ < select0_cache_size_
+                            ? select_cache_[node->node_id_]
+                            : index_.Select0(node->node_id_) + 1;
     node->node_id_ = node->edge_index_ - node->node_id_ + 1;
   }
 
@@ -145,7 +158,9 @@ class Louds {
   // REQUIRES: |node| is valid and not root.
   void MoveToParent(Node *node) const {
     node->node_id_ = node->edge_index_ - node->node_id_ + 1;
-    node->edge_index_ = index_.Select1(node->node_id_);
+    node->edge_index_ = node->node_id_ < select1_cache_size_
+                            ? select1_cache_ptr_[node->node_id_]
+                            : index_.Select1(node->node_id_);
   }
 
   // Returns true if |node| is in a valid state.
@@ -155,6 +170,10 @@ class Louds {
 
  private:
   SimpleSuccinctBitVectorIndex index_;
+  size_t select0_cache_size_;
+  size_t select1_cache_size_;
+  std::unique_ptr<int[]> select_cache_;
+  int* select1_cache_ptr_;  // = select_cache_.get() + select0_cache_size_
 
   DISALLOW_COPY_AND_ASSIGN(Louds);
 };