worldprofile.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680

  $Id$
*/
#ifndef MADNESS_WORLD_WORLDPROFILE_H__INCLUDED
#define MADNESS_WORLD_WORLDPROFILE_H__INCLUDED

#include <madness/madness_config.h>
#include <madness/world/worldtypes.h>
#include <madness/world/worldmutex.h>
#include <string>
#include <vector>

// NEED TO ADD ATTRIBUTION TO SHINY ON SOURCE FORGE

namespace madness {

    class World;

    template <typename T>
    struct ProfileStat {
        T value, max, min, sum;  // local value, parallel max, min, sum
        ProcessID pmax, pmin;    // processor with max, min values

        ProfileStat() : value(0), max(0), min(0), sum(0), pmax(0), pmin(0) {}

        void init_par_stats(ProcessID me) {
            max = min = sum = value;
            pmax = pmin = me;
        }

        void par_reduce(const ProfileStat<T>& other) {
            if (other.max > max) {
                max = other.max;
                pmax = other.pmax;
            }
            if (other.min < min) {
                min = other.min;
                pmin = other.pmin;
            }
            sum += other.sum;
        }

        void clear() {
            value = max = min = sum = 0;
            pmax = pmin = 0;
        }

        template <class Archive>
        void serialize(const Archive& ar) {
            ar & value & max & min & sum & pmax & pmin;
        }
    }; // struct ProfileStat

    struct WorldProfileEntry : public Spinlock {
        std::string name;          
        int depth;                 

        ProfileStat<unsigned long> count;   
        ProfileStat<double> xcpu; 
        ProfileStat<double> icpu; 

        WorldProfileEntry(const char* name = "");

        WorldProfileEntry(const WorldProfileEntry& other);

        WorldProfileEntry& operator=(const WorldProfileEntry& other);

        static bool exclusivecmp(const WorldProfileEntry&a, const WorldProfileEntry& b);

        static bool inclusivecmp(const WorldProfileEntry&a, const WorldProfileEntry& b);

        void init_par_stats(ProcessID me);

        void par_reduce(const WorldProfileEntry& other);

        void clear();

        template <class Archive>
        void serialize(const Archive& ar) {
            ar & name & depth & count & xcpu & icpu;
        }
    }; // struct WorldProfileEntry



    class WorldProfile {
        //static ConcurrentHashMap<std::string,WorldProfileEntry> items;
        volatile static std::vector<WorldProfileEntry> items;
        static Spinlock mutex;
        static double cpu_start;
        static double wall_start;

        static std::vector<WorldProfileEntry>& nvitems();


        static int find(const std::string& name);


    public:
        static int register_id(const char* name);

        static int register_id(const char* classname, const char* function);

        static void clear();

        static WorldProfileEntry& get_entry(int id);

        static void print(World& world);

    private:
        static void recv_stats(World& world, ProcessID p);
    };


    class WorldProfileObj {
        static thread_local WorldProfileObj* call_stack;  
        WorldProfileObj* const prev; 
        const int id;                
        const double cpu_base;       
        double cpu_start;            
    public:

        WorldProfileObj(int id);

        void pause(double now);

        void resume(double now);

        ~WorldProfileObj();
    };
}

#ifdef WORLD_PROFILE_ENABLE
#  define PROFILE_STRINGIFY(s) #s

#  define PROFILE_BLOCK(name)                                             \
    static const int __name##_id=madness::WorldProfile::register_id(PROFILE_STRINGIFY(name)); \
    madness::WorldProfileObj name(__name##_id)

#  define PROFILE_FUNC                                                    \
    static const int __profile_id=madness::WorldProfile::register_id(__FUNCTION__); \
    madness::WorldProfileObj __profile_obj(__profile_id)

#  define PROFILE_MEMBER_FUNC(classname)                                       \
    static const int __profile_id=madness::WorldProfile::register_id(PROFILE_STRINGIFY(classname),  __FUNCTION__); \
    madness::WorldProfileObj __profile_obj(__profile_id)


#else

#  define PROFILE_BLOCK(name)
#  define PROFILE_FUNC
#  define PROFILE_MEMBER_FUNC(classname)

#endif

#endif // MADNESS_WORLD_WORLDPROFILE_H__INCLUDED