00001 /* 00002 * Copyright (c) 2000, 2020, Oracle and/or its affiliates. 00003 * 00004 * Licensed under the Universal Permissive License v 1.0 as shown at 00005 * http://oss.oracle.com/licenses/upl. 00006 */ 00007 #ifndef COH_ABSTRACT_HEAP_ANALYZER_HPP 00008 #define COH_ABSTRACT_HEAP_ANALYZER_HPP 00009 00010 #include "coherence/lang/compatibility.hpp" 00011 00012 00013 #include "coherence/lang/abstract_spec.hpp" 00014 #include "coherence/lang/HeapAnalyzer.hpp" 00015 00016 00017 00018 COH_OPEN_NAMESPACE2(coherence,native) 00019 class NativeThreadLocal; 00020 COH_CLOSE_NAMESPACE2 00021 00022 COH_OPEN_NAMESPACE2(coherence,lang) 00023 00024 using coherence::native::NativeThreadLocal; 00025 00026 00027 /** 00028 * AbstractHeapAnalyzer provides a starting point for writing custom heap 00029 * analyzers. Most notably it includes support for detecting analyzer 00030 * re-entrance so that analyzers can avoid endlessly recursing if they create 00031 * objects as part of the registration process. 00032 * 00033 * @author mf 2008.04.27 00034 */ 00035 class COH_EXPORT AbstractHeapAnalyzer 00036 : public abstract_spec<AbstractHeapAnalyzer, 00037 extends<Object>, 00038 implements<HeapAnalyzer> > 00039 { 00040 // ----- constructor ---------------------------------------------------- 00041 00042 protected: 00043 /** 00044 * @internal 00045 */ 00046 AbstractHeapAnalyzer(); 00047 00048 /** 00049 * @internal 00050 */ 00051 virtual ~AbstractHeapAnalyzer(); 00052 00053 00054 // ----- AbstractHeapAnalyzer methods ----------------------------------- 00055 00056 protected: 00057 /** 00058 * Registers an object with the heap analyzer. 00059 * 00060 * @param o the object to register 00061 */ 00062 virtual void safeRegisterObject(const Object& o) = 0; 00063 00064 /** 00065 * Unregisters an object with the heap analyzer. 00066 * 00067 * @param o the object to unregister 00068 */ 00069 virtual void safeUnregisterObject(const Object& o) = 0; 00070 00071 00072 // ----- HeapAnalyzer interface ----------------------------------------- 00073 00074 protected: 00075 /** 00076 * {@inheritDoc} 00077 * 00078 * @param o the object to register 00079 * 00080 * If the calling thread is reentering this method return immediately 00081 * otherwise delegates to safeRegisterObject. 00082 */ 00083 virtual void registerObject(const Object& o); 00084 00085 /** 00086 * {@inheritDoc} 00087 * 00088 * @param o the object to unregister 00089 * 00090 * If the calling thread is reentering this method return immediately 00091 * otherwise delegates to safeUnregisterObject. 00092 */ 00093 virtual void unregisterObject(const Object& o); 00094 00095 00096 // ----- Object interface ----------------------------------------------- 00097 00098 public: 00099 /** 00100 * Capture a snapshot and output it to the supplied stream. 00101 * 00102 * @param out the stream to output to 00103 */ 00104 virtual TypedHandle<const String> toString() const; 00105 00106 00107 // ----- data members --------------------------------------------------- 00108 00109 private: 00110 /** 00111 * Tracks if the calling thread is within the analyzer. 00112 * 00113 * The use of ThreadLocalReference here is not suitable, as it is a 00114 * managed object, and causes recursion into the HeapAnalyzer. 00115 */ 00116 NativeThreadLocal* const m_pTLContext; 00117 }; 00118 00119 COH_CLOSE_NAMESPACE2 00120 00121 #endif // COH_ABSTRACT_HEAP_ANALYZER_HPP