From b949cc232b1d70fe0a47bc36a1f807deeee70cdb Mon Sep 17 00:00:00 2001
From: Alexander Kuzmenkov <akuzm@yandex-team.ru>
Date: Tue, 24 Sep 2019 22:03:10 +0300
Subject: [PATCH] Mark lookupResultGetKey/Mapped functions ALWAYS_INLINE.

They only do pointer arithmetics, so it makes sense to always inline
them.
---
 dbms/src/Common/HashTable/ClearableHashMap.h |  4 ++--
 dbms/src/Common/HashTable/ClearableHashSet.h |  4 ++--
 dbms/src/Common/HashTable/FixedHashMap.h     |  6 ++++--
 dbms/src/Common/HashTable/HashMap.h          | 12 ++++++++----
 dbms/src/Common/HashTable/HashSet.h          |  6 ++++--
 dbms/src/Common/HashTable/HashTable.h        | 10 ++++++----
 6 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/dbms/src/Common/HashTable/ClearableHashMap.h b/dbms/src/Common/HashTable/ClearableHashMap.h
index d1703394e14..e9f010cffe5 100644
--- a/dbms/src/Common/HashTable/ClearableHashMap.h
+++ b/dbms/src/Common/HashTable/ClearableHashMap.h
@@ -15,10 +15,10 @@ struct ClearableHashMapCell : public ClearableHashTableCell<Key, HashMapCell<Key
 };
 
 template<typename Key, typename Mapped, typename Hash>
-auto lookupResultGetKey(ClearableHashMapCell<Key, Mapped, Hash> * cell) { return &cell->getFirst(); }
+ALWAYS_INLINE inline auto lookupResultGetKey(ClearableHashMapCell<Key, Mapped, Hash> * cell) { return &cell->getFirst(); }
 
 template<typename Key, typename Mapped, typename Hash>
-auto lookupResultGetMapped(ClearableHashMapCell<Key, Mapped, Hash> * cell) { return &cell->getSecond(); }
+ALWAYS_INLINE inline auto lookupResultGetMapped(ClearableHashMapCell<Key, Mapped, Hash> * cell) { return &cell->getSecond(); }
 
 template
 <
diff --git a/dbms/src/Common/HashTable/ClearableHashSet.h b/dbms/src/Common/HashTable/ClearableHashSet.h
index 4f079eddc78..240c32632a9 100644
--- a/dbms/src/Common/HashTable/ClearableHashSet.h
+++ b/dbms/src/Common/HashTable/ClearableHashSet.h
@@ -49,10 +49,10 @@ struct ClearableHashTableCell : public BaseCell
 };
 
 template<typename Key, typename BaseCell>
-auto lookupResultGetKey(ClearableHashTableCell<Key, BaseCell> * cell) { return &cell->key; }
+ALWAYS_INLINE inline auto lookupResultGetKey(ClearableHashTableCell<Key, BaseCell> * cell) { return &cell->key; }
 
 template<typename Key, typename BaseCell>
-void * lookupResultGetMapped(ClearableHashTableCell<Key, BaseCell> *) { return nullptr; }
+ALWAYS_INLINE inline void * lookupResultGetMapped(ClearableHashTableCell<Key, BaseCell> *) { return nullptr; }
 
 template
 <
diff --git a/dbms/src/Common/HashTable/FixedHashMap.h b/dbms/src/Common/HashTable/FixedHashMap.h
index e0f1a2494e0..986b4af67c0 100644
--- a/dbms/src/Common/HashTable/FixedHashMap.h
+++ b/dbms/src/Common/HashTable/FixedHashMap.h
@@ -48,10 +48,12 @@ struct FixedHashMapCell
 };
 
 template<typename Key, typename Mapped, typename State>
-void * lookupResultGetKey(FixedHashMapCell<Key, Mapped, State> *) { return nullptr; }
+ALWAYS_INLINE inline void * lookupResultGetKey(FixedHashMapCell<Key, Mapped, State> *)
+{ return nullptr; }
 
 template<typename Key, typename Mapped, typename State>
-auto lookupResultGetMapped(FixedHashMapCell<Key, Mapped, State> * cell) { return &cell->getSecond(); }
+ALWAYS_INLINE inline auto lookupResultGetMapped(FixedHashMapCell<Key, Mapped, State> * cell)
+{ return &cell->getSecond(); }
 
 template <typename Key, typename Mapped, typename Allocator = HashTableAllocator>
 class FixedHashMap : public FixedHashTable<Key, FixedHashMapCell<Key, Mapped>, Allocator>
diff --git a/dbms/src/Common/HashTable/HashMap.h b/dbms/src/Common/HashTable/HashMap.h
index 1d9ca29b77a..f273d5bcdc7 100644
--- a/dbms/src/Common/HashTable/HashMap.h
+++ b/dbms/src/Common/HashTable/HashMap.h
@@ -111,10 +111,12 @@ struct HashMapCell
 };
 
 template<typename Key, typename Mapped, typename Hash, typename State>
