Revert "Reland "Create a basic IRNode pooling system.""

This reverts commit 5b09e6a.

Reason for revert: breaking g3

Original change's description:
> Reland "Create a basic IRNode pooling system."
>
> This is a reland of e16eca9
>
> Original change's description:
> > Create a basic IRNode pooling system.
> >
> > Allocations are redirected by overriding `operator new` and `operator
> > delete` on the IRNode class. This allows us to use our existing
> > `unique_ptr` and `make_unique` calls as-is. The Pool class is simple;
> > it holds a fixed number of nodes and recycles them as they are returned.
> >
> > A fixed pool size of 2000 nodes was chosen. That is large enough to hold
> > the contents of `sksl_large` during compilation, but it can be
> > overflowed by very large shaders, or if multiple programs are converted
> > at the same time. Exhausting the pool is not a problem; if this happens,
> > additional nodes will be allocated via the system allocator as usual.
> > More elaborate schemes are possible but might not add a lot of value.
> >
> > Thread safety is accomplished by placing the pool in a `thread_local`
> > static during a Program's creation and destruction; the pool is freed
> > when the program is destroyed. One important consequence of this
> > strategy is that a program must free every node that it allocated during
> > its creation, or else the node will be leaked. In debug, leaking a node
> > will be detected and causes a DEBUGFAIL. In release, the pool will be
> > freed despite having a live node in it, and if that node is later freed,
> > that pointer will be passed to the system `free` (which is likely to
> > cause a crash).
> >
> > In this CL, iOS does not support pooling, since support for
> > `thread_local` was only added on iOS 9. This is fixed in the followup
> > CL, http://review.skia.org/328837, which uses pthread keys on iOS.
> >
> > Nanobench shows ~15% improvement:
> >   (last week) http://screen/5CNBhTaZApcDA8h
> >       (today) http://screen/8ti5Rymvf6LUs8i
> >
> > Change-Id: I559de73606ee1be54e5eae7f82129dc928a63e3c
> > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326876
> > Commit-Queue: John Stiles <johnstiles@google.com>
> > Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
> > Auto-Submit: John Stiles <johnstiles@google.com>
>
> Change-Id: I114971e8e7ac0fabaf26216ae8813eeeaad0d4a2
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/329086
> Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
> Commit-Queue: John Stiles <johnstiles@google.com>

TBR=brianosman@google.com,ethannicholas@google.com,johnstiles@google.com

Change-Id: Ie77a23366f2ba52fcbb0a751d11ca2792790a30c
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/329165
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

Author: egdaniel

gn/sksl.gni

@@ -38,8 +38,6 @@ skia_sksl_sources = [
   "$_src/sksl/SkSLMemoryLayout.h",
   "$_src/sksl/SkSLParser.cpp",
   "$_src/sksl/SkSLParser.h",
-  "$_src/sksl/SkSLPool.cpp",
-  "$_src/sksl/SkSLPool.h",
   "$_src/sksl/SkSLPosition.h",
   "$_src/sksl/SkSLRehydrator.cpp",
   "$_src/sksl/SkSLRehydrator.h",

src/sksl/SkSLCompiler.cpp

@@ -1552,33 +1552,24 @@ std::unique_ptr<Program> Compiler::convertProgram(
 
     const ParsedModule& baseModule = this->moduleForProgramKind(kind);
 
-    // Enable node pooling while converting and optimizing the program for a performance boost.
-    // The Program will take ownership of the pool.
-    std::unique_ptr<Pool> pool = Pool::CreatePoolOnThread(2000);
     IRGenerator::IRBundle ir =
             fIRGenerator->convertProgram(kind, &settings, baseModule, /*isBuiltinCode=*/false,
                                          textPtr->c_str(), textPtr->size(), externalValues);
-    auto program = std::make_unique<Program>(kind,
-                                             std::move(textPtr),
-                                             settings,
-                                             fContext,
-                                             std::move(ir.fElements),
-                                             std::move(ir.fModifiers),
-                                             std::move(ir.fSymbolTable),
-                                             std::move(pool),
-                                             ir.fInputs);
-    bool success = false;
+    auto result = std::make_unique<Program>(kind,
+                                            std::move(textPtr),
+                                            settings,
+                                            fContext,
+                                            std::move(ir.fElements),
+                                            std::move(ir.fModifiers),
+                                            std::move(ir.fSymbolTable),
+                                            ir.fInputs);
     if (fErrorCount) {
-        // Do not return programs that failed to compile.
-    } else if (settings.fOptimize && !this->optimize(*program)) {
-        // Do not return programs that failed to optimize.
-    } else {
-        // We have a successful program!
-        success = true;
+        return nullptr;
     }
-
-    program->fPool->detachFromThread();
-    return success ? std::move(program) : nullptr;
+    if (settings.fOptimize && !this->optimize(*result)) {
+        return nullptr;
+    }
+    return result;
 }
 
 bool Compiler::optimize(Program& program) {

src/sksl/SkSLPool.cpp

@@ -12,7 +12,6 @@
 #include "src/sksl/SkSLASTNode.h"
 #include "src/sksl/SkSLLexer.h"
 #include "src/sksl/SkSLModifiersPool.h"
-#include "src/sksl/SkSLPool.h"
 #include "src/sksl/SkSLString.h"
 
 #include <algorithm>
@@ -65,20 +64,6 @@ class IRNode {
     // purposes
     int fOffset;
 
-    // Override operator new and delete to allow us to control allocation behavior.
-    static void* operator new(const size_t size) {
-        // TODO: once all IRNodes hold their data in fData, everything should come out of the pool,
-        // and this check should become an assertion.
-        if (size == sizeof(IRNode)) {
-            return Pool::AllocIRNode();
-        }
-        return ::operator new(size);
-    }
-
-    static void operator delete(void* ptr) {
-        Pool::FreeIRNode(ptr);
-    }
-
 protected:
     struct BlockData {
         std::shared_ptr<SymbolTable> fSymbolTable;

src/sksl/SkSLPool.h

@@ -32,7 +32,6 @@
 namespace SkSL {
 
 class Context;
-class Pool;
 
 /**
  * Represents a fully-digested program, ready for code generation.
@@ -166,30 +165,16 @@ struct Program {
             std::vector<std::unique_ptr<ProgramElement>> elements,
             std::unique_ptr<ModifiersPool> modifiers,
             std::shared_ptr<SymbolTable> symbols,
-            std::unique_ptr<Pool> pool,
             Inputs inputs)
     : fKind(kind)
     , fSource(std::move(source))
     , fSettings(settings)
     , fContext(context)
     , fSymbols(symbols)
-    , fPool(std::move(pool))
     , fInputs(inputs)
     , fElements(std::move(elements))
     , fModifiers(std::move(modifiers)) {}
 
-    ~Program() {
-        // Some or all of the program elements are in the pool. To free them safely, we must attach
-        // the pool before destroying any program elements. (Otherwise, we may accidentally call
-        // delete on a pooled node.)
-        fPool->attachToThread();
-        fElements.clear();
-        fContext.reset();
-        fSymbols.reset();
-        fModifiers.reset();
-        fPool->detachFromThread();
-    }
-
     const std::vector<std::unique_ptr<ProgramElement>>& elements() const { return fElements; }
 
     Kind fKind;
@@ -199,7 +184,6 @@ struct Program {
     // it's important to keep fElements defined after (and thus destroyed before) fSymbols,
     // because destroying elements can modify reference counts in symbols
     std::shared_ptr<SymbolTable> fSymbols;
-    std::unique_ptr<Pool> fPool;
     Inputs fInputs;
 
 private: