Revert "Make Allocator.h less silly (no creepy "proto" object). (apache#6241)"

This reverts commit b24f62f.

Revert "Call constructors and destructors for H1/2 Session/Transaction via ClassAllocator (apache#7584)"

This reverts commit a0dd3c2.

Revert "Changes HttpSM to be Proxy Allocated (apache#8082)"

This reverts commit 6806795.

Author: ezelkow1

include/tscore/Allocator.h

@@ -41,7 +41,6 @@
 
 #include <new>
 #include <cstdlib>
-#include <utility>
 #include "tscore/ink_queue.h"
 #include "tscore/ink_defs.h"
 #include "tscore/ink_resource.h"
@@ -109,39 +108,29 @@ class Allocator
     ink_freelist_madvise_init(&this->fl, name, element_size, chunk_size, alignment, advice);
   }
 
-  // Dummies
-  void
-  destroy_if_enabled(void *)
-  {
-  }
-  Allocator &
-  raw()
-  {
-    return *this;
-  }
-
 protected:
   InkFreeList *fl;
 };
 
 /**
-  Allocator for Class objects.
+  Allocator for Class objects. It uses a prototype object to do
+  fast initialization. Prototype of the template class is created
+  when the fast allocator is created. This is instantiated with
+  default (no argument) constructor. Constructor is not called for
+  the allocated objects. Instead, the prototype is just memory
+  copied onto the new objects. This is done for performance reasons.
 
 */
-template <class C, bool Destruct_on_free_ = false> class ClassAllocator : private Allocator
+template <class C> class ClassAllocator : public Allocator
 {
 public:
-  using Value_type                   = C;
-  static bool const Destruct_on_free = Destruct_on_free_;
-
-  /** Allocates objects of the templated type.  Arguments are forwarded to the constructor for the object. */
-  template <typename... Args>
+  /** Allocates objects of the templated type. */
   C *
-  alloc(Args &&... args)
+  alloc()
   {
     void *ptr = ink_freelist_new(this->fl);
 
-    ::new (ptr) C(std::forward<Args>(args)...);
+    memcpy(ptr, (void *)&this->proto.typeObject, sizeof(C));
     return (C *)ptr;
   }
 
@@ -153,47 +142,82 @@ template <class C, bool Destruct_on_free_ = false> class ClassAllocator : privat
   void
   free(C *ptr)
   {
-    destroy_if_enabled(ptr);
-
     ink_freelist_free(this->fl, ptr);
   }
 
   /**
-    Create a new class specific ClassAllocator.
+    Deallocates objects of the templated type.
 
-    @param name some identifying name, used for mem tracking purposes.
-    @param chunk_size number of units to be allocated if free pool is empty.
-    @param alignment of objects must be a power of 2.
+    @param head pointer to be freed.
+    @param tail pointer to be freed.
+    @param num_item of blocks to be freed.
+   */
+  void
+  free_bulk(C *head, C *tail, size_t num_item)
+  {
+    ink_freelist_free_bulk(this->fl, head, tail, num_item);
+  }
+
+  /**
+    Allocate objects of the templated type via the inherited interface
+    using void pointers.
   */
-  ClassAllocator(const char *name, unsigned int chunk_size = 128, unsigned int alignment = 16)
+  void *
+  alloc_void()
   {
-    ink_freelist_init(&this->fl, name, RND16(sizeof(C)), chunk_size, RND16(alignment));
+    return (void *)alloc();
   }
 
-  Allocator &
-  raw()
+  /**
+    Deallocate objects of the templated type via the inherited
+    interface using void pointers.
+
+    @param ptr pointer to be freed.
+  */
+  void
+  free_void(void *ptr)
   {
-    return *this;
+    free((C *)ptr);
   }
 
+  /**
+    Deallocate objects of the templated type via the inherited
+    interface using void pointers.
+
+    @param head pointer to be freed.
+    @param tail pointer to be freed.
+    @param num_item of blocks.
+  */
   void
-  destroy_if_enabled(C *ptr)
+  free_void_bulk(void *head, void *tail, size_t num_item)
   {
-    if (Destruct_on_free) {
-      ptr->~C();
-    }
+    free_bulk((C *)head, (C *)tail, num_item);
+  }
+
+  /**
+    Create a new class specific ClassAllocator.
+
+    @param name some identifying name, used for mem tracking purposes.
+    @param chunk_size number of units to be allocated if free pool is empty.
+    @param alignment of objects must be a power of 2.
+  */
+  ClassAllocator(const char *name, unsigned int chunk_size = 128, unsigned int alignment = 16)
+  {
+    ::new ((void *)&proto.typeObject) C();
+    ink_freelist_init(&this->fl, name, RND16(sizeof(C)), chunk_size, RND16(alignment));
   }
 
-  // Ensure that C is big enough to hold a void pointer (when it's stored in the free list as raw memory).
-  //
-  static_assert(sizeof(C) >= sizeof(void *), "Can not allocate instances of this class using ClassAllocator");
+  struct {
+    uint8_t typeObject[sizeof(C)];
+    int64_t space_holder = 0;
+  } proto;
 };
 
