Re: multithreading.

"Chris Thomasson" <cristom@comcast.net> wrote in message
news:Ya6dnaEscqVIBW3anZ2dnUVZ_o3inZ2d@comcast.com...


[...]

Actually, the only way I can really think of competing with a GC lang wrt
the C++ code provided in the link above is to simply create a slab
per-concrete-object (e.g., Var, Int, Plus and Times). That will drastically
cut down on calls to new/delete. I will have code for you in a day or two.
Probably two because I am getting ready for a move from the Bay Area to the
South Tahoe Basin. Anyway, here is simple sketch for the Int class in the
example you linked to:

origin:
_______________________________________________________________________
class Int : public Base {
  const int n;
public:
  Int(int m) : n(m) {}
  ~Int() {}
  const Base *clone() { return new Int(n); }
  const Base *d(const string &v) const { return new Int(0); }
  ostream &print(ostream &o) const { return o << n; }
};
_______________________________________________________________________

<sketch w/ typos>
_______________________________________________________________________
#define INT_DEPTH() 10000

struct Int : public Base {
  int n;
  Int* m_next;

  Int(int m) : n(m) {}
  ~Int() {}

  void Ctor(int m) {
    n = m;
  }

  static Int* g_head;
  static int g_depth;

  static Int* CachePop(int const m) {
    Int* _this = g_head;
    if (! _this) {
      _this = new Int(m);
    } else {
      g_head = _this->m_next;
      --g_depth;
      _this->Ctor(m);
    }
    return _this;
  }

  static void CachePush(Int* const _this) {
    if (g_depth < INT_DEPTH()) {
      _this->m_next = g_head;
      g_head = _this;
      ++g_depth;
    } else {
      delete _this;
    }
  }

  const Base *clone() { return CachePop(n); }
  const Base *d(const std::string &v) const { return CachePop(0); }
  std::ostream &print(std::ostream &o) const { return o << n; }
};

Int* Int::g_head = NULL;
int Int::g_depth = 0;

_______________________________________________________________________

Alls I have to do is replace 'Var, Int, Plus and Times' with the VERY simple
cache outlined above and I know it will cut the number of new/delete calls
by a large margin. That about all I can do in C++. Is that fair?

;^D