souffle::profile::Reader Class Reference

#include <Reader.h>

Collaboration diagram for souffle::profile::Reader:

Public Member Functions
void	addRelation (const DirectoryEntry &relation)
std::string	createId ()
bool	isLive ()
bool	isLoaded ()
void	processFile ()
	Read the contents from file into the class. More...
	Reader (std::shared_ptr< ProgramRun > run)
	Reader (std::string filename, std::shared_ptr< ProgramRun > run)
std::string	RelationcreateId ()
void	save (std::string f_name)

Data Fields
std::shared_ptr< ProgramRun >	run

Protected Member Functions
std::string	cleanRelationName (const std::string &relationName)
std::string	extractRelationNameFromAtom (const Atom &atom)

Private Attributes
const ProfileDatabase &	db = ProfileEventSingleton::instance().getDB()
std::string	file_loc
std::streampos	gpos
bool	loaded = false
bool	online {true}
int	rel_id {0}
std::unordered_map< std::string, std::shared_ptr< Relation > >	relationMap {}

Detailed Description

Definition at line 271 of file Reader.h.

Constructor & Destructor Documentation

Reader() [1/2]

souffle::profile::Reader::Reader ( std::string  filename, std::shared_ptr< ProgramRun >  run  )

inline

Definition at line 285 of file Reader.h.

            : file_loc(std::move(filename)), run(std::move(run)) {
        try {
            ProfileEventSingleton::instance().setDBFromFile(file_loc);
        } catch (const std::exception& e) {
            fatal("exception whilst reading profile DB: %s", e.what());
        }
    }

References e, souffle::fatal(), file_loc, souffle::ProfileEventSingleton::instance(), and souffle::ProfileEventSingleton::setDBFromFile().

Here is the call graph for this function:

Reader() [2/2]

souffle::profile::Reader::Reader ( std::shared_ptr< ProgramRun >  run )

inline

Definition at line 294 of file Reader.h.

: run(std::move(run)) {}

Member Function Documentation

addRelation()

void souffle::profile::Reader::addRelation ( const DirectoryEntry &  relation )

inline

Definition at line 355 of file Reader.h.

                                                     {
        const std::string& name = cleanRelationName(relation.getKey());
 
        relationMap.emplace(name, std::make_shared<Relation>(name, createId()));
        auto& rel = *relationMap[name];
        RelationVisitor relationVisitor(rel);
 
        for (const auto& key : relation.getKeys()) {
            relation.readEntry(key)->accept(relationVisitor);
        }
    }

References cleanRelationName(), createId(), rel(), relation, and relationMap.

Referenced by processFile().

Here is the call graph for this function:

cleanRelationName()

std::string souffle::profile::Reader::cleanRelationName ( const std::string &  relationName )

inlineprotected

Definition at line 380 of file Reader.h.

                                                               {
        std::string cleanName = relationName;
        for (auto& cur : cleanName) {
            if (cur == '-') {
                cur = '.';
            }
        }
        return cleanName;
    }

Referenced by addRelation(), and extractRelationNameFromAtom().

createId()

std::string souffle::profile::Reader::createId ( )

inline

Definition at line 375 of file Reader.h.

                         {
        return "R" + std::to_string(++rel_id);
    }

References rel_id.

Referenced by addRelation().

extractRelationNameFromAtom()

std::string souffle::profile::Reader::extractRelationNameFromAtom ( const Atom &  atom )

inlineprotected

Definition at line 389 of file Reader.h.

                                                            {
        return cleanRelationName(atom.identifier.substr(0, atom.identifier.find('(')));
    }

References cleanRelationName(), and souffle::profile::Atom::identifier.

Referenced by processFile().

Here is the call graph for this function:

isLive()

bool souffle::profile::Reader::isLive ( )

inline

Definition at line 351 of file Reader.h.

                         {
        return online;
    }

References online.

isLoaded()

bool souffle::profile::Reader::isLoaded ( )

inline

Definition at line 367 of file Reader.h.

                           {
        return loaded;
    }

References loaded.

