ChangeLogTag:Thu Feb 10 13:49:34 2000 Nanbor Wang <nanbor@cs.wustl.edu>

30 files changed, 2599 insertions, 13 deletions

diff --git a/ChangeLog b/ChangeLog
index ed93ab22f2c..21bf0149ec6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,55 @@
+Thu Feb 10 13:49:34 2000  Nanbor Wang  <nanbor@cs.wustl.edu>
+
+	* ace/MEM_SAP.h:
+	* ace/MEM_SAP.i:
+	* ace/MEM_SAP.cpp: Implemented the adaptation layer for managing
+	  shared memory in shared memory transport.
+
+	* ace/MEM_Addr.h:
+	* ace/MEM_Addr.i:
+	* ace/MEM_Addr.cpp: Implemented the "endpoint" addressing
+	  mechanism for shared memory transport.  The ACE_MEM_Addr make
+	  sure the "endpoint" is not on an interface that is accessable
+	  outside of the running host.  It also serves as endpoint
+	  identification and provides the <same_host> checking method.
+
+	* ace/MEM_IO.h:
+	* ace/MEM_IO.i:
+	* ace/MEM_IO.cpp: Implemented the IO routines for shared memory
+	  transport.  Currently, these IO routines treat shared memory
+	  transport as a streaming devide and copy the data into its own
+	  buffer before sending the data over.  We'll add method for
+	  acquiring and sending the internal buffer later.
+
+	* ace/MEM_Acceptor.h:
+	* ace/MEM_Acceptor.i:
+	* ace/MEM_Acceptor.cpp:
+	* ace/MEM_Connector.h:
+	* ace/MEM_Connector.i:
+	* ace/MEM_Connector.cpp:
+	* ace/MEM_Stream.h:
+	* ace/MEM_Stream.i:
+	* ace/MEM_Stream.cpp: These classes emulate SOCK_* classes but use
+	  shared memory as their transport mechanism.
+
+	* ace/Malloc_T.cpp: Fixed a mis-matched ACE_TRACE message.
+
+	* ace/OS.h: Added definitions of ACE_MEM_ACCEPTOR,
+	  ACE_MEM_CONNECTOR and, ACE_MEM_STREAM.
+
+	* ace/Makefile: Aded MEM_* files and updated dependencies.
+
+	* tests/Malloc_Test.cpp: Removed explicit template instantiations
+	  for ACE_Malloc[_T] as they are taken care of in MEM_SAP.cpp
+	  now.
+
+	* examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp:
+	* examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw: Added a simple example
+	  on how to use the shared-memory transport.
+
 Thu Feb 10 10:18:00 2000  Ossama Othman  <ossama@uci.edu>
 
 	* THANKS:
diff --git a/ChangeLogs/ChangeLog-02a b/ChangeLogs/ChangeLog-02a
index ed93ab22f2c..21bf0149ec6 100644
--- a/ChangeLogs/ChangeLog-02a
+++ b/ChangeLogs/ChangeLog-02a
@@ -1,3 +1,55 @@
+Thu Feb 10 13:49:34 2000  Nanbor Wang  <nanbor@cs.wustl.edu>
+
+	* ace/MEM_SAP.h:
+	* ace/MEM_SAP.i:
+	* ace/MEM_SAP.cpp: Implemented the adaptation layer for managing
+	  shared memory in shared memory transport.
+
+	* ace/MEM_Addr.h:
+	* ace/MEM_Addr.i:
+	* ace/MEM_Addr.cpp: Implemented the "endpoint" addressing
+	  mechanism for shared memory transport.  The ACE_MEM_Addr make
+	  sure the "endpoint" is not on an interface that is accessable
+	  outside of the running host.  It also serves as endpoint
+	  identification and provides the <same_host> checking method.
+
+	* ace/MEM_IO.h:
+	* ace/MEM_IO.i:
+	* ace/MEM_IO.cpp: Implemented the IO routines for shared memory
+	  transport.  Currently, these IO routines treat shared memory
+	  transport as a streaming devide and copy the data into its own
+	  buffer before sending the data over.  We'll add method for
+	  acquiring and sending the internal buffer later.
+
+	* ace/MEM_Acceptor.h:
+	* ace/MEM_Acceptor.i:
+	* ace/MEM_Acceptor.cpp:
+	* ace/MEM_Connector.h:
+	* ace/MEM_Connector.i:
+	* ace/MEM_Connector.cpp:
+	* ace/MEM_Stream.h:
+	* ace/MEM_Stream.i:
+	* ace/MEM_Stream.cpp: These classes emulate SOCK_* classes but use
+	  shared memory as their transport mechanism.
+
+	* ace/Malloc_T.cpp: Fixed a mis-matched ACE_TRACE message.
+
+	* ace/OS.h: Added definitions of ACE_MEM_ACCEPTOR,
+	  ACE_MEM_CONNECTOR and, ACE_MEM_STREAM.
+
+	* ace/Makefile: Aded MEM_* files and updated dependencies.
+
+	* tests/Malloc_Test.cpp: Removed explicit template instantiations
+	  for ACE_Malloc[_T] as they are taken care of in MEM_SAP.cpp
+	  now.
+
+	* examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp:
+	* examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw: Added a simple example
+	  on how to use the shared-memory transport.
+
 Thu Feb 10 10:18:00 2000  Ossama Othman  <ossama@uci.edu>
 
 	* THANKS:
diff --git a/ChangeLogs/ChangeLog-03a b/ChangeLogs/ChangeLog-03a
index ed93ab22f2c..21bf0149ec6 100644
--- a/ChangeLogs/ChangeLog-03a
+++ b/ChangeLogs/ChangeLog-03a
@@ -1,3 +1,55 @@
+Thu Feb 10 13:49:34 2000  Nanbor Wang  <nanbor@cs.wustl.edu>
+
+	* ace/MEM_SAP.h:
+	* ace/MEM_SAP.i:
+	* ace/MEM_SAP.cpp: Implemented the adaptation layer for managing
+	  shared memory in shared memory transport.
+
+	* ace/MEM_Addr.h:
+	* ace/MEM_Addr.i:
+	* ace/MEM_Addr.cpp: Implemented the "endpoint" addressing
+	  mechanism for shared memory transport.  The ACE_MEM_Addr make
+	  sure the "endpoint" is not on an interface that is accessable
+	  outside of the running host.  It also serves as endpoint
+	  identification and provides the <same_host> checking method.
+
+	* ace/MEM_IO.h:
+	* ace/MEM_IO.i:
+	* ace/MEM_IO.cpp: Implemented the IO routines for shared memory
+	  transport.  Currently, these IO routines treat shared memory
+	  transport as a streaming devide and copy the data into its own
+	  buffer before sending the data over.  We'll add method for
+	  acquiring and sending the internal buffer later.
+
+	* ace/MEM_Acceptor.h:
+	* ace/MEM_Acceptor.i:
+	* ace/MEM_Acceptor.cpp:
+	* ace/MEM_Connector.h:
+	* ace/MEM_Connector.i:
+	* ace/MEM_Connector.cpp:
+	* ace/MEM_Stream.h:
+	* ace/MEM_Stream.i:
+	* ace/MEM_Stream.cpp: These classes emulate SOCK_* classes but use
+	  shared memory as their transport mechanism.
+
+	* ace/Malloc_T.cpp: Fixed a mis-matched ACE_TRACE message.
+
+	* ace/OS.h: Added definitions of ACE_MEM_ACCEPTOR,
+	  ACE_MEM_CONNECTOR and, ACE_MEM_STREAM.
+
+	* ace/Makefile: Aded MEM_* files and updated dependencies.
+
+	* tests/Malloc_Test.cpp: Removed explicit template instantiations
+	  for ACE_Malloc[_T] as they are taken care of in MEM_SAP.cpp
+	  now.
+
+	* examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp:
+	* examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp:
+	* examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw: Added a simple example
+	  on how to use the shared-memory transport.
+
 Thu Feb 10 10:18:00 2000  Ossama Othman  <ossama@uci.edu>
 
 	* THANKS:
