forked from github/verilator
111 lines
4.0 KiB
C++
111 lines
4.0 KiB
C++
// -*- mode: C++; c-file-style: "cc-mode" -*-
|
|
//*************************************************************************
|
|
// DESCRIPTION: Verilator: Threading's graph structures
|
|
//
|
|
// Code available from: https://verilator.org
|
|
//
|
|
//*************************************************************************
|
|
//
|
|
// Copyright 2003-2020 by Wilson Snyder. This program is free software; you
|
|
// can redistribute it and/or modify it under the terms of either the GNU
|
|
// Lesser General Public License Version 3 or the Perl Artistic License
|
|
// Version 2.0.
|
|
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
|
|
//
|
|
//*************************************************************************
|
|
|
|
#ifndef _V3PARTITIONGRAPH_H_
|
|
#define _V3PARTITIONGRAPH_H_
|
|
|
|
#include "config_build.h"
|
|
#include "verilatedos.h"
|
|
|
|
#include "V3Graph.h"
|
|
#include "V3OrderGraph.h"
|
|
|
|
#include <list>
|
|
|
|
//*************************************************************************
|
|
// MTasks and graph structures
|
|
|
|
class AbstractMTask : public V3GraphVertex {
|
|
public:
|
|
AbstractMTask(V3Graph* graphp)
|
|
: V3GraphVertex(graphp) {}
|
|
virtual ~AbstractMTask() {}
|
|
virtual uint32_t id() const = 0;
|
|
virtual uint32_t cost() const = 0;
|
|
};
|
|
|
|
class AbstractLogicMTask : public AbstractMTask {
|
|
public:
|
|
// TYPES
|
|
typedef std::list<MTaskMoveVertex*> VxList;
|
|
// CONSTRUCTORS
|
|
AbstractLogicMTask(V3Graph* graphp)
|
|
: AbstractMTask(graphp) {}
|
|
virtual ~AbstractLogicMTask() {}
|
|
// METHODS
|
|
// Set of logic vertices in this mtask. Order is not significant.
|
|
virtual const VxList* vertexListp() const = 0;
|
|
virtual uint32_t id() const = 0; // Unique id of this mtask.
|
|
virtual uint32_t cost() const = 0;
|
|
};
|
|
|
|
class ExecMTask : public AbstractMTask {
|
|
private:
|
|
AstMTaskBody* m_bodyp; // Task body
|
|
uint32_t m_id; // Unique id of this mtask.
|
|
uint32_t m_priority; // Predicted critical path from the start of
|
|
// this mtask to the ends of the graph that are reachable from this
|
|
// mtask. In abstract time units.
|
|
uint32_t m_cost; // Predicted runtime of this mtask, in the same
|
|
// abstract time units as priority().
|
|
uint32_t m_thread; // Thread for static (pack_mtasks) scheduling,
|
|
// or 0xffffffff if not yet assigned.
|
|
const ExecMTask* m_packNextp; // Next for static (pack_mtasks) scheduling
|
|
bool m_threadRoot; // Is root thread
|
|
VL_UNCOPYABLE(ExecMTask);
|
|
|
|
public:
|
|
ExecMTask(V3Graph* graphp, AstMTaskBody* bodyp, uint32_t id)
|
|
: AbstractMTask(graphp)
|
|
, m_bodyp(bodyp)
|
|
, m_id(id)
|
|
, m_priority(0)
|
|
, m_cost(0)
|
|
, m_thread(0xffffffff)
|
|
, m_packNextp(NULL)
|
|
, m_threadRoot(false) {}
|
|
AstMTaskBody* bodyp() const { return m_bodyp; }
|
|
virtual uint32_t id() const { return m_id; }
|
|
uint32_t priority() const { return m_priority; }
|
|
void priority(uint32_t pri) { m_priority = pri; }
|
|
virtual uint32_t cost() const { return m_cost; }
|
|
void cost(uint32_t cost) { m_cost = cost; }
|
|
void thread(uint32_t thread) { m_thread = thread; }
|
|
uint32_t thread() const { return m_thread; }
|
|
void packNextp(const ExecMTask* nextp) { m_packNextp = nextp; }
|
|
const ExecMTask* packNextp() const { return m_packNextp; }
|
|
bool threadRoot() const { return m_threadRoot; }
|
|
void threadRoot(bool threadRoot) { m_threadRoot = threadRoot; }
|
|
string cFuncName() const {
|
|
// If this MTask maps to a C function, this should be the name
|
|
return string("__Vmtask") + "__" + cvtToStr(m_id);
|
|
}
|
|
string name() const { return string("mt") + cvtToStr(id()); }
|
|
void dump(std::ostream& str) const {
|
|
str << name() << "." << cvtToHex(this);
|
|
if (priority() || cost()) str << " [pr=" << priority() << " c=" << cvtToStr(cost()) << "]";
|
|
if (thread() != 0xffffffff) str << " th=" << thread();
|
|
if (threadRoot()) str << " [ROOT]";
|
|
if (packNextp()) str << " nx=" << packNextp()->name();
|
|
}
|
|
};
|
|
inline std::ostream& operator<<(std::ostream& os, const ExecMTask& rhs) {
|
|
rhs.dump(os);
|
|
return os;
|
|
}
|
|
|
|
#endif // Guard
|