processFile()

void souffle::profile::Reader::processFile ( )

inline

Read the contents from file into the class.

Definition at line 298 of file Reader.h.

                       {
        rel_id = 0;
        relationMap.clear();
        auto programDuration = dynamic_cast<DurationEntry*>(db.lookupEntry({"program", "runtime"}));
        if (programDuration == nullptr) {
            auto startTimeEntry = dynamic_cast<TimeEntry*>(db.lookupEntry({"program", "starttime"}));
            if (startTimeEntry != nullptr) {
                run->setStarttime(startTimeEntry->getTime());
                run->setEndtime(std::chrono::duration_cast<microseconds>(now().time_since_epoch()));
            }
        } else {
            run->setStarttime(programDuration->getStart());
            run->setEndtime(programDuration->getEnd());
            online = false;
        }
 
        auto relations = dynamic_cast<DirectoryEntry*>(db.lookupEntry({"program", "relation"}));
        if (relations == nullptr) {
            // Souffle hasn't generated any profiling information yet.
            return;
        }
        for (const auto& cur : relations->getKeys()) {
            auto relation = dynamic_cast<DirectoryEntry*>(db.lookupEntry({"program", "relation", cur}));
            if (relation != nullptr) {
                addRelation(*relation);
            }
        }
        for (const auto& relation : relationMap) {
            for (const auto& rule : relation.second->getRuleMap()) {
                for (const auto& atom : rule.second->getAtoms()) {
                    std::string relationName = extractRelationNameFromAtom(atom);
                    relationMap[relationName]->addReads(atom.frequency);
                }
            }
            for (const auto& iteration : relation.second->getIterations()) {
                for (const auto& rule : iteration->getRules()) {
                    for (const auto& atom : rule.second->getAtoms()) {
                        std::string relationName = extractRelationNameFromAtom(atom);
                        if (relationName.substr(0, 6) == "@delta") {
                            relationName = relationName.substr(7);
                        }
                        assert(relationMap.count(relationName) > 0 || "Relation name for atom not found");
                        relationMap[relationName]->addReads(atom.frequency);
                    }
                }
            }
        }
        run->setRelationMap(this->relationMap);
        loaded = true;
    }

References addRelation(), db, extractRelationNameFromAtom(), iteration, loaded, souffle::now(), online, rel_id, relation, relationMap, relations, rule, and run.

Here is the call graph for this function:

RelationcreateId()

std::string souffle::profile::Reader::RelationcreateId ( )

inline

Definition at line 371 of file Reader.h.

                                 {
        return "R" + std::to_string(++rel_id);
    }

References rel_id.

save()

void souffle::profile::Reader::save

(

std::string

f_name

)

Field Documentation

db

const ProfileDatabase& souffle::profile::Reader::db = ProfileEventSingleton::instance().getDB()

private

Definition at line 275 of file Reader.h.

Referenced by processFile().

file_loc

std::string souffle::profile::Reader::file_loc

private

Definition at line 273 of file Reader.h.

Referenced by Reader().

gpos

std::streampos souffle::profile::Reader::gpos

private

Definition at line 274 of file Reader.h.

loaded

bool souffle::profile::Reader::loaded = false

private

Definition at line 276 of file Reader.h.

Referenced by isLoaded(), and processFile().

online

bool souffle::profile::Reader::online {true}

private

Definition at line 277 of file Reader.h.

Referenced by isLive(), and processFile().

rel_id

int souffle::profile::Reader::rel_id {0}

private

Definition at line 280 of file Reader.h.

Referenced by createId(), processFile(), and RelationcreateId().

relationMap

std::unordered_map<std::string, std::shared_ptr<Relation> > souffle::profile::Reader::relationMap {}

private

Definition at line 279 of file Reader.h.

Referenced by addRelation(), and processFile().

run

std::shared_ptr<ProgramRun> souffle::profile::Reader::run

Definition at line 283 of file Reader.h.

Referenced by processFile().

---

The documentation for this class was generated from the following file:

• include/souffle/profile/Reader.h