diff --git a/ace/MEM_Acceptor.cpp b/ace/MEM_Acceptor.cpp
new file mode 100644
index 00000000000..d0071f5b4bc
--- /dev/null
+++ b/ace/MEM_Acceptor.cpp
@@ -0,0 +1,196 @@
+// MEM_Acceptor.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Acceptor.h"
+
+#if !defined (__ACE_INLINE__)
+#include "ace/MEM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_RCSID(ace, MEM_Acceptor, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Acceptor)
+
+void
+ACE_MEM_Acceptor::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::dump");
+}
+
+// Do nothing routine for constructor.
+
+ACE_MEM_Acceptor::ACE_MEM_Acceptor (void)
+  : mmap_prefix_ (0)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::ACE_MEM_Acceptor");
+}
+
+ACE_MEM_Acceptor::~ACE_MEM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::~ACE_MEM_Acceptor");
+  delete[] this->mmap_prefix_;
+}
+
+// General purpose routine for performing server ACE_SOCK creation.
+
+ACE_MEM_Acceptor::ACE_MEM_Acceptor (const ACE_MEM_Addr &remote_sap,
+                                    int reuse_addr,
+                                    int backlog,
+                                    int protocol)
+  : mmap_prefix_ (0)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::ACE_MEM_Acceptor");
+  if (this->open (remote_sap,
+                  reuse_addr,
+                  backlog,
+                  protocol) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "ACE_MEM_Acceptor::ACE_MEM_Acceptor"));
+}
+
+int
+ACE_MEM_Acceptor::open (const ACE_MEM_Addr &remote_sap,
+                        int reuse_addr,
+                        int back_log,
+                        int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::open");
+  return this->ACE_SOCK_Acceptor::open (remote_sap.get_local_addr (),
+                                        reuse_addr,
+                                        PF_INET,
+                                        back_log,
+                                        protocol);
+}
+
+// General purpose routine for accepting new connections.
+
+int
+ACE_MEM_Acceptor::accept (ACE_MEM_Stream &new_stream,
+                          ACE_MEM_Addr *remote_sap,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::accept");
+
+  int *len_ptr = 0;
+  sockaddr *addr = 0;
+
+  int in_blocking_mode = 0;
+  if (this->shared_accept_start (timeout,
+                                 restart,
+                                 in_blocking_mode) == -1)
+    return -1;
+  else
+    {
+      do
+        new_stream.set_handle (ACE_OS::accept (this->get_handle (),
+                                               addr,
+                                               len_ptr));
+      while (new_stream.get_handle () == ACE_INVALID_HANDLE
+             && restart != 0
+             && errno == EINTR
+             && timeout == 0);
+
+      if (remote_sap != 0)
+        {
+          ACE_INET_Addr temp ((sockaddr_in *) addr, *len_ptr);
+          remote_sap->set_port_number(temp.get_port_number ());
+        }
+    }
+
+  if (this->shared_accept_finish (new_stream,
+                                  in_blocking_mode,
+                                  reset_new_handle) == -1)
+    return -1;
+
+  ASYS_TCHAR buf [MAXPATHLEN];
+  ACE_INET_Addr local_addr;
+  if (new_stream.get_local_addr (local_addr) == -1)
+    return -1;
+
+  if (this->mmap_prefix_ != 0)
+    {
+      ACE_OS::sprintf (buf,
+                       ASYS_TEXT ("%s_%d_"),
+                       this->mmap_prefix_,
+                       local_addr.get_port_number ());
+    }
+  else
+    {
+      const ASYS_TCHAR* temp_dir =
+        ACE_OS::getenv (ASYS_TEXT (ACE_DEFAULT_TEMP_DIR_ENV));
+
+      if (temp_dir == 0)
+        temp_dir = ASYS_TEXT ("/tmp");
+
+      ACE_OS::sprintf (buf,
+                       ASYS_TEXT ("%s%cMEM_Acceptor_%d_"),
+                       temp_dir,
+                       ACE_DIRECTORY_SEPARATOR_CHAR,
+                       local_addr.get_port_number ());
+    }
+  ASYS_TCHAR unique [MAXPATHLEN];
+  ACE_OS::unique_name (&new_stream, unique, MAXPATHLEN);
+  ACE_OS::strcat (buf, unique);
+
+  // Make sure we have a fresh start.
+  ACE_OS::unlink (buf);
+
+  // Now set up the shared memory malloc pool.
+  if (new_stream.create_shm_malloc (buf, &this->malloc_options_) == -1)
+    return -1;
+
+  // @@ Need to handle timeout here.
+  ACE_UINT16 buf_len = ACE_OS::strlen (buf) + 1;
+  ACE_HANDLE new_handle = new_stream.get_handle ();
+
+  // No need to worry about byte-order because both parties should always
+  // be on the same machine.
+  if (ACE::send (new_handle, &buf_len, sizeof (ACE_UINT16)) == -1)
+    return -1;
+
+  // Now send the pathname of the mmap file.
+  if (ACE::send (new_handle, buf, buf_len) == -1)
+    return -1;
+  return 0;
+}
+
+int
+ACE_MEM_Acceptor::shared_accept_finish (ACE_MEM_Stream new_stream,
+                                        int in_blocking_mode,
+                                        int reset_new_handle) const
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::shared_accept_finish ()");
+
+  ACE_HANDLE new_handle = new_stream.get_handle ();
+
+  // Check to see if we were originally in blocking mode, and if so,
+  // set the <new_stream>'s handle and <this> handle to be in blocking
+  // mode.
+  if (in_blocking_mode)
+    {
+      // Save/restore errno.
+      ACE_Errno_Guard error (errno);
+
+      // Only disable ACE_NONBLOCK if we weren't in non-blocking mode
+      // originally.
+      ACE::clr_flags (this->get_handle (),
+                      ACE_NONBLOCK);
+      ACE::clr_flags (new_handle,
+                      ACE_NONBLOCK);
+    }
+
+#if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
+  if (reset_new_handle)
+    // Reset the event association inherited by the new handle.
+    ::WSAEventSelect ((SOCKET) new_handle, 0, 0);
+#else
+  ACE_UNUSED_ARG (reset_new_handle);
+#endif /* ACE_WIN32 */
+  if (new_handle == ACE_INVALID_HANDLE)
+    return -1;
+
+  return 0;
+}
diff --git a/ace/MEM_Acceptor.h b/ace/MEM_Acceptor.h
new file mode 100644
index 00000000000..4d8e07cc5cb
--- /dev/null
+++ b/ace/MEM_Acceptor.h
@@ -0,0 +1,148 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Aceeptor.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_ACCEPTOR_H
+#define ACE_MEM_ACCEPTOR_H
+
+#include "ace/SOCK_Acceptor.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/MEM_Stream.h"
+#include "ace/MEM_Addr.h"
+
+// Forward decl.
+class ACE_Reactor;
+
+class ACE_Export ACE_MEM_Acceptor : public ACE_SOCK_Acceptor
+{
+  // = TITLE
+  //     Defines the format and interface for the acceptor side of the
+  //     local mmap stream.  I should probably designed the class
+  //     to prevent user passing a non-localhost endpoint as the acceptor
+  //     listen point because it doesn't make any sense at all to make
+  //     the listening endpoint visible (or connectable) anywhere outside
+  //     of this machine.  However, I decided to leave the type of endpoint
+  //     as <ACE_Addr> so we can later changed to use UNIX sockets with
+  //     mmap stream if so desired.  (Currently, using UNIX socket with
+  //     this class will not work.)
+public:
+  // = Initialization methods.
+  ACE_MEM_Acceptor (void);
+  // Default constructor.
+
+  ~ACE_MEM_Acceptor (void);
+  // destructor.
+
+  ACE_MEM_Acceptor (const ACE_MEM_Addr &remote_sap,
+                    int reuse_addr = 0,
+                    int backlog = ACE_DEFAULT_BACKLOG,
+                    int protocol = 0);
+  // Initiate a passive mode socket.
+
+  int open (const ACE_MEM_Addr &local_sap,
+            int reuse_addr = 0,
+            int backlog = ACE_DEFAULT_BACKLOG,
+            int protocol = 0);
+  // Initialize a passive-mode BSD-style acceptor socket (no QoS).
+  // <local_sap> is the address that we're going to listen for
+  // connections on.  If <reuse_addr> is 1 then we'll use the
+  // <SO_REUSEADDR> to reuse this address.  Returns 0 on success and
+  // -1 on failure.
+
+  int accept (ACE_MEM_Stream &new_ipc_sap,
+              ACE_MEM_Addr *remote_addr = 0,
+              ACE_Time_Value *timeout = 0,
+              int restart = 1,
+              int reset_new_handle = 0);
+  // Accept a new data transfer connection.
+
+  int shared_accept_finish (ACE_MEM_Stream new_stream,
+                            int in_blocking_mode,
+                            int reset_new_handle) const;
+  // Perform operations that must occur after <ACE_OS::accept> is
+  // called.
+
+  const ASYS_TCHAR *mmap_prefix (void) const;
+  void mmap_prefix (ASYS_TCHAR *prefix);
+  // Accessor/mutator of mmap filename prefix.  By default, the
+  // <mmap_prefix_> is not set and the mmap filename is
+  // ${(TMP|TEMP)}//ACE_MEM_Acceptor_(port-number)_(&stream),
+  // otherwise, it is <mmap_prefix_>_(port-number)_(&stream),
+  // <mmap_prefix_> should include _absolute_ path so the connector
+  // within the same host can located the mmap file.
+  // Example:  /tmp/mmapfile
+
+  int get_local_addr (ACE_MEM_Addr &) const;
+  // Return the local endpoint address in the referenced <ACE_Addr>.
+  // Returns 0 if successful, else -1.
+
+  ACE_MEM_SAP::MALLOC_OPTIONS& malloc_options (void);
+  // Accessor to the mmap options.
+
+  // = Meta-type info
+  typedef ACE_MEM_Addr PEER_ADDR;
+  typedef ACE_MEM_Stream PEER_STREAM;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+protected:
+  // = The following methods should not be accessable externally.
+  int open (const ACE_Addr &local_sap,
+            int reuse_addr = 0,
+            int protocol_family = PF_INET,
+            int backlog = ACE_DEFAULT_BACKLOG,
+            int protocol = 0);
+
+  int open (const ACE_Addr &local_sap,
+            ACE_Protocol_Info *protocolinfo,
+            ACE_SOCK_GROUP g,
+            u_long flags,
+            int reuse_addr,
+            int protocol_family,
+            int backlog = ACE_DEFAULT_BACKLOG,
+            int protocol = 0);
+
+  int accept (ACE_SOCK_Stream &new_stream,
+              ACE_Addr *remote_addr = 0,
+              ACE_Time_Value *timeout = 0,
+              int restart = 1,
+              int reset_new_handle = 0) const;
+
+  int accept (ACE_SOCK_Stream &new_stream,
+              ACE_Accept_QoS_Params qos_params,
+              ACE_Addr *remote_addr = 0,
+              ACE_Time_Value *timeout = 0,
+              int restart = 1,
+              int reset_new_handle = 0) const;
+
+private:
+  ASYS_TCHAR *mmap_prefix_;
+
+  ACE_MEM_SAP::MALLOC_OPTIONS malloc_options_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/MEM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_MEM_ACCEPTOR_H */
diff --git a/ace/MEM_Acceptor.i b/ace/MEM_Acceptor.i
new file mode 100644
index 00000000000..bdc1c1af7ef
--- /dev/null
+++ b/ace/MEM_Acceptor.i
@@ -0,0 +1,70 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Acceptor.i
+
+ASYS_INLINE int
+ACE_MEM_Acceptor::open (const ACE_Addr &local_sap,
+                        ACE_Protocol_Info *protocolinfo,
+                        ACE_SOCK_GROUP g,
+                        u_long flags,
+                        int reuse_addr,
+                        int protocol_family,
+                        int backlog,
+                        int protocol)
+{
+  return this->ACE_SOCK_Acceptor::open
+    (local_sap, protocolinfo, g, flags, reuse_addr, protocol_family,
+     backlog, protocol);
+}
+
+ASYS_INLINE int
+ACE_MEM_Acceptor::accept (ACE_SOCK_Stream &new_stream,
+                          ACE_Addr *remote_addr,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle) const
+{
+  return this->ACE_SOCK_Acceptor::accept
+    (new_stream, remote_addr, timeout, restart, reset_new_handle);
+}
+
+ASYS_INLINE int
+ACE_MEM_Acceptor::accept (ACE_SOCK_Stream &new_stream,
+                          ACE_Accept_QoS_Params qos_params,
+                          ACE_Addr *remote_addr,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle) const
+{
+  return this->ACE_SOCK_Acceptor::accept
+    (new_stream, qos_params, remote_addr, timeout, restart, reset_new_handle);
+}
+
+ASYS_INLINE int
+ACE_MEM_Acceptor::get_local_addr (ACE_MEM_Addr &sap) const
+{
+  ACE_INET_Addr temp;
+
+  this->ACE_SOCK_Acceptor::get_local_addr (temp);
+  sap.set_port_number (temp.get_port_number ());
+  return 0;
+}
+
+ASYS_INLINE const ASYS_TCHAR *
+ACE_MEM_Acceptor::mmap_prefix (void) const
+{
+  return this->mmap_prefix_;
+}
+
+ASYS_INLINE void
+ACE_MEM_Acceptor::mmap_prefix (ASYS_TCHAR *prefix)
+{
+  this->mmap_prefix_ = ACE::strnew (prefix);
+}
+
+ASYS_INLINE ACE_MEM_SAP::MALLOC_OPTIONS &
+ACE_MEM_Acceptor::malloc_options (void)
+{
+  return this->malloc_options_;
+}
diff --git a/ace/MEM_Addr.cpp b/ace/MEM_Addr.cpp
new file mode 100644
index 00000000000..2962dfad268
--- /dev/null
+++ b/ace/MEM_Addr.cpp
@@ -0,0 +1,143 @@
+// $Id$
+
+// Defines the Internet domain address family address format.
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Addr.h"
+
+#if !defined (__ACE_INLINE__)
+#include "ace/MEM_Addr.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_RCSID(ace, MEM_Addr, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Addr)
+
+// Transform the current address into string format.
+
+ACE_MEM_Addr::ACE_MEM_Addr (void)
+  : ACE_Addr (AF_INET, sizeof (ACE_MEM_Addr))
+{
+  // ACE_TRACE ("ACE_MEM_Addr::ACE_MEM_Addr");
+  this->initialize_local (0);
+}
+
+ACE_MEM_Addr::ACE_MEM_Addr (const ACE_MEM_Addr &sa)
+  : ACE_Addr (AF_INET, sizeof (ACE_MEM_Addr))
+{
+  ACE_TRACE ("ACE_MEM_Addr::ACE_MEM_Addr");
+  this->external_.set (sa.external_);
+  this->internal_.set (sa.internal_);
+}
+
+ACE_MEM_Addr::ACE_MEM_Addr (const ASYS_TCHAR port_number[])
+  : ACE_Addr (AF_INET, sizeof (ACE_MEM_Addr))
+{
+  ACE_TRACE ("ACE_MEM_Addr::ACE_MEM_Addr");
+  u_short pn
+    = ACE_static_cast (u_short,
+                       ACE_OS::strtoul (port_number,
+                                        NULL,
+                                        10));
+  this->initialize_local (pn);
+}
+
+ACE_MEM_Addr::ACE_MEM_Addr (u_short port_number)
+  : ACE_Addr (AF_INET, sizeof (ACE_MEM_Addr))
+{
+  ACE_TRACE ("ACE_MEM_Addr::ACE_MEM_Addr");
+  this->initialize_local (port_number);
+}
+
+int
+ACE_MEM_Addr::initialize_local (u_short port_number)
+{
+  ASYS_TCHAR name[MAXHOSTNAMELEN + 1];
+  if (ACE_OS::hostname (name, MAXHOSTNAMELEN+1) == -1)
+    return -1;
+
+  this->external_.set (port_number, name);
+  this->internal_.set (port_number, ASYS_TEXT ("localhost"));
+  return 0;
+}
+
+int
+ACE_MEM_Addr::same_host (const ACE_INET_Addr &sap)
+{
+  ACE_TRACE ("ACE_MEM_Addr::same_host");
+
+  return this->external_.get_ip_address () ==
+    sap.get_ip_address ();
+}
+
+int
+ACE_MEM_Addr::addr_to_string (ASYS_TCHAR s[],
+                              size_t size,
+                              int ipaddr_format) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::addr_to_string");
+
+  return this->external_.addr_to_string (s, size, ipaddr_format);
+}
+
+// Transform the string into the current addressing format.
+
+int
+ACE_MEM_Addr::string_to_addr (const ASYS_TCHAR s[])
+{
+  ACE_TRACE ("ACE_MEM_Addr::string_to_addr");
+
+  u_short pn
+    = ACE_static_cast (u_short,
+                       ACE_OS::strtoul (s,
+                                        NULL,
+                                        10));
+  return this->set (pn);
+}
+
+// Return the address.
+
+void *
+ACE_MEM_Addr::get_addr (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_addr");
+  return this->external_.get_addr ();
+}
+
+// Set a pointer to the address.
+void
+ACE_MEM_Addr::set_addr (void *addr, int len)
+{
+  ACE_TRACE ("ACE_MEM_Addr::set_addr");
+
+  this->external_.set_addr (addr, len);
+  this->internal_.set_port_number (this->external_.get_port_number ());
+}
+
+int
+ACE_MEM_Addr::get_host_name (ASYS_TCHAR hostname[],
+                              size_t len) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_host_name");
+  return this->external_.get_host_name (hostname, len);
+}
+
+// Return the character representation of the hostname.
+
+const ASYS_TCHAR *
+ACE_MEM_Addr::get_host_name (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_host_name");
+  return this->external_.get_host_name ();
+}
+
+void
+ACE_MEM_Addr::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  this->external_.dump ();
+  this->internal_.dump ();
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
diff --git a/ace/MEM_Addr.h b/ace/MEM_Addr.h
new file mode 100644
index 00000000000..8d683f7d4b6
--- /dev/null
+++ b/ace/MEM_Addr.h
@@ -0,0 +1,143 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Addr.h
+//
+// = AUTHOR
+//    Nanbor Wang <nanbor@cs.wustl.edu>
+//
+// ============================================================================
+
+#ifndef ACE_MEM_ADDR_H
+#define ACE_MEM_ADDR_H
+
+#include "ace/ACE.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/INET_Addr.h"
+
+class ACE_Export ACE_MEM_Addr : public ACE_Addr
+{
+  // = TITLE
+  //    Defines a C++ wrapper facade for the shared memory transport
+  //    address family format.
+public:
+  // = Initialization methods.
+  ACE_MEM_Addr (void);
+  // Default constructor.
+
+  ACE_MEM_Addr (const ACE_MEM_Addr &);
+  // Copy constructor.
+
+  ACE_MEM_Addr (u_short port_number);
+  // Creates an <ACE_INET_Addr> from a <port_number> and the remote
+  // <host_name>.
+
+  ACE_MEM_Addr (const ASYS_TCHAR port_name[]);
+  // Creates an <ACE_INET_Addr> from a <port_name>.
+
+  ~ACE_MEM_Addr (void);
+  // Default dtor.
+
+  // = Direct initialization methods.
+
+  int initialize_local (u_short port);
+  // default initialization routine.
+
+  int same_host (const ACE_INET_Addr& sap);
+  // Check if <sap> designate an enpoint withing the same host.
+
+  // These methods are useful after the object has been constructed.
+
+  int set (u_short port_number,
+           int encode = 1);
+  // Initializes an <ACE_INET_Addr> from a <port_number> and the
+  // remote <host_name>.  If <encode> is enabled then <port_number> is
+  // converted into network byte order, otherwise it is assumed to be
+  // in network byte order already and are passed straight through.
+
+  int set (const ASYS_TCHAR port_name[]);
+  // Uses <getservbyname> to initialize an <ACE_INET_Addr> from a
+  // <port_name>, the remote <host_name>, and the <protocol>.
+
+  virtual void *get_addr (void) const;
+  // Return a pointer to the underlying network address.
+
+  virtual void set_addr (void *, int len);
+  // Set a pointer to the address.
+
+  virtual int addr_to_string (ASYS_TCHAR buffer[],
+                              size_t size,
+                              int ipaddr_format = 1) const;
+  // Transform the external <ACE_INET_Addr> address into string
+  // format.
+
+  virtual int string_to_addr (const ASYS_TCHAR address[]);
+  // Initializes the external <ACE_INET_Addr> from the <address>.
+
+  void set_port_number (u_short,
+                        int encode = 1);
+  // Sets the port number.
+
+  u_short get_port_number (void) const;
+  // Return the port number, converting it into host byte order.
+
+  int get_host_name (ASYS_TCHAR hostname[],
+                     size_t hostnamelen) const;
+  // Return the character representation of the hostname.
+
+  const ASYS_TCHAR *get_host_name (void) const;
+  // Return the character representation of the hostname (this version
+  // is non-reentrant since it returns a pointer to a static data
+  // area).
+
+  const char *get_host_addr (void) const;
+  // Return the "dotted decimal" external address.
+
+  ACE_UINT32 get_ip_address (void) const;
+  // Return the 4-byte external IP address, converting it into host byte
+  // order.
+
+  const ACE_INET_Addr &get_remote_addr (void) const;
+  const ACE_INET_Addr &get_local_addr (void) const;
+
+  int operator == (const ACE_MEM_Addr &SAP) const;
+  int operator == (const ACE_INET_Addr &SAP) const;
+  // Compare two addresses for equality.  The addresses are considered
+  // equal if they contain the same IP address and port number.
+
+  int operator != (const ACE_MEM_Addr &SAP) const;
+  int operator != (const ACE_INET_Addr &SAP) const;
+  // Compare two addresses for inequality.
+
+  virtual u_long hash (void) const;
+  // Computes and returns hash value.
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+private:
+  ACE_INET_Addr external_;
+  // External INET addr used for identifying host.
+
+  ACE_INET_Addr internal_;
+  // Internal INET addr for accepting/connecting.
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/MEM_Addr.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_MEM_ADDR_H */
diff --git a/ace/MEM_Addr.i b/ace/MEM_Addr.i
new file mode 100644
index 00000000000..2dd130fca7b
--- /dev/null
+++ b/ace/MEM_Addr.i
@@ -0,0 +1,117 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Addr.i
+
+// Default dtor.
+ACE_INLINE
+ACE_MEM_Addr::~ACE_MEM_Addr (void)
+{
+}
+
+// Set the port number.
+
+ACE_INLINE void
+ACE_MEM_Addr::set_port_number (u_short port_number,
+                                int encode)
+{
+  ACE_TRACE ("ACE_MEM_Addr::set_port_number");
+
+  this->external_.set_port_number (port_number, encode);
+  this->internal_.set_port_number (port_number, encode);
+}
+
+ACE_INLINE int
+ACE_MEM_Addr::set (u_short port_number, int encode)
+{
+  ACE_TRACE ("ACE_INET_Addr::set");
+  this->set_port_number (port_number, encode);
+  return 0;
+}
+
+ACE_INLINE int
+ACE_MEM_Addr::set (const ASYS_TCHAR port_number[])
+{
+  ACE_TRACE ("ACE_MEM_Addr::set");
+  return this->string_to_addr (port_number);
+}
+
+// Return the port number.
+
+ACE_INLINE u_short
+ACE_MEM_Addr::get_port_number (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_port_number");
+  return this->internal_.get_port_number ();
+}
+
+// Return the dotted Internet address.
+
+ACE_INLINE const char *
+ACE_MEM_Addr::get_host_addr (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_host_addr");
+  return this->internal_.get_host_addr ();
+}
+
+// Return the 4-byte IP address, converting it into host byte order.
+
+ACE_INLINE ACE_UINT32
+ACE_MEM_Addr::get_ip_address (void) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::get_ip_address");
+  return this->external_.get_ip_address ();
+}
+
+ACE_INLINE const ACE_INET_Addr &
+ACE_MEM_Addr::get_local_addr (void) const
+{
+  return this->internal_;
+}
+
+ACE_INLINE const ACE_INET_Addr &
+ACE_MEM_Addr::get_remote_addr (void) const
+{
+  return this->external_;
+}
+
+// Compare two addresses for equality.
+
+ACE_INLINE int
+ACE_MEM_Addr::operator == (const ACE_MEM_Addr &sap) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::operator ==");
+
+  return this->external_ == sap.external_ &&
+    this->internal_ == sap.internal_;
+}
+
+ACE_INLINE int
+ACE_MEM_Addr::operator == (const ACE_INET_Addr &sap) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::operator ==");
+
+  return this->external_ == sap;
+}
+
+// Compare two addresses for inequality.
+
+ACE_INLINE int
+ACE_MEM_Addr::operator != (const ACE_MEM_Addr &sap) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::operator !=");
+  return !((*this) == sap);
+}
+
+ACE_INLINE int
+ACE_MEM_Addr::operator != (const ACE_INET_Addr &sap) const
+{
+  ACE_TRACE ("ACE_MEM_Addr::operator !=");
+  return !((*this) == sap);
+}
+
+ACE_INLINE u_long
+ACE_MEM_Addr::hash (void) const
+{
+  return this->external_.hash ();
+}
diff --git a/ace/MEM_Connector.cpp b/ace/MEM_Connector.cpp
new file mode 100644
index 00000000000..090e2cf2e9d
--- /dev/null
+++ b/ace/MEM_Connector.cpp
@@ -0,0 +1,105 @@
+// MEM_Connector.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Connector.h"
+
+ACE_RCSID(ace, MEM_Connector, "$Id$")
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Connector.i"
+#endif
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Connector)
+
+void
+ACE_MEM_Connector::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Connector::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+ACE_MEM_Connector::ACE_MEM_Connector (void)
+{
+  ACE_TRACE ("ACE_MEM_Connector::ACE_MEM_Connector");
+}
+
+// Establish a connection.
+ACE_MEM_Connector::ACE_MEM_Connector (ACE_MEM_Stream &new_stream,
+                                      const ACE_INET_Addr &remote_sap,
+                                      ACE_Time_Value *timeout,
+                                      const ACE_Addr &local_sap,
+                                      int reuse_addr,
+                                      int flags,
+                                      int perms,
+                                      int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Connector::ACE_MEM_Connector");
+  // This is necessary due to the weird inheritance relationships of
+  // ACE_MEM_Stream.
+  this->connect (new_stream,
+                 remote_sap,
+                 timeout,
+                 local_sap,
+                 reuse_addr,
+                 flags,
+                 perms,
+                 protocol);
+}
+
+int
+ACE_MEM_Connector::connect (ACE_MEM_Stream &new_stream,
+                            const ACE_INET_Addr &remote_sap,
+                            ACE_Time_Value *timeout,
+                            const ACE_Addr &local_sap,
+                            int reuse_addr,
+                            int flags,
+                            int perms,
+                            int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Connector::connect");
+
+  if (!this->address_.same_host (remote_sap))
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("(%P|%t) MEM_Connector can't connect ")
+                       ASYS_TEXT ("to %s:%d which is not a local endpoint"),
+                       remote_sap.get_host_name (),
+                       remote_sap.get_port_number ()),
+                      -1);
+  else
+    this->address_.set_port_number (remote_sap.get_port_number ());
+
+
+  ACE_SOCK_Stream temp_stream;
+
+  if (ACE_SOCK_Connector::connect (temp_stream,
+                                   this->address_.get_local_addr (),
+                                   timeout, local_sap,
+                                   reuse_addr, flags, perms,
+                                   PF_INET, protocol) == -1)
+    return -1;
+
+  ACE_HANDLE new_handle = temp_stream.get_handle ();
+  new_stream.set_handle (new_handle);
+  // Do not close the handle.
+
+  // now we should setup the mmap malloc.
+  char buf[MAXPATHLEN];
+
+  // @@ Need to handle timeout here.
+  ACE_INT16 buf_len;
+  // Byte-order is not a problem for this read.
+  if (ACE::recv (new_handle, &buf_len, sizeof (buf_len)) == -1)
+    return -1;
+
+  if (ACE::recv (new_handle, buf, buf_len) == -1)
+    return -1;
+
+  if (new_stream.create_shm_malloc (buf, &this->malloc_options_) == -1)
+    return -1;
+
+  return 0;
+}
diff --git a/ace/MEM_Connector.h b/ace/MEM_Connector.h
new file mode 100644
index 00000000000..4879708efb4
--- /dev/null
+++ b/ace/MEM_Connector.h
@@ -0,0 +1,106 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Connector.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_CONNECTOR_H
+#define ACE_MEM_CONNECTOR_H
+
+#include "ace/SOCK_Connector.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/MEM_Stream.h"
+#include "ace/MEM_Addr.h"
+
+class ACE_Export ACE_MEM_Connector : public ACE_SOCK_Connector
+{
+  // = TITLE
+  //     Defines the format and interface for the connector side of
+  //     the <ACE_MEM_Stream>.
+public:
+  // = Initialization methods.
+  ACE_MEM_Connector (void);
+  // Default constructor.
+
+  ACE_MEM_Connector (ACE_MEM_Stream &new_stream,
+                     const ACE_INET_Addr &remote_sap,
+                     ACE_Time_Value *timeout = 0,
+                     const ACE_Addr &local_sap = ACE_Addr::sap_any,
+                     int reuse_addr = 0,
+                     int flags = 0,
+                     int perms = 0,
+                     int protocol = 0);
+  // Actively connect and produce a <new_stream> if things go well.
+  // The <remote_sap> is the address that we are trying to connect
+  // with.  The <timeout> is the amount of time to wait to connect.
+  // If it's 0 then we block indefinitely.  If *timeout == {0, 0} then
+  // the connection is done using non-blocking mode.  In this case, if
+  // the connection can't be made immediately the value of -1 is
+  // returned with <errno == EWOULDBLOCK>.  If *timeout > {0, 0} then
+  // this is the amount of time to wait before timing out.  If the
+  // time expires before the connection is made <errno == ETIME>.  The
+  // <local_sap> is the value of local address to bind to.  If it's
+  // the default value of <0> then the user is letting
+  // the OS do the binding.  If <reuse_addr> == 1 then the
+  // <local_addr> is reused, even if it hasn't been cleanedup yet.
+
+  int connect (ACE_MEM_Stream &new_stream,
+               const ACE_INET_Addr &remote_sap,
+               ACE_Time_Value *timeout = 0,
+               const ACE_Addr &local_sap = ACE_Addr::sap_any,
+               int reuse_addr = 0,
+               int flags = 0,
+               int perms = 0,
+               int protocol = 0);
+  // Actively connect and produce a <new_stream> if things go well.
+  // The <remote_sap> is the address that we are trying to connect
+  // with.  The <timeout> is the amount of time to wait to connect.
+  // If it's 0 then we block indefinitely.  If *timeout == {0, 0} then
+  // the connection is done using non-blocking mode.  In this case, if
+  // the connection can't be made immediately the value of -1 is
+  // returned with <errno == EWOULDBLOCK>.  If *timeout > {0, 0} then
+  // this is the amount of time to wait before timing out.  If the
+  // time expires before the connection is made <errno == ETIME>.  The
+  // <local_sap> is the value of local address to bind to.  If it's
+  // the default value of <0> then the user is letting
+  // the OS do the binding.  If <reuse_addr> == 1 then the
+  // <local_addr> is reused, even if it hasn't been cleanedup yet.
+
+  ACE_MEM_SAP::MALLOC_OPTIONS &malloc_options (void);
+  // Accessor to underlying malloc options.
+
+  // = Meta-type info
+  typedef ACE_INET_Addr PEER_ADDR;
+  typedef ACE_MEM_Stream PEER_STREAM;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+private:
+  ACE_MEM_Addr address_;
+
+  ACE_MEM_SAP::MALLOC_OPTIONS malloc_options_;
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Connector.i"
+#endif
+
+#endif /* ACE_MEM_CONNECTOR_H */
diff --git a/ace/MEM_Connector.i b/ace/MEM_Connector.i
new file mode 100644
index 00000000000..3fdf59e19e0
--- /dev/null
+++ b/ace/MEM_Connector.i
@@ -0,0 +1,12 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Connector.i
+
+// Establish a connection.
+
+ASYS_INLINE ACE_MEM_SAP::MALLOC_OPTIONS &
+ACE_MEM_Connector::malloc_options (void)
+{
+  return this->malloc_options_;
+}
diff --git a/ace/MEM_IO.cpp b/ace/MEM_IO.cpp
new file mode 100644
index 00000000000..3b0b8867043
--- /dev/null
+++ b/ace/MEM_IO.cpp
@@ -0,0 +1,160 @@
+// MEM_IO.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_IO.h"
+#include "ace/Handle_Set.h"
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_IO.i"
+#endif /* ACE_LACKS_INLINE_FUNCTIONS */
+
+ACE_RCSID(ace, MEM_IO, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_IO)
+
+void
+ACE_MEM_IO::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_IO::dump");
+}
+
+// Allows a client to read from a socket without having to provide
+// a buffer to read.  This method determines how much data is in the
+// socket, allocates a buffer of this size, reads in the data, and
+// returns the number of bytes read.
+
+#if 0
+ssize_t
+ACE_MEM_IO::recvv (iovec *io_vec,
+                    const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::recvv");
+#if defined (FIONREAD)
+  ACE_Handle_Set handle_set;
+  handle_set.reset ();
+  handle_set.set_bit (this->get_handle ());
+
+  io_vec->iov_base = 0;
+
+  // Check the status of the current socket.
+  switch (ACE_OS::select (int (this->get_handle ()) + 1,
+                          handle_set,
+                          0, 0,
+                          timeout))
+    {
+    case -1:
+      return -1;
+      /* NOTREACHED */
+    case 0:
+      errno = ETIME;
+      return -1;
+      /* NOTREACHED */
+    default:
+      // Goes fine, fallthrough to get data
+      break;
+    }
+
+  u_long inlen;
+
+  if (ACE_OS::ioctl (this->get_handle (),
+                     FIONREAD,
+                     (u_long *) &inlen) == -1)
+    return -1;
+  else if (inlen > 0)
+    {
+      ACE_NEW_RETURN (io_vec->iov_base,
+                      char[inlen],
+                      -1);
+      io_vec->iov_len = this->recv (io_vec->iov_base,
+                                    inlen);
+      return io_vec->iov_len;
+    }
+  else
+    return 0;
+#else
+  ACE_UNUSED_ARG (io_vec);
+  ACE_UNUSED_ARG (timeout);
+  ACE_NOTSUP_RETURN (-1);
+#endif /* FIONREAD */
+}
+
+// Send N char *ptrs and int lengths.  Note that the char *'s precede
+// the ints (basically, an varargs version of writev).  The count N is
+// the *total* number of trailing arguments, *not* a couple of the
+// number of tuple pairs!
+
+ssize_t
+ACE_MEM_IO::send (size_t n, ...) const
+{
+  ACE_TRACE ("ACE_MEM_IO::send");
+
+  va_list argp;
+  size_t total_tuples = n / 2;
+  iovec *iovp;
+#if defined (ACE_HAS_ALLOCA)
+  iovp = (iovec *) alloca (total_tuples * sizeof (iovec));
+#else
+  ACE_NEW_RETURN (iovp,
+                  iovec[total_tuples],
+                  -1);
+#endif /* !defined (ACE_HAS_ALLOCA) */
+
+  va_start (argp, n);
+
+  for (size_t i = 0; i < total_tuples; i++)
+    {
+      iovp[i].iov_base = va_arg (argp, char *);
+      iovp[i].iov_len = va_arg (argp, ssize_t);
+    }
+
+  ssize_t result = ACE_OS::sendv (this->get_handle (),
+                                  iovp,
+                                  total_tuples);
+#if !defined (ACE_HAS_ALLOCA)
+  delete [] iovp;
+#endif /* !defined (ACE_HAS_ALLOCA) */
+  va_end (argp);
+  return result;
+}
+
+// This is basically an interface to ACE_OS::readv, that doesn't use
+// the struct iovec_Base explicitly.  The ... can be passed as an arbitrary
+// number of (char *ptr, int len) tuples.  However, the count N is the
+// *total* number of trailing arguments, *not* a couple of the number
+// of tuple pairs!
+
+ssize_t
+ACE_MEM_IO::recv (size_t n, ...) const
+{
+  ACE_TRACE ("ACE_MEM_IO::recv");
+
+  va_list argp;
+  size_t total_tuples = n / 2;
+  iovec *iovp;
+#if defined (ACE_HAS_ALLOCA)
+  iovp = (iovec *) alloca (total_tuples * sizeof (iovec));
+#else
+  ACE_NEW_RETURN (iovp,
+                  iovec[total_tuples],
+                  -1);
+#endif /* !defined (ACE_HAS_ALLOCA) */
+
+  va_start (argp, n);
+
+  for (size_t i = 0; i < total_tuples; i++)
+    {
+      iovp[i].iov_base = va_arg (argp, char *);
+      iovp[i].iov_len = va_arg (argp, ssize_t);
+    }
+
+  ssize_t result = ACE_OS::recvv (this->get_handle (),
+                                  iovp,
+                                  total_tuples);
+#if !defined (ACE_HAS_ALLOCA)
+  delete [] iovp;
+#endif /* !defined (ACE_HAS_ALLOCA) */
+  va_end (argp);
+  return result;
+}
+#endif /* 0 */
diff --git a/ace/MEM_IO.h b/ace/MEM_IO.h
new file mode 100644
index 00000000000..9780f2c4701
--- /dev/null
+++ b/ace/MEM_IO.h
@@ -0,0 +1,128 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_IO.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_IO_H
+#define ACE_MEM_IO_H
+
+#include "ace/SOCK.h"
+#include "ace/MEM_SAP.h"
+#include "ace/Memory_Pool.h"
+#include "ace/Malloc_T.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+class ACE_Export ACE_MEM_IO : public ACE_SOCK, public ACE_MEM_SAP
+{
+  // = TITLE
+  //     Defines the methods for the ACE shared memeory wrapper I/O routines
+  //     (e.g., send/recv).
+public:
+  // = Initialization and termination methods.
+  ACE_MEM_IO ();
+  // Constructor.
+
+  ~ACE_MEM_IO (void);
+  // Destructor.
+
+  ssize_t send (const void *buf,
+                size_t n,
+                int flags) ;
+  // Send an <n> byte buffer to the other process using shm_malloc_
+  // connected thru the socket.
+
+  ssize_t recv (void *buf,
+                size_t n,
+                int flags) ;
+  // Recv an <n> byte buffer from the shm_malloc_ thru connected socket.
+
+  ssize_t send (const void *buf,
+                size_t n) ;
+  // Send an <n> byte buffer to the other process using shm_malloc_
+  // connected thru the socket.
+
+  ssize_t recv (void *buf,
+                size_t n) ;
+  // Recv an <n> byte buffer from the shm_malloc_ thru connected socket.
+
+  ssize_t fetch_recv_buf (int flags, const ACE_Time_Value *timeout = 0);
+  // @@ Please fill in here.
+
+  ssize_t send (const void *buf,
+                size_t n,
+                int flags,
+                const ACE_Time_Value *timeout);
+  // Wait to to <timeout> amount of time to send up to <n> bytes into
+  // <buf> from <handle> (uses the <send> call).  If <send> times out
+  // a -1 is returned with <errno == ETIME>.  If it succeeds the
+  // number of bytes sent is returned.
+
+  ssize_t recv (void *buf,
+                size_t n,
+                int flags,
+                const ACE_Time_Value *timeout);
+  // Wait up to <timeout> amount of time to receive up to <n> bytes
+  // into <buf> from <handle> (uses the <recv> call).  If <recv> times
+  // out a -1 is returned with <errno == ETIME>.  If it succeeds the
+  // number of bytes received is returned.
+
+  ssize_t send (const void *buf,
+                size_t n,
+                const ACE_Time_Value *timeout);
+  // Wait to to <timeout> amount of time to send up to <n> bytes into
+  // <buf> from <handle> (uses the <send> call).  If <send> times out
+  // a -1 is returned with <errno == ETIME>.  If it succeeds the
+  // number of bytes sent is returned.
+
+  ssize_t recv (void *buf,
+                size_t n,
+                const ACE_Time_Value *timeout);
+  // Wait up to <timeout> amount of time to receive up to <n> bytes
+  // into <buf> from <handle> (uses the <recv> call).  If <recv> times
+  // out a -1 is returned with <errno == ETIME>.  If it succeeds the
+  // number of bytes received is returned.
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+  /*  int get_local_port (u_short &) const;
+  // Return the local endpoint port number.  Returns 0 if successful,
+  // else -1.
+
+  int get_remote_port (u_short &) const;
+  // Return the port number of the remotely connected peer (if there
+  // is one). Returns 0 if successful, else -1.
+  */
+private:
+  void *recv_buffer_;
+  // Internal pointer for support recv/send.
+
+  ssize_t buf_size_;
+  // total buffer size.
+
+  ssize_t cur_offset_;
+  // current read pointer location.
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_IO.i"
+#endif
+
+#endif /* ACE_SOCK_IO_H */
diff --git a/ace/MEM_IO.i b/ace/MEM_IO.i
new file mode 100644
index 00000000000..aa2cadb1a18
--- /dev/null
+++ b/ace/MEM_IO.i
@@ -0,0 +1,168 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_IO.i
+
+// Send an n byte message to the connected socket.
+ASYS_INLINE
+ACE_MEM_IO::ACE_MEM_IO (void)
+  : recv_buffer_ (0),
+    buf_size_ (0),
+    cur_offset_ (0)
+{
+  // ACE_TRACE ("ACE_MEM_IO::ACE_MEM_IO");
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::fetch_recv_buf (int flag, const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::fetch_recv_buf");
+
+  // This method can only be called when <buf_size_> == <cur_offset_>.
+  ACE_ASSERT (this->buf_size_ == this->cur_offset_);
+
+  // We have done using the previous buffer, return it to malloc.
+  if (this->recv_buffer_ != 0)
+    this->release_buffer (this->recv_buffer_);
+
+  this->cur_offset_ = 0;
+  off_t new_offset = 0;
+  int retv = ACE::recv (this->get_handle (),
+                        (char *) &new_offset,
+                        sizeof (off_t),
+                        flag,
+                        timeout);
+
+  if (retv != sizeof (off_t))
+    {
+      //  Nothing available or we are really screwed.
+      this->buf_size_ = 0;
+      this->recv_buffer_ = 0;
+      return -1;
+    }
+  else
+      this->buf_size_ = this->get_buf_len (new_offset,
+                                           this->recv_buffer_);
+  return this->buf_size_;
+}
+
+ASYS_INLINE
+ACE_MEM_IO::~ACE_MEM_IO (void)
+{
+  // ACE_TRACE ("ACE_MEM_IO::~ACE_MEM_IO");
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::send (const void *buf,
+                   size_t len,
+                   int flags,
+                   const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::send");
+  void *sbuf = this->acquire_buffer (len);
+  if (sbuf == 0)
+    return -1;                  // Memory buffer not initialized.
+  ACE_OS::memcpy (sbuf, buf, len);
+  off_t offset = this->set_buf_len (sbuf, len); // <set_buf_len> also calculate
+                                              // the offset.
+
+  // Send the offset value over the socket.
+  if (ACE::send (this->get_handle (),
+                 (const char *) &offset,
+                 sizeof (offset),
+                 flags,
+                 timeout) != sizeof (offset))
+    {
+      // unsucessful send, release the memory in the shared-memory.
+      this->release_buffer (sbuf);
+
+      return -1;
+    }
+  return len;
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::recv (void *buf,
+                   size_t len,
+                   int flags,
+                   const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::recv");
+
+  size_t count = 0;
+
+//    while (len > 0)
+//      {
+      size_t buf_len = this->buf_size_ - this->cur_offset_;
+      if (buf_len == 0)
+        {
+          if (this->fetch_recv_buf (flags, timeout) == -1)
+            return -1;
+          buf_len = this->buf_size_;
+        }
+
+      size_t length = (len > buf_len ? buf_len : len);
+
+      ACE_OS::memcpy ((char *) buf + count,
+                      (char *) this->recv_buffer_ + this->cur_offset_,
+                      length);
+      this->cur_offset_ += length;
+//        len -= length;
+      count += length;
+//      }
+
+  return count;
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::send (const void *buf, size_t n, int flags)
+{
+  ACE_TRACE ("ACE_MEM_IO::send");
+  return this->send (buf, n, flags, 0);
+}
+
+// Recv an n byte message from the connected socket.
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::recv (void *buf, size_t n, int flags)
+{
+  ACE_TRACE ("ACE_MEM_IO::recv");
+  return this->recv (buf, n, flags, 0);
+}
+
+// Send an n byte message to the connected socket.
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::send (const void *buf, size_t n)
+{
+  ACE_TRACE ("ACE_MEM_IO::send");
+  return this->send (buf, n, 0);
+}
+
+// Recv an n byte message from the connected socket.
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::recv (void *buf, size_t n)
+{
+  ACE_TRACE ("ACE_MEM_IO::recv");
+
+  return this->recv (buf, n, 0);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::recv (void *buf,
+                   size_t len,
+                   const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::recv");
+  return this->recv (buf, len, 0, timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_IO::send (const void *buf,
+                   size_t len,
+                   const ACE_Time_Value *timeout)
+{
+  ACE_TRACE ("ACE_MEM_IO::send");
+  return this->send (buf, len, 0, timeout);
+}
diff --git a/ace/MEM_SAP.cpp b/ace/MEM_SAP.cpp
new file mode 100644
index 00000000000..6bd8dc184ee
--- /dev/null
+++ b/ace/MEM_SAP.cpp
@@ -0,0 +1,80 @@
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_SAP.h"
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_SAP.i"
+#endif
+
+ACE_RCSID(ace, IPC_SAP, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_IPC_SAP)
+
+void
+ACE_MEM_SAP::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_SAP::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  if (this->shm_malloc_ != 0)
+    this->shm_malloc_->dump ();
+  else
+    ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("ACE_MEM_SAP uninitialized.\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+ACE_MEM_SAP::ACE_MEM_SAP (void)
+  : shm_malloc_ (0)
+{
+  // ACE_TRACE ("ACE_MEM_SAP::ACE_MEM_SAP");
+}
+
+int
+ACE_MEM_SAP::create_shm_malloc (const char *name,
+                                MALLOC_OPTIONS *options)
+{
+  ACE_TRACE ("ACE_MEM_SAP::create_shm_malloc");
+
+  if (this->shm_malloc_ != 0)
+    return -1;                  // already initialized.
+
+  ACE_NEW_RETURN (this->shm_malloc_,
+                  MALLOC (name,
+                          0,
+                          options),
+                  -1);
+
+  return 0;
+}
+
+int
+ACE_MEM_SAP::close_shm_malloc (const int remove)
+{
+  if (this->shm_malloc_ != 0 && remove != 0)
+    {
+      this->shm_malloc_->remove ();
+      return 0;
+    }
+  return -1;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Write_Guard<ACE_Process_Mutex>;
+template class ACE_Read_Guard<ACE_Process_Mutex>;
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+template class ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block>;
+#else
+template class ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex>;
+template class ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_Control_Block>;
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Write_Guard<ACE_Process_Mutex>
+#pragma instantiate ACE_Read_Guard<ACE_Process_Mutex>
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+#pragma instantiate ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block>
+#else
+#pragma instantiate ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex>
+#pragma instantiate ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_Control_Block>
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/ace/MEM_SAP.h b/ace/MEM_SAP.h
new file mode 100644
index 00000000000..9cdba3e5a75
--- /dev/null
+++ b/ace/MEM_SAP.h
@@ -0,0 +1,99 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_SAP.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_SAP_H
+#define ACE_MEM_SAP_H
+
+#include "ace/Malloc.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+class ACE_Export ACE_MEM_SAP
+{
+  // = TITLE
+  //     Defines the methods of shared memory management for
+  //     shared memory transport.
+public:
+  // = Initialization and termination methods.
+
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+  typedef ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> MALLOC;
+#else
+  typedef ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_Control_Block> MALLOC;
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+  typedef ACE_MMAP_Memory_Pool_Options MALLOC_OPTIONS;
+  // I'll just hardcode this for mmap for now.
+
+  ~ACE_MEM_SAP (void);
+  // Destructor.
+
+  void * acquire_buffer (const ssize_t size);
+  // request a buffer of size <size>.  Return 0 if the <shm_malloc_> is
+  // not initialized.
+
+  int release_buffer (void *buf);
+  // release a buffer pointed by <buf>.  Return -1 if the <shm_malloc_>
+  // is not initialized.
+
+  off_t set_buf_len (const void *buf,
+                     size_t n);
+  // Set the length of buf (containing information) to <n> bytes.
+  // Return the offset of the <buf> relative to the base address.
+  // <buf> must be acquired by <get_buffer> method.  Return -1 if the
+  // <shm_malloc_> is not initialized.
+
+  ssize_t get_buf_len (const off_t off, void *&buf);
+  // Convert the buffer offset <off> to absolute address to <buf>.
+  // Return the size of valid information containing in the <buf>,
+  // -1 if <shm_malloc_> is not initialized.
+
+  int remove (void);
+  // Remove the shared resouce (mmap file) used by us.
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+protected:
+
+  // = Class initializing methods to create/connect to a shared memory pool.
+
+  int create_shm_malloc (const char *name,
+                         MALLOC_OPTIONS *options = 0);
+  // Create a new shm_malloc object.  Return 0 if succeed and -1 otherwise.
+  // This method should only be called from an acceptor class that wants to
+  // create a new memory pool for inter process communication.
+
+  int close_shm_malloc (const int remove = 0);
+  // Close down the share memory pool.  If <remove> != 0, then the mmap file
+  // will also get removed.
+
+  MALLOC *shm_malloc_;
+  // Data exchange channel.
+
+  ACE_MEM_SAP (void);
+  // Constructor.  Prevent this class from being instantiated.
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_SAP.i"
+#endif
+
+#endif /* ACE_SOCK_IO_H */
diff --git a/ace/MEM_SAP.i b/ace/MEM_SAP.i
new file mode 100644
index 00000000000..92506fe203e
--- /dev/null
+++ b/ace/MEM_SAP.i
@@ -0,0 +1,89 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_SAP.i
+
+ASYS_INLINE
+ACE_MEM_SAP::~ACE_MEM_SAP (void)
+{
+  // ACE_TRACE ("ACE_MEM_SAP::~ACE_MEM_SAP");
+  delete this->shm_malloc_;
+}
+
+
+ASYS_INLINE void *
+ACE_MEM_SAP::acquire_buffer (const ssize_t size)
+{
+  ACE_TRACE ("ACE_MEM_SAP::acquire_buffer");
+  if (this->shm_malloc_ == 0)
+    return 0;                  // not initialized.
+
+  size_t *lptr = ACE_static_cast (size_t *,
+                                  this->shm_malloc_->malloc (sizeof (size_t) + size));
+
+  *lptr = size;
+  ++lptr;
+
+  return lptr;
+}
+
+ASYS_INLINE int
+ACE_MEM_SAP::release_buffer (void *buf)
+{
+  ACE_TRACE ("ACE_MEM_SAP::release_buffer");
+  if (this->shm_malloc_ == 0)
+    return -1;                  // not initialized.
+
+  size_t *lptr = ACE_static_cast (size_t *, buf);
+
+  --lptr;
+  this->shm_malloc_->free (lptr);
+  return 0;
+}
+
+ASYS_INLINE off_t
+ACE_MEM_SAP::set_buf_len (const void *buf, size_t n)
+{
+  ACE_TRACE ("ACE_MEM_SAP::set_buf_len");
+  if (this->shm_malloc_ == 0)
+    return -1;
+
+  size_t *lptr = ACE_static_cast (size_t *, buf);
+  --lptr;
+
+  if (*lptr >= n)
+    *lptr = n;
+
+  return ((char *) lptr - (char *) this->shm_malloc_->memory_pool ().base_addr ());
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_SAP::get_buf_len (const off_t off, void *&buf)
+{
+  ACE_TRACE ("ACE_MEM_SAP::get_buf_len");
+
+  if (this->shm_malloc_ == 0)
+    return -1;
+
+  ssize_t retv = 0;
+
+  ACE_SEH_TRY
+    {
+      size_t *lptr = (size_t*) ((char *) this->shm_malloc_->memory_pool ().base_addr () + off);
+      buf = lptr + 1;
+      retv = *lptr;
+    }
+  ACE_SEH_EXCEPT (this->shm_malloc_->memory_pool ().seh_selector (GetExceptionInformation ()))
+    {
+    }
+
+  return retv;
+}
+
+ASYS_INLINE int
+ACE_MEM_SAP::remove (void)
+{
+  ACE_TRACE ("ACE_MEM_SAP::remove");
+
+  return close_shm_malloc (1);
+}
diff --git a/ace/MEM_Stream.cpp b/ace/MEM_Stream.cpp
new file mode 100644
index 00000000000..de870c1c66b
--- /dev/null
+++ b/ace/MEM_Stream.cpp
@@ -0,0 +1,35 @@
+// MEM_Stream.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Stream.h"
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Stream.i"
+#endif
+
+ACE_RCSID(ace, MEM_Stream, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Stream)
+
+void
+ACE_MEM_Stream::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::dump");
+}
+
+int
+ACE_MEM_Stream::close (void)
+{
+#if defined (ACE_WIN32)
+  // We need the following call to make things work correctly on
+  // Win32, which requires use to do a <close_writer> before doing the
+  // close in order to avoid losing data.  Note that we don't need to
+  // do this on UNIX since it doesn't have this "feature".  Moreover,
+  // this will cause subtle problems on UNIX due to the way that
+  // fork() works.
+  this->close_writer ();
+#endif /* ACE_WIN32 */
+  // Close down the socket.
+  return ACE_SOCK::close ();
+}
diff --git a/ace/MEM_Stream.h b/ace/MEM_Stream.h
new file mode 100644
index 00000000000..f31b6cbec2c
--- /dev/null
+++ b/ace/MEM_Stream.h
@@ -0,0 +1,126 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Stream.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_STREAM_H
+#define ACE_MEM_STREAM_H
+
+#include "ace/MEM_IO.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/INET_Addr.h"
+
+class ACE_MEM_Acceptor;
+class ACE_MEM_Connector;
+
+class ACE_Export ACE_MEM_Stream : public ACE_MEM_IO
+{
+  // = TITLE
+  //     Defines the methods in the <ACE_MEM_Stream> abstraction.
+  //
+  // = DESCRIPTION
+  //     This adds additional wrapper methods atop the <ACE_MEM_IO>
+  //     class.
+public:
+
+  friend class ACE_MEM_Acceptor;
+  friend class ACE_MEM_Connector;
+
+  // Initialization and termination methods.
+  ACE_MEM_Stream (void);
+  // Constructor.
+
+  ACE_MEM_Stream (ACE_HANDLE h);
+  // Constructor (sets the underlying <ACE_HANDLE> with <h>).
+
+  ~ACE_MEM_Stream (void);
+  // Destructor.
+
+  //= The following two methods use write and read system calls.
+  ssize_t send_n (const void *buf, int n);
+  // Send n bytes, keep trying until n are sent.
+  ssize_t recv_n (void *buf, int n);
+  // Recv n bytes, keep trying until n are received.
+
+  // = The following two methods use the send and recv system calls.
+  ssize_t send_n (const void *buf, int n, int flags);
+  // Send n bytes, keep trying until n are sent.
+  ssize_t recv_n (void *buf, int n, int flags);
+  // Recv n bytes, keep trying until n are received.
+
+/*
+  ssize_t send_n (const void *buf,
+                  size_t len,
+                  int flags,
+                  const ACE_Time_Value *timeout);
+  // Try to send exactly <len> bytes into <buf> from <handle> (uses
+  // the <send> call).  If <send> blocks for longer than <timeout> the
+  // number of bytes actually sent is returned with <errno == ETIME>.
+  // If a timeout does not occur, <send_n> return <len> (i.e., the
+  // number of bytes requested to be sent).
+
+  ssize_t recv_n (void *buf,
+                  size_t len,
+                  int flags,
+                  const ACE_Time_Value *timeout);
+  // Try to recv exactly <len> bytes into <buf> from <handle> (uses
+  // the <ACE::recv_n> call).  The <ACE_Time_Value> indicates how long
+  // to blocking trying to receive.  If <timeout> == 0, the caller
+  // will block until action is possible, else will wait until the
+  // relative time specified in *<timeout> elapses).  If <recv> blocks
+  // for longer than <timeout> the number of bytes actually read is
+  // returned with <errno == ETIME>.  If a timeout does not occur,
+  // <recv_n> return <len> (i.e., the number of bytes requested to be
+  // read).
+
+  ssize_t sendv_n (const iovec iov[],
+                   size_t n) const;
+  // Send an <iovec> of size <n> to the connected socket (uses
+  // <ACE::sendv_n>).  Will block until all bytes are sent or an error
+  // occurs.
+
+  ssize_t recvv_n (iovec iov[],
+                   size_t n) const;
+  // Receive an <iovec> of size <n> to the connected socket.
+*/
+  // = Selectively close endpoints.
+  int close_reader (void);
+  // Close down the reader.
+  int close_writer (void);
+  // Close down the writer.
+
+  int close (void);
+  // Close down the socket (we need this to make things work correctly
+  // on Win32, which requires use to do a <close_writer> before doing
+  // the close to avoid losing data).
+
+  // = Meta-type info
+  typedef ACE_Addr PEER_ADDR;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Stream.i"
+#endif
+
+#endif /* ACE_MEM_STREAM_H */
diff --git a/ace/MEM_Stream.i b/ace/MEM_Stream.i
new file mode 100644
index 00000000000..7aa77710e49
--- /dev/null
+++ b/ace/MEM_Stream.i
@@ -0,0 +1,176 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Stream.i
+
+#include "ace/MEM_Stream.h"
+
+ASYS_INLINE
+ACE_MEM_Stream::ACE_MEM_Stream (void)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::ACE_MEM_Stream");
+}
+
+ASYS_INLINE
+ACE_MEM_Stream::ACE_MEM_Stream (ACE_HANDLE h)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::ACE_MEM_Stream");
+  this->set_handle (h);
+}
+
+ASYS_INLINE
+ACE_MEM_Stream::~ACE_MEM_Stream (void)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::~ACE_MEM_Stream");
+}
+
+ASYS_INLINE int
+ACE_MEM_Stream::close_reader (void)
+{
+  ACE_TRACE ("ACE_MEM_Stream::close_reader");
+  if (this->get_handle () != ACE_INVALID_HANDLE)
+    return ACE_OS::shutdown (this->get_handle (), 0);
+  else
+    return 0;
+}
+
+// Shut down just the writing end of a ACE_SOCK.
+
+ASYS_INLINE int
+ACE_MEM_Stream::close_writer (void)
+{
+  ACE_TRACE ("ACE_MEM_Stream::close_writer");
+  if (this->get_handle () != ACE_INVALID_HANDLE)
+    return ACE_OS::shutdown (this->get_handle (), 1);
+  else
+    return 0;
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf, int n)
+{
+  return this->send (buf, n);
+}
+
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf, int n)
+{
+  return this->recv (buf, n);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf, int n, int flags)
+{
+  return this->send (buf, n, flags);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf, int n, int flags)
+{
+  return this->recv (buf, n, flags);
+}
+
+#if 0
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf,
+                         size_t len,
+                         int flags,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_n");
+  return ACE::recv_n (this->get_handle (),
+                      buf,
+                      len,
+                      flags,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf,
+                         size_t len,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_n");
+  return ACE::recv_n (this->get_handle (),
+                      buf,
+                      len,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recvv_n (iovec iov[],
+                          size_t n,
+                          const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recvv_n");
+  return ACE::recvv_n (this->get_handle (),
+                       iov,
+                       n,
+                       timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf,
+                         size_t len,
+                         int flags,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_n");
+  return ACE::send_n (this->get_handle (),
+                      buf,
+                      len,
+                      flags,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf,
+                         size_t len,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_n");
+  return ACE::send_n (this->get_handle (),
+                      buf,
+                      len,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::sendv_n (iovec iov[],
+                          size_t n,
+                          const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::sendv_n");
+  return ACE::sendv_n (this->get_handle (),
+                       iov,
+                       n,
+                       timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_urg (const void *ptr,
+                           size_t len,
+                           const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_urg");
+  return ACE::send (this->get_handle (),
+                    ptr,
+                    len,
+                    MSG_OOB,
+                    timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_urg (void *ptr,
+                           size_t len,
+                           const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_urg");
+  return ACE::recv (this->get_handle (),
+                    ptr,
+                    len,
+                    MSG_OOB,
+                    timeout);
+}
+#endif /* 0 */
diff --git a/ace/Makefile b/ace/Makefile
index ddbb7c4477d..54a25bf28fc 100644
--- a/ace/Makefile
+++ b/ace/Makefile
@@ -138,7 +138,13 @@ IPC_FILES = \
   UNIX_Addr \
   UPIPE_Acceptor \
   UPIPE_Connector \
-  UPIPE_Stream
+  UPIPE_Stream \
+  MEM_Acceptor \
+  MEM_Addr \
+  MEM_Connector \
+  MEM_IO \
+  MEM_SAP \
+  MEM_Stream
 SVCCONF_FILES = \
   DLL \
   Parse_Node \
diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp
index b96087af560..1665f630257 100644
--- a/ace/Malloc_T.cpp
+++ b/ace/Malloc_T.cpp
@@ -61,7 +61,7 @@ ACE_Allocator_Adapter<MALLOC>::~ACE_Allocator_Adapter (void)
 template <class MALLOC> void
 ACE_Allocator_Adapter<MALLOC>::print_stats (void) const
 {
-  ACE_TRACE ("ACE_Malloc_T<MALLOC>::print_stats");
+  ACE_TRACE ("ACE_Allocator_Adaptor<MALLOC>::print_stats");
   this->allocator_.print_stats ();
 }
 #endif /* ACE_HAS_MALLOC_STATS */
@@ -666,7 +666,7 @@ ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::unbind (const char *name, void *
 
           if (curr->next_)
             curr->next_->prev_ = prev;
-              
+
           // This will free up both the node and the name due to our
           // clever trick in <bind>!
           this->shared_free (curr);
diff --git a/ace/OS.h b/ace/OS.h
index 64b159146ef..7d1892272df 100644
--- a/ace/OS.h
+++ b/ace/OS.h
@@ -1637,6 +1637,11 @@ private:  ACE_Time_Value *max_wait_time_;
 #   define ACE_SOCK_CONNECTOR ACE_SOCK_Connector
 #   define ACE_SOCK_STREAM ACE_SOCK_Stream
 
+// Handle ACE_MEM_*
+#   define ACE_MEM_ACCEPTOR ACE_MEM_Acceptor
+#   define ACE_MEM_CONNECTOR ACE_MEM_Connector
+#   define ACE_MEM_STREAM ACE_MEM_Stream
+
 // Handle ACE_LSOCK_*
 #   define ACE_LSOCK_ACCEPTOR ACE_LSOCK_Acceptor
 #   define ACE_LSOCK_CONNECTOR ACE_LSOCK_Connector
@@ -1713,6 +1718,11 @@ private:  ACE_Time_Value *max_wait_time_;
 #   define ACE_SOCK_CONNECTOR ACE_SOCK_Connector, ACE_INET_Addr
 #   define ACE_SOCK_STREAM ACE_SOCK_Stream, ACE_INET_Addr
 
+// Handle ACE_MEM_*
+#   define ACE_MEM_ACCEPTOR ACE_MEM_Acceptor, ACE_MEM_Addr
+#   define ACE_MEM_CONNECTOR ACE_MEM_Connector, ACE_INET_Addr
+#   define ACE_MEM_STREAM ACE_MEM_Stream, ACE_INET_Addr
+
 // Handle ACE_LSOCK_*
 #   define ACE_LSOCK_ACCEPTOR ACE_LSOCK_Acceptor, ACE_UNIX_Addr
 #   define ACE_LSOCK_CONNECTOR ACE_LSOCK_Connector, ACE_UNIX_Addr
diff --git a/examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp b/examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp
new file mode 100644
index 00000000000..37182fd2c38
--- /dev/null
+++ b/examples/IPC_SAP/SOCK_SAP/CPP-memclient.cpp
@@ -0,0 +1,56 @@
+// $Id$
+
+// This tests the features of the <ACE_MEM_Connector> and
+// <ACE_MEM_Stream> classes.  In addition, it can be used to test the
+// oneway and twoway latency and throughput at the socket-level.  This
+// is useful as a baseline to compare against ORB-level performance
+// for the same types of data.
+
+#include "ace/MEM_Connector.h"
+#include "ace/INET_Addr.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Singleton.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Synch.h"
+
+ACE_RCSID(SOCK_SAP, CPP_inclient, "$Id$")
+
+static int
+run_client (void)
+{
+  ACE_MEM_Connector connector;
+  ACE_MEM_Stream stream;
+  ACE_INET_Addr server_addr (ACE_DEFAULT_SERVER_PORT, "COYOTE");
+
+  if (connector.connect (stream, server_addr) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "connect"), -1);
+
+  char buf [MAXPATHLEN];
+  while (gets (buf) >0)
+    {
+      stream.send (buf, ACE_OS::strlen (buf)+1);
+      stream.recv (buf, MAXPATHLEN);
+      ACE_DEBUG ((LM_DEBUG, "Echo: %s\n", buf));
+    }
+
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  // Initialize the logger.
+  ACE_LOG_MSG->open (argv[0]);
+
+  // Run the client
+  run_client ();
+
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Singleton<Options, ACE_SYNCH_RECURSIVE_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<Options, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp b/examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp
new file mode 100644
index 00000000000..0dcf1c29cbc
--- /dev/null
+++ b/examples/IPC_SAP/SOCK_SAP/CPP-memserver.cpp
@@ -0,0 +1,70 @@
+// $Id$
+
+// This example tests the features of the <ACE_MEM_Acceptor>,
+// <ACE_MEM_Stream>, and <ACE_Svc_Handler> classes.  If the platform
+// supports threads it uses a thread-per-connection concurrency model.
+// Otherwise, it uses a single-threaded iterative server model.
+
+#include "ace/MEM_Acceptor.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Handle_Set.h"
+#include "ace/Profile_Timer.h"
+
+ACE_RCSID(SOCK_SAP, CPP_inserver, "$Id$")
+
+static int
+run_event_loop (u_short port)
+{
+  // Create the acceptors.
+  ACE_MEM_Acceptor acceptor;
+
+  ACE_MEM_Addr server_addr (port);
+
+  // Create acceptors, reuse the address.
+  if (acceptor.open (server_addr, 1) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "open"),
+                      1);
+  else if (acceptor.get_local_addr (server_addr) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "get_local_addr"),
+                      1);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) starting server at port %d\n",
+              server_addr.get_port_number ()));
+
+  // Keep these objects out here to prevent excessive constructor
+  // calls within the loop.
+  ACE_MEM_Stream new_stream;
+
+  // blocking wait on accept.
+  if (acceptor.accept (new_stream) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "accept"),
+                      -1);
+
+  char buf[MAXPATHLEN];
+  int len = 0;
+  while ((len = new_stream.recv (buf, MAXPATHLEN)) != -1)
+    {
+      ACE_DEBUG ((LM_DEBUG, "%s\n", buf));
+      new_stream.send (buf, len);
+    }
+
+  return new_stream.remove ();
+}
+
+int
+main (int argc, char *argv[])
+{
+  u_short port = ACE_DEFAULT_SERVER_PORT;
+
+  if (argc > 1)
+    port = ACE_OS::atoi (argv[1]);
+
+  return run_event_loop (port);
+}
diff --git a/examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp b/examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp
new file mode 100644
index 00000000000..1bb3dd35869
--- /dev/null
+++ b/examples/IPC_SAP/SOCK_SAP/CPP_memclient.dsp
@@ -0,0 +1,104 @@
+# Microsoft Developer Studio Project File - Name="CPP_memclient" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=CPP_memclient - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "CPP_memclient.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "CPP_memclient.mak" CFG="CPP_memclient - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "CPP_memclient - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "CPP_memclient - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "CPP_memclient - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+

+!ELSEIF  "$(CFG)" == "CPP_memclient - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "CPP_memclient___Win32_Debug"

+# PROP BASE Intermediate_Dir "CPP_memclient___Win32_Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD   /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD   /c

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\ace"

+

+!ENDIF 

+

+# Begin Target

+

+# Name "CPP_memclient - Win32 Release"

+# Name "CPP_memclient - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=".\CPP-memclient.cpp"

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# Begin Source File

+

+SOURCE=".\CPP-memclient.h"

+# End Source File

+# End Group

+# Begin Group "Resource Files"

+

+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

+# End Group

+# End Target

+# End Project

diff --git a/examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp b/examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp
new file mode 100644
index 00000000000..9fa6802ae4d
--- /dev/null
+++ b/examples/IPC_SAP/SOCK_SAP/CPP_memserver.dsp
@@ -0,0 +1,69 @@
+# Microsoft Developer Studio Project File - Name="CPP_memserver" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=CPP_memserver - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "CPP_memserver.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "CPP_memserver.mak" CFG="CPP_memserver - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "CPP_memserver - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "CPP_memserver___Win32_Debug"

+# PROP BASE Intermediate_Dir "CPP_memserver___Win32_Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD   /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD   /c

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\ace"

+# Begin Target

+

+# Name "CPP_memserver - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=".\CPP-memserver.cpp"

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# End Group

+# Begin Group "Resource Files"

+

+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

+# End Group

+# End Target

+# End Project

diff --git a/examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw b/examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw
index ecfbf538184..36a90951e36 100644
--- a/examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw
+++ b/examples/IPC_SAP/SOCK_SAP/SOCK_SAP.dsw
@@ -27,6 +27,30 @@ Package=<4>
 

 ###############################################################################

 

+Project: "CPP_memclient"=.\CPP_memclient.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Project: "CPP_memserver"=.\CPP_memserver.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

 Project: "C_inclient"=.\SOCK_SAP.dsp - Package Owner=<4>

 

 Package=<5>

diff --git a/tests/Malloc_Test.cpp b/tests/Malloc_Test.cpp
index d974ef23ebd..c523f28c0d8 100644
--- a/tests/Malloc_Test.cpp
+++ b/tests/Malloc_Test.cpp
@@ -345,17 +345,12 @@ main (int argc, ASYS_TCHAR *[])
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 #if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-template class ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block>;
 template class auto_ptr< ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> >;
 template class ACE_Auto_Basic_Ptr< ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> >;
 #else
-template class ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex>;
-template class ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_Control_Block>;
 template class auto_ptr< ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex> >;
 template class ACE_Auto_Basic_Ptr< ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex> >;
 #endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
-template class ACE_Write_Guard<ACE_Process_Mutex>;
-template class ACE_Read_Guard<ACE_Process_Mutex>;
 template class ACE_Based_Pointer<Test_Data>;
 template class ACE_Based_Pointer_Basic<Test_Data>;
 template class ACE_Based_Pointer_Basic<long>;
@@ -363,17 +358,12 @@ template class ACE_Based_Pointer_Basic<Long_Test>;
 template class ACE_Based_Pointer<Long_Test>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-#pragma instantiate ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block>
 #pragma instantiate auto_ptr< ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> >
 #pragma instantiate ACE_Auto_Basic_Ptr< ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_PI_Control_Block> >;
 #else
-#pragma instantiate ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex>
-#pragma instantiate ACE_Malloc_T<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex, ACE_Control_Block>
 #pragma instantiate auto_ptr< ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex> >
 #pragma instantiate ACE_Auto_Basic_Ptr< ACE_Malloc<ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex> >;
 #endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
-#pragma instantiate ACE_Write_Guard<ACE_Process_Mutex>
-#pragma instantiate ACE_Read_Guard<ACE_Process_Mutex>
 #pragma instantiate ACE_Based_Pointer<Test_Data>
 #pragma instantiate ACE_Based_Pointer_Basic<Test_Data>
 #pragma instantiate ACE_Based_Pointer_Basic<long>