[muscle] Re: node path info

Hey Gabe...

I sure do... I've attached the 3.00 change log.  I don't forsee any other 
major changes before release, but I won't guarantee it. 

If you want I can send you the full current source code also, just let me 
know.

Should we attempt to get the Ruby bindings in as part of the 3.00 release?   
(I'm planning to release v3.00 probably in the next week or two)

Jeremy

On Tuesday 21 June 2005 13:53, Gabriel Bauman wrote:
> On 6/18/05, Jeremy Friesner <jaf@xxxxxxxxxxxx> wrote:
> > Thanks, I'm glad you like it.  Note that v3.00 will be out pretty soon,
> > and it will change a few things, so watch out for that.
>
> Jeremy, do you have any info you can release on the changes so I can
> be sure that the Ruby bindings work with your upcoming release?
>
> Gabe

This file contains the version history/change log for this software.

key:  - new feature
      * bug fixed
      o other

v3.00 Released ???
  NOTE:  THIS RELEASE BREAKS SOURCE CODE COMPATIBILITY WITH PREVIOUS
  RELEASES OF THE MUSCLE API.  IF YOU HAVE CODE THAT WAS WRITTEN FOR
  PREVIOUS VERSIONS OF  MUSCLE, YOU WILL NEED TO MODIFY IT SOMEWHAT 
  IN ORDER FOR IT TO COMPILE AND RUN PROPERLY.  SEE THE TWO ITEMS 
  MARKED WITH (o) BELOW FOR DETAILS.
  - Updated the included zlib distribution to v1.2.2.
  - Added StoreTraceValue(), TCHECKPOINT(), SetTraceValuesLocation(),
    and associated functions to MuscleSupport.h.  These functions can 
    be useful in tracking down where code is executing at when a 
    debugger isn't available.
  - Added a maxDepth argument to the LogStackTrace() call.
  - Added a PrintStackTrace() function to syslog/SysLog.{cpp,h}.
    This is similar to LogStackTrace(), but the stack trace
    goes directly to stdout instead of going to the log facility.
  - Added a "win32client" test/example app to the tests folder.
    This app tests/demos the Win32MessageTransceiverThread class.
  - Added a SetSignalHandlingEnabled() method to the ReflectServer
    class, to allow servers to exit cleanly when an interrupt
    signal is received.
  - muscled now accepts an optional "catchsignals" argument that
    enables handling of interrupt signals (Control-C) to initiate
    a controlled shutdown.
  - muscleMax() and muscleMin() can now take up to five arguments,
    for convenience.
  - If you define the compiler constant MUSCLE_ENABLE_MEMORY_PARANOIA
    to an integer value (as well as MUSCLE_ENABLE_MEMORY_TRACKING), 
    then the muscle memory allocator/deallocator code will add that many
    guard values to the front and end of all dynamically allocated 
    buffers in order to detect bad memory writes.  The guard values will 
    be checked whenever the buffers are freed or resized, to make sure
    they haven't been overwritten, and it will also fill all allocated
    and freed buffers with special garbage bytes (0x55 and 0x66), 
    so that it will be more obvious when freed or uninitialized
    memory is read.  This slows down execution a bit and uses up 
    extra memory, so it should only be enabled while debugging.
  - Added a MemoryParanoiaCheckBuffer() function to 
    GlobalMemoryAllocator.{cpp,h}.  Call this function to manually
    validate that an allocated memory buffer hasn't been corrupted.
  - All AbstractObjectRecycler objects (i.e. all ObjectPools)
    now register themselves in a global linked list, so that
    they can be iterated over.
  - Added the function GlobalFlushAllCachedObjects() to the
    AbstractObjectRecycler class.
  - Added a FlushCachedObjects() virtual method  to the
    AbstractObjectRecycler class.  This method is implemented
    in the ObjectPool subclasses to call Drain().
  - The CompleteSetupSystem destructor now calls
    AbstractObjectRecycler::GlobalFlushAllCachedObjects(), so
    that all the ObjectPools get flushed before any static objects
    start getting destroyed.  This helps avoid dangling pointer
    problems caused by the undefined ordering of static object
    destructor calls.
  - Added GetCount() and SetCount() methods to the AtomicCounter 
    class, since it's occasionally necessary (albeit discouraged) 
    to get or set the counter's value explicitly.
  - Added IsRefPrivate() and EnsureRefIsPrivate() methods to
    the Ref class to help facilitate Copy-on-Write semantics.
  o Changed all Ref arguments to be passed by const reference 
    instead of by value.  Note that this change will break most 
    current Muscle-using source code -- your source code will 
    need to be changed to match, in order for the virtual methods 
    to be overridden properly.  To update your code, you should 
    change all function arguments of type BlahRef to (const BlahRef &).
  o Moved the AbstractObjectRecycler pointer out of the Ref class
    and into the RefCountable class, and changed it into an
    AbstractObjectManager pointer.  Removed the recycler
    argument from all Ref class methods.  This makes the
    Ref class a bit simpler and more efficient, but it also
    breaks existing source code.  To update your code, you
    should change all instances of BlahRef(blah, NULL) to 
    BlahRef(blah), and all instances of BlahRef(blah, NULL, false)
    to BlahRef(blah, false).
  o Replaced StorageReflectSession::DrainPools() with
    AbstractObjectRecycler::GlobalFlushAllCachedObjects(),
    which does the same thing but more thoroughly, since
    it flushes all ObjectPools and not just a few of them.
  * Added a newnothrow_array #define to MuscleSupport.h and
    changed all the muscle code to use it instead of
    newnothrow when allocating arrays.  This macro works
    the same as new (nothrow) for arrays, except it works
    around a bug in gcc 3.x that could causes crashes on 
    memory failure.
  * ChildProcessDataIO now forces the removal if the SIGHUP
    signal handler in the child process, so that any 
    grandchild processes will be cleaned up when the child
    process is killed.
  * Under Win32, if there were no sockets to select() on, select()
    would error out and the server loop would return.  Fixed.
  * Added paranoia debug code to the MUSCLE_POWERPC_TIMEBASE_HZ
    implementation of GetRunTime64(), so that if the time base
    registers malfunction the app will crash instead of going
    into an infinite loop (which is harder to debug).

Other related posts: