include/pelib/Platform.hpp

Go to the documentation of this file.

/*
 Copyright 2015 Nicolas Melot

 This file is part of Pelib.

 Pelib 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 3 of the License, or
 (at your option) any later version.

 Pelib 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 Pelib. If not, see <http://www.gnu.org/licenses/>.
*/


#include <set>

#include <pelib/Core.hpp>
#include <pelib/Algebra.hpp>

#ifndef PELIB_PLATFORM
#define PELIB_PLATFORM

#define debug(var) std::cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #var << " = \"" << (var) << "\"" << std::endl;

namespace pelib
{
        class Platform: public Record
        {
                public:
                        typedef std::set<const Core*, Core::LessCorePtrByCoreId> island;
                        struct LessIslandByFirstCoreId 
                        {
                                bool operator() (const island &x, const island &y) const
                                {
                                        for(island::const_iterator xx = x.begin(), yy = y.begin(); xx != x.end() && yy != y.end(); xx++, yy++)
                                        {
                                                if(*xx == *yy)
                                                {
                                                        continue;
                                                }
                                                else
                                                {
                                                        return **xx < **yy;
                                                }
                                        }

                                        return x.size() < y.size();
                                }
                        };
                        typedef std::set<island, LessIslandByFirstCoreId> islands;

                        Platform();

                        Platform(size_t p, const Core* ref);

                        Platform(const island &cores);

                        Platform(const island& cores, const islands &shared, const islands &main, const islands &priv, const islands &voltage, const islands &freq);

                        Platform(const Platform *arch);

                        Platform(const Platform &arch);

                        Platform(const Algebra &arch);

                        virtual Platform* clone() const;

                        virtual const std::set<const Core*, Core::LessCorePtrByCoreId>& getCores() const;

                        virtual bool isHomogeneous() const;

                        virtual const islands& getSharedMemoryIslands() const;

                        virtual const islands getSharedMemoryIslands(size_t core_id) const;

                        virtual const islands getSharedMemoryIslands(const std::set<int>& islands) const;
                        virtual const std::set<int> getSharedMemoryIslands(const islands& isls) const;
                        virtual const islands& getMainMemoryIslands() const;
                        virtual const islands getMainMemoryIslands(size_t core_id) const;
                        virtual const islands& getPrivateMemoryIslands() const;
                        virtual const islands getPrivateMemoryIslands(size_t core_id) const;
                        virtual const islands& getVoltageIslands() const;
                        virtual const island& getVoltageIsland(size_t core_id) const;
                        virtual const islands& getFrequencyIslands() const;
                        virtual const island& getFrequencyIsland(size_t core_id) const;

                        virtual const Core* getCore(size_t id) const;

                        virtual size_t getCoreId(const Core*) const;

                        virtual Algebra buildAlgebra() const;

                        virtual ~Platform();
                        virtual Platform&
                        operator=(const Platform& copy);
                protected:
                        island cores;
                        islands shared, main, priv, voltage, freq;
                private:                
                        void copy(const Platform *pt);
        };
}

#undef debug

#endif