clang  3.9.0
MPIChecker.h
Go to the documentation of this file.
1 //===-- MPIChecker.h - Verify MPI API usage- --------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// This file defines the main class of MPI-Checker which serves as an entry
12 /// point. It is created once for each translation unit analysed.
13 /// The checker defines path-sensitive checks, to verify correct usage of the
14 /// MPI API.
15 ///
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKER_H
19 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKER_H
20 
21 #include "MPIBugReporter.h"
22 #include "MPIFunctionClassifier.h"
23 #include "MPITypes.h"
26 
27 namespace clang {
28 namespace ento {
29 namespace mpi {
30 
31 class MPIChecker : public Checker<check::PreCall, check::DeadSymbols> {
32 public:
33  MPIChecker() : BReporter(*this) { }
34 
35  // path-sensitive callbacks
36  void checkPreCall(const CallEvent &CE, CheckerContext &Ctx) const {
37  dynamicInit(Ctx);
38  checkUnmatchedWaits(CE, Ctx);
39  checkDoubleNonblocking(CE, Ctx);
40  }
41 
42  void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &Ctx) const {
43  dynamicInit(Ctx);
44  checkMissingWaits(SymReaper, Ctx);
45  }
46 
47  void dynamicInit(CheckerContext &Ctx) const {
48  if (FuncClassifier)
49  return;
50  const_cast<std::unique_ptr<MPIFunctionClassifier> &>(FuncClassifier)
51  .reset(new MPIFunctionClassifier{Ctx.getASTContext()});
52 
53  }
54 
55  /// Checks if a request is used by nonblocking calls multiple times
56  /// in sequence without intermediate wait. The check contains a guard,
57  /// in order to only inspect nonblocking functions.
58  ///
59  /// \param PreCallEvent MPI call to verify
60  void checkDoubleNonblocking(const clang::ento::CallEvent &PreCallEvent,
61  clang::ento::CheckerContext &Ctx) const;
62 
63  /// Checks if a request is used by a wait multiple times in sequence without
64  /// intermediate nonblocking call or if the request used by the wait
65  /// function was not used at all before. The check contains a guard,
66  /// in order to only inspect wait functions.
67  ///
68  /// \param PreCallEvent MPI call to verify
69  void checkUnmatchedWaits(const clang::ento::CallEvent &PreCallEvent,
70  clang::ento::CheckerContext &Ctx) const;
71 
72  /// Check if a nonblocking call is not matched by a wait.
73  /// If a memory region is not alive and the last function using the
74  /// request was a nonblocking call, this is rated as a missing wait.
76  clang::ento::CheckerContext &Ctx) const;
77 
78 private:
79  /// Collects all memory regions of a request(array) used by a wait
80  /// function. If the wait function uses a single request, this is a single
81  /// region. For wait functions using multiple requests, multiple regions
82  /// representing elements in the array are collected.
83  ///
84  /// \param ReqRegions vector the regions get pushed into
85  /// \param MR top most region to iterate
86  /// \param CE MPI wait call using the request(s)
87  void allRegionsUsedByWait(
89  const clang::ento::MemRegion *const MR, const clang::ento::CallEvent &CE,
90  clang::ento::CheckerContext &Ctx) const;
91 
92  /// Returns the memory region used by a wait function.
93  /// Distinguishes between MPI_Wait and MPI_Waitall.
94  ///
95  /// \param CE MPI wait call
97  topRegionUsedByWait(const clang::ento::CallEvent &CE) const;
98 
99  const std::unique_ptr<MPIFunctionClassifier> FuncClassifier;
100  MPIBugReporter BReporter;
101 };
102 
103 } // end of namespace: mpi
104 } // end of namespace: ento
105 } // end of namespace: clang
106 
107 #endif
This file provides definitions to model concepts of MPI.
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:79
void checkPreCall(const CallEvent &CE, CheckerContext &Ctx) const
Definition: MPIChecker.h:36
void checkMissingWaits(clang::ento::SymbolReaper &SymReaper, clang::ento::CheckerContext &Ctx) const
Check if a nonblocking call is not matched by a wait.
Definition: MPIChecker.cpp:99
This file defines functionality to identify and classify MPI functions.
void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &Ctx) const
Definition: MPIChecker.h:42
A class responsible for cleaning up unused symbols.
void checkDoubleNonblocking(const clang::ento::CallEvent &PreCallEvent, clang::ento::CheckerContext &Ctx) const
Checks if a request is used by nonblocking calls multiple times in sequence without intermediate wait...
Definition: MPIChecker.cpp:25
Represents an abstract call to a function or method along a particular path.
Definition: CallEvent.h:138
void checkUnmatchedWaits(const clang::ento::CallEvent &PreCallEvent, clang::ento::CheckerContext &Ctx) const
Checks if a request is used by a wait multiple times in sequence without intermediate nonblocking cal...
Definition: MPIChecker.cpp:56
void dynamicInit(CheckerContext &Ctx) const
Definition: MPIChecker.h:47
This file defines prefabricated reports which are emitted in case of MPI related bugs, detected by path-sensitive analysis.