Oracle Fusion Middleware C++ API Reference for Oracle Coherence
12c (12.1.2)
E26041-01

coherence/lang/ClassBasedHeapAnalyzer.hpp

/*
* ClassBasedHeapAnalyzer.hpp
*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_CLASS_BASED_HEAP_ANALYZER_HPP
#define COH_CLASS_BASED_HEAP_ANALYZER_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/AbstractHeapAnalyzer.hpp"
#include "coherence/lang/Comparable.hpp"
#include "coherence/lang/FinalView.hpp"

#include <ostream>

COH_OPEN_NAMESPACE2(coherence,util)
class Map;
COH_CLOSE_NAMESPACE2

COH_OPEN_NAMESPACE2(coherence,lang)

using coherence::util::Map;


/**
* ClassBasedHeapAnalyzer provides heap analysis at the class level, that is
* it tracks the number of live instances of each class.
*
* The memory consumption of this heap analyzer is relative to the number of
* classes used within the process. The CPU consumption is also very low, each
* registration consists of roughly four compare-and-set operations. It is well
* suited for development as well as many production environments.
*
* @see ObjectCountHeapAnalyzer for a lower overhead analyzer
*
* @author mf  2008.04.27
*/
class COH_EXPORT ClassBasedHeapAnalyzer
    : public class_spec<ClassBasedHeapAnalyzer,
        extends<AbstractHeapAnalyzer> >
    {
    friend class factory<ClassBasedHeapAnalyzer>;

    // ----- constructor ----------------------------------------------------

    protected:
        /**
        * Create a new ClassBasedHeapAnalyzer.
        *
        * @param fShowAllocations  true if allocations should also be shown
        */
        ClassBasedHeapAnalyzer(bool fShowAllocations = false);


    // ----- nested class: ClassStats ---------------------------------------

    public:
        /**
        * Statistics relating to a class.
        */
        class COH_EXPORT ClassStats
            : public class_spec<ClassStats,
                extends<Object>,
                implements<Comparable> >
            {
            friend class factory<ClassStats>;

            protected:
                /**
                * Create a new ClassStats.
                *
                * @param cObjs   the instance count
                * @param cBytes  the byte count
                * @param cAlloc  the allocation count
                * @return the new ClassStats
                */
                ClassStats(int64_t cObjs, int64_t cBytes, int64_t cAlloc);

            // ----- ClassStats interface ---------------------------------

            public:
                /**
                * Return the instance count for the class.
                */
                virtual int64_t getObjectCount() const;

                /**
                * Return the byte count for the class.
                */
                virtual int64_t getByteCount() const;

                /**
                * Return the allocation count for the class.
                */
                virtual int64_t getAllocationCount() const;

            // ----- Comparable interface ---------------------------------

            public:
                /**
                * {@inheritDoc}
                */
                int32_t compareTo(Object::View v) const;

            // ----- Object interface -------------------------------------

            public:
                /**
                * {@inheritDoc}
                */
                virtual void toStream(std::ostream& out) const;

            // ----- data members -----------------------------------------

            protected:
                /**
                * The number of instances of the class.
                */
                int64_t m_cInstanceCount;

                /**
                * The byte size of all the instances.
                */
                int64_t m_cByteCount;

                /**
                * The total number of allocations of the class.
                */
                int64_t m_cAllocationCount;
            };

    // ----- nested class: Snapshot -----------------------------------------

    public:
        /**
        * Snapshot containing the object count.
        */
        class COH_EXPORT Snapshot
            : public class_spec<Snapshot,
                extends<Object>,
                implements<HeapAnalyzer::Snapshot> >
            {
            friend class factory<Snapshot>;

            // ----- constructors ---------------------------------------

            protected:
                /**
                * Create a new Snapshot.
                */
                Snapshot(TypedHandle<const Map> vMap, bool fShowAllocations);

            // ----- Snapshot interface ---------------------------------

            public:
                /**
                * Return the Snapshots map of class names to ClassStats.
                *
                * The keys are class names, the values are ClassStats.
                *
                * @return the snapshots map.
                */
                virtual TypedHandle<const Map> getStatsMap() const;

                /**
                * {@inheritDoc}
                */
                virtual int64_t getObjectCount() const;

                /**
                * {@inheritDoc}
                */
                virtual HeapAnalyzer::Snapshot::View delta(
                        HeapAnalyzer::Snapshot::View vThat) const;

            // ----- Object interface: ----------------------------------

            public:
                /**
                * {@inheritDoc}
                */
                virtual void toStream(std::ostream& out) const;

            // ----- data members ---------------------------------------

            protected:
                /**
                * The map of class names to ClassStats.
                */
                FinalView<Object> f_vMapStats;

                /**
                * True if allocations are to be shown.
                */
                bool m_fShowAllocations;
            };


    // ----- AbstractHeapAnalyzer interface ---------------------------------

    protected:
        /**
        * {@inheritDoc}
        */
        virtual void safeRegisterObject(const Object& o);

        /**
        * {@inheritDoc}
        */
        virtual void safeUnregisterObject(const Object& o);


    // ----- HeapAnalyzer interface -----------------------------------------

    public:
        /**
        * {@inheritDoc}
        */
        virtual HeapAnalyzer::Snapshot::View capture() const;

        /**
        * {@inheritDoc}
        */
        virtual HeapAnalyzer::Snapshot::View delta(
                HeapAnalyzer::Snapshot::View vSnap) const;

        /**
        * {@inheritDoc}
        */
        virtual int64_t getObjectCount() const;

    protected:
        /**
        * {@inheritDoc}
        */
        virtual void registerObject(const Object& o);

        /**
        * {@inheritDoc}
        */
        virtual void unregisterObject(const Object& o);


    // ----- data members ---------------------------------------------------

    protected:
        /**
        * True if allocations should be printed as part of analysis.
        */
        bool m_fShowAllocations;


    // ----- friends --------------------------------------------------------

    friend class Snapshot;
    };

COH_CLOSE_NAMESPACE2

#endif // COH_CLASS_BASED_HEAP_ANALYZER_HPP

Copyright © 2000, 2013, Oracle and/or its affiliates. All rights reserved.