Groonga - fulltext search engine.

[Groonga-commit] groonga/grnxx at b7c7e1b [score-benchmark] Enable Array<Record> to disable score for benchmark.

susumu.yata null+****@clear*****
Wed Aug 27 09:59:49 JST 2014

• Previous message: [Groonga-commit] Still Failing: droonga/droonga-engine#532 (master - 60bf303)
• Next message: [Groonga-commit] groonga/grnxx at c9a7554 [master] Remove Time data type.
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

susumu.yata	2014-08-27 09:59:49 +0900 (Wed, 27 Aug 2014)

  New Revision: b7c7e1bda39204280d04d2477c1fd3d2c3712b0f
  https://github.com/groonga/grnxx/commit/b7c7e1bda39204280d04d2477c1fd3d2c3712b0f

  Message:
    Enable Array<Record> to disable score for benchmark.

  Modified files:
    include/grnxx/array.hpp
    test/test_pipeline.cpp

  Modified: include/grnxx/array.hpp (+197 -51)
===================================================================
--- include/grnxx/array.hpp    2014-08-26 14:34:02 +0900 (a0e2b54)
+++ include/grnxx/array.hpp    2014-08-27 09:59:49 +0900 (09c762a)
@@ -677,36 +677,59 @@ class ArrayCRef<Record> {
   }
 
   ArrayCRef ref(Int offset = 0) const {
-    return ArrayCRef(records_ + offset, size_ - offset);
+    if (has_score_) {
+      return ArrayCRef(records_ + offset, size_ - offset);
+    } else {
+      return ArrayCRef(row_ids_ + offset, size_ - offset);
+    }
   }
   ArrayCRef ref(Int offset, Int size) const {
-    return ArrayCRef(records_ + offset, size);
+    if (has_score_) {
+      return ArrayCRef(records_ + offset, size);
+    } else {
+      return ArrayCRef(row_ids_ + offset, size);
+    }
+  }
+
+  Bool has_score() const {
+    return has_score_ != 0;
   }
 
   Record get(Int i) const {
-    return records_[i];
+    return has_score_ ? records_[i] : Record(row_ids_[i], 0.0);
   }
   Int get_row_id(Int i) const {
-    return records_[i].row_id;
+    return has_score_ ? records_[i].row_id : row_ids_[i];
   }
   Float get_score(Int i) const {
-    return records_[i].score;
+    return has_score_ ? records_[i].score : 0.0;
   }
 
   Record operator[](Int i) const {
-    return records_[i];
+    return get(i);
   }
 
   Int size() const {
-    return size_;
+    return static_cast<Int>(size_);
   }
 
  private:
-  const Record *records_;
-  Int size_;
+  union {
+    const Int *row_ids_;
+    const Record *records_;
+  };
+  struct {
+    uint64_t has_score_:1;
+    uint64_t size_:63;
+  };
 
   ArrayCRef(const Record *records, Int size)
       : records_(records),
+        has_score_(1),
+        size_(size) {}
+  ArrayCRef(const Int *row_ids, Int size)
+      : row_ids_(row_ids),
+        has_score_(0),
         size_(size) {}
 
   friend class ArrayRef<Value>;
@@ -742,55 +765,102 @@ class ArrayRef<Record> {
   }
 
   ArrayCRef<Record> ref(Int offset = 0) const {
-    return ArrayCRef<Record>(records_ + offset, size_ - offset);
+    if (has_score_) {
+      return ArrayCRef<Record>(records_ + offset, size_ - offset);
+    } else {
+      return ArrayCRef<Record>(row_ids_ + offset, size_ - offset);
+    }
   }
   ArrayCRef<Record> ref(Int offset, Int size) const {
-    return ArrayCRef<Record>(records_ + offset, size);
+    if (has_score_) {
+      return ArrayCRef<Record>(records_ + offset, size);
+    } else {
+      return ArrayCRef<Record>(row_ids_ + offset, size);
+    }
   }
 
   ArrayRef ref(Int offset = 0) {
-    return ArrayRef(records_ + offset, size_ - offset);
+    if (has_score_) {
+      return ArrayRef(records_ + offset, size_ - offset);
+    } else {
+      return ArrayRef(row_ids_ + offset, size_ - offset);
+    }
   }
   ArrayRef ref(Int offset, Int size) {
-    return ArrayRef(records_ + offset, size);
+    if (has_score_) {
+      return ArrayRef(records_ + offset, size);
+    } else {
+      return ArrayRef(row_ids_ + offset, size);
+    }
+  }
+
+  Bool has_score() const {
+    return has_score_ != 0;
   }
 
   Record get(Int i) const {
-    return records_[i];
+    return has_score_ ? records_[i] : Record(row_ids_[i], 0.0);
   }
   Int get_row_id(Int i) const {
-    return records_[i].row_id;
+    return has_score_ ? records_[i].row_id : row_ids_[i];
   }
   Float get_score(Int i) const {
-    return records_[i].score;
+    return has_score_ ? records_[i].score : 0.0;
   }
   void set(Int i, Record record) {
-    records_[i] = record;
+    if (has_score_) {
+      records_[i] = record;
+    } else {
+      row_ids_[i] = record.row_id;
+    }
   }
   void set_row_id(Int i, Int row_id) {
-    records_[i].row_id = row_id;
+    if (has_score_) {
+      records_[i].row_id = row_id;
+    } else {
+      row_ids_[i] = row_id;
+    }
   }
   void set_score(Int i, Float score) {
-    records_[i].score = score;
+    if (has_score_) {
+      records_[i].score = score;
+    }
   }
 
   Record operator[](Int i) const {
-    return records_[i];
+    return get(i);
   }
 
   Int size() const {
-    return size_;
+    return static_cast<Int>(size_);
   }
 
   void swap(Int i, Int j) {
-    std::swap(records_[i], records_[j]);
+    if (has_score_) {
+      std::swap(records_[i], records_[j]);
+    } else {
+      std::swap(row_ids_[i], row_ids_[j]);
+    }
   }
 
  private:
