hphp/runtime/base/apc-local-array.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16 #ifndef incl_HPHP_APC_LOCAL_ARRAY_H_
  17 #define incl_HPHP_APC_LOCAL_ARRAY_H_
  18
  19 #include <vector>
  20 #include <utility>
  21 #include <cstdint>
  22 #include <sys/types.h>
  23
  24 #include "hphp/runtime/base/array-data.h"
  25 #include "hphp/runtime/base/apc-array.h"
  26 #include "hphp/runtime/base/tv-val.h"
  27
  28 namespace HPHP {
  29
  30 //////////////////////////////////////////////////////////////////////
  31
  32 struct Variant;
  33 struct TypedValue;
  34 struct StringData;
  35
  36 //////////////////////////////////////////////////////////////////////
  37
  38 /*
  39  * Wrapper for APCArray. It is what gets returned when an array is fetched
  40  * via APC. It has a pointer to the APCArray that it represents and it may
  41  * cache values locally depending on the type accessed and/or the operation.
  42  */
  43 struct APCLocalArray final : ArrayData,
  44                              type_scan::MarkCollectable<APCLocalArray> {
  45   static APCLocalArray* Make(const APCArray*);
  46
  47   static size_t Vsize(const ArrayData*);
  48   static tv_rval RvalPos(const ArrayData* ad, ssize_t pos);
  49   static bool ExistsInt(const ArrayData* ad, int64_t k);
  50   static bool ExistsStr(const ArrayData* ad, const StringData* k);
  51   static arr_lval LvalInt(ArrayData*, int64_t k, bool copy);
  52   static arr_lval LvalStr(ArrayData*, StringData* k, bool copy);
  53   static arr_lval LvalSilentInt(ArrayData*, int64_t k, bool copy);
  54   static arr_lval LvalSilentStr(ArrayData*, StringData* k, bool copy);
  55   static arr_lval LvalForceNew(ArrayData*, bool copy);
  56   static ArrayData* SetInt(ArrayData*, int64_t k, TypedValue v);
  57   static ArrayData* SetIntMove(ArrayData*, int64_t k, TypedValue v);
  58   static constexpr auto SetIntInPlace = &SetInt;
  59   static ArrayData* SetStr(ArrayData*, StringData* k, TypedValue v);
  60   static ArrayData* SetStrMove(ArrayData*, StringData* k, TypedValue v);
  61   static constexpr auto SetStrInPlace = &SetStr;
  62   static ArrayData *RemoveInt(ArrayData* ad, int64_t k);
  63   static constexpr auto RemoveIntInPlace = &RemoveInt;
  64   static ArrayData *RemoveStr(ArrayData* ad, const StringData* k);
  65   static constexpr auto RemoveStrInPlace = &RemoveStr;
  66   static ArrayData* Copy(const ArrayData*);
  67   static ArrayData* Append(ArrayData* a, TypedValue v);
  68   static constexpr auto AppendInPlace = &Append;
  69   static ArrayData* PlusEq(ArrayData*, const ArrayData *elems);
  70   static ArrayData* Merge(ArrayData*, const ArrayData *elems);
  71   static ArrayData* Prepend(ArrayData*, TypedValue v);
  72   static tv_rval NvGetInt(const ArrayData*, int64_t k);
  73   static constexpr auto NvTryGetInt = &NvGetInt;
  74   static tv_rval NvGetStr(const ArrayData*, const StringData* k);
  75   static constexpr auto NvTryGetStr = &NvGetStr;
  76   static ssize_t NvGetIntPos(const ArrayData* ad, int64_t k);
  77   static ssize_t NvGetStrPos(const ArrayData* ad, const StringData* k);
  78   static TypedValue NvGetKey(const ArrayData*, ssize_t pos);
  79   static bool IsVectorData(const ArrayData* ad);
  80   static ssize_t IterBegin(const ArrayData*);
  81   static ssize_t IterLast(const ArrayData*);
  82   static ssize_t IterEnd(const ArrayData*);
  83   static ssize_t IterAdvance(const ArrayData*, ssize_t prev);
  84   static ssize_t IterRewind(const ArrayData*, ssize_t prev);
  85   static ArrayData* CopyStatic(const ArrayData*);
  86   static constexpr auto Pop = &ArrayCommon::Pop;
  87   static constexpr auto Dequeue = &ArrayCommon::Dequeue;
  88   static void Renumber(ArrayData*);
  89   static void OnSetEvalScalar(ArrayData*);
  90   static void Release(ArrayData*);
  91   static ArrayData* EscalateForSort(ArrayData*, SortFunction);
  92   static void Ksort(ArrayData*, int, bool);
  93   static void Sort(ArrayData*, int, bool);
  94   static void Asort(ArrayData*, int, bool);
  95   static bool Uksort(ArrayData*, const Variant&);
  96   static bool Usort(ArrayData*, const Variant&);
  97   static bool Uasort(ArrayData*, const Variant&);
  98   static ArrayData* ToPHPArray(ArrayData* ad, bool) {
  99     return ad;
 100   }
 101   static constexpr auto ToPHPArrayIntishCast = &ToPHPArray;
 102   static constexpr auto ToVec = &ArrayCommon::ToVec;
 103   static constexpr auto ToDict = &ArrayCommon::ToDict;
 104   static constexpr auto ToKeyset = &ArrayCommon::ToKeyset;
 105   static constexpr auto ToVArray = &ArrayCommon::ToVArray;
 106   static constexpr auto ToDArray = &ArrayCommon::ToDArray;
 107
 108 public:
 109   using ArrayData::decRefCount;
 110   using ArrayData::hasMultipleRefs;
 111   using ArrayData::hasExactlyOneRef;
 112   using ArrayData::decWillRelease;
 113   using ArrayData::incRefCount;
 114
 115   ssize_t iterAdvanceImpl(ssize_t prev) const {
 116     assertx(prev >= 0 && prev < m_size);
 117     ssize_t next = prev + 1;
 118     return next < m_size ? next : m_size;
 119   }
 120
 121   // Only explicit conversions are allowed to and from ArrayData*.
 122   ArrayData* asArrayData() { return this; }
 123   const ArrayData* asArrayData() const { return this; }
 124
 125   // Pre: ad->isApcArray()
 126   static APCLocalArray* asApcArray(ArrayData*);
 127   static const APCLocalArray* asApcArray(const ArrayData*);
 128   static ArrayData* Escalate(const ArrayData*);
 129
 130   void scan(type_scan::Scanner& scanner) const;
 131   size_t heapSize() const;
 132
 133 private:
 134   explicit APCLocalArray(const APCArray* source, size_t heapSize);
 135   ~APCLocalArray() = delete;
 136
 137   static bool checkInvariants(const ArrayData*);
 138   ssize_t getIndex(int64_t k) const;
 139   ssize_t getIndex(const StringData* k) const;
 140   ArrayData* loadElems() const;
 141   Variant getKey(ssize_t pos) const;
 142   void sweep();
 143   TypedValue* localCache() const;
 144
 145 private:
 146   const APCArray* m_arr;
 147   unsigned m_sweep_index;
 148   friend struct MemoryManager; // access to m_sweep_index
 149 };
 150
 151 //////////////////////////////////////////////////////////////////////
 152
 153 }
 154
 155 #endif