Refactor Scope and drop shared_ptr

tadeuzagallo · May 5, 2016 · c7ac75cd3858d859c681b79c57f8d43f02b164b0 · c7ac75c
1 parent e928491
commit c7ac75cd3858d859c681b79c57f8d43f02b164b0
Unified Split

Showing with 177 additions and 55 deletions.

+4 −1 compiler/closure.h

+1 −1 compiler/gc.cc

+4 −5 compiler/gc.h

+3 −3 compiler/generator.h

+65 −0 compiler/old_scope.h

+97 −40 compiler/scope.h

+1 −2 compiler/vm.cc

+2 −3 compiler/vm.h
diff --git a/compiler/closure.h b/compiler/closure.h
@@ -9,7 +9,10 @@ namespace ceos {

  struct Closure {
    Function *fn;
-    std::shared_ptr<Scope<Value>> scope;
+    Scope *scope;
+
+    Closure(Scope *s) : scope(s->inc()) {}
+    ~Closure() { scope->dec(); }
  };

 }
diff --git a/compiler/gc.cc b/compiler/gc.cc
@@ -3,6 +3,6 @@
 namespace ceos {

  std::set<uint64_t> GC::roots;
-  std::set<ScopePtr> GC::scopes;
+  std::set<Scope *> GC::scopes;

 }
