JavaScriptCore-903.tar.gz

[apple/javascriptcore.git] / runtime / SmallStrings.cpp

diff --git a/runtime/SmallStrings.cpp b/runtime/SmallStrings.cpp
index 87b49f05a5ce7eb1a85d90264ae732a485c4adca..8741e9bd29a53220d916f9971c20278fb04de1e4 100644 (file)
--- a/runtime/SmallStrings.cpp
+++ b/runtime/SmallStrings.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2008, 2010 Apple Inc. All Rights Reserved.

  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -28,68 +28,86 @@
 
 #include "JSGlobalObject.h"
 #include "JSString.h"
 
 #include "JSGlobalObject.h"
 #include "JSString.h"

-

 #include <wtf/Noncopyable.h>
 #include <wtf/Noncopyable.h>

+#include <wtf/PassOwnPtr.h>

 
 namespace JSC {
 
 namespace JSC {

-static const unsigned numCharactersToStore = 0x100;

 
 

-class SmallStringsStorage : Noncopyable {
+static inline bool isMarked(JSCell* string)
+{
+    return string && Heap::isMarked(string);
+}
+
+class SmallStringsStorage {
+    WTF_MAKE_NONCOPYABLE(SmallStringsStorage); WTF_MAKE_FAST_ALLOCATED;

 public:
     SmallStringsStorage();
 
 public:
     SmallStringsStorage();
 

-    UString::Rep* rep(unsigned char character) { return &m_reps[character]; }
+    StringImpl* rep(unsigned char character)
+    {
+        return m_reps[character].get();
+    }

 
 private:
 
 private:

-    UChar m_characters[numCharactersToStore];
-    UString::BaseString m_base;
-    UString::Rep m_reps[numCharactersToStore];
+    static const unsigned singleCharacterStringCount = maxSingleCharacterString + 1;
+
+    RefPtr<StringImpl> m_reps[singleCharacterStringCount];

 };
 
 SmallStringsStorage::SmallStringsStorage()
 };
 
 SmallStringsStorage::SmallStringsStorage()

-    : m_base(m_characters, numCharactersToStore)

 {
 {

-    m_base.rc = numCharactersToStore + 1;
-    // make sure UString doesn't try to reuse the buffer by pretending we have one more character in it
-    m_base.usedCapacity = numCharactersToStore + 1;
-    m_base.capacity = numCharactersToStore + 1;
-    m_base.checkConsistency();
-
-    for (unsigned i = 0; i < numCharactersToStore; ++i)
-        m_characters[i] = i;
-
-    memset(&m_reps, 0, sizeof(m_reps));
-    for (unsigned i = 0; i < numCharactersToStore; ++i) {
-        m_reps[i].offset = i;
-        m_reps[i].len = 1;
-        m_reps[i].rc = 1;
-        m_reps[i].setBaseString(&m_base);
-        m_reps[i].checkConsistency();
+    UChar* characterBuffer = 0;
+    RefPtr<StringImpl> baseString = StringImpl::createUninitialized(singleCharacterStringCount, characterBuffer);
+    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
+        characterBuffer[i] = i;
+        m_reps[i] = StringImpl::create(baseString, i, 1);

     }
 }
 
 SmallStrings::SmallStrings()
     }
 }
 
 SmallStrings::SmallStrings()

-    : m_emptyString(0)
-    , m_storage(0)

 {
 {

-    COMPILE_ASSERT(numCharactersToStore == sizeof(m_singleCharacterStrings) / sizeof(m_singleCharacterStrings[0]), IsNumCharactersConstInSyncWithClassUsage);
-
-    for (unsigned i = 0; i < numCharactersToStore; ++i)
-        m_singleCharacterStrings[i] = 0;
+    COMPILE_ASSERT(singleCharacterStringCount == sizeof(m_singleCharacterStrings) / sizeof(m_singleCharacterStrings[0]), IsNumCharactersConstInSyncWithClassUsage);
+    clear();

 }
 
 SmallStrings::~SmallStrings()
 {
 }
 
 }
 
 SmallStrings::~SmallStrings()
 {
 }
 

-void SmallStrings::mark()
+void SmallStrings::visitChildren(HeapRootVisitor& heapRootMarker)

 {
 {

-    if (m_emptyString && !m_emptyString->marked())
-        m_emptyString->mark();
-    for (unsigned i = 0; i < numCharactersToStore; ++i) {
-        if (m_singleCharacterStrings[i] && !m_singleCharacterStrings[i]->marked())
-            m_singleCharacterStrings[i]->mark();
+    /*
+       Our hypothesis is that small strings are very common. So, we cache them
+       to avoid GC churn. However, in cases where this hypothesis turns out to
+       be false -- including the degenerate case where all JavaScript execution
+       has terminated -- we don't want to waste memory.
+
+       To test our hypothesis, we check if any small string has been marked. If
+       so, it's probably reasonable to mark the rest. If not, we clear the cache.
+     */
+
+    bool isAnyStringMarked = isMarked(m_emptyString);
+    for (unsigned i = 0; i < singleCharacterStringCount && !isAnyStringMarked; ++i)
+        isAnyStringMarked = isMarked(m_singleCharacterStrings[i]);
+    
+    if (!isAnyStringMarked) {
+        clear();
+        return;

     }
     }

+    
+    if (m_emptyString)
+        heapRootMarker.mark(&m_emptyString);
+    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
+        if (m_singleCharacterStrings[i])
+            heapRootMarker.mark(&m_singleCharacterStrings[i]);
+    }
+}
+
+void SmallStrings::clear()
+{
+    m_emptyString = 0;
+    for (unsigned i = 0; i < singleCharacterStringCount; ++i)
+        m_singleCharacterStrings[i] = 0;

 }
 
 unsigned SmallStrings::count() const
 }
 
 unsigned SmallStrings::count() const


@@ -97,7 +115,7 @@ unsigned SmallStrings::count() const
     unsigned count = 0;
     if (m_emptyString)
         ++count;
     unsigned count = 0;
     if (m_emptyString)
         ++count;

-    for (unsigned i = 0; i < numCharactersToStore; ++i) {
+    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {

         if (m_singleCharacterStrings[i])
             ++count;
     }
         if (m_singleCharacterStrings[i])
             ++count;
     }


@@ -113,15 +131,15 @@ void SmallStrings::createEmptyString(JSGlobalData* globalData)
 void SmallStrings::createSingleCharacterString(JSGlobalData* globalData, unsigned char character)
 {
     if (!m_storage)
 void SmallStrings::createSingleCharacterString(JSGlobalData* globalData, unsigned char character)
 {
     if (!m_storage)

-        m_storage.set(new SmallStringsStorage);
+        m_storage = adoptPtr(new SmallStringsStorage);

     ASSERT(!m_singleCharacterStrings[character]);
     ASSERT(!m_singleCharacterStrings[character]);

-    m_singleCharacterStrings[character] = new (globalData) JSString(globalData, m_storage->rep(character), JSString::HasOtherOwner);
+    m_singleCharacterStrings[character] = new (globalData) JSString(globalData, PassRefPtr<StringImpl>(m_storage->rep(character)), JSString::HasOtherOwner);

 }
 
 }
 

-UString::Rep* SmallStrings::singleCharacterStringRep(unsigned char character)
+StringImpl* SmallStrings::singleCharacterStringRep(unsigned char character)

 {
     if (!m_storage)
 {
     if (!m_storage)

-        m_storage.set(new SmallStringsStorage);
+        m_storage = adoptPtr(new SmallStringsStorage);

     return m_storage->rep(character);
 }
 
     return m_storage->rep(character);
 }