Various performance optimizations (LLNL#457)

* Implement hash for variable length variant types

* Refactor MetadataTree class

* Optimize variant copy

* Specialize variant constructor for string

* Simplify Caliper::create_attribute()

* More optimizations

* More improvements and cleanup in Caliper.cpp

Author: daboehme

include/caliper/common/Node.h

@@ -49,7 +49,7 @@ class Node : public util::LockfreeIntrusiveTree<Node>
     /// \brief Check if the node's attribute and value are equal to
     ///   \a attr and \a v
     bool equals(cali_id_t attr, const Variant& v) const {
-        return m_attribute == attr ? m_data == v : false;
+        return m_data == v && m_attribute == attr;
     }
 
     /// \brief Return the node's attribute ID

include/caliper/common/Variant.h

@@ -49,10 +49,10 @@ class Variant
 
     template<typename U, typename std::enable_if< std::is_unsigned<U>::value, int >::type = 0>
     Variant(U val)
-        : m_v(cali_make_variant_from_uint(val)) { }
+        : m_v(cali_make_variant_from_uint(val))   { }
 
     Variant(const char* val)
-            : m_v(cali_make_variant_from_string(val))   { }
+        : m_v(cali_make_variant_from_string(val)) { }
     Variant(cali_attr_type val)
         : m_v(cali_make_variant_from_type(val))   { }
 
@@ -68,6 +68,11 @@ class Variant
         return !empty();
     }
 
+    bool has_unmanaged_data() const {
+        cali_attr_type t = type();
+        return (t == CALI_TYPE_STRING || t == CALI_TYPE_USR);
+    }
+
     cali_variant_t c_variant() const { return m_v; }
 
     cali_attr_type type() const    { return cali_variant_get_type(m_v);  }
@@ -98,6 +103,16 @@ class Variant
 
     std::string    to_string() const;
 
+    Variant        copy(void* ptr) const {
+        Variant to(*this);
+
+        if (has_unmanaged_data())
+            to.m_v.value.unmanaged_ptr =
+                memcpy(ptr, m_v.value.unmanaged_const_ptr, size());
+
+        return to;
+    }
+
     Variant& operator += (const Variant& val);
 
     size_t         pack(unsigned char* buf) const {

include/caliper/common/cali_variant.h

@@ -23,8 +23,9 @@ extern "C" {
  *  Variable-length types (strings and blobs) are stored as unmanaged pointers.
  */
 typedef struct {
-    /** Least significant bytes encode the type.
-     *  Remaining bytes encode the size of variable-length types (strings and blobs (usr)).
+    /** Least significant byte encode the type.
+     *  Top 4 bytes encode the size of variable-length types (strings and blobs).
+     *  Remainder encodes a small hash for variable-length types for faster comparisons.
      */
     uint64_t type_and_size;
 
@@ -42,6 +43,7 @@ typedef struct {
 } cali_variant_t;
 
 #define CALI_VARIANT_TYPE_MASK 0xFF
+#define CALI_VARIANT_HASH_MASK 0xFFFFFF00
 
 inline cali_variant_t
 cali_make_empty_variant()
@@ -130,7 +132,23 @@ cali_make_variant_from_double(double value)
 inline cali_variant_t
 cali_make_variant_from_string(const char* value)
 {
-    return cali_make_variant(CALI_TYPE_STRING, value, strlen(value));
+    size_t size = strlen(value);
+    uint64_t hash = 0;
+
+    const unsigned char* p = (const unsigned char*) value;
+    hash |= p[0];
+    hash <<= 8;
+    hash |= p[size/2];
+    hash <<= 8;
+    hash |= p[size-1];
+    hash <<= 8;
+
+    cali_variant_t v;
+
+    v.type_and_size = (size << 32) | hash | (CALI_TYPE_STRING & CALI_VARIANT_TYPE_MASK);
+    v.value.unmanaged_const_ptr = value;
+
+    return v;
 }
 
 inline cali_variant_t
@@ -186,8 +204,19 @@ cali_variant_to_bool(cali_variant_t v, bool* okptr);
 int
 cali_variant_compare(cali_variant_t lhs, cali_variant_t rhs);
 
+/** \brief Check if lhs and rhs' values are equal using a deep comparison.
+ * Caller must make sure that lhs' and rhs' type and size are equal.
+ */
 bool
-cali_variant_eq(cali_variant_t lhs, cali_variant_t rhs);
+_cali_variant_value_eq(cali_variant_t lhs, cali_variant_t rhs);
+
+/** \brief Check if lhs is equal to rhs
+ */
+inline bool
+cali_variant_eq(cali_variant_t lhs, cali_variant_t rhs)
+{
+    return lhs.type_and_size == rhs.type_and_size ? _cali_variant_value_eq(lhs, rhs) : false;
+}
 
 /** \brief Pack variant into byte buffer
  */

src/caliper/Annotation.cpp

@@ -284,7 +284,7 @@ Annotation& Annotation::begin(double data)
 
 Annotation& Annotation::begin(const char* data)
 {
-    return begin(Variant(CALI_TYPE_STRING, data, strlen(data)));
+    return begin(Variant(data));
 }
 
 Annotation& Annotation::begin(cali_attr_type type, void* data, uint64_t size)