diff --git a/compiler/gc.h b/compiler/gc.h
@@ -10,7 +10,6 @@

 namespace ceos {

-  typedef std::shared_ptr<Scope<Value>> ScopePtr;
  typedef std::vector<std::pair<size_t, void *>> Heap;

  class GC {
@@ -52,7 +51,7 @@ namespace ceos {
        }
      }

-      static void markScope(ScopePtr &scope, Heap &heap) {
+      static void markScope(Scope *scope, Heap &heap) {
        if (scopes.find(scope) != scopes.end()) {
          return;
        }
@@ -63,8 +62,8 @@ namespace ceos {
            markValue(value, heap);
        });

-        if (scope->parent()) {
-          markScope(scope->parent(), heap);
+        if (scope->parent) {
+          markScope(scope->parent, heap);
        }
      }

@@ -97,7 +96,7 @@ namespace ceos {
    private:

      static std::set<uint64_t> roots;
-      static std::set<ScopePtr> scopes;
+      static std::set<Scope *> scopes;
  };
 }

diff --git a/compiler/generator.h b/compiler/generator.h
@@ -4,7 +4,7 @@

 #include "ast.h"
 #include "opcodes.h"
-#include "scope.h"
+#include "old_scope.h"

 #ifndef CEOS_GENERATOR_H
 #define CEOS_GENERATOR_H
@@ -14,7 +14,7 @@ namespace ceos {
  class Generator {
    public:
      Generator(std::shared_ptr<AST::Program> ast) : m_ast(ast) {
-        m_scope = std::make_shared<Scope<std::shared_ptr<AST>>>();
+        m_scope = std::make_shared<OldScope<std::shared_ptr<AST>>>();
      }

      std::stringstream &generate(void);
@@ -42,7 +42,7 @@ namespace ceos {
      static void printOpcode(std::stringstream &, Opcode::Type);

      std::shared_ptr<AST::Program> m_ast;
-      std::shared_ptr<Scope<std::shared_ptr<AST>>> m_scope;
+      std::shared_ptr<OldScope<std::shared_ptr<AST>>> m_scope;
      std::stringstream m_output;
  };

diff --git a/compiler/old_scope.h b/compiler/old_scope.h
@@ -0,0 +1,65 @@
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <unordered_map>
+
+#ifndef CEOS_OLD_SCOPE_H
+#define CEOS_OLD_SCOPE_H
+
+namespace ceos {
+
+  template<typename T>
+  class OldScope : public std::enable_shared_from_this<OldScope<T>> {
+    typedef std::shared_ptr<OldScope<T>> OldScopePtr;
+
+    public:
+      OldScope() {}
+
+      inline OldScopePtr create() {
+        auto s = std::make_shared<OldScope<T>>();
+        s->m_parent = this->shared_from_this();
+        return s;
+      }
+
+      inline OldScopePtr create(OldScopePtr parent) {
+        auto s = std::make_shared<OldScope<T>>();
+        s->m_parent = parent;
+        s->m_previous = this->shared_from_this();
+        return s;
+      }
+
+      inline OldScopePtr restore() {
+        return m_previous ?: m_parent ?: this->shared_from_this();
+      }
+
+      inline T get(std::string var) {
+        auto it = m_table.find(var);
+        if (it != m_table.end()) return it->second;
+        else if (m_parent) return m_parent->get(var);
+        else return T();
+      }
+
+      inline void set(std::string key, T value) {
+        m_table[key] = value;
+      }
+
+      inline void visit(std::function<void(T)> visitor) {
+        OldScopePtr ptr = this->shared_from_this();
+        for (auto it : m_table) {
+          visitor(it.second);
+        }
+      }
+
+      inline OldScopePtr &parent() {
+        return m_parent;
+      }
+
+    private:
+      OldScopePtr m_parent;
+      OldScopePtr m_previous;
+      std::unordered_map<std::string, T> m_table;
+  };
+
+}
+
+#endif
diff --git a/compiler/scope.h b/compiler/scope.h
@@ -1,63 +1,120 @@
+#include "value.h"
+
 #include <functional>
-#include <iostream>
-#include <memory>
-#include <unordered_map>

 #ifndef CEOS_SCOPE_H
 #define CEOS_SCOPE_H

 namespace ceos {
+  class ScopeTest;

-  template<typename T>
-  class Scope : public std::enable_shared_from_this<Scope<T>> {
-    typedef std::shared_ptr<Scope<T>> ScopePtr;
+  namespace {
+    static inline unsigned hash(const char *str) {
+      unsigned limit = 16;
+      unsigned long hash = 5381;
+      int c;
+      while ((c = *str++) && --limit) {
+        hash = ((hash << 5) + hash) + c;
+      }
+      return hash;
+    }
+  }

-    public:
-      Scope() {}
+  struct Scope {

-      inline ScopePtr create() {
-        auto s = std::make_shared<Scope<T>>();
-        s->m_parent = this->shared_from_this();
-        return s;
-      }
+    friend class ScopeTest;

-      inline ScopePtr create(ScopePtr parent) {
-        auto s = std::make_shared<Scope<T>>();
-        s->m_parent = parent;
-        s->m_previous = this->shared_from_this();
-        return s;
-      }
+    Scope() : Scope(32) {}

-      inline ScopePtr restore() {
-        return m_previous ?: m_parent ?: this->shared_from_this();
-      }
+    Scope(unsigned size) : cacheSize(size), cacheHash(size - 1) {
+      refCount = 1;
+      table = new Entry[cacheSize]();
+      parent = NULL;
+      previous = NULL;
+    }
+
+    ~Scope() {
+      if (parent) parent->dec();
+      if (previous) previous->dec();
+    }

-      inline T get(std::string var) {
-        auto it = m_table.find(var);
-        if (it != m_table.end()) return it->second;
-        else if (m_parent) return m_parent->get(var);
-        else return T();
+    inline Scope *inc() {
+      refCount++;
+      return this;
+    }
+    inline void dec() {
+      if (!--refCount) {
+        delete this;
      }
+    }
+
+    inline Scope *create(Scope *p) {
+      auto s = new Scope();
+      s->parent = p->inc();
+      s->previous = this->inc();
+      return s;
+    }

-      inline void set(std::string key, T value) {
-        m_table[key] = value;
+    inline Scope *create() {
+      auto s = new Scope();
+      s->parent = this->inc();
+      s->previous = NULL;
+      return s;
+    }
+
+    inline Scope *restore() {
+      auto ret = previous ?: parent ?: this;
+      if (ret != this) this->dec();
+      return ret;
+    }
+
+    Value get(char *key) {
+      unsigned index = hash(key) % cacheSize;
+      auto begin = index;
+      while (table[index].key != NULL) {
+        if (table[index].key == key || strcmp(table[index].key, key) == 0) {
+          return table[index].value;
+        } 
+        if ((index = (index + 1) & cacheHash) == begin) break;
      }
+      if (parent) return parent->get(key);
+      return Value();
+    }

-      inline void visit(std::function<void(T)> visitor) {
-        ScopePtr ptr = this->shared_from_this();
-        for (auto it : m_table) {
-          visitor(it.second);
+    void set(char *key, Value value) {
+      unsigned index = hash(key) % cacheSize;
+      auto begin = index;
+      do {
+        if (table[index].key == NULL || table[index].key == key) {
+          table[index].key = key;
+          table[index].value = value;
+          return;
        }
-      }
+      } while((index = (index + 1) & cacheHash) != begin);
+      throw;
+    }

-      inline ScopePtr &parent() {
-        return m_parent;
+    inline void visit(std::function<void(Value)> visitor) {
+      for (unsigned i = 0; i < cacheSize; i++) {
+        if (table[i].key != NULL) {
+          visitor(table[i].value);
+        }
      }
+    }
+
+    struct Entry {
+      char *key;
+      Value value;
+    };
+
+    Scope *parent;

-    private:
-      ScopePtr m_parent;
-      ScopePtr m_previous;
-      std::unordered_map<std::string, T> m_table;
+  private:
+    Entry *table;
+    Scope *previous;
+    unsigned refCount;
+    unsigned cacheSize;
+    unsigned cacheHash;
  };

 }
diff --git a/compiler/vm.cc b/compiler/vm.cc
@@ -35,10 +35,9 @@ void restoreScope(VM *vm) {

 extern "C" uint64_t createClosure(VM *vm, unsigned fnID);
 uint64_t createClosure(VM *vm, unsigned fnID) {
-  auto closure = new Closure();
+  auto closure = new Closure(vm->m_scope);
  vm->trackAllocation(closure, sizeof(Closure));
  closure->fn = &vm->m_userFunctions[fnID];
-  closure->scope = vm->m_scope;
  return Value(closure).encode();
 }

diff --git a/compiler/vm.h b/compiler/vm.h
@@ -26,8 +26,7 @@ namespace ceos {
        m_bytecode = (uint8_t *)malloc(length);
        memcpy(m_bytecode, bc.data(), length);

-        m_scope = std::make_shared<Scope<Value>>();
-
+        m_scope = new Scope(1024);
        registerBuiltins(*this);
      }

@@ -77,7 +76,7 @@ namespace ceos {
      size_t heapLimit;
      std::vector<std::pair<size_t, void *>> blocks;

-      std::shared_ptr<Scope<Value>> m_scope;
+      Scope *m_scope;
      std::vector<char *> m_stringTable;
      std::vector<Function> m_userFunctions;