Changeset 244300 in webkit

Timestamp:

Apr 15, 2019 3:23:38 PM (5 years ago)

Author:

Tadeu Zagallo

Message:

Bytecode cache should not encode the SourceProvider for UnlinkedFunctionExecutable's classSource
​https://bugs.webkit.org/show_bug.cgi?id=196878

Reviewed by Saam Barati.

Every time we encode an (Unlinked)SourceCode, we encode its SourceProvider,
including the full source if it's a StringSourceProvider. This wasn't an issue,
since the SourceCode contains a RefPtr to the SourceProvider, and the Encoder
would avoid encoding the provider multiple times. With the addition of the
incremental cache, each UnlinkedFunctionCodeBlock is encoded in isolation, which
means we can no longer deduplicate it and the full program text was being encoded
multiple times in the cache.
As a work around, this patch adds a custom cached type for encoding the SourceCode
without its provider, and later injects the SourceProvider through the Decoder.

• parser/SourceCode.h:
• parser/UnlinkedSourceCode.h:

(JSC::UnlinkedSourceCode::provider const):

• runtime/CachedTypes.cpp:

(JSC::Decoder::Decoder):
(JSC::Decoder::create):
(JSC::Decoder::provider const):
(JSC::CachedSourceCodeWithoutProvider::encode):
(JSC::CachedSourceCodeWithoutProvider::decode const):
(JSC::decodeCodeBlockImpl):