-  Record *records_;
-  Int size_;
+  union {
+    Record *records_;
+    Int *row_ids_;
+  };
+  struct {
+    uint64_t has_score_:1;
+    uint64_t size_:63;
+  };
 
-  ArrayRef(Record *records, Int size) : records_(records), size_(size) {}
+  ArrayRef(Record *records, Int size)
+      : records_(records),
+        has_score_(1),
+        size_(size) {}
+  ArrayRef(Int *row_ids, Int size)
+      : row_ids_(row_ids),
+        has_score_(0),
+        size_(size) {}
 
   friend class Array<Value>;
 };
@@ -798,13 +868,21 @@ class ArrayRef<Record> {
 template <>
 class Array<Record> {
  public:
-  Array() : records_() {}
+  explicit Array(Bool has_score = true)
+      : records_(),
+        row_ids_(),
+        has_score_(has_score) {}
   ~Array() {}
 
-  Array(Array &&array) : records_(std::move(array.records_)) {}
+  Array(Array &&array)
+      : records_(std::move(array.records_)),
+        row_ids_(std::move(array.row_ids_)),
+        has_score_(array.has_score_) {}
 
   Array &operator=(Array &&array) {
     records_ = std::move(array.records_);
+    row_ids_ = std::move(array.row_ids_);
+    has_score_ = array.has_score_;
     return *this;
   }
 
@@ -816,59 +894,93 @@ class Array<Record> {
   }
 
   ArrayCRef<Record> ref(Int offset = 0) const {
-    return ArrayCRef<Record>(records_.data() + offset, size() - offset);
+    if (has_score_) {
+      return ArrayCRef<Record>(records_.data() + offset, size() - offset);
+    } else {
+      return ArrayCRef<Record>(row_ids_.data() + offset, size() - offset);
+    }
   }
   ArrayCRef<Record> ref(Int offset, Int size) const {
-    return ArrayCRef<Record>(records_.data() + offset, size);
+    if (has_score_) {
+      return ArrayCRef<Record>(records_.data() + offset, size);
+    } else {
+      return ArrayCRef<Record>(row_ids_.data() + offset, size);
+    }
   }
 
   ArrayRef<Record> ref(Int offset = 0) {
-    return ArrayRef<Record>(records_.data() + offset, size() - offset);
+    if (has_score_) {
+      return ArrayRef<Record>(records_.data() + offset, size() - offset);
+    } else {
+      return ArrayRef<Record>(row_ids_.data() + offset, size() - offset);
+    }
   }
   ArrayRef<Record> ref(Int offset, Int size) {
-    return ArrayRef<Record>(records_.data() + offset, size);
+    if (has_score_) {
+      return ArrayRef<Record>(records_.data() + offset, size);
+    } else {
+      return ArrayRef<Record>(row_ids_.data() + offset, size);
+    }
+  }
+
+  Bool has_score() const {
+    return has_score_;
   }
 
   Record get(Int i) const {
-    return records_[i];
+    return has_score_ ? records_[i] : Record(row_ids_[i], 0.0);
   }
   Int get_row_id(Int i) const {
-    return records_[i].row_id;
+    return has_score_ ? records_[i].row_id : row_ids_[i];
   }
   Float get_score(Int i) const {
-    return records_[i].score;
+    return has_score_ ? records_[i].score : 0.0;
   }
   void set(Int i, Record record) {
-    records_[i] = record;
+    if (has_score_) {
+      records_[i] = record;
+    } else {
+      row_ids_[i] = record.row_id;
+    }
   }
   void set_row_id(Int i, Int row_id) {
-    records_[i].row_id = row_id;
+    if (has_score_) {
+      records_[i].row_id = row_id;
+    } else {
+      row_ids_[i] = row_id;
+    }
   }
   void set_score(Int i, Float score) {
-    records_[i].score = score;
+    if (has_score_) {
+      records_[i].score = score;
+    }
   }
 
   Record operator[](Int i) const {
-    return records_[static_cast<size_t>(i)];
+    return get(i);
   }
 
   Record front() const {
-    return records_.front();
+    return has_score_ ? records_.front() : Record(row_ids_.front(), 0.0);
   }
 
   Record back() const {
-    return records_.back();
+    return has_score_ ? records_.back() : Record(row_ids_.back(), 0.0);
   }
 
   Int size() const {
-    return static_cast<Int>(records_.size());
+    return static_cast<Int>(has_score_ ? records_.size() : row_ids_.size());
   }
   Int capacity() const {
-    return static_cast<Int>(records_.capacity());
+    return static_cast<Int>(has_score_ ? records_.capacity() : row_ids_.capacity());
   }
 
   bool reserve(Error *error, Int new_size) try {
-    records_.reserve(new_size);
+    if (has_score_) {
+      records_.reserve(new_size);
+    } else {
+      row_ids_.reserve(new_size);
+    }
     return true;
   } catch (...) {
     ArrayErrorReporter::report_memory_error(error);
@@ -876,14 +988,22 @@ class Array<Record> {
   }
 
   bool resize(Error *error, Int new_size) try {
-    records_.resize(new_size);
+    if (has_score_) {
+      records_.resize(new_size);
+    } else {
+      row_ids_.resize(new_size);
+    }
     return true;
   } catch (...) {
     ArrayErrorReporter::report_memory_error(error);
     return false;
   }
   bool resize(Error *error, Int new_size, Record record) try {
-    records_.resize(new_size, record);
+    if (has_score_) {
+      records_.resize(new_size, record);
+    } else {
+      row_ids_.resize(new_size, record.row_id);
+    }
     return true;
   } catch (...) {
     ArrayErrorReporter::report_memory_error(error);
@@ -891,7 +1011,11 @@ class Array<Record> {
   }
 
   bool shrink_to_fit(Error *error) try {
-    records_.shrink_to_fit();
+    if (has_score_) {
+      records_.shrink_to_fit();
+    } else {
+      row_ids_.shrink_to_fit();
+    }
     return true;
   } catch (...) {
     ArrayErrorReporter::report_memory_error(error);
@@ -899,30 +1023,52 @@ class Array<Record> {
   }
 
   void clear() {
-    records_.clear();
+    if (has_score_) {
+      records_.clear();
+    } else {
+      row_ids_.clear();
+    }
   }
 
   void erase(Int i) {
-    records_.erase(records_.begin() + i);
+    if (has_score_) {
+      records_.erase(records_.begin() + i);
+    } else {
+      row_ids_.erase(row_ids_.begin() + i);
+    }
   }
 
   bool push_back(Error *error, Record record) try {
-    records_.push_back(record);
+    if (has_score_) {
+      records_.push_back(record);
+    } else {
+      row_ids_.push_back(record.row_id);
+    }
     return true;
   } catch (...) {
     ArrayErrorReporter::report_memory_error(error);
     return false;
   }
   void pop_back() {
-    records_.pop_back();
+    if (has_score_) {
+      records_.pop_back();
+    } else {
+      row_ids_.pop_back();
+    }
   }
 
   void swap(Int i, Int j) {
-    std::swap(records_[i], records_[j]);
+    if (has_score_) {
+      std::swap(records_[i], records_[j]);
+    } else {
+      std::swap(row_ids_[i], row_ids_[j]);
+    }
   }
 
  private:
   std::vector<Record> records_;
+  std::vector<Int> row_ids_;
+  Bool has_score_;
 };
 
 }  // namespace grnxx

  Modified: test/test_pipeline.cpp (+2 -2)
===================================================================
--- test/test_pipeline.cpp    2014-08-26 14:34:02 +0900 (d7088a4)
+++ test/test_pipeline.cpp    2014-08-27 09:59:49 +0900 (e0be9fd)
@@ -105,7 +105,7 @@ void test_cursor() {
   assert(pipeline);
 
   // Read records through the pipeline.
-  grnxx::Array<grnxx::Record> records;
+  grnxx::Array<grnxx::Record> records(false);
   assert(pipeline->flush(&error, &records));
   assert(records.size() == test.table->num_rows());
 }
@@ -148,7 +148,7 @@ void test_filter() {
   assert(pipeline);
 
   // Read records through the pipeline.
-  grnxx::Array<grnxx::Record> records;
+  grnxx::Array<grnxx::Record> records(false);
   assert(pipeline->flush(&error, &records));
 
   grnxx::Int count = 0;
-------------- next part --------------
HTML����������������������������...
Télécharger 

• Previous message: [Groonga-commit] Still Failing: droonga/droonga-engine#532 (master - 60bf303)
• Next message: [Groonga-commit] groonga/grnxx at c9a7554 [master] Remove Time data type.
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]