[JSON][PM] Port json import/export over to new pm

[philip.pfaffe]

Summary

I pulled out all functionality into static functions, and use those both
in the legacy passes and in the new ones. There is one functional
change: Before, if we fail to parse a jscop file, this will be reported
as an error and importing is aborted. However, this isn't actually
strong enough, since although the import is aborted, the scop has
already been modified and is very likely broken. Instead, make this a
hard failure and throw an LLVM error. This new behaviour requires small
changes to the tests for the legacy pass, namely using not.

[Meinersbur]

There are multiple changes in this patch:

• Fixing some broken regression tests
• Add import/export to new PM
• Hard error on jscop import fail (cool!)
• Make some private methods of JSONImporter free functions.

I'd wish for a clearer commit message about these changes, if not even committing separately.

lib/Exchange/JSONExporter.cpp

212 ↗

(On Diff #110569)

[Style] Make static?

391–392 ↗

(On Diff #110569)

unrelated?

434–435 ↗

(On Diff #110569)

unrelated?

polly/trunk/include/polly/JSONExporter.h

+#ifndef POLLY_JSONEXPORTER_H
+#define POLLY_JSONEXPORTER_H
+
+#include "polly/ScopPass.h"
+#include "llvm/IR/PassManager.h"
+
+namespace polly {
+/// This pass exports a scop to a jscop file. The filename is generated from the
+/// concatenation of the function and scop name.
+struct JSONExportPass : public llvm::PassInfoMixin<JSONExportPass> {
+  llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &,
+                              ScopStandardAnalysisResults &, SPMUpdater &);
+};
+
+/// This pass imports a scop from a jscop file. The filename is deduced from the
+/// concatenation of the function and scop name.
+struct JSONImportPass : public llvm::PassInfoMixin<JSONExportPass> {
+  llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &,
+                              ScopStandardAnalysisResults &, SPMUpdater &);
+};
+} // namespace polly
+
+#endif /* POLLY_JSONEXPORTER_H */

polly/trunk/lib/Exchange/JSONExporter.cpp

 //===-- JSONExporter.cpp  - Export Scops as JSON  -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Export the Scops build by ScopInfo pass as a JSON file.
 //
 //===----------------------------------------------------------------------===//
 
+#include "polly/JSONExporter.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "polly/ScopPass.h"
 #include "polly/Support/ScopLocation.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/RegionInfo.h"
ImportPostfix("polly-import-jscop-postfix",
                   cl::desc("Postfix to append to the import .jsop files."),
                   cl::Hidden, cl::value_desc("File postfix"), cl::ValueRequired,
                   cl::init(""), cl::cat(PollyCategory));
 
 struct JSONExporter : public ScopPass {
   static char ID;
   explicit JSONExporter() : ScopPass(ID) {}
 
-  std::string getFileName(Scop &S) const;
-  Json::Value getJSON(Scop &S) const;
-
   /// Export the SCoP @p S to a JSON file.
   bool runOnScop(Scop &S) override;
 
   /// Print the SCoP @p S as it is exported.
   void printScop(raw_ostream &OS, Scop &S) const override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
 struct JSONImporter : public ScopPass {
   static char ID;
   std::vector<std::string> NewAccessStrings;
   explicit JSONImporter() : ScopPass(ID) {}
-
-  /// Import a new context from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importContext(Scop &S, Json::Value &JScop);
-
-  /// Import a new schedule from JScop.
-  ///
-  /// ... and verify that the new schedule does preserve existing data
-  /// dependences.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  /// @param D The data dependences of the @p S.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importSchedule(Scop &S, Json::Value &JScop, const Dependences &D);
-
-  /// Import new arrays from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing new arrays.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importArrays(Scop &S, Json::Value &JScop);
-
-  /// Import new memory accesses from JScop.
-  ///
-  /// @param S The scop to update.
-  /// @param JScop The JScop file describing the new schedule.
-  /// @param DL The data layout to assume.
-  ///
-  /// @returns True if the import succeeded, otherwise False.
-  bool importAccesses(Scop &S, Json::Value &JScop, const DataLayout &DL);
-
-  std::string getFileName(Scop &S) const;
-
   /// Import new access functions for SCoP @p S from a JSON file.
   bool runOnScop(Scop &S) override;
 
   /// Print the SCoP @p S and the imported access functions.
   void printScop(raw_ostream &OS, Scop &S) const override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 } // namespace
 
-char JSONExporter::ID = 0;
-std::string JSONExporter::getFileName(Scop &S) const {
+static std::string getFileName(Scop &S, StringRef Suffix = "") {
   std::string FunctionName = S.getFunction().getName();
   std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
+
+  if (Suffix != "")
+    FileName += "." + Suffix.str();
+
   return FileName;
 }
 
-void JSONExporter::printScop(raw_ostream &OS, Scop &S) const { OS << S; }
-
 /// Export all arrays from the Scop.
 ///
 /// @param S The Scop containing the arrays.
 ///
 /// @returns Json::Value containing the arrays.
-Json::Value exportArrays(const Scop &S) {
+static Json::Value exportArrays(const Scop &S) {
   Json::Value Arrays;
   std::string Buffer;
   llvm::raw_string_ostream RawStringOstream(Buffer);
 
   for (auto &SAI : S.arrays()) {
     if (!SAI->isArrayKind())
       continue;
 
for (auto &SAI : S.arrays()) {
     SAI->getElementType()->print(RawStringOstream);
     Array["type"] = RawStringOstream.str();
     Buffer.clear();
     Arrays.append(Array);
   }
   return Arrays;
 }
 
-Json::Value JSONExporter::getJSON(Scop &S) const {
+static Json::Value getJSON(Scop &S) {
   Json::Value root;
   unsigned LineBegin, LineEnd;
   std::string FileName;
 
   getDebugLocation(&S.getRegion(), LineBegin, LineEnd, FileName);
   std::string Location;
   if (LineBegin != (unsigned)-1)
     Location = FileName + ":" + std::to_string(LineBegin) + "-" +
for (ScopStmt &Stmt : S) {
     }
 
     root["statements"].append(statement);
   }
 
   return root;
 }
 
-bool JSONExporter::runOnScop(Scop &S) {
+static void exportScop(Scop &S) {
   std::string FileName = ImportDir + "/" + getFileName(S);
 
   Json::Value jscop = getJSON(S);
   Json::StyledWriter writer;
   std::string fileContent = writer.write(jscop);
 
   // Write to file.
   std::error_code EC;
   tool_output_file F(FileName, EC, llvm::sys::fs::F_Text);
 
   std::string FunctionName = S.getFunction().getName();
   errs() << "Writing JScop '" << S.getNameStr() << "' in function '"
          << FunctionName << "' to '" << FileName << "'.\n";
 
   if (!EC) {
     F.os() << fileContent;
     F.os().close();
     if (!F.os().has_error()) {
       errs() << "\n";
       F.keep();
-      return false;
+      return;
     }
   }
 
   errs() << "  error opening file for writing!\n";
   F.os().clear_error();
-
-  return false;
-}
-
-void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesAll();
-  AU.addRequired<ScopInfoRegionPass>();
-}
-
-Pass *polly::createJSONExporterPass() { return new JSONExporter(); }
-
-char JSONImporter::ID = 0;
-std::string JSONImporter::getFileName(Scop &S) const {
-  std::string FunctionName = S.getFunction().getName();
-  std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
-
-  if (ImportPostfix != "")
-    FileName += "." + ImportPostfix;
-
-  return FileName;
-}
-
-void JSONImporter::printScop(raw_ostream &OS, Scop &S) const {
-  OS << S;
-  for (std::vector<std::string>::const_iterator I = NewAccessStrings.begin(),
-                                                E = NewAccessStrings.end();
-       I != E; I++)
-    OS << "New access function '" << *I << "' detected in JSCOP file\n";
 }
 
 typedef Dependences::StatementToIslMapTy StatementToIslMapTy;
 
-bool JSONImporter::importContext(Scop &S, Json::Value &JScop) {
+/// Import a new context from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool importContext(Scop &S, Json::Value &JScop) {
   isl_set *OldContext = S.getContext().release();
 
   // Check if key 'context' is present.
   if (!JScop.isMember("context")) {
     errs() << "JScop file has no key named 'context'.\n";
     isl_set_free(OldContext);
     return false;
   }
for (unsigned i = 0; i < OldContextDim; i++) {
     NewContext = isl_set_set_dim_id(NewContext, isl_dim_param, i, Id);
   }
 
   isl_set_free(OldContext);
   S.setContext(NewContext);
   return true;
 }
 
-bool JSONImporter::importSchedule(Scop &S, Json::Value &JScop,
-                                  const Dependences &D) {
+/// Import a new schedule from JScop.
+///
+/// ... and verify that the new schedule does preserve existing data
+/// dependences.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+/// @param D The data dependences of the @p S.
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool importSchedule(Scop &S, Json::Value &JScop, const Dependences &D) {
   StatementToIslMapTy NewSchedule;
 
   // Check if key 'statements' is present.
   if (!JScop.isMember("statements")) {
     errs() << "JScop file has no key name 'statements'.\n";
     return false;
   }
 
else
           isl_union_map_add_map(ScheduleMap, Stmt.getSchedule().release());
   }
 
   S.setSchedule(ScheduleMap);
 
   return true;
 }
 
-bool JSONImporter::importAccesses(Scop &S, Json::Value &JScop,
-                                  const DataLayout &DL) {
+/// Import new memory accesses from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing the new schedule.
+/// @param DL The data layout to assume.
+/// @param NewAccessStrings optionally record the imported access strings
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool
+importAccesses(Scop &S, Json::Value &JScop, const DataLayout &DL,
+               std::vector<std::string> *NewAccessStrings = nullptr) {
   int StatementIdx = 0;
 
   // Check if key 'statements' is present.
   if (!JScop.isMember("statements")) {
     errs() << "JScop file has no key name 'statements'.\n";
     return false;
   }
   Json::Value statements = JScop["statements"];
for (MemoryAccess *MA : Stmt) {
       }
 
       isl_set_free(CurrentAccessDomain);
       isl_set_free(NewAccessDomain);
 
       if (!isl_map_is_equal(NewAccessMap, CurrentAccessMap)) {
         // Statistics.
         ++NewAccessMapFound;
-        NewAccessStrings.push_back(Accesses.asCString());
+        if (NewAccessStrings)
+          NewAccessStrings->push_back(Accesses.asCString());
         MA->setNewAccessRelation(isl::manage(NewAccessMap));
       } else {
         isl_map_free(NewAccessMap);
       }
       isl_map_free(CurrentAccessMap);
       MemoryAccessIdx++;
     }
     StatementIdx++;
   }
 
   return true;
 }
 
 /// Check whether @p SAI and @p Array represent the same array.
-bool areArraysEqual(ScopArrayInfo *SAI, Json::Value Array) {
+static bool areArraysEqual(ScopArrayInfo *SAI, Json::Value Array) {
   std::string Buffer;
   llvm::raw_string_ostream RawStringOstream(Buffer);
 
   // Check if key 'type' is present.
   if (!Array.isMember("type")) {
     errs() << "Array has no key 'type'.\n";
     return false;
   }

 }
 
 /// Get the accepted primitive type from its textual representation
 ///        @p TypeTextRepresentation.
 ///
 /// @param TypeTextRepresentation The textual representation of the type.
 /// @return The pointer to the primitive type, if this type is accepted
 ///         or nullptr otherwise.
-Type *parseTextType(const std::string &TypeTextRepresentation,
+static Type *parseTextType(const std::string &TypeTextRepresentation,
                            LLVMContext &LLVMContext) {
   std::map<std::string, Type *> MapStrToType = {
       {"void", Type::getVoidTy(LLVMContext)},
       {"half", Type::getHalfTy(LLVMContext)},
       {"float", Type::getFloatTy(LLVMContext)},
       {"double", Type::getDoubleTy(LLVMContext)},
       {"x86_fp80", Type::getX86_FP80Ty(LLVMContext)},
       {"fp128", Type::getFP128Ty(LLVMContext)},
       {"ppc_fp128", Type::getPPC_FP128Ty(LLVMContext)},
       {"i1", Type::getInt1Ty(LLVMContext)},
       {"i8", Type::getInt8Ty(LLVMContext)},
       {"i16", Type::getInt16Ty(LLVMContext)},
       {"i32", Type::getInt32Ty(LLVMContext)},
       {"i64", Type::getInt64Ty(LLVMContext)},
       {"i128", Type::getInt128Ty(LLVMContext)}};
 
   auto It = MapStrToType.find(TypeTextRepresentation);
   if (It != MapStrToType.end())
     return It->second;
 
   errs() << "Textual representation can not be parsed: "
          << TypeTextRepresentation << "\n";
   return nullptr;
 }
 
-bool JSONImporter::importArrays(Scop &S, Json::Value &JScop) {
+/// Import new arrays from JScop.
+///
+/// @param S The scop to update.
+/// @param JScop The JScop file describing new arrays.
+///
+/// @returns True if the import succeeded, otherwise False.
+static bool importArrays(Scop &S, Json::Value &JScop) {
   Json::Value Arrays = JScop["arrays"];
   if (Arrays.size() == 0)
     return true;
 
   unsigned ArrayIdx = 0;
   for (auto &SAI : S.arrays()) {
     if (!SAI->isArrayKind())
       continue;
for (; ArrayIdx < Arrays.size(); ArrayIdx++) {
     if (Array.isMember("allocation")) {
       NewSAI->setIsOnHeap(Array["allocation"].asString() == "heap");
     }
   }
 
   return true;
 }
 
-bool JSONImporter::runOnScop(Scop &S) {
-  const Dependences &D =
-      getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
-  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
-
-  std::string FileName = ImportDir + "/" + getFileName(S);
+/// Import a Scop from a JSCOP file
+/// @param S The scop to be modified
+/// @param D Dependence Info
+/// @param DL The DataLayout of the function
+/// @param NewAccessStrings Optionally record the imported access strings
+///
+/// @returns true on success, false otherwise. Beware that if this returns
+/// false, the Scop may still have been modified. In this case the Scop contains
+/// invalid information.
+static bool importScop(Scop &S, const Dependences &D, const DataLayout &DL,
+                       std::vector<std::string> *NewAccessStrings = nullptr) {
+  std::string FileName = ImportDir + "/" + getFileName(S, ImportPostfix);
 
   std::string FunctionName = S.getFunction().getName();
   errs() << "Reading JScop '" << S.getNameStr() << "' in function '"
          << FunctionName << "' from '" << FileName << "'.\n";
   ErrorOr<std::unique_ptr<MemoryBuffer>> result =
       MemoryBuffer::getFile(FileName);
   std::error_code ec = result.getError();
 
static bool importScop(Scop &S, const Dependences &D, const DataLayout &DL,
   if (!Success)
     return false;
 
   Success = importArrays(S, jscop);
 
   if (!Success)
     return false;
 
-  Success = importAccesses(S, jscop, DL);
+  Success = importAccesses(S, jscop, DL, NewAccessStrings);
 
   if (!Success)
     return false;
+  return true;
+}
+
+char JSONExporter::ID = 0;
+void JSONExporter::printScop(raw_ostream &OS, Scop &S) const { OS << S; }
+
+bool JSONExporter::runOnScop(Scop &S) {
+  exportScop(S);
+  return false;
+}
+
+void JSONExporter::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired<ScopInfoRegionPass>();
+}
 
+Pass *polly::createJSONExporterPass() { return new JSONExporter(); }
+
+PreservedAnalyses JSONExportPass::run(Scop &S, ScopAnalysisManager &SAM,
+                                      ScopStandardAnalysisResults &SAR,
+                                      SPMUpdater &) {
+  exportScop(S);
+  return PreservedAnalyses::all();
+}
+
+char JSONImporter::ID = 0;
+
+void JSONImporter::printScop(raw_ostream &OS, Scop &S) const {
+  OS << S;
+  for (std::vector<std::string>::const_iterator I = NewAccessStrings.begin(),
+                                                E = NewAccessStrings.end();
+       I != E; I++)
+    OS << "New access function '" << *I << "' detected in JSCOP file\n";
+}
+
+bool JSONImporter::runOnScop(Scop &S) {
+  const Dependences &D =
+      getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
+  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
+  importScop(S, D, DL, &NewAccessStrings);
   return false;
 }
 
 void JSONImporter::getAnalysisUsage(AnalysisUsage &AU) const {
   ScopPass::getAnalysisUsage(AU);
   AU.addRequired<DependenceInfo>();
 }
 
 Pass *polly::createJSONImporterPass() { return new JSONImporter(); }
 
+PreservedAnalyses JSONImportPass::run(Scop &S, ScopAnalysisManager &SAM,
+                                      ScopStandardAnalysisResults &SAR,
+                                      SPMUpdater &) {
+  const Dependences &D =
+      SAM.getResult<DependenceAnalysis>(S, SAR).getDependences(
+          Dependences::AL_Statement);
+  const DataLayout &DL = S.getFunction().getParent()->getDataLayout();
+
+  importScop(S, D, DL);
+
+  // This invalidates all analyses on Scop.
+  PreservedAnalyses PA;
+  PA.preserveSet<AllAnalysesOn<Module>>();
+  PA.preserveSet<AllAnalysesOn<Function>>();
+  PA.preserveSet<AllAnalysesOn<Loop>>();
+  return PA;
+}
+
 INITIALIZE_PASS_BEGIN(JSONExporter, "polly-export-jscop",
                       "Polly - Export Scops as JSON"
                       " (Writes a .jscop file for each Scop)",
                       false, false);
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo)
 INITIALIZE_PASS_END(JSONExporter, "polly-export-jscop",
                     "Polly - Export Scops as JSON"
                     " (Writes a .jscop file for each Scop)",

polly/trunk/lib/Support/PollyPasses.def

 #endif
 SCOP_ANALYSIS("polly-ast", IslAstAnalysis())
 SCOP_ANALYSIS("polly-dependences", DependenceAnalysis())
 #undef SCOP_ANALYSIS
 
 #ifndef SCOP_PASS
 #define SCOP_PASS(NAME, CREATE_PASS)
 #endif
+SCOP_PASS("polly-export-jscop", JSONExportPass())
+SCOP_PASS("polly-import-jscop", JSONImportPass())
 SCOP_PASS("print<polly-ast>", IslAstPrinterPass(outs()))
 SCOP_PASS("print<polly-dependences>", DependenceInfoPrinterPass(outs()))
 SCOP_PASS("polly-codegen", CodeGenerationPass())
 #undef SCOP_PASS

polly/trunk/lib/Support/RegisterPasses.cpp

 #include "polly/CodeGen/CodegenCleanup.h"
 #include "polly/CodeGen/IslAst.h"
 #include "polly/CodeGen/PPCGCodeGeneration.h"
 #include "polly/CodePreparation.h"
 #include "polly/DeLICM.h"
 #include "polly/DependenceInfo.h"
 #include "polly/FlattenSchedule.h"
 #include "polly/ForwardOpTree.h"
+#include "polly/JSONExporter.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/PolyhedralInfo.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
 #include "polly/Simplify.h"
 #include "polly/Support/DumpModulePass.h"
 #include "llvm/Analysis/CFGPrinter.h"
static void buildDefaultPollyPipeline(FunctionPassManager &PM,
 
   assert(!PollyViewer && "This option is not implemented");
   assert(!PollyOnlyViewer && "This option is not implemented");
   assert(!PollyPrinter && "This option is not implemented");
   assert(!PollyOnlyPrinter && "This option is not implemented");
   assert(!EnablePolyhedralInfo && "This option is not implemented");
   assert(!EnableDeLICM && "This option is not implemented");
   assert(!EnableSimplify && "This option is not implemented");
-  assert(!ImportJScop && "This option is not implemented");
+  if (ImportJScop)
+    SPM.addPass(JSONImportPass());
   assert(!DeadCodeElim && "This option is not implemented");
   assert(!EnablePruneUnprofitable && "This option is not implemented");
   if (Target == TARGET_CPU || Target == TARGET_HYBRID)
     switch (Optimizer) {
     case OPTIMIZER_NONE:
       break; /* Do nothing */
     case OPTIMIZER_ISL:
       llvm_unreachable("ISL optimizer is not implemented");