From ed3a3495d2942ef98f3f003c4eee39101f60953b Mon Sep 17 00:00:00 2001 From: venkita Date: Sun, 29 Jun 2003 13:41:09 +0000 Subject: *** empty log message *** --- TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qos.pidl | 45 + TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.cpp | 647 ++++++ TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.h | 350 +++ TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.i | 559 +++++ .../fp_example/FP_Scheduler.cpp | 622 +++++ .../fp_example/FP_Scheduler.h | 167 ++ .../fp_example/FP_Scheduling.idl | 24 + .../fp_example/Kokyu_qosC.cpp | 647 ++++++ .../Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.h | 350 +++ .../Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.i | 559 +++++ .../Kokyu_dsrt_schedulers/fp_example/Makefile | 2384 +++++++++++++++++++ .../Kokyu_dsrt_schedulers/fp_example/client.cpp | 271 +++ .../Kokyu_dsrt_schedulers/fp_example/client.dsp | 196 ++ .../Kokyu_dsrt_schedulers/fp_example/server.cpp | 212 ++ .../Kokyu_dsrt_schedulers/fp_example/server.dsp | 208 ++ .../Kokyu_dsrt_schedulers/fp_example/test.idl | 10 + .../Kokyu_dsrt_schedulers/fp_example/test_i.cpp | 69 + .../Kokyu_dsrt_schedulers/fp_example/test_i.h | 49 + .../Kokyu_dsrt_schedulers/fp_example/test_i.i | 7 + .../mif_example/Kokyu_qosC.cpp | 647 ++++++ .../Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.h | 350 +++ .../Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.i | 559 +++++ .../mif_example/MIF_Scheduler.cpp | 604 +++++ .../mif_example/MIF_Scheduler.h | 158 ++ .../mif_example/MIF_Scheduling.idl | 24 + .../Kokyu_dsrt_schedulers/mif_example/Makefile | 2441 ++++++++++++++++++++ .../Kokyu_dsrt_schedulers/mif_example/client.cpp | 270 +++ .../Kokyu_dsrt_schedulers/mif_example/client.dsp | 196 ++ .../Kokyu_dsrt_schedulers/mif_example/server.cpp | 213 ++ .../Kokyu_dsrt_schedulers/mif_example/server.dsp | 208 ++ .../Kokyu_dsrt_schedulers/mif_example/test.idl | 10 + .../Kokyu_dsrt_schedulers/mif_example/test_i.cpp | 69 + .../Kokyu_dsrt_schedulers/mif_example/test_i.h | 49 + .../Kokyu_dsrt_schedulers/mif_example/test_i.i | 7 + .../muf_example/Kokyu_qosC.cpp | 647 ++++++ .../Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.h | 350 +++ .../Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.i | 559 +++++ .../muf_example/MUF_Scheduler.cpp | 656 ++++++ .../muf_example/MUF_Scheduler.h | 161 ++ .../muf_example/MUF_Scheduling.idl | 26 + 40 files changed, 15580 insertions(+) create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qos.pidl create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduling.idl create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/Makefile create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.dsp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.dsp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/test.idl create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduling.idl create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/Makefile create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.dsp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.dsp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/test.idl create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduling.idl diff --git a/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qos.pidl b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qos.pidl new file mode 100644 index 00000000000..de63ae70e9a --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qos.pidl @@ -0,0 +1,45 @@ + +/** + * @file Kokyu_qos.pidl + * + * $Id$ + * + * @brief Pre-compiled IDL source to help with the service context + * propagation of dynamic scheduling parameters using Kokyu + * + * This file was used to generate the code in Kokyu_qosC.{h,i,cpp}. + * The steps to regenerate the code are as follows: + * + * 1. Run the tao_idl compiler on the pidl file. The command used for + * this is: + * + * tao_idl -I $TAO_ROOT -Ge 1 Kokyu_qos.pidl + * + */ + +#ifndef _KOKYU_DSRT_QOS_PIDL_ +#define _KOKYU_DSRT_QOS_PIDL_ + +#include +#include +#include +#include + +#pragma prefix "omg.org" + +module Kokyu +{ + typedef sequence GuidType; + + struct Svc_Ctxt_DSRT_QoS + { + GuidType guid; + long importance; + long criticality; + RTCORBA::Priority desired_priority; + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + }; +}; + +#endif /* KOKYU_DSRT_QOS_PIDL */ diff --git a/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.cpp new file mode 100644 index 00000000000..cc9bc66c9ce --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.cpp @@ -0,0 +1,647 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:318 + + +#include "Kokyu_qosC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* !defined INLINE */ + +#if !defined (_KOKYU_GUIDTYPE_CS_) +#define _KOKYU_GUIDTYPE_CS_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_cs.cpp:250 + +// ************************************************************* +// Kokyu::GuidType +// ************************************************************* + +Kokyu::GuidType::GuidType (void) +{} + +Kokyu::GuidType::GuidType (CORBA::ULong max) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} + +Kokyu::GuidType::GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release + ) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} + +Kokyu::GuidType::GuidType (const GuidType &seq) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} + +Kokyu::GuidType::~GuidType (void) // dtor +{} + +void Kokyu::GuidType::_tao_any_destructor (void *_tao_void_pointer) +{ + GuidType *tmp = ACE_static_cast (GuidType*, _tao_void_pointer); + delete tmp; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_GuidType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_GuidType ( + CORBA::tk_alias, + sizeof (_oc_Kokyu_GuidType), + (char *) &_oc_Kokyu_GuidType, + 0, + sizeof (Kokyu::GuidType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_GuidType, + &_tc_TAO_tc_Kokyu_GuidType + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_Svc_Ctxt_DSRT_QoS[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f5376), + ACE_NTOHL (0x635f4374), + ACE_NTOHL (0x78745f44), + ACE_NTOHL (0x5352545f), + ACE_NTOHL (0x516f533a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/Kokyu/Svc_Ctxt_DSRT_QoS:1.0 + 18, + ACE_NTOHL (0x5376635f), + ACE_NTOHL (0x43747874), + ACE_NTOHL (0x5f445352), + ACE_NTOHL (0x545f516f), + ACE_NTOHL (0x53000000), // name = Svc_Ctxt_DSRT_QoS + 6, // member count + 5, + ACE_NTOHL (0x67756964), + ACE_NTOHL (0x0), // name = guid + CORBA::tk_alias, // typecode kind for typedefs + 76, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + + + 11, + ACE_NTOHL (0x696d706f), + ACE_NTOHL (0x7274616e), + ACE_NTOHL (0x63650000), // name = importance + CORBA::tk_long, + + 12, + ACE_NTOHL (0x63726974), + ACE_NTOHL (0x6963616c), + ACE_NTOHL (0x69747900), // name = criticality + CORBA::tk_long, + + 17, + ACE_NTOHL (0x64657369), + ACE_NTOHL (0x7265645f), + ACE_NTOHL (0x7072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = desired_priority + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/RTCORBA/Priority:1.0 + 9, + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = Priority + CORBA::tk_short, + + + 9, + ACE_NTOHL (0x64656164), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = deadline + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 33, + ACE_NTOHL (0x65737469), + ACE_NTOHL (0x6d617465), + ACE_NTOHL (0x645f696e), + ACE_NTOHL (0x69746961), + ACE_NTOHL (0x6c5f6578), + ACE_NTOHL (0x65637574), + ACE_NTOHL (0x696f6e5f), + ACE_NTOHL (0x74696d65), + ACE_NTOHL (0x0), // name = estimated_initial_execution_time + 0xffffffff, // indirection + 0xffffff94, // negative offset (-108) +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS ( + CORBA::tk_struct, + sizeof (_oc_Kokyu_Svc_Ctxt_DSRT_QoS), + (char *) &_oc_Kokyu_Svc_Ctxt_DSRT_QoS, + 0, + sizeof (Kokyu::Svc_Ctxt_DSRT_QoS) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Svc_Ctxt_DSRT_QoS, + &_tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:67 + +void Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor (void *_tao_void_pointer) +{ + Svc_Ctxt_DSRT_QoS *tmp = ACE_static_cast (Svc_Ctxt_DSRT_QoS*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::GuidType &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::GuidType *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::GuidType::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::GuidType *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast( + const Kokyu::GuidType*&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::GuidType *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_GuidType + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (!result) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const Kokyu::GuidType*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::GuidType *tmp = 0; + ACE_NEW_RETURN ( + tmp, + Kokyu::GuidType, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_GuidType, + 1, + ACE_static_cast (void *, tmp), + Kokyu::GuidType::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (result == 0) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::Svc_Ctxt_DSRT_QoS *tmp; + ACE_NEW_RETURN ( + tmp, + Kokyu::Svc_Ctxt_DSRT_QoS, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + 1, + ACE_static_cast (void *, tmp), + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_cs.cpp:103 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast (TAO_Unbounded_Sequence*, (Kokyu::GuidType *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return 0; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return 1; + } + + // Retrieve all the elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + if (ACE_BIT_DISABLED (strm.start ()->flags (), + ACE_Message_Block::DONT_DELETE)) + { + TAO_ORB_Core* orb_core = strm.orb_core (); + if (orb_core != 0 && + strm.orb_core ()->resource_factory ()-> + input_cdr_allocator_type_locked () == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + } + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.h b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.h new file mode 100644 index 00000000000..5c1ad4e62c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.h @@ -0,0 +1,350 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_KOKYU_QOSC_H_ +#define _TAO_IDL_KOKYU_QOSC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "RTSchedulerC.h" +#include "RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE Kokyu +{ + +#if !defined (_KOKYU_GUIDTYPE_CH_) +#define _KOKYU_GUIDTYPE_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:371 + + class GuidType; + class GuidType_var; + + // ************************************************************* + // Kokyu::GuidType + // ************************************************************* + + class GuidType : public + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:51 + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + GuidType (void); + GuidType (CORBA::ULong max); + GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release = 0 + ); + GuidType (const GuidType &); + ~GuidType (void); + + static void _tao_any_destructor (void*); + + typedef GuidType_var _var_type; +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + GuidType ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___VAR_CH_) +#define _KOKYU_GUIDTYPE___VAR_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:549 + + // ************************************************************* + // class Kokyu::GuidType_var + // ************************************************************* + + class GuidType_var + { + public: + GuidType_var (void); + GuidType_var (GuidType *); + GuidType_var (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var (const GuidType &); + + ~GuidType_var (void); + + GuidType_var &operator= (GuidType *); + GuidType_var &operator= (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var &operator= (const GuidType &); + + GuidType *operator-> (void); + const GuidType *operator-> (void) const; + + operator const GuidType &() const; + operator GuidType &(); + operator GuidType &() const; + CORBA::Octet & operator[] (CORBA::ULong index); + const CORBA::Octet & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const GuidType &in (void) const; + GuidType &inout (void); + GuidType *&out (void); + GuidType *_retn (void); + GuidType *ptr (void) const; + + private: + GuidType *ptr_; + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___OUT_CH_) +#define _KOKYU_GUIDTYPE___OUT_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:753 + + class GuidType_out + { + public: + GuidType_out (GuidType *&); + GuidType_out (GuidType_var &); + GuidType_out (const GuidType_out &); + GuidType_out &operator= (const GuidType_out &); + GuidType_out &operator= (GuidType *); + operator GuidType *&(); + GuidType *&ptr (void); + GuidType *operator-> (void); + CORBA::Octet & operator[] (CORBA::ULong index); + + private: + GuidType *&ptr_; + // Assignment from T_var not allowed. + void operator= (const GuidType_var &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_GuidType; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:49 + + class Svc_Ctxt_DSRT_QoS_var; + + struct Svc_Ctxt_DSRT_QoS + { + typedef Svc_Ctxt_DSRT_QoS_var _var_type; + + static void _tao_any_destructor (void *); + Kokyu::GuidType guid; + CORBA::Long importance; + CORBA::Long criticality; + RTCORBA::Priority desired_priority; + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:71 + + class Svc_Ctxt_DSRT_QoS_var + { + public: + Svc_Ctxt_DSRT_QoS_var (void); + Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var (const Svc_Ctxt_DSRT_QoS_var &); + ~Svc_Ctxt_DSRT_QoS_var (void); + + Svc_Ctxt_DSRT_QoS_var &operator= (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var &operator= (const Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS *operator-> (void); + const Svc_Ctxt_DSRT_QoS *operator-> (void) const; + + operator const Svc_Ctxt_DSRT_QoS &() const; + operator Svc_Ctxt_DSRT_QoS &(); + operator Svc_Ctxt_DSRT_QoS &() const; + + // Variable-size types only. + operator Svc_Ctxt_DSRT_QoS *&(); + + // in, inout, out, _retn + const Svc_Ctxt_DSRT_QoS &in (void) const; + Svc_Ctxt_DSRT_QoS &inout (void); + Svc_Ctxt_DSRT_QoS *&out (void); + Svc_Ctxt_DSRT_QoS *_retn (void); + Svc_Ctxt_DSRT_QoS *ptr (void) const; + + private: + Svc_Ctxt_DSRT_QoS *ptr_; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:445 + + class Svc_Ctxt_DSRT_QoS_out + { + public: + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS *&); + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS_out (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (Svc_Ctxt_DSRT_QoS *); + operator Svc_Ctxt_DSRT_QoS *&(); + Svc_Ctxt_DSRT_QoS *&ptr (void); + Svc_Ctxt_DSRT_QoS *operator-> (void); + + private: + Svc_Ctxt_DSRT_QoS *&ptr_; + // Assignment from T_var not allowed. + void operator= (const Svc_Ctxt_DSRT_QoS_var &); + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Svc_Ctxt_DSRT_QoS; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module Kokyu + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::GuidType &); // copying version + void operator<<= (CORBA::Any &, Kokyu::GuidType*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::GuidType *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::GuidType *&); + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS &); // copying version + void operator<<= (CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS *&); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ch.cpp:57 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_H_ +#define _TAO_CDR_OP_Kokyu_GuidType_H_ + + CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_H_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:54 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const Kokyu::Svc_Ctxt_DSRT_QoS &); + CORBA::Boolean operator>> (TAO_InputCDR &, Kokyu::Svc_Ctxt_DSRT_QoS &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1004 + +#if defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.i b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.i new file mode 100644 index 00000000000..56edaae1cd6 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/Kokyu_qosC.i @@ -0,0 +1,559 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +#if !defined (_KOKYU_GUIDTYPE_CI_) +#define _KOKYU_GUIDTYPE_CI_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:226 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_var +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (GuidType *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::GuidType (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +// Fixed-size base types only. +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType &p) +{ + ACE_NEW (this->ptr_, ::Kokyu::GuidType (p)); +} + +ACE_INLINE +Kokyu::GuidType_var::~GuidType_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (GuidType *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + GuidType *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + GuidType (*p.ptr_), + *this + ); + + if (deep_copy != 0) + { + GuidType *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// Fixed-size types only. +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::Kokyu::GuidType (p), *this); + } + + return *this; +} + +ACE_INLINE +const ::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator const ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE +const CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index)); +} + +ACE_INLINE +const ::Kokyu::GuidType & +Kokyu::GuidType_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType & +Kokyu::GuidType_var::inout (void) +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::_retn (void) +{ + ::Kokyu::GuidType *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:567 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_out +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (const ::Kokyu::GuidType_out &p) + : ptr_ (ACE_const_cast (GuidType_out&, p).ptr_) +{} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (const ::Kokyu::GuidType_out &p) +{ + this->ptr_ = ACE_const_cast (GuidType_out&, p).ptr_; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (GuidType *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +Kokyu::GuidType_out::operator ::Kokyu::GuidType *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_structure.cpp:194 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_var +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::Svc_Ctxt_DSRT_QoS (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::~Svc_Ctxt_DSRT_QoS_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_var) +{ + delete this->ptr_; + this->ptr_ = _tao_struct_var; + return *this; +} + +ACE_INLINE +::Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &_tao_struct_var) +{ + if (this != &_tao_struct_var) + { + if (_tao_struct_var.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + Svc_Ctxt_DSRT_QoS *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + Svc_Ctxt_DSRT_QoS (*_tao_struct_var.ptr_), + *this + ); + + if (deep_copy != 0) + { + Svc_Ctxt_DSRT_QoS *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator const ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +// Variable-size types only. +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::inout (void) +{ + return *this->ptr_; +} + +// Mapping for variable size. +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::_retn (void) +{ + ::Kokyu::Svc_Ctxt_DSRT_QoS *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_structure.cpp:523 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_out +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (::Kokyu::Svc_Ctxt_DSRT_QoS *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) + : ptr_ (ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) +{ + this->ptr_ = ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_out) +{ + this->ptr_ = _tao_struct_out; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator-> (void) +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ci.cpp:84 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_I_ +#define _TAO_CDR_OP_Kokyu_GuidType_I_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_I_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:71 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm << _tao_aggregate.guid) && + (strm << _tao_aggregate.importance) && + (strm << _tao_aggregate.criticality) && + (strm << _tao_aggregate.desired_priority) && + (strm << _tao_aggregate.deadline) && + (strm << _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm >> _tao_aggregate.guid) && + (strm >> _tao_aggregate.importance) && + (strm >> _tao_aggregate.criticality) && + (strm >> _tao_aggregate.desired_priority) && + (strm >> _tao_aggregate.deadline) && + (strm >> _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.cpp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.cpp new file mode 100644 index 00000000000..dd21764b73b --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.cpp @@ -0,0 +1,622 @@ +//$Id$ + +#include "FP_Scheduler.h" +#include "ace/Atomic_Op.h" +#include "Kokyu_qosC.h" + +//this needs to be formally defined in IOP.pidl +namespace +{ + static const IOP::ServiceId service_id = 0xdddd; +} + +void guid_copy( Kokyu::GuidType& lhs, const RTScheduling::Current::IdType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +void guid_copy( RTScheduling::Current::IdType& lhs, const Kokyu::GuidType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +ACE_Atomic_Op server_guid_counter; + +FP_Scheduling::SegmentSchedulingParameter +FP_Segment_Sched_Param_Policy::value ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + return value_; +} + +void +FP_Segment_Sched_Param_Policy::value ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + value_ = value; +} + +Fixed_Priority_Scheduler::Fixed_Priority_Scheduler (CORBA::ORB_ptr orb) + : orb_ (orb) +{ + Kokyu::DSRT_ConfigInfo config; + + config.sched_strategy_ = Kokyu::DSRT_FP; + kokyu_dispatcher_ = Kokyu::Dispatcher_Factory::create_DSRT_dispatcher (config); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + this->current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + IOP::CodecFactory_var codec_factory; + CORBA::Object_var obj = orb->resolve_initial_references ("CodecFactory"); + + if (CORBA::is_nil(obj.in ())) + { + ACE_ERROR ((LM_ERROR, "Nil Codec factory\n")); + } + else + { + codec_factory = IOP::CodecFactory::_narrow (obj.in ()); + } + + IOP::Encoding encoding; + encoding.format = IOP::ENCODING_CDR_ENCAPS; + encoding.major_version = 1; + encoding.minor_version = 2; + + codec_ = codec_factory->create_codec (encoding); +} + +Fixed_Priority_Scheduler::~Fixed_Priority_Scheduler (void) +{ +} + +void +Fixed_Priority_Scheduler::shutdown (void) +{ + kokyu_dispatcher_->shutdown (); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +Fixed_Priority_Scheduler::create_segment_scheduling_parameter ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr segment_policy; + ACE_NEW_THROW_EX (segment_policy, + FP_Segment_Sched_Param_Policy, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + + segment_policy->value (value); + + return segment_policy; +} + + +void +Fixed_Priority_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char *, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + Kokyu::DSRT_QoSDescriptor qos; + FP_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_policy = + FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + FP_Scheduling::SegmentSchedulingParameter sched_param = sched_param_policy->value (); + RTCORBA::Priority desired_priority = sched_param.base_priority; + qos.priority_ = desired_priority; + kokyu_dispatcher_->schedule (count, qos); +} + +void +Fixed_Priority_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +void +Fixed_Priority_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char */*name*/, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr /*implicit_sched_param*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count ; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + FP_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_policy = + FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + FP_Scheduling::SegmentSchedulingParameter sched_param = + sched_param_policy->value (); + + RTCORBA::Priority desired_priority = sched_param.base_priority; + + Kokyu::DSRT_QoSDescriptor qos; + qos.priority_ = desired_priority; + + kokyu_dispatcher_->update_schedule (count, qos); +} + +void +Fixed_Priority_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char * + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int count; + ACE_OS::memcpy (&count, + guid.get_buffer (), + guid.length ()); + + + ACE_DEBUG ((LM_DEBUG, "(%t) call to end_sched_segment for guid %d\n", count)); + kokyu_dispatcher_->cancel_schedule (count); +} + +void +Fixed_Priority_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + +} + + +void +Fixed_Priority_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_request " + "from \"%s\"\n", + operation.in ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + RTCORBA::Priority desired_priority; + if (CORBA::is_nil (sched_policy)) + { + desired_priority = 0; + } + else + { + FP_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_policy = + FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + FP_Scheduling::SegmentSchedulingParameter sched_param = + sched_param_policy->value (); + + desired_priority = sched_param.base_priority; + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request desired_priority from current = %d\n"), + desired_priority)); + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + + //Fill the guid in the SC Qos struct + sc_qos.guid.length (this->current_->id ()->length ()); + //sc_qos.guid = *(this->current_->id ()); + guid_copy (sc_qos.guid, *(this->current_->id ())); + sc_qos.desired_priority = desired_priority; + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + ACE_TRY_NEW_ENV + { + sc.context_data = + ACE_reinterpret_cast(IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + } + ACE_ENDTRY; + + + ACE_DEBUG ((LM_DEBUG, "after encode\n")); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to add sched SC\n"))); + + // Add this context to the service context list. + ri->add_request_service_context (sc, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to call scheduler to inform block\n") + )); + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): guid = %d, send_request interceptor done\n"), + guid)); +} + +void +Fixed_Priority_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid_out, + CORBA::String_out /*name*/, + CORBA::Policy_out sched_param_out, + CORBA::Policy_out /*implicit_sched_param_out*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + ACE_DEBUG ((LM_DEBUG, "entered Fixed_Priority_Scheduler::receive_request\n")); + RTScheduling::Current::IdType* guid; + ACE_NEW (guid, + RTScheduling::Current::IdType); + + + // Generate GUID. + guid->length (sizeof(long)); + + long temp = ++server_guid_counter; + ACE_OS::memcpy (guid->get_buffer (), + &temp, + sizeof(long)); + + int id; + ACE_OS::memcpy (&id, + guid->get_buffer (), + guid->length ()); + + guid_out.ptr () = guid; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): receive_request from " + "\"%s\"\n", + operation.in ())); + + // Ignore the "_is_a" operation since it may have been invoked + // locally on the server side as a side effect of another call, + // meaning that the client hasn't added the service context yet. + if (ACE_OS_String::strcmp ("_is_a", operation.in ()) == 0) + return; + + IOP::ServiceContext_var sc = + ri->get_request_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + RTCORBA::Priority desired_priority; + + if (sc.ptr () == 0) + { + desired_priority = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + desired_priority = sc_qos_ptr->desired_priority; + //*(guid_out.ptr ()) = sc_qos_ptr->guid; + guid_copy (*(guid_out.ptr ()), sc_qos_ptr->guid); + + + ACE_OS::memcpy (&id, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Desired_Priority = %d, guid = %d in recvd service context\n", + desired_priority, + id)); + + FP_Scheduling::SegmentSchedulingParameter sched_param; + sched_param.base_priority = desired_priority; + sched_param_out.ptr () = this->create_segment_scheduling_parameter (sched_param); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.priority_ = desired_priority; + this->kokyu_dispatcher_->schedule (id, qos); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, receive_request interceptor done\n", id)); +} + +void +Fixed_Priority_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + RTCORBA::Priority desired_priority = 0; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_reply from \"%s\"\n", + ri->operation ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + ACE_DEBUG ((LM_DEBUG, "in send_reply: before accessing current_->sched_param\n")); + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + ACE_DEBUG ((LM_DEBUG, "in send_reply: after accessing current_->sched_param\n")); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + if (CORBA::is_nil (sched_policy)) + { + ACE_DEBUG ((LM_DEBUG, "sched_policy nil. desired_priority not set in sched params\n")); + desired_priority = 0; + } + else + { + ACE_DEBUG ((LM_DEBUG, "sched_policy not nil. desired_priority set in sched params\n")); + + FP_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_policy = + FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + FP_Scheduling::SegmentSchedulingParameter sched_param = + sched_param_policy->value (); + + desired_priority = sched_param.base_priority; + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + //Fill the guid in the SC Qos struct + //sc_qos.guid = *(this->current_->id ()); + guid_copy ( sc_qos.guid, *(this->current_->id ())); + sc_qos.desired_priority = desired_priority; + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + sc.context_data = ACE_reinterpret_cast( + IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + + // Add this context to the service context list. + ri->add_reply_service_context (sc, 1 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, "reply sc added\n")); + } + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, send_reply interceptor done\n", guid)); +} + +void +Fixed_Priority_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int guid = 0; + RTCORBA::Priority desired_priority=0; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "receive_reply from " + "\"%s\"\n", + operation.in ())); + + // Check that the reply service context was received as + // expected. + IOP::ServiceContext_var sc = + ri->get_reply_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (sc.ptr () == 0) + { + ACE_DEBUG ((LM_DEBUG, "service context was not filled\n")); + desired_priority = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + desired_priority = sc_qos_ptr->desired_priority; + + ACE_OS::memcpy (&guid, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Desired_Priority = %d, guid = %d in recvd service context\n", + desired_priority, + guid)); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.priority_ = desired_priority; + this->kokyu_dispatcher_->schedule (guid, qos); +} + +void +Fixed_Priority_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::cancel (const RTScheduling::Current::IdType & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +Fixed_Priority_Scheduler::scheduling_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +Fixed_Priority_Scheduler::scheduling_policies (const CORBA::PolicyList & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +Fixed_Priority_Scheduler::poa_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +char * +Fixed_Priority_Scheduler::scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +RTScheduling::ResourceManager_ptr +Fixed_Priority_Scheduler::create_resource_manager (const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +Fixed_Priority_Scheduler::set_scheduling_parameter (PortableServer::Servant &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.h b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.h new file mode 100644 index 00000000000..9cbe7e3de11 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduler.h @@ -0,0 +1,167 @@ +//$Id$ + +#ifndef FIXED_PRIORITY_SCHEDULER_H +#define FIXED_PRIORITY_SCHEDULER_H + +#include "tao/RTScheduling/RTSchedulerC.h" +#include "FP_SchedulingC.h" +#include "Kokyu.h" + +class FP_Segment_Sched_Param_Policy: +public FP_Scheduling::SegmentSchedulingParameterPolicy, + public TAO_Local_RefCounted_Object +{ + public: + FP_Scheduling::SegmentSchedulingParameter value ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + void value ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + private: + FP_Scheduling::SegmentSchedulingParameter value_; +}; + +class Fixed_Priority_Scheduler: +public FP_Scheduling::FP_Scheduler, +public TAO_Local_RefCounted_Object +{ + public: + + Fixed_Priority_Scheduler (CORBA::ORB_ptr orb); + + ~Fixed_Priority_Scheduler (void); + + void shutdown (void); + + virtual FP_Scheduling::SegmentSchedulingParameterPolicy_ptr + create_segment_scheduling_parameter ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void begin_new_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void begin_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void update_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void end_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void end_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr outer_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid, + CORBA::String_out name, + CORBA::Policy_out sched_param, + CORBA::Policy_out implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void cancel (const RTScheduling::Current::IdType & guid + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void scheduling_policies (const CORBA::PolicyList & scheduling_policies + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * poa_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual RTScheduling::ResourceManager_ptr create_resource_manager (const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void set_scheduling_parameter (PortableServer::Servant & resource, + const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + CORBA::ORB_var orb_; + IOP::Codec_var codec_; + RTScheduling::Current_var current_; + Kokyu::DSRT_Dispatcher_Auto_Ptr kokyu_dispatcher_; +}; + +#endif //FIXED_PRIORITY_SCHEDULER_H diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduling.idl b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduling.idl new file mode 100644 index 00000000000..d87b8e170fa --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/FP_Scheduling.idl @@ -0,0 +1,24 @@ +//$Id$ +#include +#include + +module FP_Scheduling +{ + struct SegmentSchedulingParameter + { + RTCORBA::Priority base_priority; + }; + + local interface SegmentSchedulingParameterPolicy + : CORBA::Policy + { + attribute SegmentSchedulingParameter value; + }; + + local interface FP_Scheduler : RTScheduling::Scheduler + { + SegmentSchedulingParameterPolicy + create_segment_scheduling_parameter + (in SegmentSchedulingParameter value); + }; +}; diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.cpp new file mode 100644 index 00000000000..cc9bc66c9ce --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.cpp @@ -0,0 +1,647 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:318 + + +#include "Kokyu_qosC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* !defined INLINE */ + +#if !defined (_KOKYU_GUIDTYPE_CS_) +#define _KOKYU_GUIDTYPE_CS_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_cs.cpp:250 + +// ************************************************************* +// Kokyu::GuidType +// ************************************************************* + +Kokyu::GuidType::GuidType (void) +{} + +Kokyu::GuidType::GuidType (CORBA::ULong max) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} + +Kokyu::GuidType::GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release + ) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} + +Kokyu::GuidType::GuidType (const GuidType &seq) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} + +Kokyu::GuidType::~GuidType (void) // dtor +{} + +void Kokyu::GuidType::_tao_any_destructor (void *_tao_void_pointer) +{ + GuidType *tmp = ACE_static_cast (GuidType*, _tao_void_pointer); + delete tmp; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_GuidType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_GuidType ( + CORBA::tk_alias, + sizeof (_oc_Kokyu_GuidType), + (char *) &_oc_Kokyu_GuidType, + 0, + sizeof (Kokyu::GuidType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_GuidType, + &_tc_TAO_tc_Kokyu_GuidType + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_Svc_Ctxt_DSRT_QoS[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f5376), + ACE_NTOHL (0x635f4374), + ACE_NTOHL (0x78745f44), + ACE_NTOHL (0x5352545f), + ACE_NTOHL (0x516f533a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/Kokyu/Svc_Ctxt_DSRT_QoS:1.0 + 18, + ACE_NTOHL (0x5376635f), + ACE_NTOHL (0x43747874), + ACE_NTOHL (0x5f445352), + ACE_NTOHL (0x545f516f), + ACE_NTOHL (0x53000000), // name = Svc_Ctxt_DSRT_QoS + 6, // member count + 5, + ACE_NTOHL (0x67756964), + ACE_NTOHL (0x0), // name = guid + CORBA::tk_alias, // typecode kind for typedefs + 76, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + + + 11, + ACE_NTOHL (0x696d706f), + ACE_NTOHL (0x7274616e), + ACE_NTOHL (0x63650000), // name = importance + CORBA::tk_long, + + 12, + ACE_NTOHL (0x63726974), + ACE_NTOHL (0x6963616c), + ACE_NTOHL (0x69747900), // name = criticality + CORBA::tk_long, + + 17, + ACE_NTOHL (0x64657369), + ACE_NTOHL (0x7265645f), + ACE_NTOHL (0x7072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = desired_priority + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/RTCORBA/Priority:1.0 + 9, + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = Priority + CORBA::tk_short, + + + 9, + ACE_NTOHL (0x64656164), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = deadline + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 33, + ACE_NTOHL (0x65737469), + ACE_NTOHL (0x6d617465), + ACE_NTOHL (0x645f696e), + ACE_NTOHL (0x69746961), + ACE_NTOHL (0x6c5f6578), + ACE_NTOHL (0x65637574), + ACE_NTOHL (0x696f6e5f), + ACE_NTOHL (0x74696d65), + ACE_NTOHL (0x0), // name = estimated_initial_execution_time + 0xffffffff, // indirection + 0xffffff94, // negative offset (-108) +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS ( + CORBA::tk_struct, + sizeof (_oc_Kokyu_Svc_Ctxt_DSRT_QoS), + (char *) &_oc_Kokyu_Svc_Ctxt_DSRT_QoS, + 0, + sizeof (Kokyu::Svc_Ctxt_DSRT_QoS) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Svc_Ctxt_DSRT_QoS, + &_tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:67 + +void Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor (void *_tao_void_pointer) +{ + Svc_Ctxt_DSRT_QoS *tmp = ACE_static_cast (Svc_Ctxt_DSRT_QoS*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::GuidType &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::GuidType *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::GuidType::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::GuidType *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast( + const Kokyu::GuidType*&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::GuidType *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_GuidType + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (!result) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const Kokyu::GuidType*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::GuidType *tmp = 0; + ACE_NEW_RETURN ( + tmp, + Kokyu::GuidType, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_GuidType, + 1, + ACE_static_cast (void *, tmp), + Kokyu::GuidType::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (result == 0) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::Svc_Ctxt_DSRT_QoS *tmp; + ACE_NEW_RETURN ( + tmp, + Kokyu::Svc_Ctxt_DSRT_QoS, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + 1, + ACE_static_cast (void *, tmp), + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_cs.cpp:103 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast (TAO_Unbounded_Sequence*, (Kokyu::GuidType *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return 0; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return 1; + } + + // Retrieve all the elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + if (ACE_BIT_DISABLED (strm.start ()->flags (), + ACE_Message_Block::DONT_DELETE)) + { + TAO_ORB_Core* orb_core = strm.orb_core (); + if (orb_core != 0 && + strm.orb_core ()->resource_factory ()-> + input_cdr_allocator_type_locked () == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + } + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.h b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.h new file mode 100644 index 00000000000..5c1ad4e62c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.h @@ -0,0 +1,350 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_KOKYU_QOSC_H_ +#define _TAO_IDL_KOKYU_QOSC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "RTSchedulerC.h" +#include "RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE Kokyu +{ + +#if !defined (_KOKYU_GUIDTYPE_CH_) +#define _KOKYU_GUIDTYPE_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:371 + + class GuidType; + class GuidType_var; + + // ************************************************************* + // Kokyu::GuidType + // ************************************************************* + + class GuidType : public + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:51 + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + GuidType (void); + GuidType (CORBA::ULong max); + GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release = 0 + ); + GuidType (const GuidType &); + ~GuidType (void); + + static void _tao_any_destructor (void*); + + typedef GuidType_var _var_type; +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + GuidType ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___VAR_CH_) +#define _KOKYU_GUIDTYPE___VAR_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:549 + + // ************************************************************* + // class Kokyu::GuidType_var + // ************************************************************* + + class GuidType_var + { + public: + GuidType_var (void); + GuidType_var (GuidType *); + GuidType_var (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var (const GuidType &); + + ~GuidType_var (void); + + GuidType_var &operator= (GuidType *); + GuidType_var &operator= (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var &operator= (const GuidType &); + + GuidType *operator-> (void); + const GuidType *operator-> (void) const; + + operator const GuidType &() const; + operator GuidType &(); + operator GuidType &() const; + CORBA::Octet & operator[] (CORBA::ULong index); + const CORBA::Octet & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const GuidType &in (void) const; + GuidType &inout (void); + GuidType *&out (void); + GuidType *_retn (void); + GuidType *ptr (void) const; + + private: + GuidType *ptr_; + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___OUT_CH_) +#define _KOKYU_GUIDTYPE___OUT_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:753 + + class GuidType_out + { + public: + GuidType_out (GuidType *&); + GuidType_out (GuidType_var &); + GuidType_out (const GuidType_out &); + GuidType_out &operator= (const GuidType_out &); + GuidType_out &operator= (GuidType *); + operator GuidType *&(); + GuidType *&ptr (void); + GuidType *operator-> (void); + CORBA::Octet & operator[] (CORBA::ULong index); + + private: + GuidType *&ptr_; + // Assignment from T_var not allowed. + void operator= (const GuidType_var &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_GuidType; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:49 + + class Svc_Ctxt_DSRT_QoS_var; + + struct Svc_Ctxt_DSRT_QoS + { + typedef Svc_Ctxt_DSRT_QoS_var _var_type; + + static void _tao_any_destructor (void *); + Kokyu::GuidType guid; + CORBA::Long importance; + CORBA::Long criticality; + RTCORBA::Priority desired_priority; + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:71 + + class Svc_Ctxt_DSRT_QoS_var + { + public: + Svc_Ctxt_DSRT_QoS_var (void); + Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var (const Svc_Ctxt_DSRT_QoS_var &); + ~Svc_Ctxt_DSRT_QoS_var (void); + + Svc_Ctxt_DSRT_QoS_var &operator= (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var &operator= (const Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS *operator-> (void); + const Svc_Ctxt_DSRT_QoS *operator-> (void) const; + + operator const Svc_Ctxt_DSRT_QoS &() const; + operator Svc_Ctxt_DSRT_QoS &(); + operator Svc_Ctxt_DSRT_QoS &() const; + + // Variable-size types only. + operator Svc_Ctxt_DSRT_QoS *&(); + + // in, inout, out, _retn + const Svc_Ctxt_DSRT_QoS &in (void) const; + Svc_Ctxt_DSRT_QoS &inout (void); + Svc_Ctxt_DSRT_QoS *&out (void); + Svc_Ctxt_DSRT_QoS *_retn (void); + Svc_Ctxt_DSRT_QoS *ptr (void) const; + + private: + Svc_Ctxt_DSRT_QoS *ptr_; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:445 + + class Svc_Ctxt_DSRT_QoS_out + { + public: + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS *&); + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS_out (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (Svc_Ctxt_DSRT_QoS *); + operator Svc_Ctxt_DSRT_QoS *&(); + Svc_Ctxt_DSRT_QoS *&ptr (void); + Svc_Ctxt_DSRT_QoS *operator-> (void); + + private: + Svc_Ctxt_DSRT_QoS *&ptr_; + // Assignment from T_var not allowed. + void operator= (const Svc_Ctxt_DSRT_QoS_var &); + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Svc_Ctxt_DSRT_QoS; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module Kokyu + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::GuidType &); // copying version + void operator<<= (CORBA::Any &, Kokyu::GuidType*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::GuidType *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::GuidType *&); + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS &); // copying version + void operator<<= (CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS *&); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ch.cpp:57 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_H_ +#define _TAO_CDR_OP_Kokyu_GuidType_H_ + + CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_H_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:54 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const Kokyu::Svc_Ctxt_DSRT_QoS &); + CORBA::Boolean operator>> (TAO_InputCDR &, Kokyu::Svc_Ctxt_DSRT_QoS &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1004 + +#if defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.i b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.i new file mode 100644 index 00000000000..56edaae1cd6 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Kokyu_qosC.i @@ -0,0 +1,559 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +#if !defined (_KOKYU_GUIDTYPE_CI_) +#define _KOKYU_GUIDTYPE_CI_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:226 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_var +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (GuidType *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::GuidType (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +// Fixed-size base types only. +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType &p) +{ + ACE_NEW (this->ptr_, ::Kokyu::GuidType (p)); +} + +ACE_INLINE +Kokyu::GuidType_var::~GuidType_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (GuidType *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + GuidType *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + GuidType (*p.ptr_), + *this + ); + + if (deep_copy != 0) + { + GuidType *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// Fixed-size types only. +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::Kokyu::GuidType (p), *this); + } + + return *this; +} + +ACE_INLINE +const ::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator const ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE +const CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index)); +} + +ACE_INLINE +const ::Kokyu::GuidType & +Kokyu::GuidType_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType & +Kokyu::GuidType_var::inout (void) +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::_retn (void) +{ + ::Kokyu::GuidType *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:567 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_out +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (const ::Kokyu::GuidType_out &p) + : ptr_ (ACE_const_cast (GuidType_out&, p).ptr_) +{} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (const ::Kokyu::GuidType_out &p) +{ + this->ptr_ = ACE_const_cast (GuidType_out&, p).ptr_; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (GuidType *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +Kokyu::GuidType_out::operator ::Kokyu::GuidType *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_structure.cpp:194 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_var +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::Svc_Ctxt_DSRT_QoS (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::~Svc_Ctxt_DSRT_QoS_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_var) +{ + delete this->ptr_; + this->ptr_ = _tao_struct_var; + return *this; +} + +ACE_INLINE +::Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &_tao_struct_var) +{ + if (this != &_tao_struct_var) + { + if (_tao_struct_var.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + Svc_Ctxt_DSRT_QoS *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + Svc_Ctxt_DSRT_QoS (*_tao_struct_var.ptr_), + *this + ); + + if (deep_copy != 0) + { + Svc_Ctxt_DSRT_QoS *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator const ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +// Variable-size types only. +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::inout (void) +{ + return *this->ptr_; +} + +// Mapping for variable size. +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::_retn (void) +{ + ::Kokyu::Svc_Ctxt_DSRT_QoS *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_structure.cpp:523 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_out +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (::Kokyu::Svc_Ctxt_DSRT_QoS *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) + : ptr_ (ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) +{ + this->ptr_ = ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_out) +{ + this->ptr_ = _tao_struct_out; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator-> (void) +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ci.cpp:84 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_I_ +#define _TAO_CDR_OP_Kokyu_GuidType_I_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_I_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:71 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm << _tao_aggregate.guid) && + (strm << _tao_aggregate.importance) && + (strm << _tao_aggregate.criticality) && + (strm << _tao_aggregate.desired_priority) && + (strm << _tao_aggregate.deadline) && + (strm << _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm >> _tao_aggregate.guid) && + (strm >> _tao_aggregate.importance) && + (strm >> _tao_aggregate.criticality) && + (strm >> _tao_aggregate.desired_priority) && + (strm >> _tao_aggregate.deadline) && + (strm >> _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Makefile b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Makefile new file mode 100644 index 00000000000..c6f74fc532a --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/Makefile @@ -0,0 +1,2384 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +IDL_FILES = test FP_Scheduling +IDL_SRC = testC.cpp testS.cpp FP_SchedulingC.cpp +BIN = client server + +SRC = $(addsuffix .cpp, $(BIN) test_i FP_Scheduler) $(IDL_SRC) Kokyu_qosC.cpp + +CLIENT_OBJS = client.o testC.o FP_Scheduler.o Kokyu_qosC.o FP_SchedulingC.o +SERVER_OBJS = server.o test_i.o FP_Scheduler.o Kokyu_qosC.o $(IDL_SRC:.cpp=.o) + +LIBS = -lTAO_RTScheduler -lKokyu + +TAO_IDLFLAGS += -Ge 1 \ + -I $(TAO_ROOT) \ + -I $(TAO_ROOT)/tao/RTScheduling \ + -I $(TAO_ROOT)/tao/RTCORBA \ + -I $(TAO_ROOT)/tao/PortableServer \ + -I $(TAO_ROOT)/tao/PortableInterceptor + +CPPFLAGS += -I$(TAO_ROOT)/tao/RTScheduling \ + -I$(TAO_ROOT)/tao/RTCORBA \ + -I$(ACE_ROOT)/Kokyu + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_CLNT_LIBS) $(LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/ORB_Core.i testC.h testC.i \ + FP_Scheduler.h FP_SchedulingC.h FP_SchedulingC.i + +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp test_i.h testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i test_i.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/ORB_Core.i FP_Scheduler.h \ + FP_SchedulingC.h FP_SchedulingC.i + +.obj/test_i.o .obj/test_i.so .shobj/test_i.o .shobj/test_i.so: test_i.cpp test_i.h testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i test_i.i \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(TAO_ROOT)/tao/debug.h + +.obj/FP_Scheduler.o .obj/FP_Scheduler.so .shobj/FP_Scheduler.o .shobj/FP_Scheduler.so: FP_Scheduler.cpp FP_Scheduler.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + FP_SchedulingC.h FP_SchedulingC.i \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i ../Kokyu_qosC.h \ + ../Kokyu_qosC.i + +.obj/testC.o .obj/testC.so .shobj/testC.o .shobj/testC.so: testC.cpp testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +.obj/testS.o .obj/testS.so .shobj/testS.o .shobj/testS.so: testS.cpp testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PortableServer/Default_Policy_Validator.h \ + $(TAO_ROOT)/tao/Policy_Validator.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policy_Set.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policies.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policies.i \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/PortableServer/POA_Policy_Set.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.i \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/Tagged_Profile.i \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/TAO_Server_Request.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.inl \ + $(TAO_ROOT)/tao/PortableServer/ServerInterceptorAdapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerInterceptorAdapter.inl \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp + +.obj/FP_SchedulingC.o .obj/FP_SchedulingC.so .shobj/FP_SchedulingC.o .shobj/FP_SchedulingC.so: FP_SchedulingC.cpp FP_SchedulingC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + FP_SchedulingC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +.obj/Kokyu_qosC.o .obj/Kokyu_qosC.so .shobj/Kokyu_qosC.o .shobj/Kokyu_qosC.so: Kokyu_qosC.cpp Kokyu_qosC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + Kokyu_qosC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.cpp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.cpp new file mode 100644 index 00000000000..a324815863d --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.cpp @@ -0,0 +1,271 @@ +// $Id$ + +#include "ace/Get_Opt.h" +#include "ace/Task.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "testC.h" +#include "FP_Scheduler.h" + +ACE_RCSID(MT_Server, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 5; +int do_shutdown = 0; +int enable_dynamic_scheduling = 0; + +class Worker : public ACE_Task_Base +{ + // = TITLE + // Run a server thread + // + // = DESCRIPTION + // Use the ACE_Task_Base class to run server threads + // +public: + Worker (CORBA::ORB_ptr orb, + Simple_Server_ptr server_ptr, + RTScheduling::Current_ptr current, + Fixed_Priority_Scheduler* scheduler, + RTCORBA::Priority priority, + CORBA::Long server_load); + // ctor + + virtual int svc (void); + // The thread entry point. + +private: + CORBA::ORB_var orb_; + // The orb + + Simple_Server_var server_; + RTScheduling::Current_var scheduler_current_; + Fixed_Priority_Scheduler* scheduler_; + RTCORBA::Priority priority_; + CORBA::Long server_load_; +}; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "xk:i:d"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'x': + do_shutdown = 1; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'd': + enable_dynamic_scheduling = 1; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k " + "-i " + "-d" + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + Fixed_Priority_Scheduler* scheduler; + RTScheduling::Current_var current; + + ACE_hthread_t main_thr_handle; + ACE_Thread::self (main_thr_handle); + + ACE_OS::thr_setprio (main_thr_handle, + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD)); + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Simple_Server_var server = + Simple_Server::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (server.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Object reference <%s> is nil\n", + ior), + 1); + } + + if (enable_dynamic_scheduling) + { + ACE_DEBUG ((LM_DEBUG, "Dyn Sched enabled\n")); + CORBA::Object_ptr manager_obj = + orb->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = + TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + + ACE_NEW_RETURN (scheduler, + Fixed_Priority_Scheduler (orb.in ()), -1); + + manager->rtscheduler (scheduler); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + current = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + } + + Worker worker1 (orb.in (), server.in (), current.in (), scheduler, 10, 200000 ); + + long flags = THR_NEW_LWP | THR_JOINABLE ; + + if (worker1.activate (flags, 1) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate client thread 1\n"), + 1); + + ACE_OS::sleep(5); + Worker worker2 (orb.in (), server.in (), current.in (), scheduler, 12, 20000); + if (worker2.activate (flags, 1) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate client thread 2\n"), + 1); + + worker1.wait (); + worker2.wait (); + + ACE_DEBUG ((LM_DEBUG, "(%t): wait for worker threads done in main thread\n")); + + if (do_shutdown) + { + if (enable_dynamic_scheduling) + { + FP_Scheduling::SegmentSchedulingParameter sched_param; + sched_param.base_priority = 0; + CORBA::Policy_var sched_param_policy + = scheduler->create_segment_scheduling_parameter (sched_param); + CORBA::Policy_ptr implicit_sched_param = 0; + current->begin_scheduling_segment (0, + sched_param_policy.in (), + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "(%t): about to call server shutdown\n")); + server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, "after shutdown call in main thread\n")); + + + if (enable_dynamic_scheduling) + { + current->end_scheduling_segment (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + } + + scheduler->shutdown (); + ACE_DEBUG ((LM_DEBUG, "scheduler shutdown done\n")); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + +// **************************************************************** + +Worker::Worker (CORBA::ORB_ptr orb, + Simple_Server_ptr server_ptr, + RTScheduling::Current_ptr current, + Fixed_Priority_Scheduler* scheduler, + RTCORBA::Priority priority, + CORBA::Long server_load) + : orb_ (CORBA::ORB::_duplicate (orb)), + server_ (Simple_Server::_duplicate (server_ptr)), + scheduler_current_ (RTScheduling::Current::_duplicate (current)), + scheduler_ (scheduler), + priority_ (priority), + server_load_ (server_load) +{ +} + +int +Worker::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + const char * name = 0; + + if (enable_dynamic_scheduling) + { + FP_Scheduling::SegmentSchedulingParameter sched_param; + sched_param.base_priority = priority_; + CORBA::Policy_var sched_param_policy + = scheduler_->create_segment_scheduling_parameter (sched_param); + + CORBA::Policy_ptr implicit_sched_param = 0; + scheduler_current_->begin_scheduling_segment (name, + sched_param_policy.in (), + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "about to make two way call\n")); + server_->test_method (server_load_ ACE_ENV_ARG_PARAMETER); + ACE_DEBUG ((LM_DEBUG, "two way call done\n")); + ACE_TRY_CHECK; + + if (enable_dynamic_scheduling) + { + scheduler_current_->end_scheduling_segment (name); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "client worker thread (%t) done\n")); + + return 0; +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.dsp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.dsp new file mode 100644 index 00000000000..7b50a416ab0 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/client.dsp @@ -0,0 +1,196 @@ +# Microsoft Developer Studio Project File - Name="MT_Server Client" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MT_Server Client - 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 "client.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 "client.mak" CFG="MT_Server Client - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MT_Server Client - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MT_Server Client - 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)" == "MT_Server Client - 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 Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\.." /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 ace.lib tao.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao" /libpath:"..\..\..\ace" + +!ELSEIF "$(CFG)" == "MT_Server Client - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# 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 "..\..\.." /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 taod.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao" /libpath:"..\..\..\ace" + +!ENDIF + +# Begin Target + +# Name "MT_Server Client - Win32 Release" +# Name "MT_Server Client - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\client.cpp +# End Source File +# Begin Source File + +SOURCE=.\testC.cpp +# ADD CPP /GR +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\testC.h +# End Source File +# End Group +# Begin Group "IDL Files" + +# PROP Default_Filter "idl" +# Begin Source File + +SOURCE=.\test.idl + +!IF "$(CFG)" == "MT_Server Client - Win32 Release" + +USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ELSEIF "$(CFG)" == "MT_Server Client - Win32 Debug" + +USERDEP__TEST_="..\..\..\bin\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ENDIF + +# End Source File +# End Group +# End Target +# End Project diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.cpp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.cpp new file mode 100644 index 00000000000..8d668e45602 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.cpp @@ -0,0 +1,212 @@ +// $Id$ + +#include "test_i.h" +#include "ace/Get_Opt.h" +#include "ace/Task.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "FP_Scheduler.h" + +ACE_RCSID(MT_Server, server, "$Id$") + +const char *ior_output_file = 0; + +int nthreads = 2; +int enable_dynamic_scheduling = 0; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:n:d"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.opt_arg (); + break; + + case 'n': + nthreads = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'd': + enable_dynamic_scheduling = 1; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +class Worker : public ACE_Task_Base +{ + // = TITLE + // Run a server thread + // + // = DESCRIPTION + // Use the ACE_Task_Base class to run server threads + // +public: + Worker (CORBA::ORB_ptr orb); + // ctor + + virtual int svc (void); + // The thread entry point. + +private: + CORBA::ORB_var orb_; + // The orb +}; + +int +main (int argc, char *argv[]) +{ + Fixed_Priority_Scheduler* scheduler; + RTScheduling::Current_var current; + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the POA.\n"), + 1); + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + if (enable_dynamic_scheduling) + { + CORBA::Object_ptr manager_obj = + orb->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = + TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_NEW_RETURN (scheduler, + Fixed_Priority_Scheduler (orb.in ()), -1); + + manager->rtscheduler (scheduler); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + current = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + Simple_Server_i server_impl (orb.in ()); + + Simple_Server_var server = + server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); + + // If the ior_output_file exists, output the ior to it + if (ior_output_file != 0) + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + long flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND | THR_SCHED_RR; + Worker worker (orb.in ()); + if (worker.activate (flags, + nthreads) != 0) + { + flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND; + if (worker.activate (flags, nthreads) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate server threads\n"), + 1); + } + } + + worker.wait (); + + ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); + + ACE_DEBUG ((LM_DEBUG, "shutting down scheduler\n")); + scheduler->shutdown (); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + +// **************************************************************** + +Worker::Worker (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +int +Worker::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_Time_Value tv(120); + + ACE_TRY + { + this->orb_->run (tv ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.dsp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.dsp new file mode 100644 index 00000000000..2f1cfb0a3c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/server.dsp @@ -0,0 +1,208 @@ +# Microsoft Developer Studio Project File - Name="MT_Server Server" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MT_Server Server - 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 "server.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 "server.mak" CFG="MT_Server Server - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MT_Server Server - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MT_Server Server - 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)" == "MT_Server Server - 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 Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\.." /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 ace.lib TAO.lib TAO_PortableServer.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\lib" /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer" + +!ELSEIF "$(CFG)" == "MT_Server Server - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "server___Win32_Debug" +# PROP BASE Intermediate_Dir "server___Win32_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# 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 "..\..\.." /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 TAOd.lib TAO_PortableServerd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\lib" /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer" + +!ENDIF + +# Begin Target + +# Name "MT_Server Server - Win32 Release" +# Name "MT_Server Server - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\server.cpp +# End Source File +# Begin Source File + +SOURCE=.\test_i.cpp +# End Source File +# Begin Source File + +SOURCE=.\testC.cpp +# ADD CPP /GR +# End Source File +# Begin Source File + +SOURCE=.\testS.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\test_i.h +# End Source File +# Begin Source File + +SOURCE=.\testS.h +# End Source File +# End Group +# Begin Group "IDL Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\test.idl + +!IF "$(CFG)" == "MT_Server Server - Win32 Release" + +USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ELSEIF "$(CFG)" == "MT_Server Server - Win32 Debug" + +USERDEP__TEST_="..\..\..\bin\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ENDIF + +# End Source File +# End Group +# End Target +# End Project diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test.idl b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test.idl new file mode 100644 index 00000000000..deed5409437 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test.idl @@ -0,0 +1,10 @@ +// +// $Id$ +// + +interface Simple_Server +{ + long test_method (in long x); + + void shutdown (); +}; diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.cpp b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.cpp new file mode 100644 index 00000000000..8d5f3d797d8 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.cpp @@ -0,0 +1,69 @@ +// $Id$ + +#include "test_i.h" +#include "ace/High_Res_Timer.h" +#include "tao/debug.h" + +#if !defined(__ACE_INLINE__) +#include "test_i.i" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID(MT_Server, test_i, "$Id$") + +CORBA::Long +Simple_Server_i::test_method (CORBA::Long x ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_hthread_t thr_handle; + ACE_Thread::self (thr_handle); + int prio; + long server_load = x; + + ACE_High_Res_Timer timer; + ACE_Time_Value elapsed_time; + + ACE_DEBUG ((LM_DEBUG, "Request in thread %t\n")); + + if (ACE_Thread::getprio (thr_handle, prio) == -1) + { + if (errno == ENOTSUP) + { + ACE_DEBUG((LM_DEBUG, + ACE_TEXT ("getprio not supported on this platform\n") + )); + return 0; + } + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("getprio failed")), + -1); + } + + // if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Request in thread %t, prio = %d, load = %u\n", prio, server_load)); + + static CORBA::ULong prime_number = 9619899; + + timer.start (); + for (long j = 0; j < server_load; ++j) + { + ACE_DEBUG ((LM_DEBUG, "(%t) loop # = %d, load = %u\n", j, server_load)); + ACE::is_prime (prime_number, + 2, + prime_number / 2); + } + timer.stop (); + timer.elapsed_time (elapsed_time); + + ACE_DEBUG ((LM_DEBUG, "Request processing in thread %t done, prio = %d, load = %d, elapsed time = %u\n", prio, x, elapsed_time.msec () )); + + return x; +} + +void +Simple_Server_i::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_DEBUG ((LM_DEBUG, "shutdown request from client\n")); + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.h b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.h new file mode 100644 index 00000000000..65fa40ed8b2 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.h @@ -0,0 +1,49 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/MT_Server +// +// = FILENAME +// test_i.h +// +// = AUTHOR +// Carlos O'Ryan +// +// ============================================================================ + +#ifndef TAO_MT_SERVER_TEST_I_H +#define TAO_MT_SERVER_TEST_I_H + +#include "testS.h" + +class Simple_Server_i : public POA_Simple_Server +{ + // = TITLE + // Simpler Server implementation + // + // = DESCRIPTION + // Implements the Simple_Server interface in test.idl + // +public: + Simple_Server_i (CORBA::ORB_ptr orb); + // ctor + + // = The Simple_Server methods. + CORBA::Long test_method (CORBA::Long x ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + CORBA::ORB_var orb_; + // The ORB +}; + +#if defined(__ACE_INLINE__) +#include "test_i.i" +#endif /* __ACE_INLINE__ */ + +#endif /* TAO_MT_SERVER_TEST_I_H */ diff --git a/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.i b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.i new file mode 100644 index 00000000000..97524552ff4 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/fp_example/test_i.i @@ -0,0 +1,7 @@ +// $Id$ + +ACE_INLINE +Simple_Server_i::Simple_Server_i (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.cpp new file mode 100644 index 00000000000..cc9bc66c9ce --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.cpp @@ -0,0 +1,647 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:318 + + +#include "Kokyu_qosC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* !defined INLINE */ + +#if !defined (_KOKYU_GUIDTYPE_CS_) +#define _KOKYU_GUIDTYPE_CS_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_cs.cpp:250 + +// ************************************************************* +// Kokyu::GuidType +// ************************************************************* + +Kokyu::GuidType::GuidType (void) +{} + +Kokyu::GuidType::GuidType (CORBA::ULong max) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} + +Kokyu::GuidType::GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release + ) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} + +Kokyu::GuidType::GuidType (const GuidType &seq) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} + +Kokyu::GuidType::~GuidType (void) // dtor +{} + +void Kokyu::GuidType::_tao_any_destructor (void *_tao_void_pointer) +{ + GuidType *tmp = ACE_static_cast (GuidType*, _tao_void_pointer); + delete tmp; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_GuidType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_GuidType ( + CORBA::tk_alias, + sizeof (_oc_Kokyu_GuidType), + (char *) &_oc_Kokyu_GuidType, + 0, + sizeof (Kokyu::GuidType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_GuidType, + &_tc_TAO_tc_Kokyu_GuidType + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_Svc_Ctxt_DSRT_QoS[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f5376), + ACE_NTOHL (0x635f4374), + ACE_NTOHL (0x78745f44), + ACE_NTOHL (0x5352545f), + ACE_NTOHL (0x516f533a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/Kokyu/Svc_Ctxt_DSRT_QoS:1.0 + 18, + ACE_NTOHL (0x5376635f), + ACE_NTOHL (0x43747874), + ACE_NTOHL (0x5f445352), + ACE_NTOHL (0x545f516f), + ACE_NTOHL (0x53000000), // name = Svc_Ctxt_DSRT_QoS + 6, // member count + 5, + ACE_NTOHL (0x67756964), + ACE_NTOHL (0x0), // name = guid + CORBA::tk_alias, // typecode kind for typedefs + 76, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + + + 11, + ACE_NTOHL (0x696d706f), + ACE_NTOHL (0x7274616e), + ACE_NTOHL (0x63650000), // name = importance + CORBA::tk_long, + + 12, + ACE_NTOHL (0x63726974), + ACE_NTOHL (0x6963616c), + ACE_NTOHL (0x69747900), // name = criticality + CORBA::tk_long, + + 17, + ACE_NTOHL (0x64657369), + ACE_NTOHL (0x7265645f), + ACE_NTOHL (0x7072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = desired_priority + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/RTCORBA/Priority:1.0 + 9, + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = Priority + CORBA::tk_short, + + + 9, + ACE_NTOHL (0x64656164), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = deadline + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 33, + ACE_NTOHL (0x65737469), + ACE_NTOHL (0x6d617465), + ACE_NTOHL (0x645f696e), + ACE_NTOHL (0x69746961), + ACE_NTOHL (0x6c5f6578), + ACE_NTOHL (0x65637574), + ACE_NTOHL (0x696f6e5f), + ACE_NTOHL (0x74696d65), + ACE_NTOHL (0x0), // name = estimated_initial_execution_time + 0xffffffff, // indirection + 0xffffff94, // negative offset (-108) +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS ( + CORBA::tk_struct, + sizeof (_oc_Kokyu_Svc_Ctxt_DSRT_QoS), + (char *) &_oc_Kokyu_Svc_Ctxt_DSRT_QoS, + 0, + sizeof (Kokyu::Svc_Ctxt_DSRT_QoS) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Svc_Ctxt_DSRT_QoS, + &_tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:67 + +void Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor (void *_tao_void_pointer) +{ + Svc_Ctxt_DSRT_QoS *tmp = ACE_static_cast (Svc_Ctxt_DSRT_QoS*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::GuidType &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::GuidType *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::GuidType::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::GuidType *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast( + const Kokyu::GuidType*&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::GuidType *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_GuidType + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (!result) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const Kokyu::GuidType*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::GuidType *tmp = 0; + ACE_NEW_RETURN ( + tmp, + Kokyu::GuidType, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_GuidType, + 1, + ACE_static_cast (void *, tmp), + Kokyu::GuidType::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (result == 0) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::Svc_Ctxt_DSRT_QoS *tmp; + ACE_NEW_RETURN ( + tmp, + Kokyu::Svc_Ctxt_DSRT_QoS, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + 1, + ACE_static_cast (void *, tmp), + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_cs.cpp:103 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast (TAO_Unbounded_Sequence*, (Kokyu::GuidType *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return 0; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return 1; + } + + // Retrieve all the elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + if (ACE_BIT_DISABLED (strm.start ()->flags (), + ACE_Message_Block::DONT_DELETE)) + { + TAO_ORB_Core* orb_core = strm.orb_core (); + if (orb_core != 0 && + strm.orb_core ()->resource_factory ()-> + input_cdr_allocator_type_locked () == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + } + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.h b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.h new file mode 100644 index 00000000000..5c1ad4e62c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.h @@ -0,0 +1,350 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_KOKYU_QOSC_H_ +#define _TAO_IDL_KOKYU_QOSC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "RTSchedulerC.h" +#include "RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE Kokyu +{ + +#if !defined (_KOKYU_GUIDTYPE_CH_) +#define _KOKYU_GUIDTYPE_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:371 + + class GuidType; + class GuidType_var; + + // ************************************************************* + // Kokyu::GuidType + // ************************************************************* + + class GuidType : public + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:51 + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + GuidType (void); + GuidType (CORBA::ULong max); + GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release = 0 + ); + GuidType (const GuidType &); + ~GuidType (void); + + static void _tao_any_destructor (void*); + + typedef GuidType_var _var_type; +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + GuidType ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___VAR_CH_) +#define _KOKYU_GUIDTYPE___VAR_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:549 + + // ************************************************************* + // class Kokyu::GuidType_var + // ************************************************************* + + class GuidType_var + { + public: + GuidType_var (void); + GuidType_var (GuidType *); + GuidType_var (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var (const GuidType &); + + ~GuidType_var (void); + + GuidType_var &operator= (GuidType *); + GuidType_var &operator= (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var &operator= (const GuidType &); + + GuidType *operator-> (void); + const GuidType *operator-> (void) const; + + operator const GuidType &() const; + operator GuidType &(); + operator GuidType &() const; + CORBA::Octet & operator[] (CORBA::ULong index); + const CORBA::Octet & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const GuidType &in (void) const; + GuidType &inout (void); + GuidType *&out (void); + GuidType *_retn (void); + GuidType *ptr (void) const; + + private: + GuidType *ptr_; + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___OUT_CH_) +#define _KOKYU_GUIDTYPE___OUT_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:753 + + class GuidType_out + { + public: + GuidType_out (GuidType *&); + GuidType_out (GuidType_var &); + GuidType_out (const GuidType_out &); + GuidType_out &operator= (const GuidType_out &); + GuidType_out &operator= (GuidType *); + operator GuidType *&(); + GuidType *&ptr (void); + GuidType *operator-> (void); + CORBA::Octet & operator[] (CORBA::ULong index); + + private: + GuidType *&ptr_; + // Assignment from T_var not allowed. + void operator= (const GuidType_var &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_GuidType; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:49 + + class Svc_Ctxt_DSRT_QoS_var; + + struct Svc_Ctxt_DSRT_QoS + { + typedef Svc_Ctxt_DSRT_QoS_var _var_type; + + static void _tao_any_destructor (void *); + Kokyu::GuidType guid; + CORBA::Long importance; + CORBA::Long criticality; + RTCORBA::Priority desired_priority; + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:71 + + class Svc_Ctxt_DSRT_QoS_var + { + public: + Svc_Ctxt_DSRT_QoS_var (void); + Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var (const Svc_Ctxt_DSRT_QoS_var &); + ~Svc_Ctxt_DSRT_QoS_var (void); + + Svc_Ctxt_DSRT_QoS_var &operator= (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var &operator= (const Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS *operator-> (void); + const Svc_Ctxt_DSRT_QoS *operator-> (void) const; + + operator const Svc_Ctxt_DSRT_QoS &() const; + operator Svc_Ctxt_DSRT_QoS &(); + operator Svc_Ctxt_DSRT_QoS &() const; + + // Variable-size types only. + operator Svc_Ctxt_DSRT_QoS *&(); + + // in, inout, out, _retn + const Svc_Ctxt_DSRT_QoS &in (void) const; + Svc_Ctxt_DSRT_QoS &inout (void); + Svc_Ctxt_DSRT_QoS *&out (void); + Svc_Ctxt_DSRT_QoS *_retn (void); + Svc_Ctxt_DSRT_QoS *ptr (void) const; + + private: + Svc_Ctxt_DSRT_QoS *ptr_; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:445 + + class Svc_Ctxt_DSRT_QoS_out + { + public: + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS *&); + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS_out (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (Svc_Ctxt_DSRT_QoS *); + operator Svc_Ctxt_DSRT_QoS *&(); + Svc_Ctxt_DSRT_QoS *&ptr (void); + Svc_Ctxt_DSRT_QoS *operator-> (void); + + private: + Svc_Ctxt_DSRT_QoS *&ptr_; + // Assignment from T_var not allowed. + void operator= (const Svc_Ctxt_DSRT_QoS_var &); + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Svc_Ctxt_DSRT_QoS; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module Kokyu + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::GuidType &); // copying version + void operator<<= (CORBA::Any &, Kokyu::GuidType*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::GuidType *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::GuidType *&); + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS &); // copying version + void operator<<= (CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS *&); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ch.cpp:57 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_H_ +#define _TAO_CDR_OP_Kokyu_GuidType_H_ + + CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_H_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:54 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const Kokyu::Svc_Ctxt_DSRT_QoS &); + CORBA::Boolean operator>> (TAO_InputCDR &, Kokyu::Svc_Ctxt_DSRT_QoS &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1004 + +#if defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.i b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.i new file mode 100644 index 00000000000..56edaae1cd6 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Kokyu_qosC.i @@ -0,0 +1,559 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +#if !defined (_KOKYU_GUIDTYPE_CI_) +#define _KOKYU_GUIDTYPE_CI_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:226 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_var +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (GuidType *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::GuidType (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +// Fixed-size base types only. +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType &p) +{ + ACE_NEW (this->ptr_, ::Kokyu::GuidType (p)); +} + +ACE_INLINE +Kokyu::GuidType_var::~GuidType_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (GuidType *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + GuidType *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + GuidType (*p.ptr_), + *this + ); + + if (deep_copy != 0) + { + GuidType *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// Fixed-size types only. +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::Kokyu::GuidType (p), *this); + } + + return *this; +} + +ACE_INLINE +const ::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator const ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE +const CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index)); +} + +ACE_INLINE +const ::Kokyu::GuidType & +Kokyu::GuidType_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType & +Kokyu::GuidType_var::inout (void) +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::_retn (void) +{ + ::Kokyu::GuidType *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:567 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_out +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (const ::Kokyu::GuidType_out &p) + : ptr_ (ACE_const_cast (GuidType_out&, p).ptr_) +{} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (const ::Kokyu::GuidType_out &p) +{ + this->ptr_ = ACE_const_cast (GuidType_out&, p).ptr_; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (GuidType *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +Kokyu::GuidType_out::operator ::Kokyu::GuidType *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_structure.cpp:194 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_var +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::Svc_Ctxt_DSRT_QoS (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::~Svc_Ctxt_DSRT_QoS_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_var) +{ + delete this->ptr_; + this->ptr_ = _tao_struct_var; + return *this; +} + +ACE_INLINE +::Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &_tao_struct_var) +{ + if (this != &_tao_struct_var) + { + if (_tao_struct_var.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + Svc_Ctxt_DSRT_QoS *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + Svc_Ctxt_DSRT_QoS (*_tao_struct_var.ptr_), + *this + ); + + if (deep_copy != 0) + { + Svc_Ctxt_DSRT_QoS *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator const ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +// Variable-size types only. +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::inout (void) +{ + return *this->ptr_; +} + +// Mapping for variable size. +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::_retn (void) +{ + ::Kokyu::Svc_Ctxt_DSRT_QoS *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_structure.cpp:523 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_out +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (::Kokyu::Svc_Ctxt_DSRT_QoS *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) + : ptr_ (ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) +{ + this->ptr_ = ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_out) +{ + this->ptr_ = _tao_struct_out; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator-> (void) +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ci.cpp:84 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_I_ +#define _TAO_CDR_OP_Kokyu_GuidType_I_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_I_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:71 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm << _tao_aggregate.guid) && + (strm << _tao_aggregate.importance) && + (strm << _tao_aggregate.criticality) && + (strm << _tao_aggregate.desired_priority) && + (strm << _tao_aggregate.deadline) && + (strm << _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm >> _tao_aggregate.guid) && + (strm >> _tao_aggregate.importance) && + (strm >> _tao_aggregate.criticality) && + (strm >> _tao_aggregate.desired_priority) && + (strm >> _tao_aggregate.deadline) && + (strm >> _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.cpp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.cpp new file mode 100644 index 00000000000..0bb4982b62b --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.cpp @@ -0,0 +1,604 @@ +//$Id$ + +#include "MIF_Scheduler.h" +#include "ace/Atomic_Op.h" +#include "Kokyu_qosC.h" + +//this needs to be formally defined in IOP.pidl +namespace +{ + static const IOP::ServiceId service_id = 0xdddd; +} + +void guid_copy( Kokyu::GuidType& lhs, const RTScheduling::Current::IdType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +void guid_copy( RTScheduling::Current::IdType& lhs, const Kokyu::GuidType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +ACE_Atomic_Op server_guid_counter; + +MIF_Scheduling::SchedulingParameter +MIF_Sched_Param_Policy::value (void) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->value_; +} + +void +MIF_Sched_Param_Policy::value (const MIF_Scheduling::SchedulingParameter& value) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->value_ = value; +} + +MIF_Scheduler::MIF_Scheduler (CORBA::ORB_ptr orb) + : orb_ (orb) +{ + Kokyu::DSRT_ConfigInfo config; + + config.sched_strategy_ = Kokyu::DSRT_MIF; + kokyu_dispatcher_ = Kokyu::Dispatcher_Factory::create_DSRT_dispatcher (config); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + this->current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + IOP::CodecFactory_var codec_factory; + CORBA::Object_var obj = orb->resolve_initial_references ("CodecFactory"); + + if (CORBA::is_nil(obj.in ())) + { + ACE_ERROR ((LM_ERROR, "Nil Codec factory\n")); + } + else + { + codec_factory = IOP::CodecFactory::_narrow (obj.in ()); + } + + IOP::Encoding encoding; + encoding.format = IOP::ENCODING_CDR_ENCAPS; + encoding.major_version = 1; + encoding.minor_version = 2; + + codec_ = codec_factory->create_codec (encoding); +} + +MIF_Scheduler::~MIF_Scheduler (void) +{ + // delete kokyu_dispatcher_; +} + +void +MIF_Scheduler::shutdown (void) +{ + kokyu_dispatcher_->shutdown (); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduler::create_scheduling_parameter (const MIF_Scheduling::SchedulingParameter & value) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + MIF_Scheduling::SchedulingParameterPolicy_ptr sched_param_policy; + ACE_NEW_THROW_EX (sched_param_policy, + MIF_Sched_Param_Policy, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + + sched_param_policy->value (value); + + return sched_param_policy; +} + + +void +MIF_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char *, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + Kokyu::DSRT_QoSDescriptor qos; + MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + CORBA::Short importance = sched_param->importance; + qos.importance_ = importance; + kokyu_dispatcher_->schedule (count, qos); +} + +void +MIF_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +void +MIF_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char */*name*/, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr /*implicit_sched_param*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count ; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + CORBA::Short importance = sched_param->importance; + + Kokyu::DSRT_QoSDescriptor qos; + qos.importance_ = importance; + + kokyu_dispatcher_->update_schedule (count, qos); +} + +void +MIF_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char * + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int count; + ACE_OS::memcpy (&count, + guid.get_buffer (), + guid.length ()); + + + ACE_DEBUG ((LM_DEBUG, "(%t) call to end_sched_segment for guid %d\n", count)); + kokyu_dispatcher_->cancel_schedule (count); +} + +void +MIF_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + +} + + +void +MIF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_request " + "from \"%s\"\n", + operation.in ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + CORBA::Short importance; + if (CORBA::is_nil (sched_policy)) + { + importance = 0; + } + else + { + MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + importance = sched_param->importance; + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request importance from current = %d\n"), + importance)); + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + + //Fill the guid in the SC Qos struct + sc_qos.guid.length (this->current_->id ()->length ()); + //sc_qos.guid = *(this->current_->id ()); + guid_copy (sc_qos.guid, *(this->current_->id ())); + sc_qos.importance = importance; + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + ACE_TRY_NEW_ENV + { + sc.context_data = + ACE_reinterpret_cast(IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + } + ACE_ENDTRY; + + + ACE_DEBUG ((LM_DEBUG, "after encode\n")); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to add sched SC\n"))); + + // Add this context to the service context list. + ri->add_request_service_context (sc, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to call scheduler to inform block\n") + )); + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): guid = %d, send_request interceptor done\n"), + guid)); +} + +void +MIF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid_out, + CORBA::String_out /*name*/, + CORBA::Policy_out sched_param_out, + CORBA::Policy_out /*implicit_sched_param_out*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + ACE_DEBUG ((LM_DEBUG, "entered MIF_Scheduler::receive_request\n")); + RTScheduling::Current::IdType* guid; + ACE_NEW (guid, + RTScheduling::Current::IdType); + + + // Generate GUID. + guid->length (sizeof(long)); + + long temp = ++server_guid_counter; + ACE_OS::memcpy (guid->get_buffer (), + &temp, + sizeof(long)); + + int id; + ACE_OS::memcpy (&id, + guid->get_buffer (), + guid->length ()); + + guid_out.ptr () = guid; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): receive_request from " + "\"%s\"\n", + operation.in ())); + + // Ignore the "_is_a" operation since it may have been invoked + // locally on the server side as a side effect of another call, + // meaning that the client hasn't added the service context yet. + if (ACE_OS_String::strcmp ("_is_a", operation.in ()) == 0) + return; + + IOP::ServiceContext_var sc = + ri->get_request_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Short importance; + + if (sc.ptr () == 0) + { + importance = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + importance = sc_qos_ptr->importance; + //*(guid_out.ptr ()) = sc_qos_ptr->guid; + guid_copy (*(guid_out.ptr ()), sc_qos_ptr->guid); + + + ACE_OS::memcpy (&id, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Importance = %d, guid = %d in recvd service context\n", + importance, + id)); + + MIF_Scheduling::SchedulingParameter sched_param; + sched_param.importance = importance; + sched_param_out.ptr () = this->create_scheduling_parameter (sched_param); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.importance_ = importance; + this->kokyu_dispatcher_->schedule (id, qos); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, receive_request interceptor done\n", id)); +} + +void +MIF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + CORBA::Short importance = 0; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_reply from \"%s\"\n", + ri->operation ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + ACE_DEBUG ((LM_DEBUG, "in send_reply: before accessing current_->sched_param\n")); + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + ACE_DEBUG ((LM_DEBUG, "in send_reply: after accessing current_->sched_param\n")); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + if (CORBA::is_nil (sched_policy)) + { + ACE_DEBUG ((LM_DEBUG, "sched_policy nil. importance not set in sched params\n")); + importance = 0; + } + else + { + ACE_DEBUG ((LM_DEBUG, "sched_policy not nil. importance set in sched params\n")); + + MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + + importance = sched_param->importance; + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + //Fill the guid in the SC Qos struct + //sc_qos.guid = *(this->current_->id ()); + guid_copy ( sc_qos.guid, *(this->current_->id ())); + sc_qos.importance = importance; + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + sc.context_data = ACE_reinterpret_cast( + IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + + // Add this context to the service context list. + ri->add_reply_service_context (sc, 1 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, "reply sc added\n")); + } + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, send_reply interceptor done\n", guid)); +} + +void +MIF_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MIF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MIF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int guid = 0; + CORBA::Short importance=0; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "receive_reply from " + "\"%s\"\n", + operation.in ())); + + // Check that the reply service context was received as + // expected. + IOP::ServiceContext_var sc = + ri->get_reply_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (sc.ptr () == 0) + { + ACE_DEBUG ((LM_DEBUG, "service context was not filled\n")); + importance = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + importance = sc_qos_ptr->importance; + + ACE_OS::memcpy (&guid, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Importance = %d, guid = %d in recvd service context\n", + importance, + guid)); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.importance_ = importance; + this->kokyu_dispatcher_->schedule (guid, qos); +} + +void +MIF_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MIF_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MIF_Scheduler::cancel (const RTScheduling::Current::IdType & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MIF_Scheduler::scheduling_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MIF_Scheduler::scheduling_policies (const CORBA::PolicyList & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MIF_Scheduler::poa_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +char * +MIF_Scheduler::scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +RTScheduling::ResourceManager_ptr +MIF_Scheduler::create_resource_manager (const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MIF_Scheduler::set_scheduling_parameter (PortableServer::Servant &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.h b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.h new file mode 100644 index 00000000000..31871275ce4 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduler.h @@ -0,0 +1,158 @@ +//$Id$ + +#ifndef MIF_SCHEDULER_H +#define MIF_SCHEDULER_H + +#include "tao/RTScheduling/RTSchedulerC.h" +#include "MIF_SchedulingC.h" +#include "Kokyu.h" + +class MIF_Sched_Param_Policy: +public MIF_Scheduling::SchedulingParameterPolicy, + public TAO_Local_RefCounted_Object +{ + public: + + MIF_Scheduling::SchedulingParameter value (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void value (const MIF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + MIF_Scheduling::SchedulingParameter value_; +}; + +class MIF_Scheduler: +public MIF_Scheduling::Scheduler, +public TAO_Local_RefCounted_Object +{ + public: + + MIF_Scheduler (CORBA::ORB_ptr orb); + + ~MIF_Scheduler (void); + + + virtual MIF_Scheduling::SchedulingParameterPolicy_ptr + create_scheduling_parameter (const MIF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void shutdown (void); + + virtual void begin_new_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void begin_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void update_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void end_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void end_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr outer_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid, + CORBA::String_out name, + CORBA::Policy_out sched_param, + CORBA::Policy_out implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void cancel (const RTScheduling::Current::IdType & guid + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void scheduling_policies (const CORBA::PolicyList & scheduling_policies + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * poa_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual RTScheduling::ResourceManager_ptr create_resource_manager (const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void set_scheduling_parameter (PortableServer::Servant & resource, + const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + CORBA::ORB_var orb_; + IOP::Codec_var codec_; + RTScheduling::Current_var current_; + Kokyu::DSRT_Dispatcher_Auto_Ptr kokyu_dispatcher_; +}; + +#endif //MIF_SCHEDULER_H diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduling.idl b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduling.idl new file mode 100644 index 00000000000..6b050a1afa1 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/MIF_Scheduling.idl @@ -0,0 +1,24 @@ +//$Id$ +#include +#include + +module MIF_Scheduling +{ + struct SchedulingParameter + { + long importance; + }; + + local interface SchedulingParameterPolicy + : CORBA::Policy + { + attribute SchedulingParameter value; + }; + + local interface Scheduler : RTScheduling::Scheduler + { + SchedulingParameterPolicy + create_scheduling_parameter + (in SchedulingParameter value); + }; +}; diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Makefile b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Makefile new file mode 100644 index 00000000000..3e8efcee85a --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/Makefile @@ -0,0 +1,2441 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +IDL_FILES = test MIF_Scheduling +IDL_SRC = testC.cpp testS.cpp MIF_SchedulingC.cpp +BIN = client server + +SRC = $(addsuffix .cpp, $(BIN) test_i MIF_Scheduler) $(IDL_SRC) Kokyu_qosC.cpp + +CLIENT_OBJS = client.o testC.o MIF_Scheduler.o Kokyu_qosC.o MIF_SchedulingC.o +SERVER_OBJS = server.o test_i.o MIF_Scheduler.o Kokyu_qosC.o $(IDL_SRC:.cpp=.o) + +LIBS = -lTAO_RTScheduler -lKokyu + +TAO_IDLFLAGS += -Ge 1 \ + -I $(TAO_ROOT) \ + -I $(TAO_ROOT)/tao/RTScheduling \ + -I $(TAO_ROOT)/tao/RTCORBA \ + -I $(TAO_ROOT)/tao/PortableServer \ + -I $(TAO_ROOT)/tao/PortableInterceptor + +CPPFLAGS += -I$(TAO_ROOT)/tao/RTScheduling \ + -I$(TAO_ROOT)/tao/RTCORBA \ + -I$(ACE_ROOT)/Kokyu + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_CLNT_LIBS) $(LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/ORB_Core.i testC.h testC.i \ + MIF_Scheduler.h MIF_SchedulingC.h MIF_SchedulingC.i \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/Kokyu/Kokyu.h \ + $(ACE_ROOT)/Kokyu/kokyu_export.h \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.h \ + $(ACE_ROOT)/ace/Array.h \ + $(ACE_ROOT)/ace/Sched_Params.h \ + $(ACE_ROOT)/ace/Sched_Params.i \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.i \ + $(ACE_ROOT)/Kokyu/Kokyu.i \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.i \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.i + +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp test_i.h testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i test_i.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/ORB_Core.i MIF_Scheduler.h \ + MIF_SchedulingC.h MIF_SchedulingC.i \ + $(ACE_ROOT)/Kokyu/Kokyu.h \ + $(ACE_ROOT)/Kokyu/kokyu_export.h \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.h \ + $(ACE_ROOT)/ace/Array.h \ + $(ACE_ROOT)/ace/Sched_Params.h \ + $(ACE_ROOT)/ace/Sched_Params.i \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.i \ + $(ACE_ROOT)/Kokyu/Kokyu.i \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.i \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.i + +.obj/test_i.o .obj/test_i.so .shobj/test_i.o .shobj/test_i.so: test_i.cpp test_i.h testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i test_i.i \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(TAO_ROOT)/tao/debug.h + +.obj/MIF_Scheduler.o .obj/MIF_Scheduler.so .shobj/MIF_Scheduler.o .shobj/MIF_Scheduler.so: MIF_Scheduler.cpp MIF_Scheduler.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + MIF_SchedulingC.h MIF_SchedulingC.i \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/Kokyu/Kokyu.h \ + $(ACE_ROOT)/Kokyu/kokyu_export.h \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.h \ + $(ACE_ROOT)/ace/Array.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Sched_Params.h \ + $(ACE_ROOT)/ace/Sched_Params.i \ + $(ACE_ROOT)/Kokyu/Kokyu_defs.i \ + $(ACE_ROOT)/Kokyu/Kokyu.i \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/Dispatcher_Impl.i \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.h \ + $(ACE_ROOT)/Kokyu/DSRT_Dispatcher_Impl.i \ + ../Kokyu_qosC.h ../Kokyu_qosC.i + +.obj/testC.o .obj/testC.so .shobj/testC.o .shobj/testC.so: testC.cpp testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +.obj/testS.o .obj/testS.so .shobj/testS.o .shobj/testS.so: testS.cpp testS.h testC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + testC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + testS_T.h testS_T.i testS_T.cpp testS.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PortableServer/Default_Policy_Validator.h \ + $(TAO_ROOT)/tao/Policy_Validator.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policy_Set.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policies.h \ + $(TAO_ROOT)/tao/PortableServer/POA_Policies.i \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/PortableServer/POA_Policy_Set.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.i \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/Tagged_Profile.i \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(TAO_ROOT)/tao/TAO_Server_Request.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.inl \ + $(TAO_ROOT)/tao/PortableServer/ServerInterceptorAdapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerInterceptorAdapter.inl \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp + +.obj/MIF_SchedulingC.o .obj/MIF_SchedulingC.so .shobj/MIF_SchedulingC.o .shobj/MIF_SchedulingC.so: MIF_SchedulingC.cpp MIF_SchedulingC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + MIF_SchedulingC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +.obj/Kokyu_qosC.o .obj/Kokyu_qosC.so .shobj/Kokyu_qosC.o .shobj/Kokyu_qosC.so: Kokyu_qosC.cpp Kokyu_qosC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/AbstractBase.h \ + $(TAO_ROOT)/tao/AbstractBase.inl \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.h \ + $(TAO_ROOT)/tao/ObjectReferenceTemplateC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + Kokyu_qosC.i $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/LF_Event.h \ + $(TAO_ROOT)/tao/LF_Event.inl \ + $(TAO_ROOT)/tao/GIOP_Message_Version.h \ + $(TAO_ROOT)/tao/GIOP_Message_Version.inl \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.h \ + $(TAO_ROOT)/tao/ClientRequestInfo_i.inl \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.h \ + $(TAO_ROOT)/tao/ClientInterceptorAdapter.inl + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.cpp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.cpp new file mode 100644 index 00000000000..9290057b003 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.cpp @@ -0,0 +1,270 @@ +// $Id$ + +#include "ace/Get_Opt.h" +#include "ace/Task.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "testC.h" +#include "MIF_Scheduler.h" + +ACE_RCSID(MT_Server, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 5; +int do_shutdown = 0; +int enable_dynamic_scheduling = 0; + +class Worker : public ACE_Task_Base +{ + // = TITLE + // Run a server thread + // + // = DESCRIPTION + // Use the ACE_Task_Base class to run server threads + // +public: + Worker (CORBA::ORB_ptr orb, + Simple_Server_ptr server_ptr, + RTScheduling::Current_ptr current, + MIF_Scheduler* scheduler, + CORBA::Short importance, + CORBA::Long server_load); + // ctor + + virtual int svc (void); + // The thread entry point. + +private: + CORBA::ORB_var orb_; + // The orb + + Simple_Server_var server_; + RTScheduling::Current_var scheduler_current_; + MIF_Scheduler* scheduler_; + CORBA::Short importance_; + CORBA::Long server_load_; +}; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "xk:i:d"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'x': + do_shutdown = 1; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'd': + enable_dynamic_scheduling = 1; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k " + "-i " + "-d" + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + MIF_Scheduler* scheduler; + RTScheduling::Current_var current; + + ACE_hthread_t main_thr_handle; + ACE_Thread::self (main_thr_handle); + + ACE_OS::thr_setprio (main_thr_handle, + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD)); + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Simple_Server_var server = + Simple_Server::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (server.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Object reference <%s> is nil\n", + ior), + 1); + } + + if (enable_dynamic_scheduling) + { + ACE_DEBUG ((LM_DEBUG, "Dyn Sched enabled\n")); + CORBA::Object_ptr manager_obj = + orb->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = + TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + + ACE_NEW_RETURN (scheduler, + MIF_Scheduler (orb.in ()), -1); + + manager->rtscheduler (scheduler); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + current = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + } + + Worker worker1 (orb.in (), server.in (), current.in (), scheduler, 10, 500000 ); + + long flags = THR_NEW_LWP | THR_JOINABLE ; + + if (worker1.activate (flags, 1) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate client thread 1\n"), + 1); + + ACE_OS::sleep(5); + Worker worker2 (orb.in (), server.in (), current.in (), scheduler, 12, 20000); + if (worker2.activate (flags, 1) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate client thread 2\n"), + 1); + + worker1.wait (); + worker2.wait (); + + ACE_DEBUG ((LM_DEBUG, "(%t): wait for worker threads done in main thread\n")); + + if (do_shutdown) + { + if (enable_dynamic_scheduling) + { + MIF_Scheduling::SchedulingParameter sched_param; + sched_param.importance = 0; + CORBA::Policy_var sched_param_policy = + scheduler->create_scheduling_parameter (sched_param); + CORBA::Policy_ptr implicit_sched_param = 0; + current->begin_scheduling_segment (0, + sched_param_policy.in (), + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "(%t): about to call server shutdown\n")); + server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, "after shutdown call in main thread\n")); + + + if (enable_dynamic_scheduling) + { + current->end_scheduling_segment (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + } + + scheduler->shutdown (); + ACE_DEBUG ((LM_DEBUG, "scheduler shutdown done\n")); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + +// **************************************************************** + +Worker::Worker (CORBA::ORB_ptr orb, + Simple_Server_ptr server_ptr, + RTScheduling::Current_ptr current, + MIF_Scheduler* scheduler, + CORBA::Short importance, + CORBA::Long server_load) + : orb_ (CORBA::ORB::_duplicate (orb)), + server_ (Simple_Server::_duplicate (server_ptr)), + scheduler_current_ (RTScheduling::Current::_duplicate (current)), + scheduler_ (scheduler), + importance_ (importance), + server_load_ (server_load) +{ +} + +int +Worker::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + const char * name = 0; + + if (enable_dynamic_scheduling) + { + MIF_Scheduling::SchedulingParameter sched_param; + CORBA::Policy_var sched_param_policy; + sched_param.importance = importance_; + sched_param_policy = scheduler_->create_scheduling_parameter (sched_param); + CORBA::Policy_ptr implicit_sched_param = 0; + scheduler_current_->begin_scheduling_segment (name, + sched_param_policy.in (), + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "about to make two way call\n")); + server_->test_method (server_load_ ACE_ENV_ARG_PARAMETER); + ACE_DEBUG ((LM_DEBUG, "two way call done\n")); + ACE_TRY_CHECK; + + if (enable_dynamic_scheduling) + { + scheduler_current_->end_scheduling_segment (name); + ACE_CHECK; + } + + ACE_DEBUG ((LM_DEBUG, "client worker thread (%t) done\n")); + + return 0; +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.dsp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.dsp new file mode 100644 index 00000000000..7b50a416ab0 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/client.dsp @@ -0,0 +1,196 @@ +# Microsoft Developer Studio Project File - Name="MT_Server Client" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MT_Server Client - 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 "client.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 "client.mak" CFG="MT_Server Client - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MT_Server Client - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MT_Server Client - 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)" == "MT_Server Client - 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 Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\.." /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 ace.lib tao.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao" /libpath:"..\..\..\ace" + +!ELSEIF "$(CFG)" == "MT_Server Client - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# 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 "..\..\.." /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 taod.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao" /libpath:"..\..\..\ace" + +!ENDIF + +# Begin Target + +# Name "MT_Server Client - Win32 Release" +# Name "MT_Server Client - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\client.cpp +# End Source File +# Begin Source File + +SOURCE=.\testC.cpp +# ADD CPP /GR +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\testC.h +# End Source File +# End Group +# Begin Group "IDL Files" + +# PROP Default_Filter "idl" +# Begin Source File + +SOURCE=.\test.idl + +!IF "$(CFG)" == "MT_Server Client - Win32 Release" + +USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ELSEIF "$(CFG)" == "MT_Server Client - Win32 Debug" + +USERDEP__TEST_="..\..\..\bin\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ENDIF + +# End Source File +# End Group +# End Target +# End Project diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.cpp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.cpp new file mode 100644 index 00000000000..7c935b465cf --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.cpp @@ -0,0 +1,213 @@ +// $Id$ + +#include "test_i.h" +#include "ace/Get_Opt.h" +#include "ace/Task.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "MIF_Scheduler.h" + +ACE_RCSID(MT_Server, server, "$Id$") + +const char *ior_output_file = 0; + +int nthreads = 2; +int enable_dynamic_scheduling = 0; +const CORBA::Short max_importance = 100; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:n:d"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.opt_arg (); + break; + + case 'n': + nthreads = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'd': + enable_dynamic_scheduling = 1; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +class Worker : public ACE_Task_Base +{ + // = TITLE + // Run a server thread + // + // = DESCRIPTION + // Use the ACE_Task_Base class to run server threads + // +public: + Worker (CORBA::ORB_ptr orb); + // ctor + + virtual int svc (void); + // The thread entry point. + +private: + CORBA::ORB_var orb_; + // The orb +}; + +int +main (int argc, char *argv[]) +{ + MIF_Scheduler* scheduler; + RTScheduling::Current_var current; + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the POA.\n"), + 1); + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + if (enable_dynamic_scheduling) + { + CORBA::Object_ptr manager_obj = + orb->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = + TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_NEW_RETURN (scheduler, + MIF_Scheduler (orb.in ()), -1); + + manager->rtscheduler (scheduler); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + current = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + Simple_Server_i server_impl (orb.in ()); + + Simple_Server_var server = + server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); + + // If the ior_output_file exists, output the ior to it + if (ior_output_file != 0) + { + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + } + + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + long flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND | THR_SCHED_RR; + Worker worker (orb.in ()); + if (worker.activate (flags, + nthreads) != 0) + { + flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND; + if (worker.activate (flags, nthreads) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate server threads\n"), + 1); + } + } + + worker.wait (); + + ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); + + ACE_DEBUG ((LM_DEBUG, "shutting down scheduler\n")); + scheduler->shutdown (); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + +// **************************************************************** + +Worker::Worker (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +int +Worker::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_Time_Value tv(120); + + ACE_TRY + { + this->orb_->run (tv ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.dsp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.dsp new file mode 100644 index 00000000000..2f1cfb0a3c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/server.dsp @@ -0,0 +1,208 @@ +# Microsoft Developer Studio Project File - Name="MT_Server Server" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MT_Server Server - 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 "server.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 "server.mak" CFG="MT_Server Server - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MT_Server Server - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MT_Server Server - 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)" == "MT_Server Server - 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 Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\.." /I "..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 ace.lib TAO.lib TAO_PortableServer.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\lib" /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer" + +!ELSEIF "$(CFG)" == "MT_Server Server - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "server___Win32_Debug" +# PROP BASE Intermediate_Dir "server___Win32_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# 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 "..\..\.." /I "..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# 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 TAOd.lib TAO_PortableServerd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\lib" /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer" + +!ENDIF + +# Begin Target + +# Name "MT_Server Server - Win32 Release" +# Name "MT_Server Server - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\server.cpp +# End Source File +# Begin Source File + +SOURCE=.\test_i.cpp +# End Source File +# Begin Source File + +SOURCE=.\testC.cpp +# ADD CPP /GR +# End Source File +# Begin Source File + +SOURCE=.\testS.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\test_i.h +# End Source File +# Begin Source File + +SOURCE=.\testS.h +# End Source File +# End Group +# Begin Group "IDL Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\test.idl + +!IF "$(CFG)" == "MT_Server Server - Win32 Release" + +USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ELSEIF "$(CFG)" == "MT_Server Server - Win32 Debug" + +USERDEP__TEST_="..\..\..\bin\tao_idl.exe" +# Begin Custom Build - Invoking TAO's IDL Compiler on $(InputPath) +InputPath=.\test.idl +InputName=test + +BuildCmds= \ + ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl + +"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) + +"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + $(BuildCmds) +# End Custom Build + +!ENDIF + +# End Source File +# End Group +# End Target +# End Project diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test.idl b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test.idl new file mode 100644 index 00000000000..deed5409437 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test.idl @@ -0,0 +1,10 @@ +// +// $Id$ +// + +interface Simple_Server +{ + long test_method (in long x); + + void shutdown (); +}; diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.cpp b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.cpp new file mode 100644 index 00000000000..8d5f3d797d8 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.cpp @@ -0,0 +1,69 @@ +// $Id$ + +#include "test_i.h" +#include "ace/High_Res_Timer.h" +#include "tao/debug.h" + +#if !defined(__ACE_INLINE__) +#include "test_i.i" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID(MT_Server, test_i, "$Id$") + +CORBA::Long +Simple_Server_i::test_method (CORBA::Long x ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_hthread_t thr_handle; + ACE_Thread::self (thr_handle); + int prio; + long server_load = x; + + ACE_High_Res_Timer timer; + ACE_Time_Value elapsed_time; + + ACE_DEBUG ((LM_DEBUG, "Request in thread %t\n")); + + if (ACE_Thread::getprio (thr_handle, prio) == -1) + { + if (errno == ENOTSUP) + { + ACE_DEBUG((LM_DEBUG, + ACE_TEXT ("getprio not supported on this platform\n") + )); + return 0; + } + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("getprio failed")), + -1); + } + + // if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Request in thread %t, prio = %d, load = %u\n", prio, server_load)); + + static CORBA::ULong prime_number = 9619899; + + timer.start (); + for (long j = 0; j < server_load; ++j) + { + ACE_DEBUG ((LM_DEBUG, "(%t) loop # = %d, load = %u\n", j, server_load)); + ACE::is_prime (prime_number, + 2, + prime_number / 2); + } + timer.stop (); + timer.elapsed_time (elapsed_time); + + ACE_DEBUG ((LM_DEBUG, "Request processing in thread %t done, prio = %d, load = %d, elapsed time = %u\n", prio, x, elapsed_time.msec () )); + + return x; +} + +void +Simple_Server_i::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_DEBUG ((LM_DEBUG, "shutdown request from client\n")); + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.h b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.h new file mode 100644 index 00000000000..65fa40ed8b2 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.h @@ -0,0 +1,49 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/MT_Server +// +// = FILENAME +// test_i.h +// +// = AUTHOR +// Carlos O'Ryan +// +// ============================================================================ + +#ifndef TAO_MT_SERVER_TEST_I_H +#define TAO_MT_SERVER_TEST_I_H + +#include "testS.h" + +class Simple_Server_i : public POA_Simple_Server +{ + // = TITLE + // Simpler Server implementation + // + // = DESCRIPTION + // Implements the Simple_Server interface in test.idl + // +public: + Simple_Server_i (CORBA::ORB_ptr orb); + // ctor + + // = The Simple_Server methods. + CORBA::Long test_method (CORBA::Long x ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + CORBA::ORB_var orb_; + // The ORB +}; + +#if defined(__ACE_INLINE__) +#include "test_i.i" +#endif /* __ACE_INLINE__ */ + +#endif /* TAO_MT_SERVER_TEST_I_H */ diff --git a/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.i b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.i new file mode 100644 index 00000000000..97524552ff4 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/mif_example/test_i.i @@ -0,0 +1,7 @@ +// $Id$ + +ACE_INLINE +Simple_Server_i::Simple_Server_i (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.cpp new file mode 100644 index 00000000000..cc9bc66c9ce --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.cpp @@ -0,0 +1,647 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:318 + + +#include "Kokyu_qosC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* !defined INLINE */ + +#if !defined (_KOKYU_GUIDTYPE_CS_) +#define _KOKYU_GUIDTYPE_CS_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_cs.cpp:250 + +// ************************************************************* +// Kokyu::GuidType +// ************************************************************* + +Kokyu::GuidType::GuidType (void) +{} + +Kokyu::GuidType::GuidType (CORBA::ULong max) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} + +Kokyu::GuidType::GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release + ) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} + +Kokyu::GuidType::GuidType (const GuidType &seq) + : + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} + +Kokyu::GuidType::~GuidType (void) // dtor +{} + +void Kokyu::GuidType::_tao_any_destructor (void *_tao_void_pointer) +{ + GuidType *tmp = ACE_static_cast (GuidType*, _tao_void_pointer); + delete tmp; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_GuidType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_GuidType ( + CORBA::tk_alias, + sizeof (_oc_Kokyu_GuidType), + (char *) &_oc_Kokyu_GuidType, + 0, + sizeof (Kokyu::GuidType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_GuidType, + &_tc_TAO_tc_Kokyu_GuidType + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_Kokyu_Svc_Ctxt_DSRT_QoS[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f5376), + ACE_NTOHL (0x635f4374), + ACE_NTOHL (0x78745f44), + ACE_NTOHL (0x5352545f), + ACE_NTOHL (0x516f533a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/Kokyu/Svc_Ctxt_DSRT_QoS:1.0 + 18, + ACE_NTOHL (0x5376635f), + ACE_NTOHL (0x43747874), + ACE_NTOHL (0x5f445352), + ACE_NTOHL (0x545f516f), + ACE_NTOHL (0x53000000), // name = Svc_Ctxt_DSRT_QoS + 6, // member count + 5, + ACE_NTOHL (0x67756964), + ACE_NTOHL (0x0), // name = guid + CORBA::tk_alias, // typecode kind for typedefs + 76, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x4b6f6b79), + ACE_NTOHL (0x752f4775), + ACE_NTOHL (0x69645479), + ACE_NTOHL (0x70653a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/Kokyu/GuidType:1.0 + 9, + ACE_NTOHL (0x47756964), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x0), // name = GuidType + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + + + 11, + ACE_NTOHL (0x696d706f), + ACE_NTOHL (0x7274616e), + ACE_NTOHL (0x63650000), // name = importance + CORBA::tk_long, + + 12, + ACE_NTOHL (0x63726974), + ACE_NTOHL (0x6963616c), + ACE_NTOHL (0x69747900), // name = criticality + CORBA::tk_long, + + 17, + ACE_NTOHL (0x64657369), + ACE_NTOHL (0x7265645f), + ACE_NTOHL (0x7072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = desired_priority + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/RTCORBA/Priority:1.0 + 9, + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = Priority + CORBA::tk_short, + + + 9, + ACE_NTOHL (0x64656164), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = deadline + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 33, + ACE_NTOHL (0x65737469), + ACE_NTOHL (0x6d617465), + ACE_NTOHL (0x645f696e), + ACE_NTOHL (0x69746961), + ACE_NTOHL (0x6c5f6578), + ACE_NTOHL (0x65637574), + ACE_NTOHL (0x696f6e5f), + ACE_NTOHL (0x74696d65), + ACE_NTOHL (0x0), // name = estimated_initial_execution_time + 0xffffffff, // indirection + 0xffffff94, // negative offset (-108) +}; + +static CORBA::TypeCode _tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS ( + CORBA::tk_struct, + sizeof (_oc_Kokyu_Svc_Ctxt_DSRT_QoS), + (char *) &_oc_Kokyu_Svc_Ctxt_DSRT_QoS, + 0, + sizeof (Kokyu::Svc_Ctxt_DSRT_QoS) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (Kokyu) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Svc_Ctxt_DSRT_QoS, + &_tc_TAO_tc_Kokyu_Svc_Ctxt_DSRT_QoS + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:67 + +void Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor (void *_tao_void_pointer) +{ + Svc_Ctxt_DSRT_QoS *tmp = ACE_static_cast (Svc_Ctxt_DSRT_QoS*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::GuidType &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::GuidType *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_GuidType, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::GuidType::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::GuidType *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast( + const Kokyu::GuidType*&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::GuidType *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_GuidType + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (!result) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const Kokyu::GuidType*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::GuidType *tmp = 0; + ACE_NEW_RETURN ( + tmp, + Kokyu::GuidType, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_GuidType, + 1, + ACE_static_cast (void *, tmp), + Kokyu::GuidType::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *_tao_elem + ) +{ + TAO_OutputCDR stream; + + if (stream << *_tao_elem) + { + _tao_any._tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + } +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const Kokyu::Svc_Ctxt_DSRT_QoS *&_tao_elem + ) +{ + _tao_elem = 0; + + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = + type->equivalent ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS + ACE_ENV_ARG_PARAMETER + ); + ACE_TRY_CHECK; + + if (result == 0) + { + return 0; // not equivalent + } + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast ( + const Kokyu::Svc_Ctxt_DSRT_QoS*, + _tao_any.value () + ); + + return 1; + } + else + { + Kokyu::Svc_Ctxt_DSRT_QoS *tmp; + ACE_NEW_RETURN ( + tmp, + Kokyu::Svc_Ctxt_DSRT_QoS, + 0 + ); + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + Kokyu::_tc_Svc_Ctxt_DSRT_QoS, + 1, + ACE_static_cast (void *, tmp), + Kokyu::Svc_Ctxt_DSRT_QoS::_tao_any_destructor + ); + + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_cs.cpp:103 + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len = _tao_sequence.length (); + + if (strm << _tao_seq_len) + { + // Encode all elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast (TAO_Unbounded_Sequence*, (Kokyu::GuidType *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::GuidType &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + + if (strm >> _tao_seq_len) + { + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length ()) + { + return 0; + } + + // Set the length of the sequence. + _tao_sequence.length (_tao_seq_len); + + // If length is 0 we return true. + if (0 >= _tao_seq_len) + { + return 1; + } + + // Retrieve all the elements. + +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + if (ACE_BIT_DISABLED (strm.start ()->flags (), + ACE_Message_Block::DONT_DELETE)) + { + TAO_ORB_Core* orb_core = strm.orb_core (); + if (orb_core != 0 && + strm.orb_core ()->resource_factory ()-> + input_cdr_allocator_type_locked () == 1) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + } + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); +#else /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 0 */ + } + + return 0; +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.h b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.h new file mode 100644 index 00000000000..5c1ad4e62c5 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.h @@ -0,0 +1,350 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_KOKYU_QOSC_H_ +#define _TAO_IDL_KOKYU_QOSC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "RTSchedulerC.h" +#include "RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE Kokyu +{ + +#if !defined (_KOKYU_GUIDTYPE_CH_) +#define _KOKYU_GUIDTYPE_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:371 + + class GuidType; + class GuidType_var; + + // ************************************************************* + // Kokyu::GuidType + // ************************************************************* + + class GuidType : public + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:51 + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + GuidType (void); + GuidType (CORBA::ULong max); + GuidType ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release = 0 + ); + GuidType (const GuidType &); + ~GuidType (void); + + static void _tao_any_destructor (void*); + + typedef GuidType_var _var_type; +#if (TAO_NO_COPY_OCTET_SEQUENCES == 1) + GuidType ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE == 1 */ + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___VAR_CH_) +#define _KOKYU_GUIDTYPE___VAR_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:549 + + // ************************************************************* + // class Kokyu::GuidType_var + // ************************************************************* + + class GuidType_var + { + public: + GuidType_var (void); + GuidType_var (GuidType *); + GuidType_var (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var (const GuidType &); + + ~GuidType_var (void); + + GuidType_var &operator= (GuidType *); + GuidType_var &operator= (const GuidType_var &); + + // Fixed-size base types only. + GuidType_var &operator= (const GuidType &); + + GuidType *operator-> (void); + const GuidType *operator-> (void) const; + + operator const GuidType &() const; + operator GuidType &(); + operator GuidType &() const; + CORBA::Octet & operator[] (CORBA::ULong index); + const CORBA::Octet & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const GuidType &in (void) const; + GuidType &inout (void); + GuidType *&out (void); + GuidType *_retn (void); + GuidType *ptr (void) const; + + private: + GuidType *ptr_; + }; + +#endif /* end #if !defined */ + +#if !defined (_KOKYU_GUIDTYPE___OUT_CH_) +#define _KOKYU_GUIDTYPE___OUT_CH_ + + // TAO_IDL - Generated from + // be/be_visitor_sequence/sequence_ch.cpp:753 + + class GuidType_out + { + public: + GuidType_out (GuidType *&); + GuidType_out (GuidType_var &); + GuidType_out (const GuidType_out &); + GuidType_out &operator= (const GuidType_out &); + GuidType_out &operator= (GuidType *); + operator GuidType *&(); + GuidType *&ptr (void); + GuidType *operator-> (void); + CORBA::Octet & operator[] (CORBA::ULong index); + + private: + GuidType *&ptr_; + // Assignment from T_var not allowed. + void operator= (const GuidType_var &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_GuidType; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:49 + + class Svc_Ctxt_DSRT_QoS_var; + + struct Svc_Ctxt_DSRT_QoS + { + typedef Svc_Ctxt_DSRT_QoS_var _var_type; + + static void _tao_any_destructor (void *); + Kokyu::GuidType guid; + CORBA::Long importance; + CORBA::Long criticality; + RTCORBA::Priority desired_priority; + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:71 + + class Svc_Ctxt_DSRT_QoS_var + { + public: + Svc_Ctxt_DSRT_QoS_var (void); + Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var (const Svc_Ctxt_DSRT_QoS_var &); + ~Svc_Ctxt_DSRT_QoS_var (void); + + Svc_Ctxt_DSRT_QoS_var &operator= (Svc_Ctxt_DSRT_QoS *); + Svc_Ctxt_DSRT_QoS_var &operator= (const Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS *operator-> (void); + const Svc_Ctxt_DSRT_QoS *operator-> (void) const; + + operator const Svc_Ctxt_DSRT_QoS &() const; + operator Svc_Ctxt_DSRT_QoS &(); + operator Svc_Ctxt_DSRT_QoS &() const; + + // Variable-size types only. + operator Svc_Ctxt_DSRT_QoS *&(); + + // in, inout, out, _retn + const Svc_Ctxt_DSRT_QoS &in (void) const; + Svc_Ctxt_DSRT_QoS &inout (void); + Svc_Ctxt_DSRT_QoS *&out (void); + Svc_Ctxt_DSRT_QoS *_retn (void); + Svc_Ctxt_DSRT_QoS *ptr (void) const; + + private: + Svc_Ctxt_DSRT_QoS *ptr_; + }; + + // TAO_IDL - Generated from + // be/be_structure.cpp:445 + + class Svc_Ctxt_DSRT_QoS_out + { + public: + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS *&); + Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &); + Svc_Ctxt_DSRT_QoS_out (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (const Svc_Ctxt_DSRT_QoS_out &); + Svc_Ctxt_DSRT_QoS_out &operator= (Svc_Ctxt_DSRT_QoS *); + operator Svc_Ctxt_DSRT_QoS *&(); + Svc_Ctxt_DSRT_QoS *&ptr (void); + Svc_Ctxt_DSRT_QoS *operator-> (void); + + private: + Svc_Ctxt_DSRT_QoS *&ptr_; + // Assignment from T_var not allowed. + void operator= (const Svc_Ctxt_DSRT_QoS_var &); + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Svc_Ctxt_DSRT_QoS; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module Kokyu + +// TAO_IDL - Generated from +// be/be_visitor_sequence/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::GuidType &); // copying version + void operator<<= (CORBA::Any &, Kokyu::GuidType*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::GuidType *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::GuidType *&); + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS &); // copying version + void operator<<= (CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, Kokyu::Svc_Ctxt_DSRT_QoS *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const Kokyu::Svc_Ctxt_DSRT_QoS *&); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ch.cpp:57 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_H_ +#define _TAO_CDR_OP_Kokyu_GuidType_H_ + + CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_H_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:54 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const Kokyu::Svc_Ctxt_DSRT_QoS &); + CORBA::Boolean operator>> (TAO_InputCDR &, Kokyu::Svc_Ctxt_DSRT_QoS &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1004 + +#if defined (__ACE_INLINE__) +#include "Kokyu_qosC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.i b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.i new file mode 100644 index 00000000000..56edaae1cd6 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/Kokyu_qosC.i @@ -0,0 +1,559 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +#if !defined (_KOKYU_GUIDTYPE_CI_) +#define _KOKYU_GUIDTYPE_CI_ + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:226 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_var +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (GuidType *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::GuidType (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +// Fixed-size base types only. +ACE_INLINE +Kokyu::GuidType_var::GuidType_var (const ::Kokyu::GuidType &p) +{ + ACE_NEW (this->ptr_, ::Kokyu::GuidType (p)); +} + +ACE_INLINE +Kokyu::GuidType_var::~GuidType_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (GuidType *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + GuidType *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + GuidType (*p.ptr_), + *this + ); + + if (deep_copy != 0) + { + GuidType *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// Fixed-size types only. +ACE_INLINE +::Kokyu::GuidType_var & +Kokyu::GuidType_var::operator= (const ::Kokyu::GuidType &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::Kokyu::GuidType (p), *this); + } + + return *this; +} + +ACE_INLINE +const ::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator const ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::GuidType_var::operator ::Kokyu::GuidType &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE +const CORBA::Octet & +Kokyu::GuidType_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index)); +} + +ACE_INLINE +const ::Kokyu::GuidType & +Kokyu::GuidType_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType & +Kokyu::GuidType_var::inout (void) +{ + return *this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::_retn (void) +{ + ::Kokyu::GuidType *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/sequence_ci.cpp:567 + +// ************************************************************* +// Inline operations for class Kokyu::GuidType_out +// ************************************************************* + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (GuidType_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::GuidType_out::GuidType_out (const ::Kokyu::GuidType_out &p) + : ptr_ (ACE_const_cast (GuidType_out&, p).ptr_) +{} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (const ::Kokyu::GuidType_out &p) +{ + this->ptr_ = ACE_const_cast (GuidType_out&, p).ptr_; + return *this; +} + +ACE_INLINE +::Kokyu::GuidType_out & +Kokyu::GuidType_out::operator= (GuidType *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +Kokyu::GuidType_out::operator ::Kokyu::GuidType *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType *& +Kokyu::GuidType_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE +::Kokyu::GuidType * +Kokyu::GuidType_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::Octet & +Kokyu::GuidType_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_structure.cpp:194 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_var +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (void) + : ptr_ (0) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (Svc_Ctxt_DSRT_QoS *p) + : ptr_ (p) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::Svc_Ctxt_DSRT_QoS_var (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &p) +{ + if (p.ptr_) + { + ACE_NEW (this->ptr_, ::Kokyu::Svc_Ctxt_DSRT_QoS (*p.ptr_)); + } + else + { + this->ptr_ = 0; + } +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::~Svc_Ctxt_DSRT_QoS_var (void) +{ + delete this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_var) +{ + delete this->ptr_; + this->ptr_ = _tao_struct_var; + return *this; +} + +ACE_INLINE +::Kokyu::Svc_Ctxt_DSRT_QoS_var & +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_var &_tao_struct_var) +{ + if (this != &_tao_struct_var) + { + if (_tao_struct_var.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + Svc_Ctxt_DSRT_QoS *deep_copy = 0; + ACE_NEW_RETURN ( + deep_copy, + Svc_Ctxt_DSRT_QoS (*_tao_struct_var.ptr_), + *this + ); + + if (deep_copy != 0) + { + Svc_Ctxt_DSRT_QoS *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator const ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS &() const // cast +{ + return *this->ptr_; +} + +// Variable-size types only. +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_var::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS & +Kokyu::Svc_Ctxt_DSRT_QoS_var::inout (void) +{ + return *this->ptr_; +} + +// Mapping for variable size. +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::_retn (void) +{ + ::Kokyu::Svc_Ctxt_DSRT_QoS *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_var::ptr (void) const +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_structure.cpp:523 + +// ************************************************************* +// Inline operations for class Kokyu::Svc_Ctxt_DSRT_QoS_out +// ************************************************************* + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (::Kokyu::Svc_Ctxt_DSRT_QoS *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (Svc_Ctxt_DSRT_QoS_var &p) + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::Svc_Ctxt_DSRT_QoS_out (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) + : ptr_ (ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_) +{} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (const ::Kokyu::Svc_Ctxt_DSRT_QoS_out &p) +{ + this->ptr_ = ACE_const_cast (Svc_Ctxt_DSRT_QoS_out&, p).ptr_; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out & +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator= (Svc_Ctxt_DSRT_QoS *_tao_struct_out) +{ + this->ptr_ = _tao_struct_out; + return *this; +} + +ACE_INLINE +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator ::Kokyu::Svc_Ctxt_DSRT_QoS *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS *& +Kokyu::Svc_Ctxt_DSRT_QoS_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::Kokyu::Svc_Ctxt_DSRT_QoS * +Kokyu::Svc_Ctxt_DSRT_QoS_out::operator-> (void) +{ + return this->ptr_; +} + +// TAO_IDL - Generated from +// be/be_visitor_sequence/cdr_op_ci.cpp:84 + +#if !defined _TAO_CDR_OP_Kokyu_GuidType_I_ +#define _TAO_CDR_OP_Kokyu_GuidType_I_ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const Kokyu::GuidType & + ); + +CORBA::Boolean operator>> ( + TAO_InputCDR &, + Kokyu::GuidType & + ); + +#endif /* _TAO_CDR_OP_Kokyu_GuidType_I_ */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:71 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm << _tao_aggregate.guid) && + (strm << _tao_aggregate.importance) && + (strm << _tao_aggregate.criticality) && + (strm << _tao_aggregate.desired_priority) && + (strm << _tao_aggregate.deadline) && + (strm << _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + Kokyu::Svc_Ctxt_DSRT_QoS &_tao_aggregate + ) +{ + if ( + (strm >> _tao_aggregate.guid) && + (strm >> _tao_aggregate.importance) && + (strm >> _tao_aggregate.criticality) && + (strm >> _tao_aggregate.desired_priority) && + (strm >> _tao_aggregate.deadline) && + (strm >> _tao_aggregate.estimated_initial_execution_time) + ) + { + return 1; + } + else + { + return 0; + } +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.cpp b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.cpp new file mode 100644 index 00000000000..93d48cbfaf7 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.cpp @@ -0,0 +1,656 @@ +//$Id$ + +#include "MUF_Scheduler.h" +#include "ace/Atomic_Op.h" +#include "../Kokyu_qosC.h" + +//this needs to be formally defined in IOP.pidl +namespace +{ + static const IOP::ServiceId service_id = 0xdddd; +} + +ACE_Time_Value time_base_to_tv (TimeBase::TimeT time) +{ + ACE_Time_Value tv(0,time/10); + + return tv; +} + +void guid_copy( Kokyu::GuidType& lhs, const RTScheduling::Current::IdType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +void guid_copy( RTScheduling::Current::IdType& lhs, const Kokyu::GuidType& rhs) +{ + lhs.length(rhs.length ()); + ACE_OS::memcpy(lhs.get_buffer (), + rhs.get_buffer (), + rhs.length ()); +} + +ACE_Atomic_Op server_guid_counter; + +MUF_Scheduling::SchedulingParameter +MUF_Sched_Param_Policy::value (void) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->value_; +} + +void +MUF_Sched_Param_Policy::value (const MUF_Scheduling::SchedulingParameter& value) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->value_ = value; +} + +MUF_Scheduler::MUF_Scheduler (CORBA::ORB_ptr orb) + : orb_ (orb) +{ + Kokyu::DSRT_ConfigInfo config; + + config.sched_strategy_ = Kokyu::DSRT_MUF; + kokyu_dispatcher_ = Kokyu::Dispatcher_Factory::create_DSRT_dispatcher (config); + + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + this->current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + IOP::CodecFactory_var codec_factory; + CORBA::Object_var obj = orb->resolve_initial_references ("CodecFactory"); + + if (CORBA::is_nil(obj.in ())) + { + ACE_ERROR ((LM_ERROR, "Nil Codec factory\n")); + } + else + { + codec_factory = IOP::CodecFactory::_narrow (obj.in ()); + } + + IOP::Encoding encoding; + encoding.format = IOP::ENCODING_CDR_ENCAPS; + encoding.major_version = 1; + encoding.minor_version = 2; + + codec_ = codec_factory->create_codec (encoding); +} + +MUF_Scheduler::~MUF_Scheduler (void) +{ + delete kokyu_dispatcher_; +} + +void +MUF_Scheduler::shutdown (void) +{ + kokyu_dispatcher_->shutdown (); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduler::create_scheduling_parameter (const MUF_Scheduling::SchedulingParameter & value) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + MUF_Scheduling::SchedulingParameterPolicy_ptr sched_param_policy; + ACE_NEW_THROW_EX (sched_param_policy, + MUF_Sched_Param_Policy, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + + sched_param_policy->value (value); + + return sched_param_policy; +} + + +void +MUF_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char *, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + Kokyu::DSRT_QoSDescriptor qos; + MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + + qos.deadline_ = time_base_to_tv (sched_param->deadline); + qos.exec_time_ = time_base_to_tv (sched_param->estimated_initial_execution_time); + qos.criticality_ = sched_param->criticality; + + kokyu_dispatcher_->schedule (count, qos); +} + +void +MUF_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +void +MUF_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char */*name*/, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr /*implicit_sched_param*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count ; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + Kokyu::DSRT_QoSDescriptor qos; + + qos.deadline_ = time_base_to_tv (sched_param->deadline); + qos.exec_time_ = time_base_to_tv (sched_param->estimated_initial_execution_time); + qos.criticality_ = sched_param->criticality; + + kokyu_dispatcher_->update_schedule (count, qos); +} + +void +MUF_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char * + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int count; + ACE_OS::memcpy (&count, + guid.get_buffer (), + guid.length ()); + + + ACE_DEBUG ((LM_DEBUG, "(%t) call to end_sched_segment for guid %d\n", count)); + kokyu_dispatcher_->cancel_schedule (count); +} + +void +MUF_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + +} + + +void +MUF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_request " + "from \"%s\"\n", + operation.in ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + CORBA::Long criticality; + TimeBase::TimeT deadline,exec_time; + + if (CORBA::is_nil (sched_policy)) + { + //24 hrs from now - infinity + ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0); + deadline = deadline_tv.sec () * 1000000 + deadline_tv.usec () * 10; //100s of nanoseconds for TimeBase::TimeT + exec_time = 0; + criticality = 0; + } + else + { + MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + deadline = sched_param->deadline; + exec_time = sched_param->estimated_initial_execution_time; + criticality = sched_param->criticality; + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request criticality from current = %d\n"), + criticality)); + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + + //Fill the guid in the SC Qos struct + sc_qos.guid.length (this->current_->id ()->length ()); + //sc_qos.guid = *(this->current_->id ()); + guid_copy (sc_qos.guid, *(this->current_->id ())); + sc_qos.deadline = deadline; + sc_qos.estimated_initial_execution_time = exec_time; + sc_qos.criticality = criticality; + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + ACE_TRY_NEW_ENV + { + sc.context_data = + ACE_reinterpret_cast(IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + } + ACE_ENDTRY; + + + ACE_DEBUG ((LM_DEBUG, "after encode\n")); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to add sched SC\n"))); + + // Add this context to the service context list. + ri->add_request_service_context (sc, 0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): send_request : about to call scheduler to inform block\n") + )); + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%t): guid = %d, send_request interceptor done\n"), + guid)); +} + +void +MUF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid_out, + CORBA::String_out /*name*/, + CORBA::Policy_out sched_param_out, + CORBA::Policy_out /*implicit_sched_param_out*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + ACE_DEBUG ((LM_DEBUG, "entered MUF_Scheduler::receive_request\n")); + RTScheduling::Current::IdType* guid; + ACE_NEW (guid, + RTScheduling::Current::IdType); + + + // Generate GUID. + guid->length (sizeof(long)); + + long temp = ++server_guid_counter; + ACE_OS::memcpy (guid->get_buffer (), + &temp, + sizeof(long)); + + int id; + ACE_OS::memcpy (&id, + guid->get_buffer (), + guid->length ()); + + guid_out.ptr () = guid; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): receive_request from " + "\"%s\"\n", + operation.in ())); + + // Ignore the "_is_a" operation since it may have been invoked + // locally on the server side as a side effect of another call, + // meaning that the client hasn't added the service context yet. + if (ACE_OS_String::strcmp ("_is_a", operation.in ()) == 0) + return; + + IOP::ServiceContext_var sc = + ri->get_request_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Long criticality; + TimeBase::TimeT deadline,exec_time; + + if (sc.ptr () == 0) + { + //24 hrs from now - infinity + ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0); + deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT + exec_time = 0; + criticality = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + deadline = sc_qos_ptr->deadline; + criticality = sc_qos_ptr->criticality; + exec_time = sc_qos_ptr->estimated_initial_execution_time; + + //*(guid_out.ptr ()) = sc_qos_ptr->guid; + guid_copy (*(guid_out.ptr ()), sc_qos_ptr->guid); + + + ACE_OS::memcpy (&id, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Criticality = %d, guid = %d in recvd service context\n", + criticality, + id)); + + MUF_Scheduling::SchedulingParameter sched_param; + sched_param.criticality = criticality; + sched_param.deadline = deadline; + sched_param_out.ptr () = this->create_scheduling_parameter (sched_param); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.criticality_ = criticality; + qos.deadline_ = time_base_to_tv (deadline); + qos.exec_time_ = time_base_to_tv (exec_time); + + this->kokyu_dispatcher_->schedule (id, qos); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, receive_request interceptor done\n", id)); +} + +void +MUF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "(%t): send_reply from \"%s\"\n", + ri->operation ())); + + // Make the context to send the context to the target + IOP::ServiceContext sc; + sc.context_id = ::service_id; + + CORBA::Long criticality; + TimeBase::TimeT deadline,exec_time; + + CORBA::Policy_ptr sched_policy = + this->current_->scheduling_parameter(ACE_ENV_ARG_PARAMETER); + + int guid; + ACE_OS::memcpy (&guid, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + if (CORBA::is_nil (sched_policy)) + { + ACE_DEBUG ((LM_DEBUG, "sched_policy nil\n")); + + //24 hrs from now - infinity + ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0); + deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT + exec_time = 0; + criticality = 0; + } + else + { + ACE_DEBUG ((LM_DEBUG, "sched_policy not nil\n")); + + MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy = + MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy); + + MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value (); + + Kokyu::Svc_Ctxt_DSRT_QoS sc_qos; + //Fill the guid in the SC Qos struct + //sc_qos.guid = *(this->current_->id ()); + guid_copy ( sc_qos.guid, *(this->current_->id ())); + + deadline = sched_param->deadline; + exec_time = sched_param->estimated_initial_execution_time; + criticality = sched_param->criticality; + sc_qos.deadline = deadline; + sc_qos.estimated_initial_execution_time = exec_time; + sc_qos.criticality = criticality; + + CORBA::Any sc_qos_as_any; + sc_qos_as_any <<= sc_qos; + + sc.context_data = ACE_reinterpret_cast( + IOP::ServiceContext::_tao_seq_Octet &, + *codec_->encode (sc_qos_as_any)); + + // Add this context to the service context list. + ri->add_reply_service_context (sc, 1 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, "reply sc added\n")); + } + + kokyu_dispatcher_->update_schedule (guid, Kokyu::BLOCK); + + ACE_DEBUG ((LM_DEBUG, "(%t): guid = %d, send_reply interceptor done\n", guid)); +} + +void +MUF_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MUF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MUF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int guid = 0; + + CORBA::String_var operation = ri->operation (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var target = ri->target (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "receive_reply from " + "\"%s\"\n", + operation.in ())); + + // Check that the reply service context was received as + // expected. + IOP::ServiceContext_var sc = + ri->get_reply_service_context (::service_id ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Long criticality; + TimeBase::TimeT deadline,exec_time; + + if (sc.ptr () == 0) + { + ACE_DEBUG ((LM_DEBUG, "service context was not filled\n")); + //24 hrs from now - infinity + ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0); + deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT + exec_time = 0; + criticality = 0; + } + else + { + CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (), + sc->context_data.length (), + sc->context_data.get_buffer (), + 0); + + //Don't store in a _var, since >>= returns a pointer to an internal buffer + //and we are not supposed to free it. + Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr; + CORBA::Any sc_qos_as_any; + sc_qos_as_any = *codec_->decode (oc_seq); + sc_qos_as_any >>= sc_qos_ptr; + + deadline = sc_qos_ptr->deadline; + criticality = sc_qos_ptr->criticality; + exec_time = sc_qos_ptr->estimated_initial_execution_time; + + ACE_OS::memcpy (&guid, + sc_qos_ptr->guid.get_buffer (), + sc_qos_ptr->guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "(%t): Criticality = %d, guid = %d in recvd service context\n", + criticality, + guid)); + } + + Kokyu::DSRT_QoSDescriptor qos; + qos.criticality_ = criticality; + qos.deadline_ = time_base_to_tv (deadline); + qos.exec_time_ = time_base_to_tv (exec_time); + this->kokyu_dispatcher_->schedule (guid, qos); +} + +void +MUF_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MUF_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +MUF_Scheduler::cancel (const RTScheduling::Current::IdType & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MUF_Scheduler::scheduling_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MUF_Scheduler::scheduling_policies (const CORBA::PolicyList & + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MUF_Scheduler::poa_policies (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +char * +MUF_Scheduler::scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +RTScheduling::ResourceManager_ptr +MUF_Scheduler::create_resource_manager (const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MUF_Scheduler::set_scheduling_parameter (PortableServer::Servant &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.h b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.h new file mode 100644 index 00000000000..f1e2770c1b6 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduler.h @@ -0,0 +1,161 @@ +//$Id$ + +#ifndef MUF_SCHEDULER_H +#define MUF_SCHEDULER_H + +#include "tao/RTScheduling/RTSchedulerC.h" +#include "MUF_SchedulingC.h" +#include "Kokyu.h" + +class MUF_Sched_Param_Policy: +public MUF_Scheduling::SchedulingParameterPolicy, + public TAO_Local_RefCounted_Object +{ + public: + + MUF_Scheduling::SchedulingParameter value (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void value (const MUF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + MUF_Scheduling::SchedulingParameter value_; +}; + +class MUF_Scheduler: +public MUF_Scheduling::Scheduler, +public TAO_Local_RefCounted_Object +{ + public: + + MUF_Scheduler (CORBA::ORB_ptr orb); + + ~MUF_Scheduler (void); + + + virtual MUF_Scheduling::SchedulingParameterPolicy_ptr + create_scheduling_parameter (const MUF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void shutdown (void); + + virtual void begin_new_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void begin_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void update_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void end_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void end_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr outer_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid, + CORBA::String_out name, + CORBA::Policy_out sched_param, + CORBA::Policy_out implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void cancel (const RTScheduling::Current::IdType & guid + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void scheduling_policies (const CORBA::PolicyList & scheduling_policies + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * poa_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual RTScheduling::ResourceManager_ptr create_resource_manager (const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void set_scheduling_parameter (PortableServer::Servant & resource, + const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + CORBA::ORB_var orb_; + IOP::Codec_var codec_; + RTScheduling::Current_var current_; + Kokyu::DSRT_Dispatcher* kokyu_dispatcher_; +}; + +#endif //MUF_SCHEDULER_H + + + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduling.idl b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduling.idl new file mode 100644 index 00000000000..a317bb26239 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/muf_example/MUF_Scheduling.idl @@ -0,0 +1,26 @@ +//$Id$ +#include +#include + +module MUF_Scheduling +{ + struct SchedulingParameter + { + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + long criticality; + }; + + local interface SchedulingParameterPolicy + : CORBA::Policy + { + attribute SchedulingParameter value; + }; + + local interface Scheduler : RTScheduling::Scheduler + { + SchedulingParameterPolicy + create_scheduling_parameter + (in SchedulingParameter value); + }; +}; -- cgit v1.2.1