CL for perf tryjob ThreadSafeRefCountedStringImpl Linux blink_perf.dom

Source/wtf/text/StringImpl.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef StringImpl_h
 #define StringImpl_h
 
 #include <limits.h>
 #include "wtf/ASCIICType.h"
+#include "wtf/DynamicAnnotations.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/StringHasher.h"
 #include "wtf/Vector.h"
 #include "wtf/WTFExport.h"
 #include "wtf/unicode/Unicode.h"
 
 #if USE(CF)
 typedef const struct __CFString * CFStringRef;
 #endif
@@ skipping 238 matching lines @@
         return rawHash();
     }
 
     unsigned hash() const
     {
         if (hasHash())
             return existingHash();
         return hashSlowCase();
     }
 
+    ALWAYS_INLINE unsigned refCount() const
+    {
+        return static_cast<int const volatile &>(m_refCount);
+    }
+
     ALWAYS_INLINE bool hasOneRef() const
     {
-        return m_refCount == 1;
+        return refCount() == 1;
     }
 
     ALWAYS_INLINE void ref()
     {
-        ++m_refCount;
+        atomicIncrement(&m_refCount);
     }
 
     ALWAYS_INLINE void deref()
     {
-        if (hasOneRef()) {
+        WTF_ANNOTATE_HAPPENS_BEFORE(&m_refCount);
+        if (atomicDecrement(&m_refCount) <= 0) {
+            WTF_ANNOTATE_HAPPENS_AFTER(&m_refCount);

[Alexander Potapenko, 2014/12/08 11:46:57]

Please do not use WTF_ANNOTATE_HAPPENS_AFTER.
They were intended to aid TSan v1, which couldn't comprehend atomics, and which
is retired now.
TSan v2 is able to understand atomic-based synchronization, and adding excessive
happens-before annotations may mask actual errors in the implementation.
I think we should plan removing all WTF_ANNOTATE_HAPPENS_{BEFORE,AFTER} from
Blink at some point.

             destroyIfNotStatic();
-            return;
         }
-
-        --m_refCount;
     }
 
     static StringImpl* empty();
     static StringImpl* empty16Bit();
 
     // FIXME: Does this really belong in StringImpl?
     template <typename T> static void copyChars(T* destination, const T* source, unsigned numCharacters)
     {
         memcpy(destination, source, numCharacters * sizeof(T));
     }
@@ skipping 127 matching lines @@
 
 #if ENABLE(ASSERT)
     void assertHashIsCorrect()
     {
         ASSERT(hasHash());
         ASSERT(existingHash() == StringHasher::computeHashAndMaskTop8Bits(characters8(), length()));
     }
 #endif
 
 private:
-    unsigned m_refCount;
+    int m_refCount;
     unsigned m_length;
     mutable unsigned m_hash : 24;
     unsigned m_isAtomic : 1;
     unsigned m_is8Bit : 1;
     unsigned m_isStatic : 1;
 };
 
 template <>
 ALWAYS_INLINE const LChar* StringImpl::getCharacters<LChar>() const { return characters8(); }
 
@@ skipping 281 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif