coherence/lang/ObjectCountHeapAnalyzer.hpp

/*
* ObjectCountHeapAnalyzer.hpp
*
* Copyright 2001-2008 by Oracle. 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_OBJECT_COUNT_HEAP_ANALYZER_HPP
#define COH_OBJECT_COUNT_HEAP_ANALYZER_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/HeapAnalyzer.hpp"
#include "coherence/native/NativeAtomic64.hpp"

#include <ostream>

COH_OPEN_NAMESPACE2(coherence,lang)


/**
* ObjectCountHeapAnalyzer provides simple heap analysis based soley on the
* count of the number of live objects in the system.
*
* This heap analyzer has next to no CPU or memory costs, there is a single
* 64 bit counter which is updated using the non-blocking compare-and-set
* operations. It is well suited for performance sensitive production
* envrionments.
*
* @see ClassBasedHeapAnalyzer for more detailed heap analysis
*
* @author mf  2008.04.27
*/
class COH_EXPORT ObjectCountHeapAnalyzer
    : public class_spec<ObjectCountHeapAnalyzer,
        extends<Object>,
        implements<HeapAnalyzer> >
    {
    friend class factory<ObjectCountHeapAnalyzer>;

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

    protected:
        /**
        * Create a new ObjectCountHeapAnalyzer.
        *
        * @return the analyzer
        */
        ObjectCountHeapAnalyzer();


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

    public:
        /**
        * Snapshot containging 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.
                *
                * @return the new snapshot
                */
                Snapshot(int64_t cObjects);


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

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

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

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

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

            protected:
                /**
                * The object count.
                */
                int64_t m_cObjects;
            };


    // ----- 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);


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

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


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

    protected:
        /**
        * The object count.
        */
        coherence::native::NativeAtomic64 m_cObjects;
    };

COH_CLOSE_NAMESPACE2

#endif // COH_OBJECT_COUNT_HEAP_ANALYZER_HPP

Copyright (c) 2000-2008 Oracle. All rights reserved.