Changeset 31677 in webkit for trunk/JavaScriptCore/kjs/ustring.cpp

Timestamp:

Apr 6, 2008, 11:33:20 PM (17 years ago)

Author:

[email protected]

Message:

Reviewed by Darin.

Make UString thread-safe.

No change on SunSpider total, although individual tests have changed a lot, up to 3%.

• kjs/InitializeThreading.cpp: (KJS::initializeThreading): Call UString::null() to initialize a static.

• kjs/identifier.cpp: (KJS::CStringTranslator::translate): (KJS::UCharBufferTranslator::translate): Use "true" for a boolean value instead of 1, because it's C++.

• kjs/ustring.h: (KJS::CString::adopt): Added a method to create from a char* buffer without copying. (KJS::UString::Rep::ref): Removed an assertion for JSLock::lockCount, as it's no longer necessary to hold JSLock when working with strings. (KJS::UString::Rep::deref): Ditto. (KJS::UString::Rep::isStatic): Added a field to quickly determine that this is an empty or null static string.

• kjs/ustring.cpp: (KJS::): Removed normalStatBufferSize and statBufferSize, as there is no reason to have such an advanced implementation of a debug-only ascii() method. Removed a long-obsolete comment about UChar. (KJS::UString::Rep::createCopying): Removed an assertion for JSLock::lockCount. (KJS::UString::Rep::create): Ditto. (KJS::UString::Rep::destroy): Ditto. Do not do anything for static null and empty strings, as refcounting is not reliable for those. Reordered branches for a noticeable speed gain - apparently this functiton is hot enough for SunSpider to see an effect from this! (KJS::UString::null): Moved a star, added a comment. (KJS::UString::cstring): Reimplemented to not call ascii(), which is not thread-safe. (KJS::UString::ascii): Simplified statBuffer handling logic. (KJS::UString::toDouble): Use cstring() instead of ascii().

File:

• trunk/JavaScriptCore/kjs/ustring.cpp (modified) (10 diffs)

trunk/JavaScriptCore/kjs/ustring.cpp

@@ -111 +111 @@
 }
 
+CString CString::adopt(char* c, size_t len)
+{
+    CString s;
+    s.data = c;
+    s.length = len;
+    
+    return s;
+}
+
 CString &CString::append(const CString &t)
 {
@@ -163 +172 @@
 }
 
-// Hack here to avoid a global with a constructor; point to an unsigned short instead of a UChar.
+// These static strings are immutable, except for rc, whose initial value is chosen to reduce the possibility of it becoming zero due to ref/deref not being thread-safe.
 static UChar sharedEmptyChar;
-UString::Rep UString::Rep::null = { 0, 0, 1, 0, 0, &UString::Rep::null, 0, 0, 0, 0, 0, 0 };
-UString::Rep UString::Rep::empty = { 0, 0, 1, 0, 0, &UString::Rep::empty, 0, &sharedEmptyChar, 0, 0, 0, 0 };
-const int normalStatBufferSize = 4096;
-static char *statBuffer = 0; // FIXME: This buffer is never deallocated.
-static int statBufferSize = 0;
+UString::Rep UString::Rep::null = { 0, 0, INT_MAX / 2, 0, false, true, &UString::Rep::null, 0, 0, 0, 0, 0, 0 };
+UString::Rep UString::Rep::empty = { 0, 0, INT_MAX / 2, 0, false, true, &UString::Rep::empty, 0, &sharedEmptyChar, 0, 0, 0, 0 };
+
+static char* statBuffer = 0; // Only used for debugging via UString::ascii().
 
 PassRefPtr<UString::Rep> UString::Rep::createCopying(const UChar *d, int l)
 {
-  ASSERT(JSLock::lockCount() > 0);
-
   int sizeInBytes = l * sizeof(UChar);
   UChar *copyD = static_cast<UChar *>(fastMalloc(sizeInBytes));
@@ -184 +190 @@
 PassRefPtr<UString::Rep> UString::Rep::create(UChar *d, int l)
 {
-  ASSERT(JSLock::lockCount() > 0);
-
   Rep* r = new Rep;
   r->offset = 0;
@@ -191 +195 @@
   r->rc = 1;
   r->_hash = 0;
-  r->isIdentifier = 0;
+  r->isIdentifier = false;
+  r->isStatic = false;
   r->baseString = r;
   r->reportedCost = 0;
@@ -206 +211 @@
 PassRefPtr<UString::Rep> UString::Rep::create(PassRefPtr<Rep> base, int offset, int length)
 {
-  ASSERT(JSLock::lockCount() > 0);
   ASSERT(base);
 
@@ -221 +225 @@
   r->rc = 1;
   r->_hash = 0;
-  r->isIdentifier = 0;
+  r->isIdentifier = false;
+  r->isStatic = false;
   r->baseString = base.releaseRef();
   r->reportedCost = 0;
@@ -236 +241 @@
 void UString::Rep::destroy()
 {
-  ASSERT(JSLock::lockCount() > 0);
-
-  if (isIdentifier)
-    Identifier::remove(this);
-  if (baseString != this) {
-    baseString->deref();
-  } else {
-    fastFree(buf);
-  }
-  delete this;
+  // Static null and empty strings can never be destroyed, but we cannot rely on reference counting, because ref/deref are not thread-safe.
+  if (!isStatic) {
+    if (isIdentifier)
+      Identifier::remove(this);
+    if (baseString == this)
+      fastFree(buf);
+    else
+      baseString->deref();
+
+    delete this;
+  }
 }
 
@@ -519 +525 @@
 const UString& UString::null()
 {
-  static UString* n = new UString;
+  static UString* n = new UString; // Should be called from main thread at least once to be safely initialized.
   return *n;
 }
@@ -858 +864 @@
 CString UString::cstring() const
 {
-  return ascii();
-}
-
-char *UString::ascii() const
-{
-  // Never make the buffer smaller than normalStatBufferSize.
-  // Thus we almost never need to reallocate.
   int length = size();
   int neededSize = length + 1;
-  if (neededSize < normalStatBufferSize) {
-    neededSize = normalStatBufferSize;
-  }
-  if (neededSize != statBufferSize) {
-    delete [] statBuffer;
-    statBuffer = new char [neededSize];
-    statBufferSize = neededSize;
-  }
+  char* buf = new char[neededSize];
+  
+  const UChar* p = data();
+  char* q = buf;
+  const UChar* limit = p + length;
+  while (p != limit) {
+    *q = static_cast<char>(p[0]);
+    ++p;
+    ++q;
+  }
+  *q = '\0';
+  
+  return CString::adopt(buf, length);
+}
+
+char *UString::ascii() const
+{
+  int length = size();
+  int neededSize = length + 1;
+  delete[] statBuffer;
+  statBuffer = new char[neededSize];
   
   const UChar *p = data();
@@ -950 +962 @@
     return NaN;
 
-  const char *c = ascii();
+  CString s = cstring();
+  const char* c = s.c_str();
 
   // skip leading white space