284 lines
10 KiB
C++
284 lines
10 KiB
C++
//===-- MPIFunctionClassifier.cpp - classifies MPI functions ----*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file defines functionality to identify and classify MPI functions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
namespace clang {
|
|
namespace ento {
|
|
namespace mpi {
|
|
|
|
void MPIFunctionClassifier::identifierInit(ASTContext &ASTCtx) {
|
|
// Initialize function identifiers.
|
|
initPointToPointIdentifiers(ASTCtx);
|
|
initCollectiveIdentifiers(ASTCtx);
|
|
initAdditionalIdentifiers(ASTCtx);
|
|
}
|
|
|
|
void MPIFunctionClassifier::initPointToPointIdentifiers(ASTContext &ASTCtx) {
|
|
// Copy identifiers into the correct classification containers.
|
|
IdentInfo_MPI_Send = &ASTCtx.Idents.get("MPI_Send");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Send);
|
|
MPIType.push_back(IdentInfo_MPI_Send);
|
|
assert(IdentInfo_MPI_Send);
|
|
|
|
IdentInfo_MPI_Isend = &ASTCtx.Idents.get("MPI_Isend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Isend);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Isend);
|
|
MPIType.push_back(IdentInfo_MPI_Isend);
|
|
assert(IdentInfo_MPI_Isend);
|
|
|
|
IdentInfo_MPI_Ssend = &ASTCtx.Idents.get("MPI_Ssend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Ssend);
|
|
MPIType.push_back(IdentInfo_MPI_Ssend);
|
|
assert(IdentInfo_MPI_Ssend);
|
|
|
|
IdentInfo_MPI_Issend = &ASTCtx.Idents.get("MPI_Issend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Issend);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Issend);
|
|
MPIType.push_back(IdentInfo_MPI_Issend);
|
|
assert(IdentInfo_MPI_Issend);
|
|
|
|
IdentInfo_MPI_Bsend = &ASTCtx.Idents.get("MPI_Bsend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Bsend);
|
|
MPIType.push_back(IdentInfo_MPI_Bsend);
|
|
assert(IdentInfo_MPI_Bsend);
|
|
|
|
IdentInfo_MPI_Ibsend = &ASTCtx.Idents.get("MPI_Ibsend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Ibsend);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Ibsend);
|
|
MPIType.push_back(IdentInfo_MPI_Ibsend);
|
|
assert(IdentInfo_MPI_Ibsend);
|
|
|
|
IdentInfo_MPI_Rsend = &ASTCtx.Idents.get("MPI_Rsend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Rsend);
|
|
MPIType.push_back(IdentInfo_MPI_Rsend);
|
|
assert(IdentInfo_MPI_Rsend);
|
|
|
|
IdentInfo_MPI_Irsend = &ASTCtx.Idents.get("MPI_Irsend");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Irsend);
|
|
MPIType.push_back(IdentInfo_MPI_Irsend);
|
|
assert(IdentInfo_MPI_Irsend);
|
|
|
|
IdentInfo_MPI_Recv = &ASTCtx.Idents.get("MPI_Recv");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Recv);
|
|
MPIType.push_back(IdentInfo_MPI_Recv);
|
|
assert(IdentInfo_MPI_Recv);
|
|
|
|
IdentInfo_MPI_Irecv = &ASTCtx.Idents.get("MPI_Irecv");
|
|
MPIPointToPointTypes.push_back(IdentInfo_MPI_Irecv);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Irecv);
|
|
MPIType.push_back(IdentInfo_MPI_Irecv);
|
|
assert(IdentInfo_MPI_Irecv);
|
|
}
|
|
|
|
void MPIFunctionClassifier::initCollectiveIdentifiers(ASTContext &ASTCtx) {
|
|
// Copy identifiers into the correct classification containers.
|
|
IdentInfo_MPI_Scatter = &ASTCtx.Idents.get("MPI_Scatter");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Scatter);
|
|
MPIPointToCollTypes.push_back(IdentInfo_MPI_Scatter);
|
|
MPIType.push_back(IdentInfo_MPI_Scatter);
|
|
assert(IdentInfo_MPI_Scatter);
|
|
|
|
IdentInfo_MPI_Iscatter = &ASTCtx.Idents.get("MPI_Iscatter");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Iscatter);
|
|
MPIPointToCollTypes.push_back(IdentInfo_MPI_Iscatter);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Iscatter);
|
|
MPIType.push_back(IdentInfo_MPI_Iscatter);
|
|
assert(IdentInfo_MPI_Iscatter);
|
|
|
|
IdentInfo_MPI_Gather = &ASTCtx.Idents.get("MPI_Gather");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Gather);
|
|
MPICollToPointTypes.push_back(IdentInfo_MPI_Gather);
|
|
MPIType.push_back(IdentInfo_MPI_Gather);
|
|
assert(IdentInfo_MPI_Gather);
|
|
|
|
IdentInfo_MPI_Igather = &ASTCtx.Idents.get("MPI_Igather");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Igather);
|
|
MPICollToPointTypes.push_back(IdentInfo_MPI_Igather);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Igather);
|
|
MPIType.push_back(IdentInfo_MPI_Igather);
|
|
assert(IdentInfo_MPI_Igather);
|
|
|
|
IdentInfo_MPI_Allgather = &ASTCtx.Idents.get("MPI_Allgather");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Allgather);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Allgather);
|
|
MPIType.push_back(IdentInfo_MPI_Allgather);
|
|
assert(IdentInfo_MPI_Allgather);
|
|
|
|
IdentInfo_MPI_Iallgather = &ASTCtx.Idents.get("MPI_Iallgather");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Iallgather);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Iallgather);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Iallgather);
|
|
MPIType.push_back(IdentInfo_MPI_Iallgather);
|
|
assert(IdentInfo_MPI_Iallgather);
|
|
|
|
IdentInfo_MPI_Bcast = &ASTCtx.Idents.get("MPI_Bcast");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Bcast);
|
|
MPIPointToCollTypes.push_back(IdentInfo_MPI_Bcast);
|
|
MPIType.push_back(IdentInfo_MPI_Bcast);
|
|
assert(IdentInfo_MPI_Bcast);
|
|
|
|
IdentInfo_MPI_Ibcast = &ASTCtx.Idents.get("MPI_Ibcast");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Ibcast);
|
|
MPIPointToCollTypes.push_back(IdentInfo_MPI_Ibcast);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Ibcast);
|
|
MPIType.push_back(IdentInfo_MPI_Ibcast);
|
|
assert(IdentInfo_MPI_Ibcast);
|
|
|
|
IdentInfo_MPI_Reduce = &ASTCtx.Idents.get("MPI_Reduce");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Reduce);
|
|
MPICollToPointTypes.push_back(IdentInfo_MPI_Reduce);
|
|
MPIType.push_back(IdentInfo_MPI_Reduce);
|
|
assert(IdentInfo_MPI_Reduce);
|
|
|
|
IdentInfo_MPI_Ireduce = &ASTCtx.Idents.get("MPI_Ireduce");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Ireduce);
|
|
MPICollToPointTypes.push_back(IdentInfo_MPI_Ireduce);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Ireduce);
|
|
MPIType.push_back(IdentInfo_MPI_Ireduce);
|
|
assert(IdentInfo_MPI_Ireduce);
|
|
|
|
IdentInfo_MPI_Allreduce = &ASTCtx.Idents.get("MPI_Allreduce");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Allreduce);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Allreduce);
|
|
MPIType.push_back(IdentInfo_MPI_Allreduce);
|
|
assert(IdentInfo_MPI_Allreduce);
|
|
|
|
IdentInfo_MPI_Iallreduce = &ASTCtx.Idents.get("MPI_Iallreduce");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Iallreduce);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Iallreduce);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Iallreduce);
|
|
MPIType.push_back(IdentInfo_MPI_Iallreduce);
|
|
assert(IdentInfo_MPI_Iallreduce);
|
|
|
|
IdentInfo_MPI_Alltoall = &ASTCtx.Idents.get("MPI_Alltoall");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Alltoall);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Alltoall);
|
|
MPIType.push_back(IdentInfo_MPI_Alltoall);
|
|
assert(IdentInfo_MPI_Alltoall);
|
|
|
|
IdentInfo_MPI_Ialltoall = &ASTCtx.Idents.get("MPI_Ialltoall");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Ialltoall);
|
|
MPICollToCollTypes.push_back(IdentInfo_MPI_Ialltoall);
|
|
MPINonBlockingTypes.push_back(IdentInfo_MPI_Ialltoall);
|
|
MPIType.push_back(IdentInfo_MPI_Ialltoall);
|
|
assert(IdentInfo_MPI_Ialltoall);
|
|
}
|
|
|
|
void MPIFunctionClassifier::initAdditionalIdentifiers(ASTContext &ASTCtx) {
|
|
IdentInfo_MPI_Comm_rank = &ASTCtx.Idents.get("MPI_Comm_rank");
|
|
MPIType.push_back(IdentInfo_MPI_Comm_rank);
|
|
assert(IdentInfo_MPI_Comm_rank);
|
|
|
|
IdentInfo_MPI_Comm_size = &ASTCtx.Idents.get("MPI_Comm_size");
|
|
MPIType.push_back(IdentInfo_MPI_Comm_size);
|
|
assert(IdentInfo_MPI_Comm_size);
|
|
|
|
IdentInfo_MPI_Wait = &ASTCtx.Idents.get("MPI_Wait");
|
|
MPIType.push_back(IdentInfo_MPI_Wait);
|
|
assert(IdentInfo_MPI_Wait);
|
|
|
|
IdentInfo_MPI_Waitall = &ASTCtx.Idents.get("MPI_Waitall");
|
|
MPIType.push_back(IdentInfo_MPI_Waitall);
|
|
assert(IdentInfo_MPI_Waitall);
|
|
|
|
IdentInfo_MPI_Barrier = &ASTCtx.Idents.get("MPI_Barrier");
|
|
MPICollectiveTypes.push_back(IdentInfo_MPI_Barrier);
|
|
MPIType.push_back(IdentInfo_MPI_Barrier);
|
|
assert(IdentInfo_MPI_Barrier);
|
|
}
|
|
|
|
// general identifiers
|
|
bool MPIFunctionClassifier::isMPIType(const IdentifierInfo *IdentInfo) const {
|
|
return llvm::is_contained(MPIType, IdentInfo);
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isNonBlockingType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return llvm::is_contained(MPINonBlockingTypes, IdentInfo);
|
|
}
|
|
|
|
// point-to-point identifiers
|
|
bool MPIFunctionClassifier::isPointToPointType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return llvm::is_contained(MPIPointToPointTypes, IdentInfo);
|
|
}
|
|
|
|
// collective identifiers
|
|
bool MPIFunctionClassifier::isCollectiveType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return llvm::is_contained(MPICollectiveTypes, IdentInfo);
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isCollToColl(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return llvm::is_contained(MPICollToCollTypes, IdentInfo);
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isScatterType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Scatter ||
|
|
IdentInfo == IdentInfo_MPI_Iscatter;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isGatherType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Gather ||
|
|
IdentInfo == IdentInfo_MPI_Igather ||
|
|
IdentInfo == IdentInfo_MPI_Allgather ||
|
|
IdentInfo == IdentInfo_MPI_Iallgather;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isAllgatherType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Allgather ||
|
|
IdentInfo == IdentInfo_MPI_Iallgather;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isAlltoallType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Alltoall ||
|
|
IdentInfo == IdentInfo_MPI_Ialltoall;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isBcastType(const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Bcast || IdentInfo == IdentInfo_MPI_Ibcast;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isReduceType(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Reduce ||
|
|
IdentInfo == IdentInfo_MPI_Ireduce ||
|
|
IdentInfo == IdentInfo_MPI_Allreduce ||
|
|
IdentInfo == IdentInfo_MPI_Iallreduce;
|
|
}
|
|
|
|
// additional identifiers
|
|
bool MPIFunctionClassifier::isMPI_Wait(const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Wait;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isMPI_Waitall(
|
|
const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Waitall;
|
|
}
|
|
|
|
bool MPIFunctionClassifier::isWaitType(const IdentifierInfo *IdentInfo) const {
|
|
return IdentInfo == IdentInfo_MPI_Wait || IdentInfo == IdentInfo_MPI_Waitall;
|
|
}
|
|
|
|
} // end of namespace: mpi
|
|
} // end of namespace: ento
|
|
} // end of namespace: clang
|