-auto lookupResultGetKey(HashMapCell<Key, Mapped, Hash, State> * cell) { return &cell->getFirst(); }
+ALWAYS_INLINE inline auto lookupResultGetKey(HashMapCell<Key, Mapped, Hash, State> * cell)
+{ return &cell->getFirst(); }
 
 template<typename Key, typename Mapped, typename Hash, typename State>
-auto lookupResultGetMapped(HashMapCell<Key, Mapped, Hash, State> * cell) { return &cell->getSecond(); }
+ALWAYS_INLINE inline auto lookupResultGetMapped(HashMapCell<Key, Mapped, Hash, State> * cell)
+{ return &cell->getSecond(); }
 
 
 template <typename Key, typename TMapped, typename Hash, typename TState = HashTableNoState>
@@ -135,10 +137,12 @@ struct HashMapCellWithSavedHash : public HashMapCell<Key, TMapped, Hash, TState>
 };
 
 template<typename Key, typename Mapped, typename Hash, typename State>
-auto lookupResultGetKey(HashMapCellWithSavedHash<Key, Mapped, Hash, State> * cell) { return &cell->getFirst(); }
+ALWAYS_INLINE inline auto lookupResultGetKey(HashMapCellWithSavedHash<Key, Mapped, Hash, State> * cell)
+{ return &cell->getFirst(); }
 
 template<typename Key, typename Mapped, typename Hash, typename State>
-auto lookupResultGetMapped(HashMapCellWithSavedHash<Key, Mapped, Hash, State> * cell) { return &cell->getSecond(); }
+ALWAYS_INLINE inline auto lookupResultGetMapped(HashMapCellWithSavedHash<Key, Mapped, Hash, State> * cell)
+{ return &cell->getSecond(); }
 
 
 template <
diff --git a/dbms/src/Common/HashTable/HashSet.h b/dbms/src/Common/HashTable/HashSet.h
index 9c25f7f906b..4b3aa5204ea 100644
--- a/dbms/src/Common/HashTable/HashSet.h
+++ b/dbms/src/Common/HashTable/HashSet.h
@@ -85,10 +85,12 @@ struct HashSetCellWithSavedHash : public HashTableCell<Key, Hash, TState>
 };
 
 template<typename Key, typename Hash, typename State>
-auto lookupResultGetKey(HashSetCellWithSavedHash<Key, Hash, State> * cell) { return &cell->key; }
+ALWAYS_INLINE inline auto lookupResultGetKey(HashSetCellWithSavedHash<Key, Hash, State> * cell)
+{ return &cell->key; }
 
 template<typename Key, typename Hash, typename State>
-void * lookupResultGetMapped(HashSetCellWithSavedHash<Key, Hash, State> *) { return nullptr; }
+ALWAYS_INLINE inline void * lookupResultGetMapped(HashSetCellWithSavedHash<Key, Hash, State> *)
+{ return nullptr; }
 
 template
 <
diff --git a/dbms/src/Common/HashTable/HashTable.h b/dbms/src/Common/HashTable/HashTable.h
index 03822996361..f13d6f6e3dd 100644
--- a/dbms/src/Common/HashTable/HashTable.h
+++ b/dbms/src/Common/HashTable/HashTable.h
@@ -124,7 +124,7 @@ void set(T & x) { x = 0; }
   * The default implementation of GetMapped that is used for the above case (2).
   */
 template<typename PointerLike>
-inline auto lookupResultGetMapped(PointerLike && ptr) { return &*ptr; }
+ALWAYS_INLINE inline auto lookupResultGetMapped(PointerLike && ptr) { return &*ptr; }
 
 /**
   * Generic const wrapper for lookupResultGetMapped, that calls a non-const
@@ -132,7 +132,7 @@ inline auto lookupResultGetMapped(PointerLike && ptr) { return &*ptr; }
   * arithmetics.
   */
 template<typename T>
-auto lookupResultGetMapped(const T * obj)
+ALWAYS_INLINE inline auto lookupResultGetMapped(const T * obj)
 {
     auto mapped_ptr = lookupResultGetMapped(const_cast<T *>(obj));
     const auto const_mapped_ptr = mapped_ptr;
@@ -208,10 +208,12 @@ struct HashTableCell
 };
 
 template<typename Key, typename Hash, typename State>
-auto lookupResultGetKey(HashTableCell<Key, Hash, State> * cell) { return &cell->key; }
+ALWAYS_INLINE inline auto lookupResultGetKey(HashTableCell<Key, Hash, State> * cell)
+{ return &cell->key; }
 
 template<typename Key, typename Hash, typename State>
-void * lookupResultGetMapped(HashTableCell<Key, Hash, State> *) { return nullptr; }
+ALWAYS_INLINE inline void * lookupResultGetMapped(HashTableCell<Key, Hash, State> *)
+{ return nullptr; }
 
 /**
   * A helper function for HashTable::insert() to set the "mapped" value.