*** empty log message ***

1 files changed, 193 insertions, 0 deletions

diff --git a/ace/Timeprobe.h b/ace/Timeprobe.h
new file mode 100644
index 00000000000..72123a093d2
--- /dev/null
+++ b/ace/Timeprobe.h
@@ -0,0 +1,193 @@
+// $Id$
+
+#if !defined (ACE_TIMEPROBE_H)
+#define ACE_TIMEPROBE_H
+
+// This class is compiled only when ACE_COMPILE_TIMEPROBES is defined
+#if defined (ACE_COMPILE_TIMEPROBES)
+
+#include "ace/Malloc.h"
+
+template <class ACE_LOCK>
+class ACE_Timeprobe
+{
+  // = TITLE
+  //
+  //     This class is used to instrument code.  This is accomplished
+  //     by inserting time probes at different location in the code.
+  //     ACE_Timeprobe then measures the time difference between two
+  //     time probes.
+  //
+  // = DESCRIPTION
+  //
+  //     This class provides a lightweight implementation for
+  //     measuring the time required to execute code between two time
+  //     probes.  When a time probe executes, it records the time, the
+  //     id of the calling thread, and an event description.  The
+  //     event description can either be an unsigned long or a string
+  //     (char *). If string are used, care must be taken cause only
+  //     pointer copies are done and the string data is *not* copied.
+  //     
+  //     The recorded time probes can then be printed by calling
+  //     print_times().  If you have used unsigned longs as event
+  //     descriptions in any of your time probes, you must provide an
+  //     event description table that maps the unsigned longs to
+  //     readable strings.  This map is a simple array of strings, and
+  //     the event number is used as the index into the array when
+  //     looking for the event description.  If you have only used
+  //     strings for the event description, this map is not necessary.
+  //
+public:
+
+  enum
+  {
+    ACE_DEFAULT_TABLE_SIZE = 4 * 1024
+    // Default size of the slots in Timeprobe
+  };
+
+  ACE_Timeprobe (u_long size = ACE_DEFAULT_TABLE_SIZE,
+                 ACE_Allocator *alloc = 0);
+  // Create Timeprobes with <size> slots, using <alloc> for the
+  // allocator.
+
+  ~ACE_Timeprobe (void);
+  // Destructor
+
+  void timeprobe (u_long event);
+  // Record a time. <event> is used to describe this time probe.
+
+  void timeprobe (const char *id);
+  // Record a time. <id> is used to describe this time probe.
+
+  void print_times (const char *event_description[] = 0) const;
+  // Print the time probes.  Use <event_description> as a map for
+  // converting unsigned long events to strings.
+
+  void reset (void);
+  // Reset the slots.  All old time probes will be lost.
+
+protected:
+
+  ACE_Timeprobe (const ACE_Timeprobe &);
+  // Not implemented.
+
+  // = Time probe record
+  struct timeprobe_t
+  {
+    union event
+    {
+      u_long event_number_;
+      const char *event_description_;
+    };
+    // Events are record as strings or numbers
+
+    enum event_type
+    {
+      NUMBER,
+      STRING
+    };
+    // Type of event
+
+    event event_;
+    // Event
+
+    event_type event_type_;
+    // Event type
+
+    ACE_hrtime_t time_;
+    // Timestamp
+
+    ACE_thread_t thread_;
+    // Id of thread posting the time probe
+  };
+
+  timeprobe_t *timeprobes_;
+  // Time probe slots
+
+  ACE_Allocator *allocator_;
+  // Pointer to a memory allocator.
+
+  ACE_LOCK lock_;
+  // Synchronization variable.
+
+  u_long max_size_;
+  // Max size of timestamp table
+
+  u_long current_size_;
+  // Current size of timestamp table
+};
+
+template <class Timeprobe> 
+class ACE_Function_Timeprobe 
+{
+public:
+  ACE_Function_Timeprobe (Timeprobe &timeprobe, 
+                          u_long event);
+
+  ~ACE_Function_Timeprobe (void);
+
+protected:
+
+  Timeprobe &timeprobe_;
+
+  u_long event_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/Timeprobe.i"
+#endif /* __ACE_INLINE__ */
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "ace/Timeprobe.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Timeprobe.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include "ace/Synch.h"
+#include "ace/Singleton.h"
+
+// If ACE_MT_TIMEPROBES is defined, use a Thread_Mutex to lock the
+// internal state of ACE_Timerprobe.  This allows multiple threads to
+// use the same ACE_Timerprobe.
+#  if defined (ACE_MT_TIMEPROBES)
+typedef ACE_Timeprobe<ACE_Thread_Mutex> ACE_TIMEPROBE_WITH_LOCKING;
+#  else /* ACE_MT_TIMEPROBES */
+typedef ACE_Timeprobe<ACE_Null_Mutex> ACE_TIMEPROBE_WITH_LOCKING;
+#  endif /* ACE_MT_TIMEPROBES */
+
+// If ACE_TSS_TIMEPROBES is defined, store the ACE_Timeprobe singleton
+// in thread specific storage.  This allows multiple threads to use
+// their own instance of ACE_Timerprobe, without interfering with each
+// other.
+#  if defined (ACE_TSS_TIMEPROBES)
+typedef ACE_TSS_Singleton<ACE_TIMEPROBE_WITH_LOCKING, ACE_Null_Mutex> ACE_TIMEPROBE_SINGLETON;
+#  else /* ACE_TSS_TIMEPROBES */
+typedef ACE_Singleton<ACE_TIMEPROBE_WITH_LOCKING, ACE_Thread_Mutex> ACE_TIMEPROBE_SINGLETON;
+#  endif /* ACE_TSS_TIMEPROBES */
+
+#endif /* ACE_COMPILE_TIMEPROBES */
+
+// If ACE_ENABLE_TIMEPROBES is defined, the macros below will
+// work. Otherwise, they just vanish.  Using this macro, you can
+// control which files/libraries are probed.
+#if defined (ACE_ENABLE_TIMEPROBES)
+
+#  define ACE_TIMEPROBE_RESET ACE_TIMEPROBE_SINGLETON::instance ()->reset ()
+#  define ACE_TIMEPROBE(id) ACE_TIMEPROBE_SINGLETON::instance ()->timeprobe (id)
+#  define ACE_TIMEPROBE_PRINT ACE_TIMEPROBE_SINGLETON::instance ()->print_times ()
+#  define ACE_TIMEPROBE_PRINT_USING_TABLE(table) ACE_TIMEPROBE_SINGLETON::instance ()->print_times (table)
+#  define ACE_FUNCTION_TIMEPROBE(X) ACE_Function_Timeprobe<ACE_TIMEPROBE_WITH_LOCKING> function_timeprobe (*ACE_TIMEPROBE_SINGLETON::instance (), X)
+
+#else /* ACE_ENABLE_TIMEPROBES */
+
+#  define ACE_TIMEPROBE_RESET
+#  define ACE_TIMEPROBE(id)
+#  define ACE_TIMEPROBE_PRINT
+#  define ACE_TIMEPROBE_PRINT_USING_TABLE(table)
+#  define ACE_FUNCTION_TIMEPROBE(X) 
+
+#endif /* ACE_ENABLE_TIMEPROBES */
+
+#endif /* ACE_TIMEPROBE_H */