-template <class C, bool Destruct_on_free = false> class TrackerClassAllocator : public ClassAllocator<C, Destruct_on_free>
+template <class C> class TrackerClassAllocator : public ClassAllocator<C>
 {
 public:
   TrackerClassAllocator(const char *name, unsigned int chunk_size = 128, unsigned int alignment = 16)
-    : ClassAllocator<C, Destruct_on_free>(name, chunk_size, alignment), allocations(0), trackerLock(PTHREAD_MUTEX_INITIALIZER)
+    : ClassAllocator<C>(name, chunk_size, alignment), allocations(0), trackerLock(PTHREAD_MUTEX_INITIALIZER)
   {
   }
 
@@ -202,7 +226,7 @@ template <class C, bool Destruct_on_free = false> class TrackerClassAllocator :
   {
     void *callstack[3];
     int frames = backtrace(callstack, 3);
-    C *ptr     = ClassAllocator<C, Destruct_on_free>::alloc();
+    C *ptr     = ClassAllocator<C>::alloc();
 
     const void *symbol = nullptr;
     if (frames == 3 && callstack[2] != nullptr) {
@@ -228,7 +252,7 @@ template <class C, bool Destruct_on_free = false> class TrackerClassAllocator :
       reverse_lookup.erase(it);
     }
     ink_mutex_release(&trackerLock);
-    ClassAllocator<C, Destruct_on_free>::free(ptr);
+    ClassAllocator<C>::free(ptr);
   }
 
 private:

iocore/cache/P_CacheInternal.h

@@ -432,7 +432,7 @@ struct CacheVC : public CacheVConnection {
   Ptr<IOBufferBlock> blocks; // data available to write
   Ptr<IOBufferBlock> writer_buf;
 
-  OpenDirEntry *od = nullptr;
+  OpenDirEntry *od;
   AIOCallbackInternal io;
   int alternate_index = CACHE_ALT_INDEX_DEFAULT; // preferred position in vector
   LINK(CacheVC, opendir_link);

iocore/eventsystem/I_ProxyAllocator.h

@@ -30,9 +30,6 @@
 *****************************************************************************/
 #pragma once
 
-#include <new>
-#include <utility>
-
 #include "tscore/ink_platform.h"
 
 class EThread;
@@ -48,51 +45,84 @@ struct ProxyAllocator {
   ProxyAllocator() {}
 };
 
-template <class CAlloc, typename... Args>
-typename CAlloc::Value_type *
-thread_alloc(CAlloc &a, ProxyAllocator &l, Args &&... args)
+template <class C>
+inline C *
+thread_alloc(ClassAllocator<C> &a, ProxyAllocator &l)
 {
   if (!cmd_disable_pfreelist && l.freelist) {
-    void *v    = l.freelist;
-    l.freelist = *reinterpret_cast<void **>(l.freelist);
+    C *v       = (C *)l.freelist;
+    l.freelist = *(C **)l.freelist;
     --(l.allocated);
-    ::new (v) typename CAlloc::Value_type(std::forward<Args>(args)...);
-    return static_cast<typename CAlloc::Value_type *>(v);
+    *(void **)v = *(void **)&a.proto.typeObject;
+    return v;
   }
-  return a.alloc(std::forward<Args>(args)...);
+  return a.alloc();
 }
 
-class Allocator;
+template <class C>
+inline C *
+thread_alloc_init(ClassAllocator<C> &a, ProxyAllocator &l)
+{
+  if (!cmd_disable_pfreelist && l.freelist) {
+    C *v       = (C *)l.freelist;
+    l.freelist = *(C **)l.freelist;
+    --(l.allocated);
+    memcpy((void *)v, (void *)&a.proto.typeObject, sizeof(C));
+    return v;
+  }
+  return a.alloc();
+}
 
-void *thread_alloc(Allocator &a, ProxyAllocator &l);
-void thread_freeup(Allocator &a, ProxyAllocator &l);
+template <class C>
+inline void
+thread_free(ClassAllocator<C> &a, C *p)
+{
+  a.free(p);
+}
 
-#if 1
+static inline void
+thread_free(Allocator &a, void *p)
+{
+  a.free_void(p);
+}
 
-// Potentially empty variable arguments -- non-standard GCC way
-//
-#define THREAD_ALLOC(_a, _t, ...) thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
-#define THREAD_ALLOC_INIT(_a, _t, ...) thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
+template <class C>
+inline void
+thread_freeup(ClassAllocator<C> &a, ProxyAllocator &l)
+{
+  C *head      = (C *)l.freelist;
+  C *tail      = (C *)l.freelist;
+  size_t count = 0;
+  while (l.freelist && l.allocated > thread_freelist_low_watermark) {
+    tail       = (C *)l.freelist;
+    l.freelist = *(C **)l.freelist;
+    --(l.allocated);
+    ++count;
+  }
 
-#else
+  if (unlikely(count == 1)) {
+    a.free(tail);
+  } else if (count > 0) {
+    a.free_bulk(head, tail, count);
+  }
 
-// Potentially empty variable arguments -- Standard C++20 way
-//
-#define THREAD_ALLOC(_a, _t, ...) thread_alloc(::_a, _t->_a __VA_OPT__(, ) __VA_ARGS__)
-#define THREAD_ALLOC_INIT(_a, _t, ...) thread_alloc(::_a, _t->_a __VA_OPT__(, ) __VA_ARGS__)
+  ink_assert(l.allocated >= thread_freelist_low_watermark);
+}
 
-#endif
+void *thread_alloc(Allocator &a, ProxyAllocator &l);
+void thread_freeup(Allocator &a, ProxyAllocator &l);
 
+#define THREAD_ALLOC(_a, _t) thread_alloc(::_a, _t->_a)
+#define THREAD_ALLOC_INIT(_a, _t) thread_alloc_init(::_a, _t->_a)
 #define THREAD_FREE(_p, _a, _t)                              \
-  do {                                                       \
-    ::_a.destroy_if_enabled(_p);                             \
-    if (!cmd_disable_pfreelist) {                            \
+  if (!cmd_disable_pfreelist) {                              \
+    do {                                                     \
       *(char **)_p    = (char *)_t->_a.freelist;             \
       _t->_a.freelist = _p;                                  \
       _t->_a.allocated++;                                    \
       if (_t->_a.allocated > thread_freelist_high_watermark) \
-        thread_freeup(::_a.raw(), _t->_a);                   \
-    } else {                                                 \
-      ::_a.raw().free_void(_p);                              \
-    }                                                        \
-  } while (0)
+        thread_freeup(::_a, _t->_a);                         \
+    } while (0);                                             \
+  } else {                                                   \
+    thread_free(::_a, _p);                                   \
+  }

iocore/eventsystem/I_Thread.h

@@ -122,7 +122,6 @@ class Thread
   ProxyAllocator http1ClientSessionAllocator;
   ProxyAllocator http2ClientSessionAllocator;
   ProxyAllocator http2StreamAllocator;
-  ProxyAllocator httpSMAllocator;
   ProxyAllocator quicClientSessionAllocator;
   ProxyAllocator quicBidiStreamAllocator;
   ProxyAllocator quicSendStreamAllocator;

proxy/ProxyTransaction.cc

@@ -26,8 +26,6 @@
 
 #define HttpTxnDebug(fmt, ...) SsnDebug(this, "http_txn", fmt, __VA_ARGS__)
 
-extern ClassAllocator<HttpSM> httpSMAllocator;
-
 ProxyTransaction::ProxyTransaction(ProxySession *session) : VConnection(nullptr), _proxy_ssn(session) {}
 
 ProxyTransaction::~ProxyTransaction()
@@ -45,7 +43,7 @@ ProxyTransaction::new_transaction(bool from_early_data)
   // connection re-use
 
   ink_release_assert(_proxy_ssn != nullptr);
-  _sm = THREAD_ALLOC(httpSMAllocator, this_thread());
+  _sm = HttpSM::allocate();
   _sm->init(from_early_data);
   HttpTxnDebug("[%" PRId64 "] Starting transaction %d using sm [%" PRId64 "]", _proxy_ssn->connection_id(),
                _proxy_ssn->get_transact_count(), _sm->sm_id);

proxy/http/Http1ClientSession.cc

@@ -55,7 +55,7 @@ ink_mutex debug_cs_list_mutex;
 
 #endif /* USE_HTTP_DEBUG_LISTS */
 
-ClassAllocator<Http1ClientSession, true> http1ClientSessionAllocator("http1ClientSessionAllocator");
+ClassAllocator<Http1ClientSession> http1ClientSessionAllocator("http1ClientSessionAllocator");
 
 Http1ClientSession::Http1ClientSession() : super(), trans(this) {}
 
@@ -118,6 +118,7 @@ Http1ClientSession::free()
     _vc = nullptr;
   }
 
+  this->~Http1ClientSession();
   THREAD_FREE(this, http1ClientSessionAllocator, this_thread());
 }
 

