fix: resolved issue with GC-managed object creation in a fully multit…

…hreaded environment
ArgonLang · Jun 11, 2024 · c0973ab · c0973ab
1 parent ec79d20
commit c0973ab
Show file tree

Hide file tree

Showing 14 changed files with 37 additions and 23 deletions.
diff --git a/argon/lang/parser2/node/node.h b/argon/lang/parser2/node/node.h
@@ -269,10 +269,7 @@ const argon::vm::datatype::TypeInfo *argon::lang::parser2::ExtName = &alias##Ast
  T *NewNode(const TypeInfo *t_info, bool gc, NodeType node_type) {
  T *node;
 
- if (!gc)
- node = MakeObject<T>(t_info);
- else
- node = MakeGCObject<T>(t_info, false);
+ node = !gc ? MakeObject<T>(t_info) : MakeGCObject<T>(t_info);
 
  if (node == nullptr)
  return nullptr;
@@ -283,6 +280,9 @@ const argon::vm::datatype::TypeInfo *argon::lang::parser2::ExtName = &alias##Ast
 
  *((NodeType *) n_obj) = node_type;
 
+ if (gc)
+ argon::vm::memory::Track((ArObject *) node);
+
  return node;
  }
 

diff --git a/argon/vm/datatype/arobject.h b/argon/vm/datatype/arobject.h
@@ -111,13 +111,13 @@ namespace argon::vm::datatype {
  }
 
  template<typename T>
