Skip to content

Commit

Permalink
Merge pull request #286 from PrincetonUniversity/tasklist_extension
Browse files Browse the repository at this point in the history 
Extend TaskList to support more than 64 task IDs
  • Loading branch information
@felker
felker committed Jun 25, 2019
2 parents aae037d + fcdafcf commit 318b1b1
Show file tree
Hide file tree
Showing 9 changed files with 668 additions and 680 deletions.
60 changes: 27 additions & 33 deletions src/task_list/fft_grav_task_list.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -42,46 +42,40 @@ FFTGravitySolverTaskList::FFTGravitySolverTaskList(ParameterInput *pin, Mesh *pm
}

//----------------------------------------------------------------------------------------
//! \fn void FFTGravitySolverTaskList::AddTask(std::uint64_t id, std::uint64_t dep)
//! \fn void FFTGravitySolverTaskList::AddTask(const TaskID& id, const TaskID& dep)
// \brief Sets id and dependency for "ntask" member of task_list_ array, then iterates
// value of ntask.

void FFTGravitySolverTaskList::AddTask(std::uint64_t id, std::uint64_t dep) {
void FFTGravitySolverTaskList::AddTask(const TaskID& id, const TaskID& dep) {
task_list_[ntasks].task_id=id;
task_list_[ntasks].dependency=dep;

using namespace FFTGravitySolverTaskNames; // NOLINT (build/namespace)
switch (id) {
case (CLEAR_GRAV):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::ClearFFTGravityBoundary);
break;
case (SEND_GRAV_BND):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::SendFFTGravityBoundary);
break;
case (RECV_GRAV_BND):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::ReceiveFFTGravityBoundary);
break;
case (SETB_GRAV_BND):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::SetFFTGravityBoundary);
break;
case (GRAV_PHYS_BND):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::PhysicalBoundary);
break;
default:
std::stringstream msg;
msg << "### FATAL ERROR in FFTGravitySolverTaskList::AddTask" << std::endl
<< "Invalid Task "<< id << " is specified" << std::endl;
ATHENA_ERROR(msg);
if (id == CLEAR_GRAV) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::ClearFFTGravityBoundary);
} else if (id == SEND_GRAV_BND) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::SendFFTGravityBoundary);
} else if (id == RECV_GRAV_BND) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::ReceiveFFTGravityBoundary);
} else if (id == SETB_GRAV_BND) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::SetFFTGravityBoundary);
} else if (id == GRAV_PHYS_BND) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (TaskList::*)(MeshBlock*,int)>
(&FFTGravitySolverTaskList::PhysicalBoundary);
} else {
std::stringstream msg;
msg << "### FATAL ERROR in FFTGravitySolverTaskList::AddTask" << std::endl
<< "Invalid Task is specified" << std::endl;
ATHENA_ERROR(msg);
}
ntasks++;
return;
Expand Down
14 changes: 7 additions & 7 deletions src/task_list/fft_grav_task_list.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,20 +37,20 @@ class FFTGravitySolverTaskList : public TaskList {
TaskStatus PhysicalBoundary(MeshBlock *pmb, int stage);

private:
void AddTask(std::uint64_t id, std::uint64_t dep) override;
void AddTask(const TaskID& id, const TaskID& dep) override;
void StartupTaskList(MeshBlock *pmb, int stage) override;
};