proxy/http/Http1ClientSession.h

@@ -129,4 +129,4 @@ class Http1ClientSession : public ProxySession
   Http1Transaction trans;
 };
 
-extern ClassAllocator<Http1ClientSession, true> http1ClientSessionAllocator;
+extern ClassAllocator<Http1ClientSession> http1ClientSessionAllocator;

proxy/http/Http1ServerSession.cc

@@ -36,7 +36,7 @@
 #include "HttpSessionManager.h"
 #include "HttpSM.h"
 
-ClassAllocator<Http1ServerSession, true> httpServerSessionAllocator("httpServerSessionAllocator");
+ClassAllocator<Http1ServerSession> httpServerSessionAllocator("httpServerSessionAllocator");
 
 void
 Http1ServerSession::destroy()
@@ -50,6 +50,7 @@ Http1ServerSession::destroy()
   }
 
   mutex.clear();
+  this->~Http1ServerSession();
   if (httpSessionManager.get_pool_type() == TS_SERVER_SESSION_SHARING_POOL_THREAD) {
     THREAD_FREE(this, httpServerSessionAllocator, this_thread());
   } else {

proxy/http/Http1ServerSession.h

@@ -107,7 +107,7 @@ class Http1ServerSession : public PoolableSession
   IOBufferReader *buf_reader = nullptr;
 };
 
-extern ClassAllocator<Http1ServerSession, true> httpServerSessionAllocator;
+extern ClassAllocator<Http1ServerSession> httpServerSessionAllocator;
 
 ////////////////////////////////////////////
 // INLINE