metrics_utils.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

     }

     // Store the first tile processed handle, and make room for the others.
     REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_queuing_0",
                                   TAO_Metrics_Utils::QUO,
                                   *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                   this->tile_queuing_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_queuing_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                       temp_metrics_handle);
     }

     // Store the first tile processed handle, and make room for the others.
     REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_decompression_0",
                                   TAO_Metrics_Utils::QUO,
                                   *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                   this->tile_decompression_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_decompression_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                       temp_metrics_handle);
     }

     REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_ipm_0",
                                   TAO_Metrics_Utils::QUO,
                                   *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                   this->tile_ipm_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_ipm_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                       temp_metrics_handle);
     }

     REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "zlib Compression",
                                   TAO_Metrics_Utils::SCHED,
                                   *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                   this->zlib_compression_handle_);

     REGISTER_METRICS_REPORTING_PROBE_RETURN(TAO_METRICS_REPORTING_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "zlib Compression",
                                   TAO_Metrics_Utils::SCHED,
                                   *TAO_METRICS_LOGGER_REF_SINGLETON::instance(),
                                   this->zlib_decompression_handle_);
#else /* ! TAO_USES_REPORTING_METRICS */
     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "TAO_compute_scheduling",
                                   TAO_Metrics_Utils::SCHED,
                                   this->compute_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "RTARM_triggered_adaptation",
                                   TAO_Metrics_Utils::RTARM,
                                   this->RTARM_triggered_adaptation_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "RTARM_region_transition",
                                   TAO_Metrics_Utils::RTARM,
                                   this->RTARM_region_transition_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "QuO_contract_eval",
                                   TAO_Metrics_Utils::QUO,
                                   this->QuO_contract_eval_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_request_delegate",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_request_delegate_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "image_received",
                                   TAO_Metrics_Utils::QUO,
                                   this->image_received_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "image_processed",
                                   TAO_Metrics_Utils::QUO,
                                   this->image_processed_metrics_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "image_quiescent",
                                   TAO_Metrics_Utils::QUO,
                                   this->image_quiescent_metrics_handle_);

     char registration_name[64];
     u_int i;

     // Store the first tile received handle, and make room for the others.
     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_received_0",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_received_first_metrics_handle_);

     RtecScheduler::handle_t temp_metrics_handle;
     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_received_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       temp_metrics_handle);
     }

     // Store the first tile processed handle, and make room for the others.
     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_processed_0",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_processed_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_processed_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
        REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                      base_metrics,
                                      registration_name,
                                      TAO_Metrics_Utils::QUO,
                                      temp_metrics_handle);
     }

     // Store the first tile processed handle, and make room for the others.
     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_queuing_0",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_queuing_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_queuing_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       temp_metrics_handle);
     }

     // Store the first tile processed handle, and make room for the others.
     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_decompression_0",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_decompression_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_decompression_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       temp_metrics_handle);
     }

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "tile_ipm_0",
                                   TAO_Metrics_Utils::QUO,
                                   this->tile_ipm_first_metrics_handle_);

     for (i = 1; i <= WSOA_METRICS_MAX_TILING_FACTOR; ++i)
     {
             ::sprintf (registration_name, "tile_ipm_%d", i);

         // We just throw the handles away rather than storing them,
             // as they're always calculated by offset from the first.
         REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       temp_metrics_handle);

         REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                       base_metrics,
                                       registration_name,
                                       TAO_Metrics_Utils::QUO,
                                       tile_decompression_handle_);
     }

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "zlib Compression",
                                   TAO_Metrics_Utils::SCHED,
                                   this->zlib_compression_handle_);

     REGISTER_METRICS_PROBE_RETURN(TAO_METRICS_CACHE_SINGLETON_TYPE::instance(),
                                   base_metrics,
                                   "zlib Compression",
                                   TAO_Metrics_Utils::SCHED,
                                   this->zlib_decompression_handle_);
#endif /* TAO_USES_REPORTING_METRICS */
}



#if !defined (__ACE_INLINE__)
#include "Metrics_Utils.i"
#endif /* __ACE_INLINE__ */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
template class ACE_Singleton<WSOA_Metrics_Handles, ACE_Thread_Mutex>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#pragma instantiate ACE_Singleton<WSOA_Metrics_Handles, ACE_Thread_Mutex>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#else
#error ACE_COMPILE_TIMEPROBES must be defined in order to collect metrics
#endif /* ACE_ENABLE_TIMEPROBES & ACE_COMPILE_TIMEPROBES */
#endif /* ACE_METRICS_COLLECTION */

#endif /* METRICS_UTILS_CPP */