• runtime/CachedTypes.h:

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• parser/SourceCode.h (modified) (1 diff)
• parser/UnlinkedSourceCode.h (modified) (2 diffs)
• runtime/CachedTypes.cpp (modified) (6 diffs)
• runtime/CachedTypes.h (modified) (4 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2019-04-15  Tadeu Zagallo  <tzagallo@apple.com>
+
+        Bytecode cache should not encode the SourceProvider for UnlinkedFunctionExecutable's classSource
+        https://bugs.webkit.org/show_bug.cgi?id=196878
+
+        Reviewed by Saam Barati.
+
+        Every time we encode an (Unlinked)SourceCode, we encode its SourceProvider,
+        including the full source if it's a StringSourceProvider. This wasn't an issue,
+        since the SourceCode contains a RefPtr to the SourceProvider, and the Encoder
+        would avoid encoding the provider multiple times. With the addition of the
+        incremental cache, each UnlinkedFunctionCodeBlock is encoded in isolation, which
+        means we can no longer deduplicate it and the full program text was being encoded
+        multiple times in the cache.
+        As a work around, this patch adds a custom cached type for encoding the SourceCode
+        without its provider, and later injects the SourceProvider through the Decoder.
+
+        * parser/SourceCode.h:
+        * parser/UnlinkedSourceCode.h:
+        (JSC::UnlinkedSourceCode::provider const):
+        * runtime/CachedTypes.cpp:
+        (JSC::Decoder::Decoder):
+        (JSC::Decoder::create):
+        (JSC::Decoder::provider const):
+        (JSC::CachedSourceCodeWithoutProvider::encode):
+        (JSC::CachedSourceCodeWithoutProvider::decode const):
+        (JSC::decodeCodeBlockImpl):
+        * runtime/CachedTypes.h:
+
 2019-04-15  Robin Morisset  <rmorisset@apple.com>
 

trunk/Source/JavaScriptCore/parser/SourceCode.h

@@ -35 +35 @@
     class SourceCode : public UnlinkedSourceCode {
         friend class CachedSourceCode;
+        friend class CachedSourceCodeWithoutProvider;
 
     public:

trunk/Source/JavaScriptCore/parser/UnlinkedSourceCode.h

@@ -37 +37 @@
         template<typename SourceType>
         friend class CachedUnlinkedSourceCodeShape;
+        friend class CachedSourceCodeWithoutProvider;
 
     public:
@@ -74 +75 @@
         bool isHashTableDeletedValue() const { return m_provider.isHashTableDeletedValue(); }
 
-        const SourceProvider& provider() const
+        SourceProvider& provider() const
         {
             return *m_provider;

trunk/Source/JavaScriptCore/runtime/CachedTypes.cpp

@@ -221 +221 @@
 };
 
-Decoder::Decoder(VM& vm, Ref<CachedBytecode> cachedBytecode)
+Decoder::Decoder(VM& vm, Ref<CachedBytecode> cachedBytecode, RefPtr<SourceProvider> provider)
     : m_vm(vm)
     , m_cachedBytecode(WTFMove(cachedBytecode))
+    , m_provider(provider)
 {
 }
@@ -233 +234 @@
 }
 
-Ref<Decoder> Decoder::create(VM& vm, Ref<CachedBytecode> cachedBytecode)
-{
-    return adoptRef(*new Decoder(vm, WTFMove(cachedBytecode)));
+Ref<Decoder> Decoder::create(VM& vm, Ref<CachedBytecode> cachedBytecode, RefPtr<SourceProvider> provider)
+{
+    return adoptRef(*new Decoder(vm, WTFMove(cachedBytecode), WTFMove(provider)));
 }
 
@@ -293 +294 @@
 {
     m_finalizers.append(fn);
+}
+
+RefPtr<SourceProvider> Decoder::provider() const
+{
+    return m_provider;
 }
 
@@ -1548 +1554 @@
 };
 
+class CachedSourceCodeWithoutProvider : public CachedObject<SourceCode> {
+public:
+    void encode(Encoder&, const SourceCode& sourceCode)
+    {
+        m_hasProvider = !!sourceCode.provider();
+        m_startOffset = sourceCode.startOffset();
+        m_endOffset = sourceCode.endOffset();
+        m_firstLine = sourceCode.firstLine().zeroBasedInt();
+        m_startColumn = sourceCode.startColumn().zeroBasedInt();
+    }
+
+    void decode(Decoder& decoder, SourceCode& sourceCode) const
+    {
+        if (m_hasProvider)
+            sourceCode.m_provider = decoder.provider();
+        sourceCode.m_startOffset = m_startOffset;
+        sourceCode.m_endOffset = m_endOffset;
+        sourceCode.m_firstLine = OrdinalNumber::fromZeroBasedInt(m_firstLine);
+        sourceCode.m_startColumn = OrdinalNumber::fromZeroBasedInt(m_startColumn);
+    }
+
+private:
+    bool m_hasProvider;
+    int m_startOffset;
+    int m_endOffset;
+    int m_firstLine;
+    int m_startColumn;
+};
+
 class CachedFunctionExecutableRareData : public CachedObject<UnlinkedFunctionExecutable::RareData> {
 public:
@@ -1566 +1601 @@
 
 private:
-    CachedSourceCode m_classSource;
+    CachedSourceCodeWithoutProvider m_classSource;
     CachedCompactVariableMapHandle m_parentScopeTDZVariables;
 };
@@ -2298 +2333 @@
 {
     const auto* cachedEntry = bitwise_cast<const GenericCacheEntry*>(cachedBytecode->data());
-    Ref<Decoder> decoder = Decoder::create(vm, WTFMove(cachedBytecode));
+    Ref<Decoder> decoder = Decoder::create(vm, WTFMove(cachedBytecode), &key.source().provider());
     std::pair<SourceCodeKey, UnlinkedCodeBlock*> entry;
     {

trunk/Source/JavaScriptCore/runtime/CachedTypes.h

@@ -78 +78 @@
 
 public:
-    static Ref<Decoder> create(VM&, Ref<CachedBytecode>);
+    static Ref<Decoder> create(VM&, Ref<CachedBytecode>, RefPtr<SourceProvider> = nullptr);
 
     ~Decoder();
@@ -92 +92 @@
     void setHandleForEnvironment(CompactVariableEnvironment*, const CompactVariableMap::Handle&);
     void addLeafExecutable(const UnlinkedFunctionExecutable*, ptrdiff_t);
+    RefPtr<SourceProvider> provider() const;
 
     template<typename Functor>
@@ -97 +98 @@
 
 private:
-    Decoder(VM&, Ref<CachedBytecode>);
+    Decoder(VM&, Ref<CachedBytecode>, RefPtr<SourceProvider>);
 
     VM& m_vm;
@@ -104 +105 @@
     Vector<std::function<void()>> m_finalizers;
     HashMap<CompactVariableEnvironment*, CompactVariableMap::Handle> m_environmentToHandleMap;
+    RefPtr<SourceProvider> m_provider;
 };