From e16de8c8c2f4d0a6eb44160dc887fe875c83bb7f Mon Sep 17 00:00:00 2001 From: elliott_c Date: Mon, 17 Jul 2006 14:42:07 +0000 Subject: ChangeLogTag: Mon Jul 17 14:40:43 UTC 2006 Chad Elliott --- TAO/ChangeLog | 150 +++++++++++++++++++++ TAO/TAO_IDL/be/be_visitor_union/union_cs.cpp | 1 - TAO/tao/AnyTypeCode/Any_Impl.h | 2 +- TAO/tao/AnyTypeCode/NVList.h | 4 +- TAO/tao/CDR.cpp | 32 ++++- TAO/tao/CDR.h | 12 ++ .../CSD_FW_Server_Request_Wrapper.cpp | 113 +++++++++------- .../CSD_Framework/CSD_FW_Server_Request_Wrapper.h | 17 +-- TAO/tao/CSD_ThreadPool.mpc | 1 + .../CSD_TP_Collocated_Synch_Request.cpp | 6 +- TAO/tao/Client_Strategy_Factory.cpp | 7 + TAO/tao/Client_Strategy_Factory.h | 4 + TAO/tao/Configurable_Refcount.cpp | 9 ++ TAO/tao/Configurable_Refcount.h | 69 ++++++++++ TAO/tao/Configurable_Refcount.inl | 55 ++++++++ TAO/tao/Environment.i | 8 +- TAO/tao/GIOP_Message_Base.cpp | 91 ++++--------- TAO/tao/GIOP_Message_Lite.cpp | 42 ++---- TAO/tao/IORTable/Table_Adapter.cpp | 6 +- TAO/tao/Incoming_Message_Queue.cpp | 50 ++++--- TAO/tao/Incoming_Message_Queue.h | 5 +- TAO/tao/Leader_Follower.cpp | 6 +- TAO/tao/LocalObject.h | 2 +- TAO/tao/Messaging/AMH_Response_Handler.cpp | 4 +- TAO/tao/ORB.cpp | 3 +- TAO/tao/ORB.h | 6 +- TAO/tao/ORB.i | 19 +-- TAO/tao/ORB_Core.h | 2 +- TAO/tao/ORB_Core.i | 10 +- TAO/tao/Object.cpp | 51 +++---- TAO/tao/Object.h | 5 +- TAO/tao/Object.i | 4 +- TAO/tao/PortableServer/POA_Current_Impl.cpp | 2 +- TAO/tao/PortableServer/POA_Current_Impl.h | 8 ++ TAO/tao/PortableServer/POA_Current_Impl.inl | 19 ++- TAO/tao/PortableServer/Root_POA.cpp | 5 +- TAO/tao/PortableServer/Servant_Upcall.cpp | 2 +- TAO/tao/PortableServer/Servant_Upcall.h | 1 + TAO/tao/Principal.h | 2 +- TAO/tao/Profile.cpp | 31 ++--- TAO/tao/Profile.h | 6 +- TAO/tao/RTCORBA/Thread_Pool.cpp | 38 +++--- TAO/tao/Resource_Factory.cpp | 7 + TAO/tao/Resource_Factory.h | 4 + TAO/tao/Stub.cpp | 4 +- TAO/tao/Stub.h | 2 +- TAO/tao/TAO_Server_Request.cpp | 10 +- TAO/tao/TAO_Server_Request.h | 12 +- TAO/tao/TAO_Server_Request.i | 54 ++++++-- TAO/tao/TAO_Singleton_Manager.cpp | 6 +- TAO/tao/Tagged_Profile.cpp | 5 +- TAO/tao/Tagged_Profile.h | 4 +- TAO/tao/Tagged_Profile.i | 6 +- TAO/tao/Valuetype/ValueBase.h | 2 +- TAO/tao/Var_Size_Argument_T.cpp | 4 + TAO/tao/default_client.cpp | 21 ++- TAO/tao/default_client.h | 1 + TAO/tao/default_resource.cpp | 20 ++- TAO/tao/default_resource.h | 1 + TAO/tao/tao.mpc | 1 + 60 files changed, 732 insertions(+), 342 deletions(-) create mode 100644 TAO/tao/Configurable_Refcount.cpp create mode 100644 TAO/tao/Configurable_Refcount.h create mode 100644 TAO/tao/Configurable_Refcount.inl (limited to 'TAO') diff --git a/TAO/ChangeLog b/TAO/ChangeLog index b38ba11687f..a03560785e3 100644 --- a/TAO/ChangeLog +++ b/TAO/ChangeLog @@ -1,3 +1,153 @@ +Mon Jul 17 14:40:43 UTC 2006 Chad Elliott + + * TAO_IDL/be/be_visitor_union/union_cs.cpp: + + The memset of the discriminator was redundant as it is assigned + directly after the memset of the union data. + + * tao/CDR.h: + * tao/CDR.cpp: + + Added a constructor that takes an ACE_Data_Block* which can be + used to avoid an allocation while constructing the + ACE_Message_Block held by the ACE_OutputCDR. [RT 8372] + + * tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.h: + * tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.cpp: + + Use the new inline TAO_ServerRequest constructor. This avoids + having to allocate a costly dummy input and output cdr. + + Avoid using ACE_CString for the operation name which will avoid + memory allocations when it isn't necessary. Most of the time, the + operation name can be shared from the operation_details_ object. + + When the type of TAO_Tagged_Profile::type_id_ changed in the + previous commit, the cloning needed to take that into account. + [RT 8372] + + When cloning the operation details, allocate an input cdr with a + "large" message block that will be shared by the output cdr as + the marshaling of the arguments is done. This allows us to + avoid the copying of the data block, in most situations, from the + output cdr into the input cdr as was done in the previous version. + [RT 8372] + + * tao/CSD_ThreadPool.mpc: + + Added a requires for threads as this project shouldn't be built if + thread support is not going to be built into TAO. + + * tao/Client_Strategy_Factory.h: + * tao/Client_Strategy_Factory.cpp: + * tao/Configurable_Refcount.h: + * tao/Configurable_Refcount.inl: + * tao/Configurable_Refcount.cpp: + * tao/Object.h: + * tao/Object.i: + * tao/Object.cpp: + * tao/Profile.h: + * tao/Profile.cpp: + * tao/Resource_Factory.h: + * tao/Resource_Factory.cpp: + * tao/default_client.h: + * tao/default_client.cpp: + * tao/default_resource.h: + * tao/tao.mpc: + + The TAO_Configurable_Refcount can be used as an ACE_Atomic_Op with + either a null mutex or a thread mutex. Those classes that use it + used to use either a null mutex or a thread mutex and an integer + based reference count. + + * tao/GIOP_Message_Base.cpp: + + When processing a request, a character buffer is allocated on the + stack. Previously, it was passed as a parameter to the + TAO_OutputCDR and an ACE_Data_Block was heap allocated during the + construction of the ACE_Message_Block held by the ACE_OutputCDR. + + Now, the ACE_Data_Block is constructed on the stack as well and + passed in during the construction of the ACE_Message_Block to + avoid heap allocations altogether. [RT 8372] + + * tao/GIOP_Message_Lite.cpp: + * tao/Incoming_Message_Queue.h: + * tao/Incoming_Message_Queue.cpp: + + Factored various forms of creating a TAO_Queued_Data (with and + without an ACE_Message_Block) into a single method. Doing this + allows us to avoid extra manipulations of the reference count in + the ACE_Data_Block involved. + + * tao/Environment.i: + * tao/Leader_Follower.cpp: + * tao/TAO_Singleton_Manager.cpp: + * tao/Var_Size_Argument_T.cpp: + * tao/default_resource.cpp: + * tao/IORTable/Table_Adapter.cpp: + * tao/CSD_ThreadPool/CSD_TP_Collocated_Synch_Request.cpp: + * tao/RTCORBA/Thread_Pool.cpp: + + Replace many instances of the use of a bare 'new' with the + equivalent ACE_NEW or ACE_NEW_RETURN macro. [RT 8372] + + * tao/LocalObject.h: + * tao/Principal.h: + * tao/Stub.h: + * tao/Stub.cpp: + * tao/AnyTypeCode/Any_Impl.h: + * tao/AnyTypeCode/NVList.h: + * tao/Messaging/AMH_Response_Handler.cpp: + * tao/Valuetype/ValueBase.h: + + Use unsigned long instead of CORBA::ULong to be able to take + advantage of the ACE_Atomic_Op<> template specialization. + CORBA::ULong doesn't necessarily equate to unsigned long. + + * tao/ORB.h: + * tao/ORB.i: + * tao/ORB.cpp: + * tao/ORB_Core.h: + * tao/ORB_Core.i: + + Switch from using a thread mutex and CORBA::ULong to an + ACE_Atomic_Op<> with a thread mutex and unsigned long. When the + assembler based specialization of ACE_Atomic_Op<> is used, there + is a performance benefit. + + * tao/PortableServer/POA_Current_Impl.h: + * tao/PortableServer/POA_Current_Impl.inl: + * tao/PortableServer/POA_Current_Impl.cpp: + * tao/PortableServer/Servant_Upcall.h: + * tao/PortableServer/Servant_Upcall.cpp: + + Use an octet sequence array of a specific size (512 bytes by + default) when constructing the ObjectId. This allows us to avoid + allocations during an upcall in most situations. [RT 8372] + + * tao/PortableServer/Root_POA.cpp: + + Begin the starting_at index at the TAO_OBJECTKEY_PREFIX_SIZE + instead of starting it at zero and then adding the value directly + after that. This is probably immeasurable performance-wise. + + * tao/TAO_Server_Request.h: + * tao/TAO_Server_Request.i: + * tao/TAO_Server_Request.cpp: + + Avoid using ACE_CString for the operation name which will avoid + memory allocations when it isn't necessary. Most of the time, the + operation name can be shared from the operation_details_ object. + + * tao/Tagged_Profile.h: + * tao/Tagged_Profile.i: + * tao/Tagged_Profile.cpp: + + Avoid using ACE_CString as the type_id_. The type_id_ was never + used for anything more than a holder of a char* that it didn't + own, but incurred allocation penalties during construction. + Mon Jul 17 14:26:08 UTC 2006 Ciju John * orbsvcs/orbsvcs/Event/ECG_Mcast_EH.cpp: diff --git a/TAO/TAO_IDL/be/be_visitor_union/union_cs.cpp b/TAO/TAO_IDL/be/be_visitor_union/union_cs.cpp index 8e8d563605c..3405d6c8fb9 100644 --- a/TAO/TAO_IDL/be/be_visitor_union/union_cs.cpp +++ b/TAO/TAO_IDL/be/be_visitor_union/union_cs.cpp @@ -94,7 +94,6 @@ int be_visitor_union_cs::visit_union (be_union *node) *os << be_nl << be_nl << node->name () << "::" << node->local_name () << " (void)" << be_nl << "{" << be_idt_nl - << "ACE_OS::memset (&this->disc_, 0, sizeof (this->disc_));" << be_nl << "ACE_OS::memset (&this->u_, 0, sizeof (this->u_));" << be_nl << "this->disc_ = "; diff --git a/TAO/tao/AnyTypeCode/Any_Impl.h b/TAO/tao/AnyTypeCode/Any_Impl.h index 9eaf83b482d..0e04ce527b5 100644 --- a/TAO/tao/AnyTypeCode/Any_Impl.h +++ b/TAO/tao/AnyTypeCode/Any_Impl.h @@ -110,7 +110,7 @@ namespace TAO private: /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; }; } diff --git a/TAO/tao/AnyTypeCode/NVList.h b/TAO/tao/AnyTypeCode/NVList.h index 9e5ca449710..d78a228726a 100644 --- a/TAO/tao/AnyTypeCode/NVList.h +++ b/TAO/tao/AnyTypeCode/NVList.h @@ -124,7 +124,7 @@ namespace CORBA private: /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; /// holds the value Any any_; @@ -286,7 +286,7 @@ namespace CORBA ULong max_; /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; /// Protects the incoming pointer. TAO_SYNCH_MUTEX lock_; diff --git a/TAO/tao/CDR.cpp b/TAO/tao/CDR.cpp index 31efb9b0ea6..4ac35f5e957 100644 --- a/TAO/tao/CDR.cpp +++ b/TAO/tao/CDR.cpp @@ -28,7 +28,9 @@ static const char *TAO_CDR_Timeprobe_Description[] = "OutputCDR::ctor[3] - enter", "OutputCDR::ctor[3] - leave", "OutputCDR::ctor[4] - enter", - "OutputCDR::ctor[4] - leave" + "OutputCDR::ctor[4] - leave", + "OutputCDR::ctor[5] - enter", + "OutputCDR::ctor[5] - leave" }; enum @@ -40,7 +42,9 @@ enum TAO_OUTPUT_CDR_CTOR3_ENTER, TAO_OUTPUT_CDR_CTOR3_LEAVE, TAO_OUTPUT_CDR_CTOR4_ENTER, - TAO_OUTPUT_CDR_CTOR4_LEAVE + TAO_OUTPUT_CDR_CTOR4_LEAVE, + TAO_OUTPUT_CDR_CTOR5_ENTER, + TAO_OUTPUT_CDR_CTOR5_LEAVE }; // Setup Timeprobes @@ -154,6 +158,29 @@ TAO_OutputCDR::TAO_OutputCDR (ACE_Message_Block *data, ACE_FUNCTION_TIMEPROBE (TAO_OUTPUT_CDR_CTOR4_ENTER); } +TAO_OutputCDR::TAO_OutputCDR (ACE_Data_Block *data_block, + int byte_order, + ACE_Allocator* message_block_allocator, + size_t memcpy_tradeoff, + TAO_GIOP_Fragmentation_Strategy * fs, + ACE_CDR::Octet major_version, + ACE_CDR::Octet minor_version) + : ACE_OutputCDR (data_block, + byte_order, + message_block_allocator, + memcpy_tradeoff, + major_version, + minor_version) + , fragmentation_strategy_ (fs) + , more_fragments_ (false) + , request_id_ (0) + , stub_ (0) + , message_semantics_ (-1) + , timeout_ (0) +{ + ACE_FUNCTION_TIMEPROBE (TAO_OUTPUT_CDR_CTOR5_ENTER); +} + void TAO_OutputCDR::throw_stub_exception (int error_num ACE_ENV_ARG_DECL) { @@ -246,7 +273,6 @@ TAO_InputCDR::TAO_InputCDR (const TAO_OutputCDR& rhs, { } - void TAO_InputCDR::throw_stub_exception (int error_num ACE_ENV_ARG_DECL) { diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h index 3bfb47b2f14..4820a469316 100644 --- a/TAO/tao/CDR.h +++ b/TAO/tao/CDR.h @@ -148,6 +148,18 @@ public: ACE_CDR::Octet minor_version = TAO_DEF_GIOP_MINOR); + /// Build a CDR stream with an initial data block, it will *not* remove + /// , since it did not allocated it. + TAO_OutputCDR (ACE_Data_Block *data, + int byte_order = ACE_CDR_BYTE_ORDER, + ACE_Allocator* message_block_allocator = 0, + size_t memcpy_tradeoff = 0, + TAO_GIOP_Fragmentation_Strategy * fs = 0, + ACE_CDR::Octet major_version = + TAO_DEF_GIOP_MAJOR, + ACE_CDR::Octet minor_version = + TAO_DEF_GIOP_MINOR); + /// Destructor. ~TAO_OutputCDR (void); diff --git a/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.cpp b/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.cpp index 8c2b40d7f28..24684bf7866 100644 --- a/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.cpp +++ b/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.cpp @@ -22,6 +22,11 @@ TAO::CSD::FW_Server_Request_Wrapper::~FW_Server_Request_Wrapper() // Only delete the request if we cloned it. if (this->is_clone_) { + // The TAO_Tagged_Profile type_id_ may have been duplicated. + if (this->request_->profile_.type_id_ != 0) + CORBA::string_free ( + const_cast (this->request_->profile_.type_id_)); + // Since this TAO_ServerRequest object is a clone, it // "owns" the input and output CDR objects held by the // incoming_ and outgoing_ data members, respectfully. @@ -43,7 +48,7 @@ TAO::CSD::FW_Server_Request_Wrapper::~FW_Server_Request_Wrapper() delete [] opname; delete this->request_->operation_details_; } - + if (this->request_->transport_ != 0) this->request_->transport_->remove_reference (); @@ -61,7 +66,7 @@ TAO::CSD::FW_Server_Request_Wrapper::dispatch ACE_TRY { servant->_dispatch(*this->request_, 0 ACE_ENV_ARG_PARAMETER); - ACE_CHECK; + ACE_TRY_CHECK; } // Only CORBA exceptions are caught here. ACE_CATCHANY @@ -148,7 +153,10 @@ TAO_ServerRequest* TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_ServerRequest*& request) { // TBD-CSD: Ultimately add an argument for an allocator. - TAO_ServerRequest* clone_obj = this->create_new_request (); + TAO_ServerRequest* clone_obj; + ACE_NEW_RETURN (clone_obj, + TAO_ServerRequest (), + 0); if (clone_obj == 0) { @@ -159,9 +167,11 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_ServerRequest*& request) // ACTION: Assuming that a shallow-copy is ok here. clone_obj->mesg_base_ = request->mesg_base_; - // TYPE: ACE_CString - // ACTION: Assignment performs deep-copy of string contents. - clone_obj->operation_ = request->operation_; + // TYPE: const char* + // ACTION: Method performs deep-copy of string contents. + clone_obj->operation (CORBA::string_dup (request->operation ()), + request->operation_length (), + 1); // TYPE: CORBA::Object_var // ACTION: Assignment performs reference-counted copy of object ref. @@ -240,8 +250,8 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_ServerRequest*& request) if (request->operation_details_ != 0) { ACE_ASSERT (request->incoming_ == 0); - if (this->clone (request->operation_details_, - clone_obj->operation_details_, + if (this->clone (request->operation_details_, + clone_obj->operation_details_, clone_obj->incoming_) == false) { return 0; @@ -295,17 +305,28 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_InputCDR*& from) bool TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Operation_Details const *& from, - TAO_Operation_Details const *& to, + TAO_Operation_Details const *& to, TAO_InputCDR*& cdr) { TAO_Operation_Details *& from_non_const = const_cast (from); - char* cloned_op_name = new char[from_non_const->opname_len_ + 1]; + char* cloned_op_name; + ACE_NEW_RETURN (cloned_op_name, + char[from_non_const->opname_len_ + 1], + false); ACE_OS::strncpy(cloned_op_name, from_non_const->opname_, from_non_const->opname_len_); cloned_op_name[from_non_const->opname_len_] = '\0'; - TAO_OutputCDR outcdr; + static const size_t mb_size = 2048; + ACE_NEW_RETURN (cdr, + TAO_InputCDR (mb_size), + false); + + // To avoid duplicating and copying the data block, allow the + // TAO_OutputCDR to share the data block of TAO_InputCDR's message block. + ACE_Message_Block* mb = const_cast (cdr->start ()); + TAO_OutputCDR outcdr (mb); if (! from_non_const->marshal_args (outcdr)) { @@ -315,10 +336,26 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Operation_Details const *& from, return false; } - ACE_NEW_RETURN (cdr, - TAO_InputCDR (outcdr), - false); - + // The TAO_OutputCDR made a new message block around the data block + // held by the message block owned by the TAO_InputCDR. We need to + // make sure that the results of marshaling are propagated back to the + // message block in the TAO_InputCDR. + const ACE_Message_Block* begin = outcdr.begin (); + if (begin == outcdr.current ()) + { + // A chain was not made, so we can just adjust the read and write + // pointers + mb->rd_ptr (begin->rd_ptr ()); + mb->wr_ptr (begin->wr_ptr ()); + } + else + { + // A costly, but necessary, copying of data blocks. This shouldn't + // happen that often assuming that the size of the message block + // allocated during the allocation of TAO_InputCDR is "big enough" + // for most operation parameters. + cdr->reset (begin, outcdr.byte_order ()); + } // CSD-TBD: Eventually need to use allocators. @@ -373,7 +410,7 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Operation_Details const *& from, void -TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Tagged_Profile& from, +TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Tagged_Profile& from, TAO_Tagged_Profile& to) { to.orb_core_ = from.orb_core_; @@ -382,7 +419,8 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Tagged_Profile& from, to.object_key_ = from.object_key_; to.profile_ = from.profile_; to.profile_index_ = from.profile_index_; - to.type_id_ = from.type_id_; + to.type_id_ = from.type_id_ == 0 ? 0 : + CORBA::string_dup (from.type_id_); } @@ -393,45 +431,16 @@ TAO::CSD::FW_Server_Request_Wrapper::clone (TAO_Service_Context& from, to.service_context_ = from.service_context_; } -TAO_ServerRequest* -TAO::CSD::FW_Server_Request_Wrapper::create_new_request () -{ - // Use one of constructor to create the TAO_ServerRequest object then - // reset the data members. This reduces the footprint due to a default - // TAO_ServerRequest constructor. - // - //TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base, - // TAO_InputCDR &input, - // TAO_OutputCDR &output, - // TAO_Transport *transport, - // TAO_ORB_Core *orb_core); - - TAO_ServerRequest* request = 0; - - TAO_InputCDR dummy_input ((ACE_Message_Block *)0); // empty input cdr stream - TAO_OutputCDR dummy_output ((char *)0, (size_t) 0); // empty output cdr stream - ACE_NEW_RETURN (request, - TAO_ServerRequest (0, - dummy_input, - dummy_output, - 0, - 0), - 0); - - request->incoming_ = 0; - request->outgoing_ = 0; - - return request; -} - - -TAO_OutputCDR* +TAO_OutputCDR* TAO::CSD::FW_Server_Request_Wrapper::create_new_output_cdr () { - TAO_OutputCDR* cdr = 0; + TAO_OutputCDR* cdr = 0; // A buffer that we will use to initialise the CDR stream - char* repbuf = new char[ACE_CDR::DEFAULT_BUFSIZE]; + char* repbuf; + ACE_NEW_RETURN (repbuf, + char[ACE_CDR::DEFAULT_BUFSIZE], + 0); ACE_CDR::Octet major; ACE_CDR::Octet minor; diff --git a/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.h b/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.h index e76b4090487..5268fb8a357 100644 --- a/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.h +++ b/TAO/tao/CSD_Framework/CSD_FW_Server_Request_Wrapper.h @@ -52,8 +52,8 @@ namespace TAO * FW_Server_Request_Wrapper class' implementation, and all CSD * Strategies will work again. It's a maintenance issue. * - * @note: The CSD namespace is inside of TAO namespace in current - * implementation. This can be changed but, at least for now, it's + * @note: The CSD namespace is inside of TAO namespace in current + * implementation. This can be changed but, at least for now, it's * already been delivered to some customs, we leave it as-is. If it * needs to change, we will make this change. */ @@ -87,13 +87,13 @@ namespace TAO TAO_InputCDR* clone (TAO_InputCDR*& from); /// Create a deep copy of a TAO_Operation_Details object and marshall - /// the arguments into a TAO_InputCDR stream. The cloned TAO_Operation_Details - /// object is created without any arguments. This would help the skeleton - /// code to determine whether the arguments are in the operation_details_ + /// the arguments into a TAO_InputCDR stream. The cloned TAO_Operation_Details + /// object is created without any arguments. This would help the skeleton + /// code to determine whether the arguments are in the operation_details_ /// object or should be demarshalled from the incoming_ stream in the request_ /// object. bool clone (TAO_Operation_Details const *& from, - TAO_Operation_Details const *& to, + TAO_Operation_Details const *& to, TAO_InputCDR* & cdr); /// Clone the TAO_Tagged_Profile object. @@ -102,14 +102,11 @@ namespace TAO /// Clone the TAO_Service_Context object. void clone (TAO_Service_Context& from, TAO_Service_Context& to); - /// Create a new TAO_ServerRequest with default initial values. - TAO_ServerRequest* create_new_request (); - /// Create a TAO_OutputCDR stream initialized with a heap allocated /// buffer. TAO_OutputCDR* create_new_output_cdr (); - /// A flag that indicates that the TAO_ServerRequest object + /// A flag that indicates that the TAO_ServerRequest object /// is already cloned. bool is_clone_; diff --git a/TAO/tao/CSD_ThreadPool.mpc b/TAO/tao/CSD_ThreadPool.mpc index 67be4b9bf00..9181084a3fa 100644 --- a/TAO/tao/CSD_ThreadPool.mpc +++ b/TAO/tao/CSD_ThreadPool.mpc @@ -3,6 +3,7 @@ project : csd_framework, core { sharedname = TAO_CSD_ThreadPool dynamicflags = TAO_CSD_TP_BUILD_DLL includes += $(TAO_ROOT)/tao + requires += threads Source_Files { CSD_ThreadPool diff --git a/TAO/tao/CSD_ThreadPool/CSD_TP_Collocated_Synch_Request.cpp b/TAO/tao/CSD_ThreadPool/CSD_TP_Collocated_Synch_Request.cpp index 31c6c32e1a7..c7d7d00fcde 100644 --- a/TAO/tao/CSD_ThreadPool/CSD_TP_Collocated_Synch_Request.cpp +++ b/TAO/tao/CSD_ThreadPool/CSD_TP_Collocated_Synch_Request.cpp @@ -36,10 +36,10 @@ TAO::CSD::TP_Collocated_Synch_Request::dispatch_i() #if defined (TAO_HAS_EXCEPTIONS) ACE_CATCHALL { - this->exception_ - = new CORBA::UNKNOWN (CORBA::SystemException::_tao_minor_code + ACE_NEW (this->exception_ , + CORBA::UNKNOWN (CORBA::SystemException::_tao_minor_code (TAO_UNHANDLED_SERVER_CXX_EXCEPTION, 0), - CORBA::COMPLETED_MAYBE); + CORBA::COMPLETED_MAYBE)); } #endif ACE_ENDTRY; diff --git a/TAO/tao/Client_Strategy_Factory.cpp b/TAO/tao/Client_Strategy_Factory.cpp index f8cfb870b74..2cc73497870 100644 --- a/TAO/tao/Client_Strategy_Factory.cpp +++ b/TAO/tao/Client_Strategy_Factory.cpp @@ -16,6 +16,13 @@ TAO_Client_Strategy_Factory::create_profile_lock (void) return 0; } +TAO_Configurable_Refcount +TAO_Client_Strategy_Factory::create_profile_refcount (void) +{ + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_NULL_LOCK); +} + TAO_Transport_Mux_Strategy * TAO_Client_Strategy_Factory::create_transport_mux_strategy (TAO_Transport *) { diff --git a/TAO/tao/Client_Strategy_Factory.h b/TAO/tao/Client_Strategy_Factory.h index 407e580b509..14eb2370c77 100644 --- a/TAO/tao/Client_Strategy_Factory.h +++ b/TAO/tao/Client_Strategy_Factory.h @@ -23,6 +23,7 @@ #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "tao/Versioned_Namespace.h" +#include "tao/Configurable_Refcount.h" #include "ace/Service_Object.h" @@ -56,6 +57,9 @@ public: */ virtual ACE_Lock* create_profile_lock (void); + /// Create the refcount for the profile + virtual TAO_Configurable_Refcount create_profile_refcount (void); + /// Create the correct client request muxing strategy. virtual TAO_Transport_Mux_Strategy *create_transport_mux_strategy (TAO_Transport *transport); diff --git a/TAO/tao/Configurable_Refcount.cpp b/TAO/tao/Configurable_Refcount.cpp new file mode 100644 index 00000000000..44f5f7f6138 --- /dev/null +++ b/TAO/tao/Configurable_Refcount.cpp @@ -0,0 +1,9 @@ +#include "Configurable_Refcount.h" + +#if !defined (__ACE_INLINE__) +# include "Configurable_Refcount.inl" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID (tao, + Configurable_Refcount, + "$Id$") diff --git a/TAO/tao/Configurable_Refcount.h b/TAO/tao/Configurable_Refcount.h new file mode 100644 index 00000000000..cf2af53a2ba --- /dev/null +++ b/TAO/tao/Configurable_Refcount.h @@ -0,0 +1,69 @@ +// This may look like C, but it's really +// -*- C++ -*- + +//============================================================================= +/** + * @file Configurable_Refcount.h + * + * $Id$ + * + * Definition for a synchronised refcountable interface. + * + * @author Fred Kuhns + */ +//============================================================================= + +#ifndef TAO_CONFIGURABLE_REFCOUNT_H +#define TAO_CONFIGURABLE_REFCOUNT_H + +#include /**/ "ace/pre.h" +#include "ace/Atomic_Op.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/Null_Mutex.h" +#include "tao/TAO_Export.h" +#include "tao/orbconf.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +/** + * @class TAO_Configurable_Refcount + * + * @brief Definition for a synchronised refcountable interface. + */ +class TAO_Export TAO_Configurable_Refcount +{ +public: + enum Lock_Type + { + TAO_NULL_LOCK, + TAO_THREAD_LOCK + }; + + TAO_Configurable_Refcount (Lock_Type type = TAO_THREAD_LOCK, + unsigned long value = 1); + + unsigned long increment (void); + unsigned long decrement (void); + + unsigned long value (void) const; + +private: + Lock_Type type_; + ACE_Atomic_Op null_refcount_; + ACE_Atomic_Op mutex_refcount_; +}; + + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined (__ACE_INLINE__) +# include "Configurable_Refcount.inl" +#endif /* __ACE_INLINE__ */ + +#include /**/ "ace/post.h" + +#endif /* TAO_CONFIGURABLE_REFCOUNT */ diff --git a/TAO/tao/Configurable_Refcount.inl b/TAO/tao/Configurable_Refcount.inl new file mode 100644 index 00000000000..c885976bbc6 --- /dev/null +++ b/TAO/tao/Configurable_Refcount.inl @@ -0,0 +1,55 @@ +// -*- C++ -*- +//$Id$ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +ACE_INLINE +TAO_Configurable_Refcount::TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::Lock_Type type, + unsigned long value) + : type_ (type), + null_refcount_ (value), + mutex_refcount_ (value) +{ +} + +ACE_INLINE unsigned long +TAO_Configurable_Refcount::increment (void) +{ + switch(this->type_) + { + case TAO_NULL_LOCK: + return this->null_refcount_++; + case TAO_THREAD_LOCK: + default: + return this->mutex_refcount_++; + } +} + +ACE_INLINE unsigned long +TAO_Configurable_Refcount::decrement (void) +{ + switch(this->type_) + { + case TAO_NULL_LOCK: + return --this->null_refcount_; + case TAO_THREAD_LOCK: + default: + return --this->mutex_refcount_; + } +} + +ACE_INLINE unsigned long +TAO_Configurable_Refcount::value (void) const +{ + switch(this->type_) + { + case TAO_NULL_LOCK: + return this->null_refcount_.value (); + case TAO_THREAD_LOCK: + default: + return this->mutex_refcount_.value (); + } +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/Environment.i b/TAO/tao/Environment.i index 9a710cebffd..a8547215d6d 100644 --- a/TAO/tao/Environment.i +++ b/TAO/tao/Environment.i @@ -3,6 +3,8 @@ // $Id$ +#include "ace/OS_Memory.h" + TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE @@ -35,7 +37,11 @@ CORBA::Environment::_duplicate (CORBA::Environment *x) return 0; } - return new CORBA::Environment (*x); + CORBA::Environment* ptr = 0; + ACE_NEW_RETURN (ptr, + CORBA::Environment (*x), + 0); + return ptr; } ACE_INLINE diff --git a/TAO/tao/GIOP_Message_Base.cpp b/TAO/tao/GIOP_Message_Base.cpp index 242c13c983f..fdc07c0dd59 100644 --- a/TAO/tao/GIOP_Message_Base.cpp +++ b/TAO/tao/GIOP_Message_Base.cpp @@ -304,7 +304,9 @@ TAO_GIOP_Message_Base::format_message (TAO_OutputCDR &stream) ACE_Message_Block* consolidated_block = 0; if (stream.begin()->cont () != 0) { - consolidated_block = new ACE_Message_Block; + ACE_NEW_RETURN (consolidated_block, + ACE_Message_Block, + 0); ACE_CDR::consolidate (consolidated_block, stream.begin ()); buf = (char *) (consolidated_block->rd_ptr ()); } @@ -658,12 +660,22 @@ TAO_GIOP_Message_Base::process_request_message (TAO_Transport *transport, qd->minor_version_, generator_parser); - // A buffer that we will use to initialise the CDR stream + // A buffer that we will use to initialise the CDR stream. Since we're + // allocating the buffer on the stack, we may as well allocate the data + // block on the stack too and avoid an allocation inside the message + // block of the CDR. #if defined (ACE_INITIALIZE_MEMORY_BEFORE_USE) char repbuf[ACE_CDR::DEFAULT_BUFSIZE] = { 0 }; #else char repbuf[ACE_CDR::DEFAULT_BUFSIZE]; #endif /* ACE_INITIALIZE_MEMORY_BEFORE_USE */ + ACE_Data_Block out_db (sizeof (repbuf), + ACE_Message_Block::MB_DATA, + repbuf, + this->orb_core_->input_cdr_buffer_allocator (), + 0, + ACE_Message_Block::DONT_DELETE, + this->orb_core_->input_cdr_dblock_allocator ()); // Initialize an output CDR on the stack // NOTE: Don't jump to a conclusion as to why we are using the @@ -675,11 +687,8 @@ TAO_GIOP_Message_Base::process_request_message (TAO_Transport *transport, // lock, we need to set things like this -- put stuff in TSS here // and transfer to global memory when we get flow controlled. We // need to work on the message block to get it right! - TAO_OutputCDR output (repbuf, - sizeof repbuf, + TAO_OutputCDR output (&out_db, TAO_ENCAP_BYTE_ORDER, - this->orb_core_->input_cdr_buffer_allocator (), - this->orb_core_->input_cdr_dblock_allocator (), this->orb_core_->input_cdr_msgblock_allocator (), this->orb_core_->orb_params ()->cdr_memcpy_tradeoff (), this->fragmentation_strategy_.get (), @@ -1678,24 +1687,6 @@ TAO_GIOP_Message_Base::is_ready_for_bidirectional (TAO_OutputCDR &msg) TAO_Queued_Data * TAO_GIOP_Message_Base::make_queued_data (size_t sz) { - // Get a node for the queue.. - TAO_Queued_Data *qd = - TAO_Queued_Data::make_queued_data ( - this->orb_core_->transport_message_buffer_allocator ()); - - if (qd == 0) - { - if (TAO_debug_level > 0) - { - ACE_ERROR ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) - TAO_GIOP_Message_Base::make_queued_data, ") - ACE_TEXT ("our of memory, failed to allocate queued data object\n"))); - } - return 0; // NULL pointer - } - - // @@todo: We have a similar method in Transport.cpp. Need to see how - // we can factor them out.. // Make a datablock for the size requested + something. The // "something" is required because we are going to align the data // block in the message block. During alignment we could loose some @@ -1705,58 +1696,24 @@ TAO_GIOP_Message_Base::make_queued_data (size_t sz) this->orb_core_->create_input_cdr_data_block (sz + ACE_CDR::MAX_ALIGNMENT); - if (db == 0) - { - TAO_Queued_Data::release (qd); - - if (TAO_debug_level > 0) - { - ACE_ERROR ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) - TAO_GIOP_Message_Base::make_queued_data, ") - ACE_TEXT ("out of memory, failed to allocate input data block of size %u\n"), - sz)); - } - return 0; // NULL pointer - } - - ACE_Allocator *alloc = - this->orb_core_->input_cdr_msgblock_allocator (); - - if (alloc == 0) - { - if (TAO_debug_level >= 8) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) - TAO_GIOP_Message_Base::make_queued_data,") - ACE_TEXT (" no ACE_Allocator defined\n"))); - } - } - - - ACE_Message_Block mb (db, - 0, - alloc); - - ACE_Message_Block *new_mb = mb.duplicate (); + TAO_Queued_Data *qd = + TAO_Queued_Data::make_queued_data ( + this->orb_core_->transport_message_buffer_allocator (), + this->orb_core_->input_cdr_msgblock_allocator (), + db); - if (new_mb == 0) + if (qd == 0) { - TAO_Queued_Data::release (qd); - db->release(); - if (TAO_debug_level > 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - TAO_GIOP_Message_Base::make_queued_data, ") - ACE_TEXT ("out of memory, failed to allocate message block\n"))); + ACE_TEXT ("out of memory, failed to allocate queued data object\n"))); } - return 0; + db->release (); + return 0; // NULL pointer } - ACE_CDR::mb_align (new_mb); - - qd->msg_block_ = new_mb; - return qd; } diff --git a/TAO/tao/GIOP_Message_Lite.cpp b/TAO/tao/GIOP_Message_Lite.cpp index a3c30058d59..f980ee907af 100644 --- a/TAO/tao/GIOP_Message_Lite.cpp +++ b/TAO/tao/GIOP_Message_Lite.cpp @@ -220,7 +220,9 @@ TAO_GIOP_Message_Lite::format_message (TAO_OutputCDR &stream) ACE_Message_Block* consolidated_block = 0; if (stream.begin()->cont() != 0) { - consolidated_block = new ACE_Message_Block; + ACE_NEW_RETURN (consolidated_block, + ACE_Message_Block, + 0); ACE_CDR::consolidate(consolidated_block, stream.begin()); buf = (char *) (consolidated_block->rd_ptr ()); } @@ -1670,15 +1672,6 @@ TAO_GIOP_Message_Lite::dump_msg (const char *label, TAO_Queued_Data * TAO_GIOP_Message_Lite::make_queued_data (size_t sz) { - // Get a node for the queue.. - TAO_Queued_Data *qd = - TAO_Queued_Data::make_queued_data (); - - if (qd == 0) - { - return 0; - } - // Make a datablock for the size requested + something. The // "something" is required because we are going to align the data // block in the message block. During alignment we could loose some @@ -1688,33 +1681,18 @@ TAO_GIOP_Message_Lite::make_queued_data (size_t sz) this->orb_core_->create_input_cdr_data_block (sz + ACE_CDR::MAX_ALIGNMENT); - if (db == 0) - { - TAO_Queued_Data::release (qd); - return 0; - } - - ACE_Allocator *alloc = - this->orb_core_->input_cdr_msgblock_allocator (); - - ACE_Message_Block mb (db, - 0, - alloc); - - ACE_Message_Block *new_mb = mb.duplicate (); + TAO_Queued_Data *qd = + TAO_Queued_Data::make_queued_data ( + this->orb_core_->transport_message_buffer_allocator (), + this->orb_core_->input_cdr_msgblock_allocator (), + db); - if (new_mb == 0) + if (qd == 0) { - TAO_Queued_Data::release (qd); - db->release(); - + db->release (); return 0; } - ACE_CDR::mb_align (new_mb); - - qd->msg_block_ = new_mb; - return qd; } diff --git a/TAO/tao/IORTable/Table_Adapter.cpp b/TAO/tao/IORTable/Table_Adapter.cpp index 18e9873d933..bf31f486a7b 100644 --- a/TAO/tao/IORTable/Table_Adapter.cpp +++ b/TAO/tao/IORTable/Table_Adapter.cpp @@ -177,7 +177,11 @@ TAO_Table_Adapter_Factory::TAO_Table_Adapter_Factory (void) TAO_Adapter* TAO_Table_Adapter_Factory::create (TAO_ORB_Core *oc) { - return new TAO_Table_Adapter (oc); + TAO_Adapter* ptr = 0; + ACE_NEW_RETURN (ptr, + TAO_Table_Adapter (oc), + 0); + return ptr; } TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/Incoming_Message_Queue.cpp b/TAO/tao/Incoming_Message_Queue.cpp index 979aa167918..155b87b4c82 100644 --- a/TAO/tao/Incoming_Message_Queue.cpp +++ b/TAO/tao/Incoming_Message_Queue.cpp @@ -212,34 +212,52 @@ TAO_Queued_Data::TAO_Queued_Data (const TAO_Queued_Data &qd) /*static*/ TAO_Queued_Data * -TAO_Queued_Data::make_queued_data (ACE_Allocator *alloc) +TAO_Queued_Data::make_queued_data (ACE_Allocator *message_buffer_alloc, + ACE_Allocator *input_cdr_alloc, + ACE_Data_Block *db) { + // Get a node for the queue.. TAO_Queued_Data *qd = 0; - if (alloc) + if (message_buffer_alloc) { ACE_NEW_MALLOC_RETURN (qd, static_cast ( - alloc->malloc (sizeof (TAO_Queued_Data))), - TAO_Queued_Data (alloc), + message_buffer_alloc->malloc (sizeof (TAO_Queued_Data))), + TAO_Queued_Data (message_buffer_alloc), 0); - return qd; } - - // No allocator, so use the global pool! - // @@ TODO: We should be removing this at some point of time! - if (TAO_debug_level == 4) + else { - // This debug is for testing purposes! - ACE_DEBUG ((LM_DEBUG, - "TAO (%P|%t) - Queued_Data::get_queued_data\n" - "Using global pool for allocation \n")); + // No allocator, so use the global pool! + ACE_NEW_RETURN (qd, + TAO_Queued_Data, + 0); } - ACE_NEW_RETURN (qd, - TAO_Queued_Data, - 0); + // Providing an ACE_Data_Block indicates that the caller wants + // an aligned ACE_Message_Block added to the TAO_Queued_Data. + if (db != 0) + { + // If this allocation fails, the TAO_Queued_Data will be leaked. + if (input_cdr_alloc == 0) + ACE_NEW_RETURN (qd->msg_block_, + ACE_Message_Block (db, + 0, + input_cdr_alloc), + 0); + else + ACE_NEW_MALLOC_RETURN (qd->msg_block_, + static_cast ( + input_cdr_alloc->malloc (sizeof (ACE_Message_Block))), + ACE_Message_Block (db, + 0, + input_cdr_alloc), + 0); + + ACE_CDR::mb_align (qd->msg_block_); + } return qd; } diff --git a/TAO/tao/Incoming_Message_Queue.h b/TAO/tao/Incoming_Message_Queue.h index 80276c72b99..a70bfcbbcda 100644 --- a/TAO/tao/Incoming_Message_Queue.h +++ b/TAO/tao/Incoming_Message_Queue.h @@ -129,7 +129,10 @@ public: TAO_Queued_Data (const TAO_Queued_Data &qd); /// Creation of a node in the queue. - static TAO_Queued_Data* make_queued_data (ACE_Allocator *alloc = 0); + static TAO_Queued_Data* make_queued_data ( + ACE_Allocator *message_buffer_alloc = 0, + ACE_Allocator *input_cdr_alloc = 0, + ACE_Data_Block *db = 0); /// Deletion of a node from the queue. static void release (TAO_Queued_Data *qd); diff --git a/TAO/tao/Leader_Follower.cpp b/TAO/tao/Leader_Follower.cpp index 7f0eee155e3..5a49b4ec456 100644 --- a/TAO/tao/Leader_Follower.cpp +++ b/TAO/tao/Leader_Follower.cpp @@ -48,7 +48,11 @@ TAO_Leader_Follower::allocate_follower (void) if (!this->follower_free_list_.empty ()) return this->follower_free_list_.pop_front (); - return new TAO_LF_Follower (*this); + TAO_LF_Follower* ptr = 0; + ACE_NEW_RETURN (ptr, + TAO_LF_Follower (*this), + 0); + return ptr; } void diff --git a/TAO/tao/LocalObject.h b/TAO/tao/LocalObject.h index 11283cfaea6..d60a0be6a27 100644 --- a/TAO/tao/LocalObject.h +++ b/TAO/tao/LocalObject.h @@ -254,7 +254,7 @@ private: protected: /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; }; TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/Messaging/AMH_Response_Handler.cpp b/TAO/tao/Messaging/AMH_Response_Handler.cpp index 44d96d99ad5..0a1f3912dc9 100644 --- a/TAO/tao/Messaging/AMH_Response_Handler.cpp +++ b/TAO/tao/Messaging/AMH_Response_Handler.cpp @@ -234,9 +234,7 @@ TAO_AMH_Response_Handler::_tao_rh_send_exception (CORBA::Exception &ex void TAO_AMH_Response_Handler::_remove_ref (void) { - const CORBA::ULong new_count = --this->refcount_; - - if (new_count > 0) + if (--this->refcount_ > 0) return; if (this->allocator_) diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp index 32f678ad0b1..055fde725e6 100644 --- a/TAO/tao/ORB.cpp +++ b/TAO/tao/ORB.cpp @@ -142,8 +142,7 @@ void CORBA::ORB::InvalidName::_tao_decode ( // **************************************************************** CORBA::ORB::ORB (TAO_ORB_Core *orb_core) - : lock_ () - , refcount_ (1) + : refcount_ (1) , orb_core_ (orb_core) , use_omg_ior_format_ (1) , timeout_ (0) diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h index b232ea12aed..41f0bba0d24 100644 --- a/TAO/tao/ORB.h +++ b/TAO/tao/ORB.h @@ -37,6 +37,7 @@ #include "ace/Thread_Mutex.h" #include "ace/Guard_T.h" +#include "ace/Atomic_Op.h" TAO_BEGIN_VERSIONED_NAMESPACE_DECL @@ -632,12 +633,9 @@ namespace CORBA private: - /// Lock required for mutual exclusion between multiple threads. - TAO_SYNCH_MUTEX lock_; - /// Maintains a reference count of number of instantiations of the /// ORB. - CORBA::ULong refcount_; + ACE_Atomic_Op refcount_; /// The ORB_Core that created us.... TAO_ORB_Core * orb_core_; diff --git a/TAO/tao/ORB.i b/TAO/tao/ORB.i index 89ddfb694a1..6a34deb048b 100644 --- a/TAO/tao/ORB.i +++ b/TAO/tao/ORB.i @@ -11,25 +11,18 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE CORBA::ULong CORBA::ORB::_incr_refcnt (void) { - ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, - guard, - lock_, - 0); return ++this->refcount_; } ACE_INLINE CORBA::ULong CORBA::ORB::_decr_refcnt (void) { - { - ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0); - --this->refcount_; - - if (this->refcount_ != 0) - { - return this->refcount_; - } - } + CORBA::ULong count = --this->refcount_; + + if (count != 0) + { + return count; + } delete this; return 0; diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h index 5cbb2a4571e..3212778f74a 100644 --- a/TAO/tao/ORB_Core.h +++ b/TAO/tao/ORB_Core.h @@ -1217,7 +1217,7 @@ protected: TAO::Transport_Queueing_Strategy *default_transport_queueing_strategy_; /// Number of outstanding references to this object. - CORBA::ULong refcount_; + ACE_Atomic_Op refcount_; /// Registry containing all registered policy factories. TAO::PolicyFactory_Registry_Adapter *policy_factory_registry_; diff --git a/TAO/tao/ORB_Core.i b/TAO/tao/ORB_Core.i index 3f5f53cd423..5ec66789335 100644 --- a/TAO/tao/ORB_Core.i +++ b/TAO/tao/ORB_Core.i @@ -16,19 +16,15 @@ TAO_ORB_Core::configuration (void) const ACE_INLINE CORBA::ULong TAO_ORB_Core::_incr_refcnt (void) { - ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->lock_, 0); return this->refcount_++; } ACE_INLINE CORBA::ULong TAO_ORB_Core::_decr_refcnt (void) { - { - ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0); - --this->refcount_; - if (this->refcount_ != 0) - return this->refcount_; - } + CORBA::ULong count = --this->refcount_; + if (count != 0) + return count; this->fini (); return 0; diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp index b08936b74b5..deefa4cbf6c 100644 --- a/TAO/tao/Object.cpp +++ b/TAO/tao/Object.cpp @@ -39,7 +39,7 @@ CORBA::Object::~Object (void) if (this->protocol_proxy_) (void) this->protocol_proxy_->_decr_refcnt (); - delete this->refcount_lock_; + delete this->object_init_lock_; } CORBA::Object::Object (TAO_Stub * protocol_proxy, @@ -51,8 +51,8 @@ CORBA::Object::Object (TAO_Stub * protocol_proxy, , ior_ (0) , orb_core_ (orb_core) , protocol_proxy_ (protocol_proxy) - , refcount_ (1) - , refcount_lock_ (0) + , refcount_ () + , object_init_lock_ (0) { /// This constructor should not be called when the protocol proxy is /// null ie. when the object is a LocalObject. Assert that @@ -62,9 +62,12 @@ CORBA::Object::Object (TAO_Stub * protocol_proxy, if (this->orb_core_ == 0) this->orb_core_ = this->protocol_proxy_->orb_core (); - this->refcount_lock_ = + this->object_init_lock_ = this->orb_core_->resource_factory ()->create_corba_object_lock (); + this->refcount_ = + this->orb_core_->resource_factory ()->create_corba_object_refcount (); + // Set the collocation marker on the stub. This may not be news to it. // This may also change the stub's object proxy broker. this->protocol_proxy_->is_collocated (collocated); @@ -80,11 +83,14 @@ CORBA::Object::Object (IOP::IOR *ior, , ior_ (ior) , orb_core_ (orb_core) , protocol_proxy_ (0) - , refcount_ (1) - , refcount_lock_ (0) + , refcount_ () + , object_init_lock_ (0) { - this->refcount_lock_ = + this->object_init_lock_ = this->orb_core_->resource_factory ()->create_corba_object_lock (); + + this->refcount_ = + this->orb_core_->resource_factory ()->create_corba_object_refcount (); } // Too lazy to do this check in every method properly! This is useful @@ -92,14 +98,15 @@ CORBA::Object::Object (IOP::IOR *ior, #define TAO_OBJECT_IOR_EVALUATE \ if (!this->is_evaluated_) \ { \ - ACE_GUARD (ACE_Lock , mon, *this->refcount_lock_); \ - CORBA::Object::tao_object_initialize (this); \ + ACE_GUARD (ACE_Lock , mon, *this->object_init_lock_); \ + if (!this->is_evaluated_) \ + CORBA::Object::tao_object_initialize (this); \ } #define TAO_OBJECT_IOR_EVALUATE_RETURN \ if (!this->is_evaluated_) \ { \ - ACE_GUARD_RETURN (ACE_Lock , mon, *this->refcount_lock_, 0); \ + ACE_GUARD_RETURN (ACE_Lock , mon, *this->object_init_lock_, 0); \ if (!this->is_evaluated_) \ CORBA::Object::tao_object_initialize (this); \ } @@ -110,13 +117,7 @@ CORBA::Object::_add_ref (void) if (this->is_local_) return; - ACE_ASSERT (this->refcount_lock_ != 0); - - ACE_GUARD (ACE_Lock , - mon, - *this->refcount_lock_); - - this->refcount_++; + this->refcount_.increment (); } void @@ -125,20 +126,8 @@ CORBA::Object::_remove_ref (void) if (this->is_local_) return; - ACE_ASSERT (this->refcount_lock_ != 0); - - { - ACE_GUARD (ACE_Lock, - mon, - *this->refcount_lock_); - - this->refcount_--; - - if (this->refcount_ != 0) - return; - } - - ACE_ASSERT (this->refcount_ == 0); + if (this->refcount_.decrement () != 0) + return; delete this; } diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h index 39302c41a5a..a10bdb679de 100644 --- a/TAO/tao/Object.h +++ b/TAO/tao/Object.h @@ -32,6 +32,7 @@ #include "tao/Object_Argument_T.h" #include "tao/Arg_Traits_T.h" #include "tao/Any_Insert_Policy_T.h" +#include "tao/Configurable_Refcount.h" #if defined (HPUX) && defined (IOR) /* HP-UX 11.11 defines IOR in /usr/include/pa/inline.h @@ -406,7 +407,7 @@ namespace CORBA TAO_Stub * protocol_proxy_; /// Number of outstanding references to this object. - CORBA::ULong refcount_; + TAO_Configurable_Refcount refcount_; /// Protect reference count manipulation from race conditions. /** @@ -415,7 +416,7 @@ namespace CORBA * not require reference counting (the default) may be * instantiated in the critical path. */ - ACE_Lock * refcount_lock_; + ACE_Lock * object_init_lock_; }; } // End CORBA namespace. diff --git a/TAO/tao/Object.i b/TAO/tao/Object.i index 0db6581b912..e8c1606bb73 100644 --- a/TAO/tao/Object.i +++ b/TAO/tao/Object.i @@ -13,8 +13,8 @@ CORBA::Object::Object (int) ior_ (), orb_core_ (0), protocol_proxy_ (0), - refcount_ (1), - refcount_lock_ (0) + refcount_ (), + object_init_lock_ (0) { } diff --git a/TAO/tao/PortableServer/POA_Current_Impl.cpp b/TAO/tao/PortableServer/POA_Current_Impl.cpp index 1c1e81b55c2..eab3e4d0e4f 100644 --- a/TAO/tao/PortableServer/POA_Current_Impl.cpp +++ b/TAO/tao/PortableServer/POA_Current_Impl.cpp @@ -23,7 +23,7 @@ namespace TAO { POA_Current_Impl::POA_Current_Impl (void) : poa_ (0), - object_id_ (), + object_id_ (TAO_POA_OBJECT_ID_BUF_SIZE, 0, object_id_buf_), object_key_ (0), servant_ (0), priority_ (TAO_INVALID_PRIORITY), diff --git a/TAO/tao/PortableServer/POA_Current_Impl.h b/TAO/tao/PortableServer/POA_Current_Impl.h index 47f2a03994c..c14df79916d 100644 --- a/TAO/tao/PortableServer/POA_Current_Impl.h +++ b/TAO/tao/PortableServer/POA_Current_Impl.h @@ -25,6 +25,10 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL +#ifndef TAO_POA_OBJECT_ID_BUF_SIZE +#define TAO_POA_OBJECT_ID_BUF_SIZE 512 +#endif /* TAO_POA_OBJECT_ID_BUF_SIZE */ + namespace TAO { namespace Portable_Server @@ -146,6 +150,10 @@ namespace TAO /// The POA implementation invoking an upcall ::TAO_Root_POA *poa_; + /// In order to avoid memory allocations, we will populate + /// the object id with this buffer. + CORBA::Octet object_id_buf_[TAO_POA_OBJECT_ID_BUF_SIZE]; + /** * The object ID of the current context. This is the user id and * not the id the goes into the IOR. Note also that unlike the diff --git a/TAO/tao/PortableServer/POA_Current_Impl.inl b/TAO/tao/PortableServer/POA_Current_Impl.inl index db220558ae6..cf3fee49d65 100644 --- a/TAO/tao/PortableServer/POA_Current_Impl.inl +++ b/TAO/tao/PortableServer/POA_Current_Impl.inl @@ -25,7 +25,22 @@ namespace TAO ACE_INLINE void POA_Current_Impl::object_id (const PortableServer::ObjectId &id) { - this->object_id_ = id; + if (this->object_id_.release () || + this->object_id_.get_buffer() == this->object_id_buf_) + { + // Resize the current object_id_. If it is less than the + // length of the current buffer, no allocation will take place. + size_t id_size = id.length (); + this->object_id_.length (id_size); + + // Get the buffer and copy the new object id in it's place. + ACE_OS::memcpy (this->object_id_.get_buffer (), + id.get_buffer (), id_size); + } + else + { + this->object_id_ = id; + } } ACE_INLINE const PortableServer::ObjectId & @@ -38,6 +53,8 @@ namespace TAO POA_Current_Impl::replace_object_id ( const PortableServer::ObjectId &system_id) { + // This has the effect of replacing the underlying buffer + // with that of another object id without copying. object_id_.replace (system_id.maximum (), system_id.length (), const_cast (system_id.get_buffer ()), diff --git a/TAO/tao/PortableServer/Root_POA.cpp b/TAO/tao/PortableServer/Root_POA.cpp index 945aafd7c2b..a1fa33136ac 100644 --- a/TAO/tao/PortableServer/Root_POA.cpp +++ b/TAO/tao/PortableServer/Root_POA.cpp @@ -1776,14 +1776,11 @@ TAO_Root_POA::parse_key (const TAO::ObjectKey &key, CORBA::Boolean &is_system_id, TAO::Portable_Server::Temporary_Creation_Time &poa_creation_time) { - // Start at zero. - CORBA::ULong starting_at = 0; - // Get the object key octets. const CORBA::Octet *key_data = key.get_buffer (); // Skip the object key prefix since we have already checked for this. - starting_at += TAO_OBJECTKEY_PREFIX_SIZE; + CORBA::ULong starting_at = TAO_OBJECTKEY_PREFIX_SIZE; // Check the root indicator. char root_key_type = key_data[starting_at]; diff --git a/TAO/tao/PortableServer/Servant_Upcall.cpp b/TAO/tao/PortableServer/Servant_Upcall.cpp index 2842aec5bcb..9e5ef598e2b 100644 --- a/TAO/tao/PortableServer/Servant_Upcall.cpp +++ b/TAO/tao/PortableServer/Servant_Upcall.cpp @@ -34,7 +34,7 @@ namespace TAO poa_ (0), servant_ (0), state_ (INITIAL_STAGE), - system_id_ (), + system_id_ (TAO_POA_OBJECT_ID_BUF_SIZE, 0, system_id_buf_), user_id_ (0), current_context_ (), #if (TAO_HAS_MINIMUM_POA == 0) diff --git a/TAO/tao/PortableServer/Servant_Upcall.h b/TAO/tao/PortableServer/Servant_Upcall.h index 18818009aab..427934e4faa 100644 --- a/TAO/tao/PortableServer/Servant_Upcall.h +++ b/TAO/tao/PortableServer/Servant_Upcall.h @@ -205,6 +205,7 @@ namespace TAO State state_; + CORBA::Octet system_id_buf_[TAO_POA_OBJECT_ID_BUF_SIZE]; PortableServer::ObjectId system_id_; const PortableServer::ObjectId *user_id_; diff --git a/TAO/tao/Principal.h b/TAO/tao/Principal.h index 3b995e143ca..fbdb6c9df84 100644 --- a/TAO/tao/Principal.h +++ b/TAO/tao/Principal.h @@ -94,7 +94,7 @@ namespace CORBA private: /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; }; } // End CORBA namespace diff --git a/TAO/tao/Profile.cpp b/TAO/tao/Profile.cpp index d0366ce3da0..ef5900c8b6c 100644 --- a/TAO/tao/Profile.cpp +++ b/TAO/tao/Profile.cpp @@ -41,13 +41,9 @@ TAO_Profile::TAO_Profile (CORBA::ULong tag, , tag_ (tag) , orb_core_ (orb_core) , forward_to_ (0) - , refcount_lock_ (0) - , refcount_ (1) + , refcount_ (this->orb_core_-> + client_factory ()->create_profile_refcount ()) { - // @@ NOTE: Need to probably use a different type of lock. - this->refcount_lock_ = - this->orb_core_->client_factory ()->create_profile_lock (); - (void) this->orb_core_->object_key_table ().bind (obj_key, this->ref_object_key_); } @@ -63,12 +59,9 @@ TAO_Profile::TAO_Profile (CORBA::ULong tag, , tag_ (tag) , orb_core_ (orb_core) , forward_to_ (0) - , refcount_lock_ (0) - , refcount_ (1) + , refcount_ (this->orb_core_-> + client_factory ()->create_profile_refcount ()) { - // @@ NOTE: Need to probably use a different type of lock. - this->refcount_lock_ = - this->orb_core_->client_factory ()->create_profile_lock (); } TAO_Profile::~TAO_Profile (void) @@ -79,7 +72,6 @@ TAO_Profile::~TAO_Profile (void) } this->orb_core_->object_key_table ().unbind (this->ref_object_key_); - delete this->refcount_lock_; //@@ TAO_PROFILE_SPL_DESTRUCTOR_ADD_HOOK } @@ -87,22 +79,15 @@ TAO_Profile::~TAO_Profile (void) CORBA::ULong TAO_Profile::_incr_refcnt (void) { - ACE_GUARD_RETURN (ACE_Lock, guard, *this->refcount_lock_, 0); - return ++this->refcount_; + return this->refcount_.increment (); } CORBA::ULong TAO_Profile::_decr_refcnt (void) { - { - ACE_GUARD_RETURN (ACE_Lock, mon, *this->refcount_lock_, 0); - --this->refcount_; - - if (this->refcount_ != 0) - { - return this->refcount_; - } - } + CORBA::ULong count = this->refcount_.decrement (); + if (count != 0) + return count; // refcount is 0, so delete us! // delete will call our ~ destructor which in turn deletes stuff. diff --git a/TAO/tao/Profile.h b/TAO/tao/Profile.h index 5462bd8010d..d9164b8e94c 100644 --- a/TAO/tao/Profile.h +++ b/TAO/tao/Profile.h @@ -24,6 +24,7 @@ #include "tao/GIOP_Message_Version.h" #include "tao/Refcounted_ObjectKey.h" #include "tao/Service_Callbacks.h" +#include "tao/Configurable_Refcount.h" ACE_BEGIN_VERSIONED_NAMESPACE_DECL class ACE_Lock; @@ -375,11 +376,8 @@ private: /// object. TAO_MProfile* forward_to_; - /// Mutex to protect reference count. - ACE_Lock *refcount_lock_; - /// Number of outstanding references to this object. - CORBA::ULong refcount_; + TAO_Configurable_Refcount refcount_; //@@ TAO_PROFILE_SPL_PRIVATE_DATA_ADD_HOOK }; diff --git a/TAO/tao/RTCORBA/Thread_Pool.cpp b/TAO/tao/RTCORBA/Thread_Pool.cpp index f63d8809bb5..32476bbef4b 100644 --- a/TAO/tao/RTCORBA/Thread_Pool.cpp +++ b/TAO/tao/RTCORBA/Thread_Pool.cpp @@ -486,15 +486,16 @@ TAO_Thread_Pool::TAO_Thread_Pool (TAO_Thread_Pool_Manager &manager, ACE_THROW (CORBA::NO_IMPLEMENT ()); // Create one lane. - this->lanes_ = new TAO_Thread_Lane *[this->number_of_lanes_]; - this->lanes_[0] = - new TAO_Thread_Lane (*this, - 0, - default_priority, - static_threads, - dynamic_threads, - dynamic_thread_idle_timeout - ACE_ENV_ARG_PARAMETER); + ACE_NEW (this->lanes_, + TAO_Thread_Lane *[this->number_of_lanes_]); + ACE_NEW (this->lanes_[0], + TAO_Thread_Lane (*this, + 0, + default_priority, + static_threads, + dynamic_threads, + dynamic_thread_idle_timeout + ACE_ENV_ARG_PARAMETER)); } TAO_Thread_Pool::TAO_Thread_Pool (TAO_Thread_Pool_Manager &manager, @@ -525,18 +526,19 @@ TAO_Thread_Pool::TAO_Thread_Pool (TAO_Thread_Pool_Manager &manager, ACE_THROW (CORBA::NO_IMPLEMENT ()); // Create multiple lane. - this->lanes_ = new TAO_Thread_Lane *[this->number_of_lanes_]; + ACE_NEW (this->lanes_, + TAO_Thread_Lane *[this->number_of_lanes_]); for (CORBA::ULong i = 0; i != this->number_of_lanes_; ++i) - this->lanes_[i] = - new TAO_Thread_Lane (*this, - i, - lanes[i].lane_priority, - lanes[i].static_threads, - lanes[i].dynamic_threads, - dynamic_thread_idle_timeout - ACE_ENV_ARG_PARAMETER); + ACE_NEW (this->lanes_[i], + TAO_Thread_Lane (*this, + i, + lanes[i].lane_priority, + lanes[i].static_threads, + lanes[i].dynamic_threads, + dynamic_thread_idle_timeout + ACE_ENV_ARG_PARAMETER)); } void diff --git a/TAO/tao/Resource_Factory.cpp b/TAO/tao/Resource_Factory.cpp index 2f629c3331b..20a72732aa8 100644 --- a/TAO/tao/Resource_Factory.cpp +++ b/TAO/tao/Resource_Factory.cpp @@ -217,6 +217,13 @@ TAO_Resource_Factory::create_corba_object_lock (void) return 0; } +TAO_Configurable_Refcount +TAO_Resource_Factory::create_corba_object_refcount (void) +{ + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_NULL_LOCK); +} + int TAO_Resource_Factory::load_default_protocols (void) { diff --git a/TAO/tao/Resource_Factory.h b/TAO/tao/Resource_Factory.h index 1fae24ea22b..580092f2887 100644 --- a/TAO/tao/Resource_Factory.h +++ b/TAO/tao/Resource_Factory.h @@ -24,6 +24,7 @@ #include "tao/Versioned_Namespace.h" #include "tao/Basic_Types.h" +#include "tao/Configurable_Refcount.h" #include "ace/Service_Object.h" #include "ace/Unbounded_Set.h" @@ -231,6 +232,9 @@ public: /// Creates the lock for the CORBA Object virtual ACE_Lock *create_corba_object_lock (void); + /// Creates the configurable refcount for the CORBA Object + virtual TAO_Configurable_Refcount create_corba_object_refcount (void); + /// Creates the flushing strategy. The new instance is owned by the /// caller. virtual TAO_Flushing_Strategy *create_flushing_strategy (void) = 0; diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index b3e93fbd1d0..b7a03fdeedc 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -354,9 +354,7 @@ TAO_Stub::_incr_refcnt (void) void TAO_Stub::_decr_refcnt (void) { - const CORBA::ULong new_count = --this->refcount_; - - if (new_count == 0) + if (--this->refcount_ == 0) delete this; } diff --git a/TAO/tao/Stub.h b/TAO/tao/Stub.h index d9f8eb671a5..000be6649a4 100644 --- a/TAO/tao/Stub.h +++ b/TAO/tao/Stub.h @@ -384,7 +384,7 @@ protected: CORBA::Boolean profile_success_; /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; /// The policy overrides in this object, if nil then use the default /// policies. diff --git a/TAO/tao/TAO_Server_Request.cpp b/TAO/tao/TAO_Server_Request.cpp index 3b1b8e61d94..d2a06026561 100644 --- a/TAO/tao/TAO_Server_Request.cpp +++ b/TAO/tao/TAO_Server_Request.cpp @@ -54,7 +54,9 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base, TAO_Transport *transport, TAO_ORB_Core *orb_core) : mesg_base_ (mesg_base), - operation_ (), + operation_ (0), + operation_len_ (0), + release_operation_ (false), incoming_ (&input), outgoing_ (&output), // transport already duplicated in @@ -97,7 +99,9 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base, TAO_ORB_Core *orb_core, int &parse_error) : mesg_base_ (mesg_base), - operation_ (operation), + operation_ (CORBA::string_dup (operation)), + operation_len_ (operation == 0 ? 0 : ACE_OS::strlen (operation)), + release_operation_ (true), incoming_ (0), outgoing_ (&output), // transport already duplicated in @@ -133,6 +137,8 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_ORB_Core * orb_core, CORBA::Object_ptr target) : mesg_base_ (0), operation_ (details.opname ()), + operation_len_ (details.opname_len ()), + release_operation_ (false), incoming_ (0), outgoing_ (0), transport_ (0), diff --git a/TAO/tao/TAO_Server_Request.h b/TAO/tao/TAO_Server_Request.h index d2e4d4efde7..f1e065ba020 100644 --- a/TAO/tao/TAO_Server_Request.h +++ b/TAO/tao/TAO_Server_Request.h @@ -279,10 +279,20 @@ public: #endif /* TAO_HAS_INTERCEPTORS == 1 */ private: + /// Default ctor only used to create a TAO_ServerRequest that is about + /// to be the target of a clone operation. + TAO_ServerRequest (void); + TAO_Pluggable_Messaging *mesg_base_; /// Operation name. - ACE_CString operation_; + const char* operation_; + + /// Operation length. + size_t operation_len_; + + /// Do we own the memory associated with operation_? + bool release_operation_; CORBA::Object_var forward_location_; diff --git a/TAO/tao/TAO_Server_Request.i b/TAO/tao/TAO_Server_Request.i index 5fc7f50ab9b..34d7096e65d 100644 --- a/TAO/tao/TAO_Server_Request.i +++ b/TAO/tao/TAO_Server_Request.i @@ -2,8 +2,44 @@ // // $Id$ +#include "tao/GIOP_Utils.h" + TAO_BEGIN_VERSIONED_NAMESPACE_DECL +// This constructor is used by the CSD clone. +ACE_INLINE +TAO_ServerRequest::TAO_ServerRequest (void) + : mesg_base_ (0), + operation_ (0), + operation_len_ (0), + release_operation_ (false), + incoming_ (0), + outgoing_ (0), + transport_(0), + response_expected_ (false), + deferred_reply_ (false), + sync_with_server_ (false), + is_dsi_ (false), + exception_type_ (TAO_GIOP_NO_EXCEPTION), + orb_core_ (0), + request_id_ (0), + profile_ (0), + requesting_principal_ (0), + dsi_nvlist_align_ (0), + operation_details_ (0), + argument_flag_ (1) +#if TAO_HAS_INTERCEPTORS == 1 + , interceptor_count_ (0) + , rs_pi_current_ () + , result_seq_ (0) + , caught_exception_ (0) + , reply_status_ (-1) +#endif /* TAO_HAS_INTERCEPTORS == 1 */ +{ + if (this->release_operation_) + CORBA::string_free (const_cast (this->operation_)); +} + ACE_INLINE TAO_ORB_Core * TAO_ServerRequest::orb_core (void) const { @@ -25,7 +61,7 @@ TAO_ServerRequest::outgoing (void) const ACE_INLINE const char * TAO_ServerRequest::operation (void) const { - return this->operation_.c_str (); + return (this->operation_ == 0 ? "" : this->operation_); } ACE_INLINE void @@ -33,20 +69,18 @@ TAO_ServerRequest::operation (const char *operation, size_t length, int release) { - if (length == 0) - { - this->operation_.set (operation, release); - } - else - { - this->operation_.set (operation, length, release); - } + if (this->release_operation_) + CORBA::string_free (const_cast (this->operation_)); + + this->operation_len_ = (length == 0 ? ACE_OS::strlen (operation) : length); + this->release_operation_ = release; + this->operation_ = operation; } ACE_INLINE size_t TAO_ServerRequest::operation_length (void) const { - return this->operation_.length (); + return this->operation_len_; } ACE_INLINE CORBA::Boolean diff --git a/TAO/tao/TAO_Singleton_Manager.cpp b/TAO/tao/TAO_Singleton_Manager.cpp index 658c2bdff74..4438d66db11 100644 --- a/TAO/tao/TAO_Singleton_Manager.cpp +++ b/TAO/tao/TAO_Singleton_Manager.cpp @@ -63,12 +63,16 @@ TAO_Singleton_Manager::TAO_Singleton_Manager (void) exit_info_ (), registered_with_object_manager_ (-1) #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - , internal_lock_ (new TAO_SYNCH_RECURSIVE_MUTEX) + , internal_lock_ (0) # endif /* ACE_MT_SAFE */ #if defined (ACE_HAS_EXCEPTIONS) , old_unexpected_ (0) #endif /* ACE_HAS_EXCEPTIONS */ { +#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) + ACE_NEW (this->internal_lock_, + TAO_SYNCH_RECURSIVE_MUTEX); +# endif /* ACE_MT_SAFE */ // Be sure that no further instances are created via instance (). if (the_instance == 0) { diff --git a/TAO/tao/Tagged_Profile.cpp b/TAO/tao/Tagged_Profile.cpp index e5bed686c15..b3886f8150b 100644 --- a/TAO/tao/Tagged_Profile.cpp +++ b/TAO/tao/Tagged_Profile.cpp @@ -174,9 +174,8 @@ TAO_Tagged_Profile::unmarshall_ref_addr_i ( if (hdr_status) { - // Set the type_id - this->type_id_.set (input.rd_ptr (), - 0); + // Set the type_id (it is not owned by this object) + this->type_id_ = input.rd_ptr (); input.skip_bytes (id_length); } diff --git a/TAO/tao/Tagged_Profile.h b/TAO/tao/Tagged_Profile.h index 541cb4362a4..3900de617c1 100644 --- a/TAO/tao/Tagged_Profile.h +++ b/TAO/tao/Tagged_Profile.h @@ -79,7 +79,7 @@ public: /// Accessor to the type_id contained in the IOP::IOR received from /// the client. - const ACE_CString &type_id (void) const; + const char* type_id (void) const; CORBA::Short discriminator (void) const; @@ -141,7 +141,7 @@ private: /// The type_id in the IOP::IOR in case we receive the /// GIOP::IORAddressingInfo information. - ACE_CString type_id_; + const char* type_id_; }; TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/Tagged_Profile.i b/TAO/tao/Tagged_Profile.i index 60249f0ef37..688bcd6a0ba 100644 --- a/TAO/tao/Tagged_Profile.i +++ b/TAO/tao/Tagged_Profile.i @@ -11,7 +11,7 @@ TAO_Tagged_Profile::TAO_Tagged_Profile (TAO_ORB_Core *orb_core) object_key_ (), profile_ (), profile_index_ (0), - type_id_ () + type_id_ (0) { } @@ -52,10 +52,10 @@ TAO_Tagged_Profile::profile_index (void) const return this->profile_index_; } -ACE_INLINE const ACE_CString & +ACE_INLINE const char* TAO_Tagged_Profile::type_id (void) const { - return this->type_id_; + return this->type_id_ == 0 ? "" : this->type_id_; } ACE_INLINE CORBA::Short diff --git a/TAO/tao/Valuetype/ValueBase.h b/TAO/tao/Valuetype/ValueBase.h index 413b0a62801..6918787b738 100644 --- a/TAO/tao/Valuetype/ValueBase.h +++ b/TAO/tao/Valuetype/ValueBase.h @@ -287,7 +287,7 @@ namespace CORBA private: // data /// Reference counter. - ACE_Atomic_Op refcount_; + ACE_Atomic_Op refcount_; }; // DefaultValueRefCountBase // which lock has the lowest memory overhead ? diff --git a/TAO/tao/Var_Size_Argument_T.cpp b/TAO/tao/Var_Size_Argument_T.cpp index 570c37ceb20..a185d49ed28 100644 --- a/TAO/tao/Var_Size_Argument_T.cpp +++ b/TAO/tao/Var_Size_Argument_T.cpp @@ -78,7 +78,11 @@ TAO::Out_Var_Size_Argument_T::demarshal ( TAO_InputCDR & cdr ) { +#if defined (ACE_HAS_NEW_NOTHROW) + this->x_ = new (ACE_nothrow) S; +#else this->x_ = new S; +#endif /* ACE_HAS_NEW_NOTHROW */ return cdr >> *this->x_; } diff --git a/TAO/tao/default_client.cpp b/TAO/tao/default_client.cpp index 6076024c440..b2c7aad11c5 100644 --- a/TAO/tao/default_client.cpp +++ b/TAO/tao/default_client.cpp @@ -106,8 +106,8 @@ TAO_Default_Client_Strategy_Factory::parse_args (int argc, ACE_TCHAR* argv[]) else if (ACE_OS::strcasecmp (name, ACE_TEXT("null")) == 0) this->profile_lock_type_ = TAO_NULL_LOCK; - else - this->report_option_value_error (ACE_TEXT("-ORBIIOPProfileLock"), name); + else + this->report_option_value_error (ACE_TEXT("-ORBIIOPProfileLock"), name); } } @@ -218,7 +218,7 @@ TAO_Default_Client_Strategy_Factory::parse_args (int argc, ACE_TCHAR* argv[]) else if (ACE_OS::strcmp (name, ACE_TEXT("1")) == 0 || ACE_OS::strcasecmp (name, ACE_TEXT("true")) == 0) this->use_cleanup_options_ = true; - else + else this->report_option_value_error (ACE_TEXT("-ORBConnectionHandlerCleanup"), name); } } @@ -261,6 +261,21 @@ TAO_Default_Client_Strategy_Factory::create_profile_lock (void) return the_lock; } +TAO_Configurable_Refcount +TAO_Default_Client_Strategy_Factory::create_profile_refcount (void) +{ + switch (this->profile_lock_type_) + { + case TAO_NULL_LOCK: + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_NULL_LOCK); + case TAO_THREAD_LOCK: + default: + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_THREAD_LOCK); + } +} + // Create the correct client transport muxing strategy. TAO_Transport_Mux_Strategy * TAO_Default_Client_Strategy_Factory::create_transport_mux_strategy (TAO_Transport *transport) diff --git a/TAO/tao/default_client.h b/TAO/tao/default_client.h index e1660fb2041..3fd00513949 100644 --- a/TAO/tao/default_client.h +++ b/TAO/tao/default_client.h @@ -54,6 +54,7 @@ public: // = Check Client_Strategy_Factory.h for the documentation of the // following methods. virtual ACE_Lock* create_profile_lock (void); + virtual TAO_Configurable_Refcount create_profile_refcount (void); virtual TAO_Transport_Mux_Strategy *create_transport_mux_strategy (TAO_Transport *transport); virtual ACE_Lock *create_transport_mux_strategy_lock (void); virtual int reply_dispatcher_table_size (void) const; diff --git a/TAO/tao/default_resource.cpp b/TAO/tao/default_resource.cpp index 988b98a3f6d..86385720c98 100644 --- a/TAO/tao/default_resource.cpp +++ b/TAO/tao/default_resource.cpp @@ -565,8 +565,9 @@ TAO_Default_Resource_Factory::get_parser_names (char **&names, // OK fallback on the hardcoded ones.... this->parser_names_count_ = 5; // HOW MANY DO WE HAVE? - this->parser_names_ = - new char *[this->parser_names_count_]; + ACE_NEW_RETURN (this->parser_names_, + char *[this->parser_names_count_], + -1); CORBA::ULong index = 0; @@ -1109,6 +1110,21 @@ TAO_Default_Resource_Factory::create_corba_object_lock (void) return the_lock; } +TAO_Configurable_Refcount +TAO_Default_Resource_Factory::create_corba_object_refcount (void) +{ + switch (this->corba_object_lock_type_) + { + case TAO_NULL_LOCK: + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_NULL_LOCK); + case TAO_THREAD_LOCK: + default: + return TAO_Configurable_Refcount ( + TAO_Configurable_Refcount::TAO_THREAD_LOCK); + } +} + TAO_Flushing_Strategy * TAO_Default_Resource_Factory::create_flushing_strategy (void) { diff --git a/TAO/tao/default_resource.h b/TAO/tao/default_resource.h index 9cf29b89be8..924364b681c 100644 --- a/TAO/tao/default_resource.h +++ b/TAO/tao/default_resource.h @@ -130,6 +130,7 @@ public: virtual int max_muxed_connections (void) const; virtual ACE_Lock *create_cached_connection_lock (void); virtual ACE_Lock *create_object_key_table_lock (void); + virtual TAO_Configurable_Refcount create_corba_object_refcount (void); virtual ACE_Lock *create_corba_object_lock (void); virtual int locked_transport_cache (void); virtual TAO_Flushing_Strategy *create_flushing_strategy (void); diff --git a/TAO/tao/tao.mpc b/TAO/tao/tao.mpc index 6b959947cc3..7aa50efaa6a 100644 --- a/TAO/tao/tao.mpc +++ b/TAO/tao/tao.mpc @@ -34,6 +34,7 @@ project(TAO) : acelib, core, tao_output, taodefaults, pidl, extra_core, tao_vers Collocated_Invocation.cpp Collocation_Proxy_Broker.cpp Collocation_Resolver.cpp + Configurable_Refcount.cpp Connect_Strategy.cpp Connection_Handler.cpp Connection_Purging_Strategy.cpp -- cgit v1.2.1