git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

3 *

4 * Redistribution and use in source and binary forms, with or without

5 * modification, are permitted provided that the following conditions

6 * are met:

7 * 1. Redistributions of source code must retain the above copyright

8 * notice, this list of conditions and the following disclaimer.

9 * 2. Redistributions in binary form must reproduce the above copyright

10 * notice, this list of conditions and the following disclaimer in the

11 * documentation and/or other materials provided with the distribution.

12 *

13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

23 * THE POSSIBILITY OF SUCH DAMAGE.

24 */

26 #ifndef WeakBlock_h

27 #define WeakBlock_h

29 #include <wtf/DoublyLinkedList.h>

30 #include "WeakHandleOwner.h"

31 #include "WeakImpl.h"

32 #include <wtf/DoublyLinkedList.h>

33 #include <wtf/StdLibExtras.h>

35 namespace JSC {

37 class HeapRootVisitor;

38 class JSValue;

39 class MarkedBlock;

40 class WeakHandleOwner;

 class WeakBlock : public DoublyLinkedListNode<WeakBlock> {

43 public:

     friend class WTF::DoublyLinkedListNode<WeakBlock>;

     static const size_t blockSize = 1 * KB; // 1/16 of MarkedBlock size

47 struct FreeCell {

48 FreeCell* next;

49 };

51 struct SweepResult {

         bool isNull() const;

54 bool blockIsFree { true };

55 bool blockIsLogicallyEmpty { true };

56 FreeCell* freeList { nullptr };

57 };

     static WeakBlock* create(MarkedBlock&);

60 static void destroy(WeakBlock*);

     static WeakImpl* asWeakImpl(FreeCell*);

64 bool isEmpty();

     bool isLogicallyEmptyButNotFree() const;

67 void sweep();

68 SweepResult takeSweepResult();

70 void visit(HeapRootVisitor&);

71 void reap();

73 void lastChanceToFinalize();

     void disconnectMarkedBlock() { m_markedBlock = nullptr; }

76 private:

     static FreeCell* asFreeCell(WeakImpl*);

79 explicit WeakBlock(MarkedBlock&);

80 WeakImpl* firstWeakImpl();

81 void finalize(WeakImpl*);

82 WeakImpl* weakImpls();

83 size_t weakImplCount();

     void addToFreeList(FreeCell**, WeakImpl*);

86 MarkedBlock* m_markedBlock;

87 WeakBlock* m_prev;

88 WeakBlock* m_next;

89 SweepResult m_sweepResult;

90 };

 inline bool WeakBlock::SweepResult::isNull() const

93 {

94 return blockIsFree && !freeList; // This state is impossible, so we can use it to mean null.

95 }

 inline WeakImpl* WeakBlock::asWeakImpl(FreeCell* freeCell)

98 {

99 return reinterpret_cast_ptr<WeakImpl*>(freeCell);

100 }

101

 inline WeakBlock::SweepResult WeakBlock::takeSweepResult()

103 {

104 SweepResult tmp;

     std::swap(tmp, m_sweepResult);

     ASSERT(m_sweepResult.isNull());

107 return tmp;

108 }

109

 inline WeakBlock::FreeCell* WeakBlock::asFreeCell(WeakImpl* weakImpl)

111 {

112 return reinterpret_cast_ptr<FreeCell*>(weakImpl);

113 }

114

 inline WeakImpl* WeakBlock::weakImpls()

116 {

     return reinterpret_cast_ptr<WeakImpl*>(this) + ((sizeof(WeakBlock) + sizeof(WeakImpl) - 1) / sizeof(WeakImpl));

118 }

119

 inline size_t WeakBlock::weakImplCount()

121 {

     return (blockSize / sizeof(WeakImpl)) - ((sizeof(WeakBlock) + sizeof(WeakImpl) - 1) / sizeof(WeakImpl));

123 }

124

 inline void WeakBlock::addToFreeList(FreeCell** freeList, WeakImpl* weakImpl)

126 {

     ASSERT(weakImpl->state() == WeakImpl::Deallocated);

     FreeCell* freeCell = asFreeCell(weakImpl);

     ASSERT(!*freeList || ((char*)*freeList > (char*)this && (char*)*freeList < (char*)this + blockSize));

     ASSERT((char*)freeCell > (char*)this && (char*)freeCell < (char*)this + blockSize);

131 freeCell->next = *freeList;

132 *freeList = freeCell;

133 }

134

 inline bool WeakBlock::isEmpty()

136 {

     return !m_sweepResult.isNull() && m_sweepResult.blockIsFree;

138 }

139

 inline bool WeakBlock::isLogicallyEmptyButNotFree() const

141 {

     return !m_sweepResult.isNull() && !m_sweepResult.blockIsFree && m_sweepResult.blockIsLogicallyEmpty;

143 }

144

145 } // namespace JSC

146

147 #endif // WeakBlock_h