I appreciate your reply, Joe.
But I do not think this is off-topic, though. If we are going to discuss
the details of your project, Ptolomy, right, then it would have been
off-topic, I think. But I'm talking about GCC, therefore I believe this
is the right place to post these ideas.
What I am trying to say is that there is an additional realization of
dynamic binding, which is called matrix linking. There are other's
realization of that idea, like Darwin project for instance, but all of
these realization has one serious stumbling block which makes their use
almost impossible and therefore these realizations have only academic
interest, but practically they are useless. And this stumbling block is
that you need to 'suspend' the application when you do dynamic binding,
moreover you should have all the threads finished inside that code which
is going to to re-bind. This is a huge problem. New approach, which I
have called Matrix Linking does resolve this problem, it means it
becomes possible to make binding right on the fly, without any threads
suspending, directly in multi threaded application. I believe this is
quite interesting idea in order to be shared with GCC community. I do
not think this is a professional reply, saying 'Nothing new here: add a
level of indirection...'. I believe the idea has a future, just imagine
what opportunities it gives to developer, manager, analyst and clients.
I would like the community would have considered the idea. I am ready to
answer all the questions you might have.
Yours sincerely
George.
http://docs.georgeshagov.com/twiki/tiki-index.php?page=Matrix+Linking
Joe Buck ?????:
I wrote:
Nothing new here: add a level of indirection (or use C++ virtual
functions), and dynamically load code. In the Ptolemy project
(http://ptolemy.eecs.berkeley.edu/) we were doing that in 1990:
we could define new classes and load them into a running application,
without restarting.
On Sun, Nov 18, 2007 at 09:33:16AM +0300, [EMAIL PROTECTED] wrote:
Is this a thread safe operation for your Ptolomy project?
Should you suspend the application in order to load 'new classes' there?
We're getting off-topic for the list, so I'm answering off-list.
The operation could be made thread-safe with appropriate locking (the
15-year-old code did not have this locking, but it's trivial to add). It
used the object factory pattern, in which each class has a clone method
and there's support for adding a new, dynamically linked class to the
master list. If other threads are running and these threads are not in
the act of creating new objects from the object factory, they can run in
parallel.
