Attachment 362118 Details for Bug 194706 – Patch

[patch] Patch

bug-194706-20190215181624.patch (text/plain), 10.41 KB, created by Tadeu Zagallo on 2019-02-15 09:16:57 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Tadeu Zagallo

Created: 2019-02-15 09:16:57 PST

Size: 10.41 KB

patch

obsolete

>Subversion Revision: 241582
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 43466db695fa88e0ef52e2110b7a5fd6fd40d7b5..a3c4ad155763c9877f72af3d70d91af0f4bf0342 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,31 @@
>+2019-02-15  Tadeu Zagallo  <tzagallo@apple.com>
>+
>+        Cache CompactVariableMap::Handle instead of VariableEnvironment for UnlinkedFunctionExecutable
>+        https://bugs.webkit.org/show_bug.cgi?id=194706
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        In https://bugs.webkit.org/show_bug.cgi?id=194583 we started using a
>+        CompactVariableMap::Handle instead of VariableEnvironment for
>+        UnlinkedFunctionExecutables, but we were creating the full environment
>+        to encode the executable in the bytecode cache. This patch changes it so
>+        that we cache the handle instead of the environment.
>+
>+        * bytecode/UnlinkedFunctionExecutable.h:
>+        * parser/VariableEnvironment.h:
>+        * runtime/CachedTypes.cpp:
>+        (JSC::CachedCompactVariableEnvironment::encode):
>+        (JSC::CachedCompactVariableEnvironment::decode const):
>+        (JSC::CachedCompactVariableMapKey::encode):
>+        (JSC::CachedCompactVariableMapKey::decode const):
>+        (JSC::CachedCompactVariableMap::encode):
>+        (JSC::CachedCompactVariableMap::decode const):
>+        (JSC::CachedCompactVariableMapHandle::encode):
>+        (JSC::CachedCompactVariableMapHandle::decode const):
>+        (JSC::CachedFunctionExecutable::encode):
>+        (JSC::CachedFunctionExecutable::decode const):
>+        (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
>+
> 2019-02-14  Tadeu Zagallo  <tzagallo@apple.com>
> 
>         Move bytecode cache-related filesystem code out of CodeCache
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>index 7738152ed844de41397bfdac7bb7a00d482be8c1..e248460f1c86b7fdd8736304ca583ea99cfc33d5 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>@@ -153,7 +153,7 @@ public:
> 
> private:
>     UnlinkedFunctionExecutable(VM*, Structure*, const SourceCode&, FunctionMetadataNode*, UnlinkedFunctionKind, ConstructAbility, JSParserScriptMode, CompactVariableMap::Handle,  JSC::DerivedContextType, bool isBuiltinDefaultClassConstructor);
>-    UnlinkedFunctionExecutable(Decoder&, VariableEnvironment&, const CachedFunctionExecutable&);
>+    UnlinkedFunctionExecutable(Decoder&, CompactVariableMap::Handle, const CachedFunctionExecutable&);
> 
>     unsigned m_firstLineOffset;
>     unsigned m_lineCount;
>diff --git a/Source/JavaScriptCore/parser/VariableEnvironment.h b/Source/JavaScriptCore/parser/VariableEnvironment.h
>index ee6cce6e786ca56aa00081d095f0264bc3cbee5a..ea71da3cd2976c0448186fe4522446edc6d9768b 100644
>--- a/Source/JavaScriptCore/parser/VariableEnvironment.h
>+++ b/Source/JavaScriptCore/parser/VariableEnvironment.h
>@@ -125,6 +125,9 @@ private:
> class CompactVariableEnvironment {
>     WTF_MAKE_FAST_ALLOCATED;
>     WTF_MAKE_NONCOPYABLE(CompactVariableEnvironment);
>+
>+    friend class CachedCompactVariableEnvironment;
>+
> public:
>     CompactVariableEnvironment(const VariableEnvironment&);
>     VariableEnvironment toVariableEnvironment() const;
>@@ -133,6 +136,8 @@ public:
>     unsigned hash() const { return m_hash; }
> 
> private:
>+    CompactVariableEnvironment() = default;
>+
>     Vector<RefPtr<UniquedStringImpl>> m_variables;
>     Vector<VariableEnvironmentEntry> m_variableMetadata;
>     unsigned m_hash;
>@@ -174,6 +179,8 @@ struct CompactVariableMapKey {
>     }
> 
> private:
>+    friend class CachedCompactVariableMapKey;
>+
>     CompactVariableEnvironment* m_environment;
> };
> 
>@@ -202,8 +209,12 @@ template<> struct HashTraits<JSC::CompactVariableMapKey> : GenericHashTraits<JSC
> namespace JSC {
> 
> class CompactVariableMap : public RefCounted<CompactVariableMap> {
>+    friend class CachedCompactVariableMap;
>+
> public:
>     class Handle {
>+        friend class CachedCompactVariableMapHandle;
>+
>     public:
>         Handle() = default;
> 
>diff --git a/Source/JavaScriptCore/runtime/CachedTypes.cpp b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>index 610a83bf0499319ab66cecef81b0c6d264fcb0f3..cbf9ece439a5ef403f9e313835ac9527f347018c 100644
>--- a/Source/JavaScriptCore/runtime/CachedTypes.cpp
>+++ b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>@@ -876,6 +876,98 @@ private:
>     CachedHashMap<CachedRefPtr<CachedUniquedStringImpl>, VariableEnvironmentEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, VariableEnvironmentEntryHashTraits> m_map;
> };
> 
>+class CachedCompactVariableEnvironment : public CachedObject<CompactVariableEnvironment> {
>+public:
>+    void encode(Encoder& encoder, const CompactVariableEnvironment& env)
>+    {
>+        m_variables.encode(encoder, env.m_variables);
>+        m_variableMetadata.encode(encoder, env.m_variableMetadata);
>+        m_hash = env.m_hash;
>+        m_isEverythingCaptured = env.m_isEverythingCaptured;
>+    }
>+
>+    void decode(Decoder& decoder, CompactVariableEnvironment& env) const
>+    {
>+        m_variables.decode(decoder, env.m_variables);
>+        m_variableMetadata.decode(decoder, env.m_variableMetadata);
>+        env.m_hash = m_hash;
>+        env.m_isEverythingCaptured = m_isEverythingCaptured;
>+    }
>+
>+    CompactVariableEnvironment* decode(Decoder& decoder) const
>+    {
>+        CompactVariableEnvironment* env = new CompactVariableEnvironment;
>+        decode(decoder, *env);
>+        return env;
>+    }
>+
>+private:
>+    CachedVector<CachedRefPtr<CachedUniquedStringImpl>> m_variables;
>+    CachedVector<VariableEnvironmentEntry> m_variableMetadata;
>+    unsigned m_hash;
>+    bool m_isEverythingCaptured;
>+};
>+
>+class CachedCompactVariableMapKey : public CachedObject<CompactVariableMapKey> {
>+public:
>+    void encode(Encoder& encoder, const CompactVariableMapKey& key)
>+    {
>+        m_environment.encode(encoder, key.m_environment);
>+    }
>+
>+    void decode(Decoder& decoder, CompactVariableMapKey& key) const
>+    {
>+        key.m_environment = m_environment.decode(decoder);
>+    }
>+
>+private:
>+    CachedPtr<CachedCompactVariableEnvironment> m_environment;
>+};
>+
>+class CachedCompactVariableMap : public CachedObject<CompactVariableMap> {
>+public:
>+    void encode(Encoder& encoder, const CompactVariableMap& map)
>+    {
>+        m_map.encode(encoder, map.m_map);
>+    }
>+
>+    void decode(Decoder& decoder, CompactVariableMap& map) const
>+    {
>+        m_map.decode(decoder, map.m_map);
>+    }
>+
>+    CompactVariableMap* decode(Decoder& decoder) const
>+    {
>+        CompactVariableMap* map = new CompactVariableMap;
>+        decode(decoder, *map);
>+        return map;
>+    }
>+
>+private:
>+    CachedHashMap<CachedCompactVariableMapKey, unsigned> m_map;
>+};
>+
>+class CachedCompactVariableMapHandle : public CachedObject<CompactVariableMap::Handle> {
>+public:
>+    void encode(Encoder& encoder, const CompactVariableMap::Handle& handle)
>+    {
>+        m_environment.encode(encoder, handle.m_environment);
>+        m_map.encode(encoder, handle.m_map);
>+    }
>+
>+    CompactVariableMap::Handle decode(Decoder& decoder) const
>+    {
>+        CompactVariableMap::Handle handle;
>+        handle.m_environment = m_environment.decode(decoder);
>+        handle.m_map = m_map.decode(decoder);
>+        return handle;
>+    }
>+
>+private:
>+    CachedPtr<CachedCompactVariableEnvironment> m_environment;
>+    CachedRefPtr<CachedCompactVariableMap> m_map;
>+};
>+
> template<typename T, typename Source = SourceType<T>>
> class CachedArray : public VariableLengthObject<Source*> {
> public:
>@@ -1495,7 +1587,7 @@ private:
>     CachedIdentifier m_ecmaName;
>     CachedIdentifier m_inferredName;
> 
>-    CachedVariableEnvironment m_parentScopeTDZVariables;
>+    CachedCompactVariableMapHandle m_parentScopeTDZVariables;
> 
>     CachedWriteBarrier<CachedFunctionCodeBlock, UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForCall;
>     CachedWriteBarrier<CachedFunctionCodeBlock, UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForConstruct;
>@@ -1830,7 +1922,7 @@ ALWAYS_INLINE void CachedFunctionExecutable::encode(Encoder& encoder, const Unli
>     m_ecmaName.encode(encoder, executable.ecmaName());
>     m_inferredName.encode(encoder, executable.inferredName());
> 
>-    m_parentScopeTDZVariables.encode(encoder, executable.parentScopeTDZVariables());
>+    m_parentScopeTDZVariables.encode(encoder, executable.m_parentScopeTDZVariables);
> 
>     m_unlinkedCodeBlockForCall.encode(encoder, executable.m_unlinkedCodeBlockForCall);
>     m_unlinkedCodeBlockForConstruct.encode(encoder, executable.m_unlinkedCodeBlockForConstruct);
>@@ -1838,10 +1930,8 @@ ALWAYS_INLINE void CachedFunctionExecutable::encode(Encoder& encoder, const Unli
> 
> ALWAYS_INLINE UnlinkedFunctionExecutable* CachedFunctionExecutable::decode(Decoder& decoder) const
> {
>-    VariableEnvironment env;
>-    m_parentScopeTDZVariables.decode(decoder, env);
>-
>-    UnlinkedFunctionExecutable* executable = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(decoder.vm().heap)) UnlinkedFunctionExecutable(decoder, env, *this);
>+    CompactVariableMap::Handle env = m_parentScopeTDZVariables.decode(decoder);
>+    UnlinkedFunctionExecutable* executable = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(decoder.vm().heap)) UnlinkedFunctionExecutable(decoder, WTFMove(env), *this);
>     executable->finishCreation(decoder.vm());
> 
>     m_classSource.decode(decoder, executable->m_classSource);
>@@ -1851,7 +1941,7 @@ ALWAYS_INLINE UnlinkedFunctionExecutable* CachedFunctionExecutable::decode(Decod
>     return executable;
> }
> 
>-ALWAYS_INLINE UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(Decoder& decoder, VariableEnvironment& parentScopeTDZVariables, const CachedFunctionExecutable& cachedExecutable)
>+ALWAYS_INLINE UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(Decoder& decoder, CompactVariableMap::Handle parentScopeTDZVariables, const CachedFunctionExecutable& cachedExecutable)
>     : Base(decoder.vm(), decoder.vm().unlinkedFunctionExecutableStructure.get())
>     , m_firstLineOffset(cachedExecutable.firstLineOffset())
>     , m_lineCount(cachedExecutable.lineCount())
>@@ -1881,7 +1971,7 @@ ALWAYS_INLINE UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(Decoder& de
>     , m_ecmaName(cachedExecutable.ecmaName(decoder))
>     , m_inferredName(cachedExecutable.inferredName(decoder))
> 
>-    , m_parentScopeTDZVariables(decoder.vm().m_compactVariableMap->get(parentScopeTDZVariables))
>+    , m_parentScopeTDZVariables(WTFMove(parentScopeTDZVariables))
> {
> }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 194706: 362118 | 362435 | 362485 | 362498 | 362700 | 362702