Ticket #326: avoid_string_appends_and_loop_unroll_2.patch

chert_postlist.h

@@ -86 +86 @@
         /// Compose a key from a termname and docid.
         static string make_key(const string & term, Xapian::docid did) {
             string key = make_key(term);
-            key += pack_uint_preserving_sort(did);
+            append_packed_uint_preserving_sort(key, did);
             return key;
         }
 

chert_positionlist.cc

@@ -70 +70 @@
               did << ", " << term);
 
     string data;
-    if (!get_exact_entry(pack_uint_preserving_sort(did) + term, data)) {
+    string key;
+    // 5 bytes is usually enough for a packed uint
+    key.reserve(5 + term.size());
+    append_packed_uint_preserving_sort(key, did);
+    key.append(term);
+    if (!get_exact_entry(key, data)) {
         // There's no positional information for this term.
         return 0;
     }
@@ -106 +111 @@
     positions.clear();
 
     string data;
-    if (!table->get_exact_entry(pack_uint_preserving_sort(did) + tname, data)) {
+    string key;
+    // 5 bytes is usually enough for a packed uint
+    key.reserve(5 + tname.size());
+    append_packed_uint_preserving_sort(key, did);
+    key.append(tname);
+    if (!table->get_exact_entry(key, data)) {
         // There's no positional information for this term.
         current_pos = positions.begin();
         return false;

chert_positionlist.h

@@ -34 +34 @@
 
 class ChertPositionListTable : public ChertTable {
     static string make_key(Xapian::docid did, const string & tname) {
-        return pack_uint_preserving_sort(did) + tname;
+        string result;
+        // 5 bytes is usually enough for a packed uint
+        result.reserve(5 + tname.size());
+        append_packed_uint_preserving_sort(result, did);
+        result.append(tname);
+        return result + tname;
     }
 
   public:

chert_utils.h

@@ -224 +224 @@
  *  of 256 bytes on the length of the integer.  However, this is unlikely to
  *  ever be a problem.
  *
+ *  @param result A string to append the representation of the integer to.
  *  @param value  The integer to represent.
- *
- *  @result       A string containing the representation of the integer.
  */
 template<class T>
-string
-pack_uint_preserving_sort(T value)
+void
+append_packed_uint_preserving_sort(string & result, T value)
 {
     // Check unsigned
     STATIC_ASSERT_UNSIGNED_TYPE(T);
+    STATIC_ASSERT(sizeof(T) >= 4);
 
-    string result;
-    while (value != 0) {
-        om_byte part = static_cast<om_byte>(value & 0xff);
-        value = value >> 8;
-        result.insert(string::size_type(0), 1u, char(part));
+    string::size_type start = result.size();
+    if (value <= 0xffff) {
+        if (value < 0xff) {
+            // 1 byte
+            char buf[2];
+            buf[0] = char(1);
+            buf[1] = char(value & 0xff);
+            result.append(buf, 2);
+            return;
+        } else {
+            // 2 bytes
+            char buf[3];
+            buf[0] = char(2);
+            buf[1] = char((value >> 8) & 0xff);
+            buf[2] = char(value & 0xff);
+            result.append(buf, 3);
+            return;
+        }
     }
-    result.insert(string::size_type(0), 1u, char(result.size()));
-    return result;
+    if (value <= 0xffffff) {
+        // 3 bytes
+        char buf[4];
+        buf[0] = char(3);
+        buf[1] = char((value >> 16) & 0xff);
+        buf[2] = char((value >> 8) & 0xff);
+        buf[3] = char(value & 0xff);
+        result.append(buf, 4);
+        return;
+    }
+
+    if (value <= 0xffffffff) {
+        // 4 bytes.
+        char buf[5];
+        buf[0] = char(4);
+        buf[1] = char((value >> 24) & 0xff);
+        buf[2] = char((value >> 16) & 0xff);
+        buf[3] = char((value >> 8) & 0xff);
+        buf[4] = char(value & 0xff);
+        result.append(buf, 5);
+        return;
+    }
+
+    if (sizeof(T) > 4) {
+        if (result.capacity() < start + 9) {
+            result.reserve(start + 9);
+        }
+        // More than 4 bytes. Do first 4, then loop.
+        result.append(string::size_type(1u), char((value >> 24) & 0xff));
+        result.append(string::size_type(1u), char((value >> 16) & 0xff));
+        result.append(string::size_type(1u), char((value >> 8) & 0xff));
+        result.append(string::size_type(1u), char(value & 0xff));
+        value = value >> 16;
+        value = value >> 16;
+        while (value != 0) {
+            om_byte part = static_cast<om_byte>(value & 0xff);
+            value = value >> 8;
+            result.insert(start, 1u, char(part));
+        }
+        result.insert(start, 1u, char(result.size() - start));
+    }
 }
 
 /** Unpack a unsigned integer, store in sort preserving order.
@@ -401 +453 @@
 inline string
 chert_docid_to_key(Xapian::docid did)
 {
-    return pack_uint_preserving_sort(did);
+    string result;
+    append_packed_uint_preserving_sort(result, did);
+    return result;
 }
 
 #endif /* OM_HGUARD_CHERT_UTILS_H */

chert_values.h

@@ -37 +37 @@
 {
     std::string key("\0\xd8", 2);
     key += pack_uint(slot);
-    key += pack_uint_preserving_sort(did);
+    append_packed_uint_preserving_sort(key, did);
     return key;
 }