feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

TaskTree: Get rid of unused data

Browse Source 
Change-Id: I60f38e7a0efeb02615d81181a9884963a66be39b
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
Jarek Kobus
2023-11-12 17:26:20 +01:00
parent 1a44647d1e
commit e5b7f474b3
1 changed files with 28 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
src/libs/solutions/tasking/tasktree.cpp
View File

@@ -1077,12 +1077,9 @@ class TaskContainer
public: public:
TaskContainer(TaskContainer &&other) = default; TaskContainer(TaskContainer &&other) = default;
TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task, TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task);
TaskNode *parentNode, TaskContainer *parentContainer);
TaskTreePrivate *const m_taskTreePrivate = nullptr; TaskTreePrivate *const m_taskTreePrivate = nullptr;
TaskNode *const m_parentNode = nullptr;
TaskContainer *const m_parentContainer = nullptr;
const int m_parallelLimit = 1; const int m_parallelLimit = 1;
const WorkflowPolicy m_workflowPolicy = WorkflowPolicy::StopOnError; const WorkflowPolicy m_workflowPolicy = WorkflowPolicy::StopOnError;
@@ -1098,15 +1095,13 @@ class TaskNode
public: public:
TaskNode(TaskNode &&other) = default; TaskNode(TaskNode &&other) = default;
TaskNode(TaskTreePrivate *taskTreePrivate, const GroupItem &task, TaskNode(TaskTreePrivate *taskTreePrivate, const GroupItem &task)
TaskContainer *parentContainer)
: m_taskHandler(task.m_taskHandler) : m_taskHandler(task.m_taskHandler)
, m_container(taskTreePrivate, task, this, parentContainer) , m_container(taskTreePrivate, task)
{} {}
bool isTask() const { return bool(m_taskHandler.m_createHandler); } bool isTask() const { return bool(m_taskHandler.m_createHandler); }
int taskCount() const { return isTask() ? 1 : m_container.m_taskCount; } int taskCount() const { return isTask() ? 1 : m_container.m_taskCount; }
TaskContainer *parentContainer() const { return m_container.m_parentContainer; }
const GroupItem::TaskHandler m_taskHandler; const GroupItem::TaskHandler m_taskHandler;
TaskContainer m_container; TaskContainer m_container;
@@ -1210,11 +1205,9 @@ class TaskRuntimeContainer
Q_DISABLE_COPY(TaskRuntimeContainer) Q_DISABLE_COPY(TaskRuntimeContainer)
public: public:
TaskRuntimeContainer(const TaskContainer &taskContainer, TaskRuntimeNode *parentNode, TaskRuntimeContainer(const TaskContainer &taskContainer, TaskRuntimeNode *parentNode)
TaskRuntimeContainer *parentContainer)
: m_taskContainer(taskContainer) : m_taskContainer(taskContainer)
, m_parentNode(parentNode) , m_parentNode(parentNode)
, m_parentContainer(parentContainer)
, m_storageIdList(createStorages(taskContainer)) , m_storageIdList(createStorages(taskContainer))
, m_successBit(initialSuccessBit(taskContainer.m_workflowPolicy)) , m_successBit(initialSuccessBit(taskContainer.m_workflowPolicy))
{} {}
@@ -1232,13 +1225,13 @@ public:
static QList<int> createStorages(const TaskContainer &container); static QList<int> createStorages(const TaskContainer &container);
bool isStarting() const { return m_startGuard.isLocked(); } bool isStarting() const { return m_startGuard.isLocked(); }
bool updateSuccessBit(bool success);
int currentLimit() const; int currentLimit() const;
TaskRuntimeContainer *parentContainer() const;
bool updateSuccessBit(bool success);
void deleteChild(TaskRuntimeNode *node); void deleteChild(TaskRuntimeNode *node);
const TaskContainer &m_taskContainer; // Not owning. const TaskContainer &m_taskContainer; // Not owning.
TaskRuntimeNode *m_parentNode = nullptr; // Not owning. TaskRuntimeNode *m_parentNode = nullptr; // Not owning.
TaskRuntimeContainer *m_parentContainer = nullptr; // Not owning.
const QList<int> m_storageIdList; const QList<int> m_storageIdList;
std::vector<std::unique_ptr<TaskRuntimeNode>> m_children; // Owning. std::vector<std::unique_ptr<TaskRuntimeNode>> m_children; // Owning.
@@ -1277,8 +1270,8 @@ void ExecutionContextActivator::activateContext(TaskRuntimeContainer *container)
} }
// Go to the parent after activating this storages so that storage shadowing works // Go to the parent after activating this storages so that storage shadowing works
// in the direction from child to parent root. // in the direction from child to parent root.
if (container->m_parentContainer) if (container->parentContainer())
activateContext(container->m_parentContainer); activateContext(container->parentContainer());
} }
void TaskTreePrivate::start() void TaskTreePrivate::start()
@@ -1335,26 +1328,23 @@ void TaskTreePrivate::emitDone(DoneWith result)
emit q->done(result); emit q->done(result);
} }
static std::vector<TaskNode> createChildren(TaskTreePrivate *taskTreePrivate, TaskContainer *container, static std::vector<TaskNode> createChildren(TaskTreePrivate *taskTreePrivate,
const QList<GroupItem> &children) const QList<GroupItem> &children)
{ {
std::vector<TaskNode> result; std::vector<TaskNode> result;
result.reserve(children.size()); result.reserve(children.size());
for (const GroupItem &child : children) for (const GroupItem &child : children)
result.emplace_back(taskTreePrivate, child, container); result.emplace_back(taskTreePrivate, child);
return result; return result;
} }
TaskContainer::TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task, TaskContainer::TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task)
TaskNode *parentNode, TaskContainer *parentContainer)
: m_taskTreePrivate(taskTreePrivate) : m_taskTreePrivate(taskTreePrivate)
, m_parentNode(parentNode)
, m_parentContainer(parentContainer)
, m_parallelLimit(task.m_groupData.m_parallelLimit.value_or(1)) , m_parallelLimit(task.m_groupData.m_parallelLimit.value_or(1))
, m_workflowPolicy(task.m_groupData.m_workflowPolicy.value_or(WorkflowPolicy::StopOnError)) , m_workflowPolicy(task.m_groupData.m_workflowPolicy.value_or(WorkflowPolicy::StopOnError))
, m_groupHandler(task.m_groupData.m_groupHandler) , m_groupHandler(task.m_groupData.m_groupHandler)
, m_storageList(task.m_storageList) , m_storageList(task.m_storageList)
, m_children(createChildren(taskTreePrivate, this, task.m_children)) , m_children(createChildren(taskTreePrivate, task.m_children))
, m_taskCount(std::accumulate(m_children.cbegin(), m_children.cend(), 0, , m_taskCount(std::accumulate(m_children.cbegin(), m_children.cend(), 0,
[](int r, const TaskNode &n) { return r + n.taskCount(); })) [](int r, const TaskNode &n) { return r + n.taskCount(); }))
{ {
@@ -1373,6 +1363,19 @@ QList<int> TaskRuntimeContainer::createStorages(const TaskContainer &container)
return storageIdList; return storageIdList;
} }
int TaskRuntimeContainer::currentLimit() const
{
// TODO: Handle children well
const int childCount = m_taskContainer.m_children.size();
return m_taskContainer.m_parallelLimit
? qMin(m_doneCount + m_taskContainer.m_parallelLimit, childCount) : childCount;
}
TaskRuntimeContainer *TaskRuntimeContainer::parentContainer() const
{
return m_parentNode->m_parentContainer;
}
bool TaskRuntimeContainer::updateSuccessBit(bool success) bool TaskRuntimeContainer::updateSuccessBit(bool success)
{ {
if (m_taskContainer.m_workflowPolicy == WorkflowPolicy::FinishAllAndSuccess if (m_taskContainer.m_workflowPolicy == WorkflowPolicy::FinishAllAndSuccess
@@ -1389,14 +1392,6 @@ bool TaskRuntimeContainer::updateSuccessBit(bool success)
return m_successBit; return m_successBit;
} }
int TaskRuntimeContainer::currentLimit() const
{
// TODO: Handle children well
const int childCount = m_taskContainer.m_children.size();
return m_taskContainer.m_parallelLimit
? qMin(m_doneCount + m_taskContainer.m_parallelLimit, childCount) : childCount;
}
void TaskRuntimeContainer::deleteChild(TaskRuntimeNode *node) void TaskRuntimeContainer::deleteChild(TaskRuntimeNode *node)
{ {
std::remove_if(m_children.begin(), m_children.end(), [node](const auto &ptr) { std::remove_if(m_children.begin(), m_children.end(), [node](const auto &ptr) {
@@ -1431,7 +1426,7 @@ SetupResult TaskTreePrivate::continueStart(TaskRuntimeContainer *container, Setu
: startAction; : startAction;
if (groupAction != SetupResult::Continue) { if (groupAction != SetupResult::Continue) {
const bool bit = container->updateSuccessBit(groupAction == SetupResult::StopWithSuccess); const bool bit = container->updateSuccessBit(groupAction == SetupResult::StopWithSuccess);
TaskRuntimeContainer *parentContainer = container->m_parentContainer; TaskRuntimeContainer *parentContainer = container->parentContainer();
TaskRuntimeNode *parentNode = container->m_parentNode; TaskRuntimeNode *parentNode = container->m_parentNode;
QT_CHECK(parentNode); QT_CHECK(parentNode);
const bool result = invokeDoneHandler(container, bit ? DoneWith::Success : DoneWith::Error); const bool result = invokeDoneHandler(container, bit ? DoneWith::Success : DoneWith::Error);
@@ -1535,7 +1530,7 @@ bool TaskTreePrivate::invokeDoneHandler(TaskRuntimeContainer *container, DoneWit
SetupResult TaskTreePrivate::start(TaskRuntimeNode *node) SetupResult TaskTreePrivate::start(TaskRuntimeNode *node)
{ {
if (!node->m_taskNode.isTask()) { if (!node->m_taskNode.isTask()) {
node->m_container.emplace(node->m_taskNode.m_container, node, node->m_parentContainer); node->m_container.emplace(node->m_taskNode.m_container, node);
return start(&*node->m_container); return start(&*node->m_container);
} }
@@ -2295,7 +2290,7 @@ void TaskTree::setRecipe(const Group &recipe)
"TaskTree handlers, ignoring..."); return); "TaskTree handlers, ignoring..."); return);
// TODO: Should we clear the m_storageHandlers, too? // TODO: Should we clear the m_storageHandlers, too?
d->m_storages.clear(); d->m_storages.clear();
d->m_root.emplace(d, recipe, nullptr); d->m_root.emplace(d, recipe);
} }
/*! /*!