- T *MakeGCObject(const TypeInfo *type, bool track) {
- return (T *) memory::GCNew(type, track);
+ T *MakeGCObject(const TypeInfo *type) {
+ return (T *) memory::GCNew(type, false);
  }
 
  template<typename T>
- T *MakeGCObject(TypeInfo *type, bool track) {
- auto *ret = (T *) memory::GCNew(type, track);
+ T *MakeGCObject(TypeInfo *type) {
+ auto *ret = (T *) memory::GCNew(type, false);
  if (ret != nullptr)
  IncRef(type);
 

diff --git a/argon/vm/datatype/chan.cpp b/argon/vm/datatype/chan.cpp
@@ -270,7 +270,7 @@ bool argon::vm::datatype::ChanWrite(Chan *chan, ArObject *value) {
 }
 
 Chan *argon::vm::datatype::ChanNew(ArObject *defval, unsigned int backlog) {
- auto *chan = MakeGCObject<Chan>(type_chan_, false);
+ auto *chan = MakeGCObject<Chan>(type_chan_);
 
  if (chan != nullptr) {
  if ((chan->queue = (ArObject **) argon::vm::memory::Alloc(backlog * sizeof(void *))) == nullptr) {

diff --git a/argon/vm/datatype/dict.cpp b/argon/vm/datatype/dict.cpp
@@ -277,7 +277,7 @@ ArObject *dict_compare(Dict *self, ArObject *other, CompareMode mode) {
 }
 
 ArObject *dict_iter(Dict *self, bool reverse) {
- auto *li = MakeGCObject<DictIterator>(type_dict_iterator_, true);
+ auto *li = MakeGCObject<DictIterator>(type_dict_iterator_);
 
  if (li != nullptr) {
  std::shared_lock _(self->rwlock);
@@ -291,6 +291,8 @@ ArObject *dict_iter(Dict *self, bool reverse) {
  li->cursor->ref++;
 
  li->reverse = reverse;
+
+ argon::vm::memory::Track((ArObject*)li);
  }
 
  return (ArObject *) li;
@@ -631,7 +633,7 @@ Dict *argon::vm::datatype::DictMerge(Dict *dict1, Dict *dict2, bool clone) {
 }
 
 Dict *argon::vm::datatype::DictNew() {
- auto *dict = MakeGCObject<Dict>(type_dict_, false);
+ auto *dict = MakeGCObject<Dict>(type_dict_);
 
  if (dict != nullptr) {
  if (!dict->hmap.Initialize()) {
@@ -719,7 +721,7 @@ Dict *argon::vm::datatype::DictNew(ArObject *object) {
 }
 
 Dict *argon::vm::datatype::DictNew(unsigned int size) {
- auto *dict = MakeGCObject<Dict>(type_dict_, false);
+ auto *dict = MakeGCObject<Dict>(type_dict_);
 
  if (dict != nullptr) {
  if (!dict->hmap.Initialize(size)) {

diff --git a/argon/vm/datatype/function.cpp b/argon/vm/datatype/function.cpp
@@ -186,7 +186,7 @@ bool FunctionCheckParams(const PCheck *pcheck, ArObject **args, ArSize count) {
 }
 
 Function *FunctionClone(const Function *func) {
- auto *fn = MakeGCObject<Function>(type_function_, false);
+ auto *fn = MakeGCObject<Function>(type_function_);
 
  if (fn != nullptr) {
  if (func->IsNative())
@@ -213,7 +213,7 @@ Function *FunctionClone(const Function *func) {
 }
 
 Function *FunctionNew(String *name, String *doc, unsigned short arity, FunctionFlags flags) {
- auto *fn = MakeGCObject<Function>(type_function_, false);
+ auto *fn = MakeGCObject<Function>(type_function_);
 
  if (fn != nullptr) {
  fn->name = IncRef(name);

diff --git a/argon/vm/datatype/future.cpp b/argon/vm/datatype/future.cpp
@@ -80,7 +80,7 @@ bool argon::vm::datatype::FutureAWait(Future *future) {
 }
 
 Future *argon::vm::datatype::FutureNew() {
- auto *future = MakeGCObject<Future>(type_future_, false);
+ auto *future = MakeGCObject<Future>(type_future_);
 
  if (future != nullptr) {
  future->value = nullptr;

diff --git a/argon/vm/datatype/iterator.h b/argon/vm/datatype/iterator.h
@@ -60,6 +60,8 @@ namespace argon::vm::datatype {
  }
 
  inline void IteratorTrace(IteratorGeneric *self, Void_UnaryOp trace){
+ std::unique_lock _(self->lock);
+
  trace(self->iterable);
  }
 

diff --git a/argon/vm/datatype/list.cpp b/argon/vm/datatype/list.cpp
@@ -499,14 +499,16 @@ ArObject *list_compare(List *self, ArObject *other, CompareMode mode) {
 }
 
 ArObject *list_iter(List *self, bool reverse) {
- auto *li = MakeGCObject<ListIterator>(type_list_iterator_, true);
+ auto *li = MakeGCObject<ListIterator>(type_list_iterator_);
 
  if (li != nullptr) {
  new(&li->lock)std::mutex;
 
  li->iterable = IncRef(self);
  li->index = 0;
  li->reverse = reverse;
+
+ argon::vm::memory::Track((ArObject *) li);
  }
 
  return (ArObject *) li;
@@ -817,7 +819,7 @@ List *ListFromIterable(List **dest, ArObject *iterable) {
 }
 
 List *argon::vm::datatype::ListNew(ArSize capacity) {
- auto *list = MakeGCObject<List>(type_list_, false);
+ auto *list = MakeGCObject<List>(type_list_);
 
  if (list != nullptr) {
  list->objects = nullptr;

diff --git a/argon/vm/datatype/module.cpp b/argon/vm/datatype/module.cpp
@@ -347,7 +347,7 @@ Module *argon::vm::datatype::ModuleNew(const ModuleInit *init) {
 }
 
 Module *argon::vm::datatype::ModuleNew(String *name, String *doc) {
- auto *mod = MakeGCObject<Module>(type_module_, true);
+ auto *mod = MakeGCObject<Module>(type_module_);
 
  if (mod != nullptr) {
  mod->fini = nullptr;
@@ -368,6 +368,8 @@ Module *argon::vm::datatype::ModuleNew(String *name, String *doc) {
  Release(mod);
  return nullptr;
  }
+
+ memory::Track((ArObject *) mod);
  }
 
  return mod;

diff --git a/argon/vm/datatype/namespace.cpp b/argon/vm/datatype/namespace.cpp
@@ -317,7 +317,7 @@ List *argon::vm::datatype::NamespaceKeysToList(Namespace *ns, AttributeFlag matc
 }
 
 Namespace *argon::vm::datatype::NamespaceNew() {
- auto *ns = MakeGCObject<Namespace>(&NamespaceType, true);
+ auto *ns = MakeGCObject<Namespace>(&NamespaceType);
 
  if (ns != nullptr) {
  if (!ns->ns.Initialize()) {
@@ -327,6 +327,8 @@ Namespace *argon::vm::datatype::NamespaceNew() {
  }
 
  new(&ns->rwlock)sync::RecursiveSharedMutex();
+
+ memory::Track((ArObject*)ns);
  }
 
  return ns;

diff --git a/argon/vm/datatype/option.cpp b/argon/vm/datatype/option.cpp
@@ -135,7 +135,7 @@ TypeInfo OptionType = {
 const TypeInfo *argon::vm::datatype::type_option_ = &OptionType;
 
 Option *argon::vm::datatype::OptionNew(ArObject *value) {
- auto *opt = MakeGCObject<Option>(&OptionType, false);
+ auto *opt = MakeGCObject<Option>(&OptionType);
 
  if (opt != nullptr)
  opt->some = IncRef(value);

diff --git a/argon/vm/datatype/result.cpp b/argon/vm/datatype/result.cpp
@@ -140,7 +140,7 @@ TypeInfo ResultType = {
 const TypeInfo *argon::vm::datatype::type_result_ = &ResultType;
 
 Result *argon::vm::datatype::ResultNew(ArObject *value, bool success) {
- auto *result = MakeGCObject<Result>(&ResultType, false);
+ auto *result = MakeGCObject<Result>(&ResultType);
 
  if (result != nullptr) {
  result->value = IncRef(value == nullptr ? (ArObject *) Nil : value);

diff --git a/argon/vm/datatype/struct.cpp b/argon/vm/datatype/struct.cpp
@@ -164,12 +164,14 @@ Struct *argon::vm::datatype::StructNew(TypeInfo *type, ArObject **argv, unsigned
  }
  }
 
- if ((ret = MakeGCObject<Struct>(type, true)) == nullptr) {
+ if ((ret = MakeGCObject<Struct>(type)) == nullptr) {
  Release(ns);
  return nullptr;
  }
 
  ret->ns = ns;
 
+ memory::Track((ArObject *) ret);
+
  return ret;
 }
diff --git a/argon/vm/importer/import.cpp b/argon/vm/importer/import.cpp
@@ -491,7 +491,7 @@ Import *argon::vm::importer::ImportNew(Context *context) {
  goto ERROR; \
  } while(0)
 
- auto *imp = MakeGCObject<Import>(type_import_, true);
+ auto *imp = MakeGCObject<Import>(type_import_);
 
  if (imp == nullptr)
  return nullptr;
@@ -528,6 +528,8 @@ Import *argon::vm::importer::ImportNew(Context *context) {
 
  new(&imp->lock)std::mutex();
 
+ memory::Track((ArObject*)imp);
+
  return imp;
 
  ERROR: