diff --git a/hphp/runtime/base/array/array_data.cpp b/hphp/runtime/base/array/array_data.cpp
index 75d770dab..433553fbb 100644
--- a/hphp/runtime/base/array/array_data.cpp
+++ b/hphp/runtime/base/array/array_data.cpp
@@ -360,7 +360,7 @@ Variant ArrayData::key() const {
   return uninit_null();
 }
 
-Variant ArrayData::value(ssize_t &pos) const {
+Variant ArrayData::value(int32_t &pos) const {
   if (size_t(pos) < size_t(size())) {
     return getValue(pos);
   }
diff --git a/hphp/runtime/base/array/array_data.h b/hphp/runtime/base/array/array_data.h
index f71f92cb6..04d47d364 100644
--- a/hphp/runtime/base/array/array_data.h
+++ b/hphp/runtime/base/array/array_data.h
@@ -55,14 +55,26 @@ class ArrayData : public Countable {
  public:
   static const ssize_t invalid_index = -1;
 
-  explicit ArrayData(ArrayKind kind, bool nonsmart = false) :
-    m_size(-1), m_pos(0), m_strongIterators(0), m_kind(kind),
-    m_nonsmart(nonsmart) {
+  explicit ArrayData(ArrayKind kind, bool nonsmart = false)
+    : m_size(-1)
+    , m_kind(kind)
+    , m_nonsmart(nonsmart)
+    , m_pos(0)
+    , m_strongIterators(nullptr) {
+  }
+  explicit ArrayData(ArrayKind kind, bool nonsmart, uint size)
+      : m_size(size)
+      , m_kind(kind)
+      , m_nonsmart(nonsmart)
+      , m_pos(size ? 0 : ArrayData::invalid_index)
+      , m_strongIterators(nullptr) {
   }
   ArrayData(const ArrayData *src, ArrayKind kind,
-            bool nonsmart = false) :
-    m_pos(src->m_pos), m_strongIterators(0), m_kind(src->m_kind),
-    m_nonsmart(nonsmart) {
+            bool nonsmart = false)
+    : m_kind(src->m_kind)
+    , m_nonsmart(nonsmart)
+    , m_pos(src->m_pos)
+    , m_strongIterators(nullptr) {
   }
 
   static HphpArray* Make(uint capacity);
@@ -184,7 +196,7 @@ class ArrayData : public Countable {
   virtual Variant next();
   virtual Variant end();
   virtual Variant key() const;
-  virtual Variant value(ssize_t &pos) const;
+  virtual Variant value(int32_t &pos) const;
   virtual Variant each();
 
   bool isHead()            const { return m_pos == iter_begin(); }
@@ -482,13 +494,13 @@ class ArrayData : public Countable {
 
  protected:
   uint m_size;
-  ssize_t m_pos;
- private:
-  FullPos* m_strongIterators; // head of linked list
- protected:
   const ArrayKind m_kind;
   AllocMode m_allocMode;
   const bool m_nonsmart; // never use smartalloc to allocate Elms
+  int32_t m_pos;
+ private:
+  FullPos* m_strongIterators; // head of linked list
+ protected:
   /* The 4 bytes of padding here are available to subclasses if their
    * first field is also <= 4 bytes. */
 
diff --git a/hphp/runtime/base/array/hphp_array.cpp b/hphp/runtime/base/array/hphp_array.cpp
index d354937a7..9aadd0efc 100644
--- a/hphp/runtime/base/array/hphp_array.cpp
+++ b/hphp/runtime/base/array/hphp_array.cpp
@@ -66,7 +66,13 @@ static const Trace::Module TRACEMOD = Trace::runtime;
  * separately.  Even larger tables allocate the hashtable and slots
  * contiguously.
  */
-IMPLEMENT_SMART_ALLOCATION(HphpArray);
+void *HphpArray::SmaAllocatorInitSetup =  SmartAllocatorInitSetup<HphpArray>();
+
+void HphpArray::release() {
+  assert(typeid(*this) == typeid(HphpArray));
+  this->HphpArray::~HphpArray();
+  HphpArray::AllocatorType::getNoCheck()->dealloc(this);
+}
 
 //=============================================================================
 // Static members.
@@ -76,55 +82,57 @@ HphpArray HphpArray::s_theEmptyArray(StaticEmptyArray);
 //=============================================================================
 // Helpers.
 
-static inline size_t computeMaskFromNumElms(uint32_t numElms) {
-  assert(numElms <= 0x7fffffffU);
-  size_t lgSize = HphpArray::MinLgTableSize;
-  size_t maxElms = (size_t(3U)) << (lgSize-2);
-  assert(lgSize >= 2);
-  while (maxElms < numElms) {
-    ++lgSize;
-    maxElms <<= 1;
+static inline size_t computeMaskFromNumElms(const uint32_t n) {
+  if (n <= HphpArray::SmallSize) {
+    return HphpArray::SmallMask;
   }
-  assert(lgSize <= 32);
-  // return 2^lgSize - 1
-  return ((size_t(1U)) << lgSize) - 1;
-  static_assert(HphpArray::MinLgTableSize >= 2,
-                "lower limit for 0.75 load factor");
+  uint32_t cap = (3U << (HphpArray::MinLgTableSize - 2)) * 2;
+  while (cap < n) {
+    cap *= 2;
+  }
+  return ((size_t(cap) << 2UL) & (size_t(cap) << 1UL)) - 1;
 }
 
 //=============================================================================
 // Construction/destruction.
 
-inline void HphpArray::init(uint size) {
-  m_size = 0;
-  m_tableMask = computeMaskFromNumElms(size);
-  size_t tableSize = computeTableSize(m_tableMask);
-  size_t maxElms = computeMaxElms(m_tableMask);
-  allocData(maxElms, tableSize);
+inline uint32_t HphpArray::initWithoutHash(uint capacity) {
+  assert(m_size == 0);
+  m_tableMask = computeMaskFromNumElms(capacity);
+  auto const tableSize = computeTableSize(m_tableMask);
+  allocData(computeMaxElms(m_tableMask), tableSize);
   initHash(m_hash, tableSize);
-  m_pos = ArrayData::invalid_index;
+  assert(m_pos == ArrayData::invalid_index);
+  return tableSize;
 }
 
-HphpArray::HphpArray(uint size) : ArrayData(kHphpArray),
-  m_lastE(ElmIndEmpty), m_data(nullptr), m_nextKI(0), m_hLoad(0) {
+inline void HphpArray::init(uint capacity) {
+  assert(m_size == 0);
+  const auto tableSize = initWithoutHash(capacity);
+  initHash(m_hash, tableSize);
+}
+
+HphpArray::HphpArray(uint size) : ArrayData(kHphpArray, false, 0),
+  m_lastE(ElmIndEmpty), m_hLoad(0), m_nextKI(0) {
 #ifdef PEDANTIC
   if (size > 0x7fffffffU) {
     raise_error("Cannot create an array with more than 2^31 - 1 elements");
   }
 #endif
+  assert(m_size == 0);
   init(size);
 }
 
 HphpArray::HphpArray(uint size, const TypedValue* values) :
-    ArrayData(kHphpArray), m_lastE(ElmIndEmpty), m_data(nullptr),
-    m_nextKI(0), m_hLoad(0)
+    ArrayData(kHphpArray, false, 0), m_lastE(ElmIndEmpty),
+    m_hLoad(0), m_nextKI(0)
   {
 #ifdef PEDANTIC
   if (size > 0x7fffffffU) {
     raise_error("Cannot create an array with more than 2^31 - 1 elements");
   }
 #endif
-  init(size);
+  initWithoutHash(size);
   assert(size <= m_tableMask + 1);
   // append values by moving -- Caller assumes we update refcount.  Values
   // are in reverse order since they come from the stack, which grows down.
@@ -132,14 +140,18 @@ HphpArray::HphpArray(uint size, const TypedValue* values) :
   assert(m_size == 0 && m_hLoad == 0 && m_nextKI == 0);
   ElmInd* hash = m_hash;
   Elm* data = m_data;
-  for (uint i = 0; i < size; i++) {
-    assert(hash[i] == HphpArray::ElmIndEmpty);
+  uint i = 0;
+  for (; i < size; i++) {
     const TypedValue& tv = values[size - i - 1];
     data[i].data.m_data = tv.m_data;
     data[i].data.m_type = tv.m_type;
     data[i].setIntKey(i);
     hash[i] = i;
   }
+  // Initialize the leftover hash
+  for (; i < size; i++) {
+    hash[i] = ElmIndEmpty;
+  }
   m_size = size;
   m_hLoad = size;
   m_lastE = size - 1;
@@ -147,8 +159,8 @@ HphpArray::HphpArray(uint size, const TypedValue* values) :
   if (size > 0) m_pos = 0;
 }
 
-HphpArray::HphpArray(EmptyMode) : ArrayData(kHphpArray),
-  m_lastE(ElmIndEmpty), m_data(nullptr), m_nextKI(0), m_hLoad(0) {
+HphpArray::HphpArray(EmptyMode) : ArrayData(kHphpArray, false, 0),
+  m_lastE(ElmIndEmpty), m_hLoad(0), m_nextKI(0) {
   init(0);
   setStatic();
 }
@@ -192,7 +204,7 @@ void HphpArray::dumpDebugInfo() const {
          "m_tableMask = %u\tm_size = %d\tm_hLoad = %d\n"
          "m_nextKI = %" PRId64 "\t\tm_lastE = %d\tm_pos = %zd\n",
          m_data, m_hash, m_tableMask, m_size, m_hLoad,
-         m_nextKI, m_lastE, m_pos);
+          m_nextKI, m_lastE, size_t(m_pos));
   fprintf(stderr, "Elements:\n");
   ssize_t lastE = m_lastE;
   Elm* elms = m_data;
@@ -394,7 +406,7 @@ Variant HphpArray::key() const {
   return uninit_null();
 }
 
-Variant HphpArray::value(ssize_t& pos) const {
+Variant HphpArray::value(int32_t& pos) const {
   if (pos != ArrayData::invalid_index) {
     Elm* e = &m_data[pos];
     assert(e->data.m_type != KindOfTombstone);
@@ -703,7 +715,6 @@ void HphpArray::newElmStr(ElmInd* ei, strhash_t h, StringData* key,
 }
 
 void HphpArray::allocData(size_t maxElms, size_t tableSize) {
-  assert(!m_data);
   if (maxElms <= SmallSize) {
     m_data = m_inline_data.slots;
     m_hash = m_inline_data.hash;
diff --git a/hphp/runtime/base/array/hphp_array.h b/hphp/runtime/base/array/hphp_array.h
index af5e8647d..662ae7ec2 100644
--- a/hphp/runtime/base/array/hphp_array.h
+++ b/hphp/runtime/base/array/hphp_array.h
@@ -112,7 +112,7 @@ public:
   Variant next();
   Variant end();
   Variant key() const;
-  Variant value(ssize_t& pos) const;
+  Variant value(int32_t& pos) const;
   Variant each();
 
   // implements ArrayData
@@ -295,6 +295,7 @@ public:
   // Use a minimum of an 4-element hash table.  Valid range: [2..32]
   static const uint32_t MinLgTableSize = 2;
   static const uint32_t SmallHashSize = 1 << MinLgTableSize;
+  static const uint32_t SmallMask = SmallHashSize - 1;
   static const uint32_t SmallSize = SmallHashSize - SmallHashSize / LoadScale;
 
   struct InlineSlots {
@@ -356,11 +357,11 @@ private:
   //            +--------------------+
 
   ElmInd  m_lastE;       // Index of last used element.
+  uint32_t  m_tableMask; // Bitmask used when indexing into the hash table.
+  uint32_t  m_hLoad;     // Hash table load (# of non-empty slots).
+  int64_t   m_nextKI;    // Next integer key to use for append.
   Elm*    m_data;        // Contains elements and hash table.
   ElmInd* m_hash;        // Hash table.
-  int64_t   m_nextKI;      // Next integer key to use for append.
-  uint32_t  m_tableMask;   // Bitmask used when indexing into the hash table.
-  uint32_t  m_hLoad;       // Hash table load (# of non-empty slots).
   union {
     InlineSlots m_inline_data;
     ElmInd m_inline_hash[sizeof(m_inline_data) / sizeof(ElmInd)];
@@ -438,9 +439,11 @@ private:
   void reallocData(size_t maxElms, size_t tableSize, uint oldMask);
 
   /**
-   * init(size) allocates space for size elements but initializes
-   * as an empty array
+   * init(size) allocates space for size elements but initializes as
+   * an empty array. The "WithoutHash" version does not initialize the
+   * hash table and returns the hash table size.
    */
+  uint32_t initWithoutHash(uint size);
   void init(uint size);
 
   /**
diff --git a/hphp/runtime/base/array/policy_array.cpp b/hphp/runtime/base/array/policy_array.cpp
index bb55c9b0d..2e3bd45a3 100644
--- a/hphp/runtime/base/array/policy_array.cpp
+++ b/hphp/runtime/base/array/policy_array.cpp
@@ -284,7 +284,7 @@ Variant ArrayShell::key() const {
   return key(toPos(m_pos));
 }
 
-Variant ArrayShell::value(ssize_t &pos) const {
+Variant ArrayShell::value(int32_t &pos) const {
   NOT_IMPLEMENTED();
 }
 
diff --git a/hphp/runtime/base/array/policy_array.h b/hphp/runtime/base/array/policy_array.h
index 431471447..e3ced33ca 100644
--- a/hphp/runtime/base/array/policy_array.h
+++ b/hphp/runtime/base/array/policy_array.h
@@ -54,6 +54,10 @@ static uint32_t toUint32(PosType pos) {
 }
 
 // Signed to pos, no change in representation.
+inline PosType toPos(int32_t n) {
+  static_assert(sizeof(int64_t) == sizeof(PosType), "");
+  return static_cast<PosType>(n);
+}
 static PosType toPos(int64_t n) {
   static_assert(sizeof(int64_t) == sizeof(PosType), "can't");
   return static_cast<PosType>(n);
@@ -383,7 +387,7 @@ public:
   virtual Variant next() FOLLY_OVERRIDE;
   virtual Variant end() FOLLY_OVERRIDE;
   virtual Variant key() const FOLLY_OVERRIDE;
-  virtual Variant value(ssize_t &pos) const FOLLY_OVERRIDE;
+  virtual Variant value(int32_t &pos) const FOLLY_OVERRIDE;
   virtual Variant each() FOLLY_OVERRIDE;
 
   virtual bool isInvalid() const FOLLY_OVERRIDE {
diff --git a/hphp/runtime/vm/name_value_table_wrapper.cpp b/hphp/runtime/vm/name_value_table_wrapper.cpp
index 58eff0905..5f5621c05 100644
--- a/hphp/runtime/vm/name_value_table_wrapper.cpp
+++ b/hphp/runtime/vm/name_value_table_wrapper.cpp
@@ -252,7 +252,7 @@ Variant NameValueTableWrapper::key() const {
   return null_variant;
 }
 
-Variant NameValueTableWrapper::value(ssize_t& pos) const {
+Variant NameValueTableWrapper::value(int32_t& pos) const {
   return current();
 }
 
diff --git a/hphp/runtime/vm/name_value_table_wrapper.h b/hphp/runtime/vm/name_value_table_wrapper.h
index b57ee6811..8f275bd01 100644
--- a/hphp/runtime/vm/name_value_table_wrapper.h
+++ b/hphp/runtime/vm/name_value_table_wrapper.h
@@ -130,7 +130,7 @@ public: // ArrayData implementation
   virtual Variant end();
   virtual CVarRef endRef();
   virtual Variant key() const;
-  virtual Variant value(ssize_t &pos) const;
+  virtual Variant value(int32_t &pos) const;
   virtual Variant each();
   virtual bool validFullPos(const FullPos & fp) const;
   virtual bool advanceFullPos(FullPos&);
@@ -149,7 +149,7 @@ private:
 
 class GlobalNameValueTableWrapper : public NameValueTableWrapper {
  public:
-  GlobalNameValueTableWrapper(NameValueTable* tab);
+  explicit GlobalNameValueTableWrapper(NameValueTable* tab);
   Variant gvm_argc;
   Variant gvm_argv;
   Variant gvm__SERVER;