//----------------------------------------------------------------------------------------
// 64-bit integers with "1" in different bit positions used to ID each hydro task.
namespace FFTGravitySolverTaskNames {
const std::uint64_t NONE=0ULL;
const std::uint64_t CLEAR_GRAV=1ULL<<0;
const TaskID NONE(0);
const TaskID CLEAR_GRAV(1);

const std::uint64_t SEND_GRAV_BND=1ULL<<1;
const std::uint64_t RECV_GRAV_BND=1ULL<<2;
const std::uint64_t SETB_GRAV_BND=1ULL<<3;
const std::uint64_t GRAV_PHYS_BND=1ULL<<4;
const TaskID SEND_GRAV_BND(2);
const TaskID RECV_GRAV_BND(3);
const TaskID SETB_GRAV_BND(4);
const TaskID GRAV_PHYS_BND(5);
}
#endif // TASK_LIST_FFT_GRAV_TASK_LIST_HPP_
174 changes: 68 additions & 106 deletions src/task_list/mg_task_list.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,13 +61,13 @@ TaskListStatus MultigridTaskList::DoAllAvailableTasks(Multigrid *pmg, TaskStates
for (int i=ts.indx_first_task; i<ntasks; i++) {
MGTask &taski=task_list_[i];

if ((taski.task_id & ts.finished_tasks) == 0ULL) { // task not done
if (ts.finished_tasks.IsUnfinished(taski.task_id)) { // task not done
// check if dependency clear
if (((taski.dependency & ts.finished_tasks) == taski.dependency)) {
if (ts.finished_tasks.CheckDependencies(taski.dependency)) {
ret=(this->*task_list_[i].TaskFunc)(pmg);
if (ret!=TaskStatus::fail) { // success
ts.num_tasks_left--;
ts.finished_tasks |= taski.task_id;
ts.finished_tasks.SetFinished(taski.task_id);
if (skip==0) ts.indx_first_task++;
if (ts.num_tasks_left==0) return TaskListStatus::complete;
if (ret==TaskStatus::next) continue;
Expand All @@ -86,118 +86,80 @@ TaskListStatus MultigridTaskList::DoAllAvailableTasks(Multigrid *pmg, TaskStates


//----------------------------------------------------------------------------------------
//! \fn void MultigridTaskList::AddMultigridTask(std::uint64_t id, std::uint64_t dep)
//! \fn void MultigridTaskList::AddMultigridTask(const TaskID& id, const TaskID& dep)
// \brief Sets id and dependency for "ntask" member of task_list_ array, then iterates
// value of ntask.

void MultigridTaskList::AddMultigridTask(std::uint64_t id, std::uint64_t dep) {
void MultigridTaskList::AddMultigridTask(const TaskID& id, const TaskID& dep) {
task_list_[ntasks].task_id=id;
task_list_[ntasks].dependency=dep;

switch (id) {
case (MG_STARTRECV0):
case (MG_STARTRECVL):
task_list_[ntasks].TaskFunc=
if (id == MG_STARTRECV0 || id == MG_STARTRECVL) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::StartReceive);
} else if (id == MG_STARTRECV0F || id == MG_STARTRECV1R || id == MG_STARTRECV1B
|| id == MG_STARTRECV2R || id == MG_STARTRECV2B) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::StartReceiveFace);
} else if (id == MG_CLEARBND0 || id == MG_CLEARBNDL) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ClearBoundary);
} else if (id == MG_CLEARBND0F || id == MG_CLEARBND1R || id == MG_CLEARBND1B
|| id == MG_CLEARBND2R || id == MG_CLEARBND2B) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ClearBoundaryFace);
} else if (id == MG_SENDBND0 || id == MG_SENDBNDL) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SendBoundary);
} else if (id == MG_SENDBND0F || id == MG_SENDBND1R || id == MG_SENDBND1B
|| id == MG_SENDBND2R || id == MG_SENDBND2B) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SendBoundaryFace);
} else if (id == MG_RECVBND0 || id == MG_RECVBNDL) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ReceiveBoundary);
} else if (id == MG_RECVBND0F || id == MG_RECVBND1R || id == MG_RECVBND1B
|| id == MG_RECVBND2R || id == MG_RECVBND2B) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ReceiveBoundaryFace);
} else if (id == MG_SMOOTH1R || id == MG_SMOOTH2R) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SmoothRed);
} else if (id == MG_SMOOTH1B || id == MG_SMOOTH2B) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SmoothBlack);
} else if (id == MG_PHYSBND0 || id == MG_PHYSBND1R || id == MG_PHYSBND1B
|| id == MG_PHYSBND2R || id == MG_PHYSBND2B || id == MG_PHYSBNDL) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::PhysicalBoundary);
} else if (id == MG_RESTRICT) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::StartReceive);
break;
case (MG_STARTRECV0F):
case (MG_STARTRECV1R):
case (MG_STARTRECV1B):
case (MG_STARTRECV2R):
case (MG_STARTRECV2B):
task_list_[ntasks].TaskFunc=
(&MultigridTaskList::Restrict);
} else if (id == MG_PROLONG) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::StartReceiveFace);
break;
case (MG_CLEARBND0):
case (MG_CLEARBNDL):
task_list_[ntasks].TaskFunc=
(&MultigridTaskList::Prolongate);
} else if (id == MG_FMGPROLONG) {
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ClearBoundary);
break;
case (MG_CLEARBND0F):
case (MG_CLEARBND1R):
case (MG_CLEARBND1B):
case (MG_CLEARBND2R):
case (MG_CLEARBND2B):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ClearBoundaryFace);
break;
case (MG_SENDBND0):
case (MG_SENDBNDL):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SendBoundary);
break;
case (MG_SENDBND0F):
case (MG_SENDBND1R):
case (MG_SENDBND1B):
case (MG_SENDBND2R):
case (MG_SENDBND2B):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SendBoundaryFace);
break;
case (MG_RECVBND0):
case (MG_RECVBNDL):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ReceiveBoundary);
break;
case (MG_RECVBND0F):
case (MG_RECVBND1R):
case (MG_RECVBND1B):
case (MG_RECVBND2R):
case (MG_RECVBND2B):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::ReceiveBoundaryFace);
break;
case (MG_SMOOTH1R):
case (MG_SMOOTH2R):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SmoothRed);
break;
case (MG_SMOOTH1B):
case (MG_SMOOTH2B):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::SmoothBlack);
break;
case (MG_PHYSBND0):
case (MG_PHYSBND1R):
case (MG_PHYSBND1B):
case (MG_PHYSBND2R):
case (MG_PHYSBND2B):
case (MG_PHYSBNDL):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::PhysicalBoundary);
break;
case (MG_RESTRICT):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::Restrict);
break;
case (MG_PROLONG):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::Prolongate);
break;
case (MG_FMGPROLONG):
task_list_[ntasks].TaskFunc=
static_cast<TaskStatus (MultigridTaskList::*)(Multigrid*)>
(&MultigridTaskList::FMGProlongate);
break;

default:
std::stringstream msg;
msg << "### FATAL ERROR in AddMultigridTask" << std::endl
<< "Invalid Task "<< id << " is specified" << std::endl;
ATHENA_ERROR(msg);
(&MultigridTaskList::FMGProlongate);
} else {
std::stringstream msg;
msg << "### FATAL ERROR in AddMultigridTask" << std::endl
<< "Invalid Task is specified" << std::endl;
ATHENA_ERROR(msg);
}
ntasks++;
return;
Expand Down
Loading

0 comments on commit 318b1b1

Please sign in to comment.