Changeset fc70ac in git

Timestamp:

Aug 17, 2012, 3:23:05 PM (12 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

d2a236583625dd880d06a25cf10d02aefee3ba89

Parents:

75c6680561e0d1daedacd0b1599765c4061fe56d

git-author:

Alexander Dreyer <alexander.dreyer@itwm.fraunhofer.de>2012-08-17 15:23:05+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-09-05 15:52:15+02:00

Message:

Treating subscriptable objects

fix: 'shared' of subscriptable types
new: reference counting rings here
chg: classes for LeftvDeep/Shallow
chg: Using class for construction
fix: got reference counts right

File:

• Singular/countedref.cc (modified) (19 diffs)

Singular/countedref.cc

@@ -39 +39 @@
 
 };
+idhdl* getmyroot() {
+  static idhdl myroot = NULL;
+  if (myroot == NULL) {
+    myroot = enterid(" _shared_data_ ", 0, PACKAGE_CMD, &IDROOT, TRUE);
+  }
+  return &myroot;
+}
 
 class RefCounter {
@@ -51 +58 @@
 
   /// Copying resets the counter
-  RefCounter(const self& rhs): m_count(0) {}
+  RefCounter(const self&): m_count(0) {}
 
   /// Destructor
@@ -70 +77 @@
 class LeftvShallow {
   typedef LeftvShallow self;
-
-public:
-  LeftvShallow(leftv data): m_data(*data) {  copy(&m_data.e, data->e); }
-  LeftvShallow(const self& rhs): m_data(rhs.m_data) { copy(&m_data.e, rhs.m_data.e); }
-
-  ~LeftvShallow() {  kill(m_data.e); }
+  
+public:
+  LeftvShallow(): m_data(allocate()) { }
+  LeftvShallow(leftv data): 
+    m_data(init(allocate(), data)) { }
+  LeftvShallow(const self& rhs):
+    m_data(init(allocate(), rhs.m_data)) { }
+
+  ~LeftvShallow() {  
+    kill();
+    omFree(m_data);
+  }
+  self& operator=(leftv rhs) {
+    kill();
+    init(m_data, rhs);
+    return *this;
+  }
+
+  self& operator=(const self& rhs) { return (*this) = rhs.m_data; }
 
   BOOLEAN get(leftv result) {
@@ -81 +101 @@
     result->next = NULL;
     result->CleanUp();
-    memcpy(result, &m_data, sizeof(m_data));
-    copy(&result->e, m_data.e);
+    init(result, m_data);
     result->next = next;
     return FALSE;
   }
 
-  /// Read-only access to object
-  const leftv operator->() { return &m_data; }
-
-private:
-  static void copy(Subexpr* result, Subexpr rhs) {
-    for (Subexpr* current = result; rhs != NULL; 
-         current = &(*current)->next, rhs = rhs->next)
-      *current = (Subexpr)memcpy(omAlloc0Bin(sSubexpr_bin), rhs, sizeof(*rhs));
-  }
-
-  static void kill(Subexpr rhs) {
-    for (Subexpr next; rhs!=NULL; rhs = next, next = rhs->next) {
-      next = rhs->next;
-      omFree(rhs);
-    }
-  }
-  sleftv m_data;
-};
+  /// Access to object
+  leftv operator->() { return m_data;  }
+
+protected:
+  static leftv allocate() { return (leftv)omAlloc0(sizeof(sleftv)); }
+  static leftv init(leftv result, leftv data) {
+    memcpy(result, data, sizeof(sleftv));
+    copy(result->e, data->e);
+    result-> next = NULL;
+    return result;
+  }
+  static void copy(Subexpr& current, Subexpr rhs)  {
+    if (rhs == NULL) return;
+    current = (Subexpr)memcpy(omAlloc0Bin(sSubexpr_bin), rhs, sizeof(*rhs));
+    copy(current->next, rhs->next);
+  }
+  void kill() { kill(m_data->e); }
+  static void kill(Subexpr current) {
+    if(current == NULL) return;
+    kill(current->next);
+    omFree(current);
+  }
+protected:
+  leftv m_data;
+};
+
+
+class LeftvDeep:
+  public LeftvShallow {
+  typedef LeftvDeep self;
+  typedef LeftvShallow base;
+
+public:
+  LeftvDeep(): base() {}
+  LeftvDeep(leftv data): base(data) { }
+  LeftvDeep(const self& rhs): base(rhs) { }
+
+  ~LeftvDeep() { m_data->CleanUp(); }
+
+  self& operator=(const self& rhs) { return operator=(rhs.m_data); }
+  self& operator=(leftv rhs) {
+    m_data->CleanUp();
+    m_data->Copy(rhs);
+    return *this;
+  }
+};
+
 
 /** @class CountedRefData
@@ -116 +164 @@
   typedef RefCounter base;
 
-  /// Forbit copy construction and normal assignment
-  CountedRefData(const self&);
-  self& operator=(const self&);
-
 public:
   /// Construct reference for Singular object
-  CountedRefData(leftv data): base(), m_data(data), m_ring(NULL) {
-    if (RingDependend(data->Typ())  && (currRing != NULL) ) {
-      m_ring = currRing;
-      ++m_ring->ref;
-    }
-
-  }
-
-  static idhdl* id_root;
-
-  /// Destructor
+  explicit CountedRefData(leftv data, idhdl* ctx = &IDROOT):
+    base(), m_data(data), m_context(ctx) { context(); }
+
+  /// Construct deep copy
+  CountedRefData(const self& rhs):
+    base(), m_data(rhs.m_data), m_context(rhs.m_context) { }
+  
+  /// Destruct
   ~CountedRefData()  { }
 
-  BOOLEAN get(leftv result) {
-    if (m_ring && (m_ring != currRing)) {
-      Werror("Can only use references from current ring.");
-      return TRUE;
-    }
-    // dereferencing only makes sense, if something else points here, too.
-    assume(count() > 1);
-    return m_data.get(result);
-  }
-
-  LeftvShallow get() {
-    if (m_ring && (m_ring != currRing))
-      Werror("Can only use references from current ring.");
-  
-    return LeftvShallow(m_data);
-  }
+  /// Replace data
+  self& operator=(const self& rhs) {
+    m_data = rhs.m_data;
+    m_context = rhs.m_context;
+    return *this;
+  }
+ 
+  /// Replace with other Singular data
+  void set(leftv rhs, idhdl* ctx = &IDROOT) {
+    m_data = rhs;
+    m_context = ctx;
+    context();
+  }
+
+  /// Write (shallow) copy to given handle
+  BOOLEAN get(leftv res) {
+    reclaim();
+    BOOLEAN b = broken() || m_data.get(res); 
+    release();
+    return b;
+  }
+
+  /// Extract (shallow) copy of stored data
+  LeftvShallow operator*() { return (broken()? LeftvShallow(): m_data); }
 
 private:
+  /// Check whether identifier became invalid
+  /// @note Sergio Leone memorial function
+  BOOLEAN broken() {
+    if( (m_context == getmyroot()) || (m_context == &currRing->idroot))
+      return FALSE;                  // the good, 
+
+    if (m_data->RingDependend())     // the bad,
+      return complain("Referenced identifier not available in current ring");
+
+    return (brokenid(m_context) &&   // and the ugly (case)
+            ((m_context == &basePack->idroot) || brokenid())) &&
+      complain("Referenced identifier not found in current context");
+  }
+
+  /// Determine corresponding context
+  /// @note for ring-dependent object we always store @c currRing's root as marker 
+  void context() { if (m_data->RingDependend()) m_context = &currRing->idroot; }
+
+  /// 
+  BOOLEAN complain(const char* text) {
+    Werror(text);
+    return TRUE;
+  }
+  BOOLEAN brokenid(idhdl* root = &basePack->idroot) {
+    idhdl handle = (idhdl) m_data->data;
+    for(idhdl current = *root; current != NULL; current = IDNEXT(current))
+      if (current == handle) return FALSE;
+    return TRUE;
+  }
+
 
   /// Singular object
-  LeftvShallow m_data;
-
-  /// Store ring for ring-dependent objects
-  ring m_ring;
+  LeftvDeep m_data;
+
+  /// Store namespace for ring-dependent objects
+  idhdl* m_context;
 };
 
@@ -179 +258 @@
 
   /// Check whether argument is already a reference type
-  static BOOLEAN is_ref(int typ) {
+  static BOOLEAN is_ref(leftv arg) {
+    int typ = arg->Typ();
     return ((typ > MAX_TOK) &&
            (getBlackboxStuff(typ)->blackbox_Init == countedref_Init));
   }
 
-  /// Construct reference data object from 
-  static BOOLEAN construct(leftv result, leftv arg) {
-    data_type* data = (result->Typ() == arg->Typ()? 
-                       static_cast<data_type*>(arg->Data()): new data_type(arg));
-    data->reclaim();
+  /// Construct new reference from Singular data  
+  CountedRef(leftv arg):  m_data(new data_type(arg)) { m_data->reclaim(); }
+
+protected:
+  /// Recover previously constructed reference
+  CountedRef(data_type* arg):  m_data(arg) { assume(arg); m_data->reclaim(); }
+
+public:
+  /// Construct copy
+  CountedRef(const self& rhs): m_data(rhs.m_data) { m_data->reclaim(); }
+
+  /// Replace reference
+  self& operator=(const self& rhs) {
+    destruct();
+    m_data = rhs.m_data;
+    m_data->reclaim();
+    return *this;
+  }
+
+  /// Replace data that reference is pointing to
+  self& operator=(leftv rhs) {
+    m_data->set(rhs);
+    return *this;
+  }
+
+  /// Extract (shallow) copy of stored data
+  LeftvShallow operator*() { return m_data->operator*(); }
+
+  /// Construct reference data object from
+  BOOLEAN outcast(leftv result) {
+    m_data->reclaim();
     if (result->rtyp == IDHDL)
-      IDDATA((idhdl)result->data) = (char *)data;
+      IDDATA((idhdl)result->data) = (char *)m_data;
     else
-      result->data = (void *)data;
-    return (data == NULL? TRUE: FALSE);
-  }
+      result->data = (void *)m_data;
+    return FALSE;
+  }
+  data_type* outcast() { 
+    m_data->reclaim();
+    return m_data;
+  }
+  /// Kills a link to the referenced object
+  void destruct() { if(!m_data->release()) delete m_data; }
 
   /// Kills the link to the referenced object
-  static void destruct(data_type* data) {
-    if(data && !data->release()) {
-      delete data;
-    }
-  }
+  ~CountedRef() { destruct(); }
+
+  BOOLEAN dereference(leftv arg) {
+    assume(is_ref(arg));
+    return m_data->get(arg) || ((arg->next != NULL) && resolve(arg->next));
+  }
+
 
   /// Get the actual object
   /// @note It may change leftv. It is common practice, so we are fine with it.
-  static BOOLEAN dereference(leftv arg) {
-    assume((arg != NULL) && is_ref(arg->Typ()));
-    do {
-      assume(arg->Data() != NULL);
-      data_type* data = static_cast<data_type*>(arg->Data());
-      if(data->get(arg)) return TRUE;
-    } while (is_ref(arg->Typ()));
-    return resolve_tail(arg);
+
+  static self cast(void* data) {
+    assume(data != NULL);
+    return self(static_cast<data_type*>(data));
+  }
+
+  static self cast(leftv arg) {
+    assume((arg != NULL) && is_ref(arg));
+    return self::cast(arg->Data());
   }
 
@@ -219 +334 @@
   static BOOLEAN resolve(leftv arg) {
     assume(arg != NULL);
-    while (is_ref(arg->Typ())) { if(dereference(arg)) return TRUE; };
-    return resolve_tail(arg);
-  }
-
-private:
-  /// Dereference (is needed) subsequent objects of sequences
-  static BOOLEAN resolve_tail(leftv arg) {
-    for(leftv next = arg->next; next != NULL; next = next->next)
-      if(resolve(next))
-        return TRUE;
-    return FALSE;
-  }
+    while (is_ref(arg)) { if(CountedRef::cast(arg).dereference(arg)) return TRUE; };
+    return (arg->next != NULL) && resolve(arg->next);
+  }
+
+  //private:
+protected:
+  /// Store pointer to actual data
+  data_type* m_data;
 };
 
@@ -236 +347 @@
 void countedref_Print(blackbox *b, void* ptr)
 {
-  if (ptr != NULL) static_cast<CountedRefData*>(ptr)->get()->Print();
+  if (ptr == NULL)  return;
+  (*CountedRef::cast(ptr))->Print();
 }
 
@@ -242 +354 @@
 char* countedref_String(blackbox *b, void* ptr)
 {
-  if (ptr != NULL) return static_cast<CountedRefData*>(ptr)->get()->String();
+  if (ptr == NULL) return NULL;
+  return (*CountedRef::cast(ptr))->String();
 }
 
@@ -248 +361 @@
 void* countedref_Copy(blackbox*b, void* ptr)
 { 
-  if (ptr) static_cast<CountedRefData*>(ptr)->reclaim();
-  return ptr;
+  if (ptr) return CountedRef::cast(ptr).outcast();
+  return NULL;
 }
 
@@ -256 +369 @@
 {
   // Case: replace assignment behind reference
-  if (result->Data() != NULL) 
-    return CountedRef::dereference(result) || CountedRef::resolve(arg) ||
+  if (result->Data() != NULL) {
+    return CountedRef::cast(result).dereference(result) ||
+      CountedRef::resolve(arg) ||
       iiAssign(result, arg);
+  }
   
   // Case: new reference
   if(arg->rtyp == IDHDL) 
-    return CountedRef::construct(result, arg);
-  
+    return (result->Typ() == arg->Typ()?
+            CountedRef::cast(arg):
+            CountedRef(arg)).outcast(result);
+
   Werror("Can only take reference from identifier");
   return FALSE;
@@ -274 +391 @@
     return blackboxDefaultOp1(op, res, head);
 
-  return CountedRef::dereference(head) || 
+  return CountedRef::cast(head).dereference(head) || 
     iiExprArith1(res, head, (op == DEF_CMD? head->Typ(): op));
 }
@@ -281 +398 @@
 BOOLEAN countedref_Op2(int op, leftv res, leftv head, leftv arg)
 {
-  return CountedRef::dereference(head) || CountedRef::resolve(arg) ||
+
+  return CountedRef::cast(head).dereference(head) || CountedRef::resolve(arg) ||
     iiExprArith2(res, head, op, arg);
 }
@@ -288 +406 @@
 BOOLEAN countedref_Op3(int op, leftv res, leftv head, leftv arg1, leftv arg2)
 {
-  return CountedRef::dereference(head) || 
+  return  CountedRef::cast(head).dereference(head) || 
     CountedRef::resolve(arg1) || CountedRef::resolve(arg2) ||
     iiExprArith3(res, op, head, arg1, arg2);
@@ -297 +415 @@
 BOOLEAN countedref_OpM(int op, leftv res, leftv args)
 {
-  return CountedRef::dereference(args) || iiExprArithM(res, args, op);
+  return CountedRef::cast(args).dereference(args) || iiExprArithM(res, args, op);
 }
 
@@ -303 +421 @@
 void countedref_destroy(blackbox *b, void* ptr)
 {
-  CountedRef::destruct(static_cast<CountedRefData*>(ptr));
-}
+  if (ptr) CountedRef::cast(ptr).destruct();
+}
+
+
+class CountedRefShared:
+  public CountedRef {
+  typedef CountedRefShared self;
+  typedef CountedRef base;
+public:
+  /// Construct new reference from Singular data  
+  CountedRefShared(leftv arg):  base(new data_type(wrap(arg), getmyroot())) { }
+
+private:
+  /// Recover previously constructed shared data
+  CountedRefShared(data_type* arg):  base(arg) { }
+  CountedRefShared(const base& rhs):  base(rhs) { }
+public:
+  /// Construct copy
+  CountedRefShared(const self& rhs): base(rhs) { }
+
+  ~CountedRefShared() {  kill(); }
+
+  self& operator=(const self& rhs) {
+    kill();
+    base::operator=(rhs);
+    return *this;
+  }
+
+  /// Replace data that reference is pointing to
+  self& operator=(leftv rhs) {
+    m_data->set(wrap(rhs), getmyroot());
+    return *this;
+  }
+  void destruct() {
+    kill();
+    base::destruct();
+  }
+
+  static self cast(leftv arg) { return base::cast(arg); }
+  static self cast(void* arg) { return base::cast(arg); }
+private:
+
+  static leftv wrap(leftv arg) {
+      char* name = (char*)omAlloc0(512);
+      static unsigned int counter = 0;
+      idhdl* myroot=getmyroot();
+      sprintf(name, " :%u:%p:_shared_: ", ++counter, arg->Data());
+      assume((*myroot)->get(name, 0) == NULL); 
+      idhdl handle = (*myroot)->set(name, 0, arg->Typ(), FALSE);
+      ++(*myroot)->ref;
+
+      IDDATA(handle) = (char*) arg->CopyD();
+      arg->CleanUp();
+      arg->data = handle;
+      arg->rtyp = IDHDL;
+      arg->name = name;
+
+    return arg;
+  }
+
+ void kill() {
+   if (m_data->count() > 1) return;
+
+   LeftvShallow data = base::operator*();
+   idhdl* myroot = getmyroot();
+   killhdl2((idhdl)(data->data), myroot, currRing);
+   data->data = NULL;
+   data->rtyp = NONE;
+   
+   if(--((*myroot)->ref)) {
+     killhdl2(*myroot, &IDROOT, currRing);
+     (*myroot) = NULL;
+   }
+ }
+};
 
 
@@ -310 +501 @@
 BOOLEAN countedref_AssignShared(leftv result, leftv arg)
 {
-  // Case: replace assignment behind reference
-  if (result->Data() != NULL)
-    return CountedRef::dereference(result) || CountedRef::resolve(arg) ||
-      iiAssign(result, arg);
+  /// Case: replace assignment behind reference
+  if ((result->Data()) != NULL) {
+    if (CountedRefShared::resolve(arg)) return TRUE;
+    CountedRefShared::cast(result) = arg;
+    return FALSE;
+  }
   
-  
-  if(CountedRef::resolve(arg))
-    return TRUE;
-
-  char* name=(char*)omAlloc0(512);
-  static unsigned long counter = 0;
-  do {
-    sprintf(name, "_shareddata_%s_%s_%d\0", result->Name(), arg->Name(), ++counter);
-  }
-  while(ggetid(name));
-  idhdl handle = enterid(name, 0, arg->Typ(), &IDROOT, FALSE);
-  omFree(name);
-  if (handle==NULL) {
-    Werror("Initializing shared failed");
-    return TRUE;
-  }
-  
-  IDDATA(handle) = (char*)arg->CopyD();
-  arg->data = handle;
-  arg->rtyp = IDHDL;
-  
-  return CountedRef::construct(result, arg);
+  /// Case: new shared data
+  if (result->Typ() == arg->Typ()) 
+    return CountedRefShared::cast(arg).outcast(result);
+
+  return CountedRefShared(arg).outcast(result);
 }
 
@@ -342 +518 @@
 void countedref_destroyShared(blackbox *b, void* ptr)
 {
-  CountedRefData* data = static_cast<CountedRefData*>(ptr);
-
-  if(data && !data->release()) {
-    leftv tmp = (leftv) omAlloc0(sizeof(*tmp));
-    data->get(tmp);
-    killid(IDID((idhdl)(tmp->data)), &IDROOT);
-    delete data;
-  }
-
+  if (ptr) CountedRefShared::cast(ptr).destruct();
 }
 
@@ -369 +537 @@
   setBlackboxStuff(bbx, "reference");
 
+  /// The @c shared type is "inherited" from @c reference.
+  /// It just uses another constructor (to make its own copy of the).
   blackbox *bbxshared = 
     (blackbox*)memcpy(omAlloc(sizeof(blackbox)), bbx, sizeof(blackbox));
   bbxshared->blackbox_Assign  = countedref_AssignShared;
-  bbxshared->blackbox_destroy = countedref_destroyShared;
+  bbxshared->blackbox_destroy  = countedref_destroyShared;
+
   setBlackboxStuff(bbxshared, "shared");
 }