Added support for 20 nvSHMEM API migration

clang/lib/DPCT/ASTTraversal.cpp

@@ -7,27 +7,28 @@
 //===----------------------------------------------------------------------===//
 
 #include "ASTTraversal.h"
-#include "RulesLang/RulesLang.h"
 #include "AnalysisInfo.h"
+#include "CodePin/GenCodePinHeader.h"
+#include "MigrationRuleManager.h"
 #include "RulesAsm/AsmMigration.h"
+#include "RulesCCL/NCCLAPIMigration.h"
 #include "RulesDNN/DNNAPIMigration.h"
+#include "RulesLang/OptimizeMigration.h"
+#include "RulesLang/RulesLang.h"
+#include "RulesLang/WMMAAPIMigration.h"
+#include "RulesLangLib/LIBCUAPIMigration.h"
+#include "RulesLangLib/NvtxAPIMigration.h"
+#include "RulesLangLib/ThrustAPIMigration.h"
+#include "RulesMathLib/BLASAPIMigration.h"
 #include "RulesMathLib/FFTAPIMigration.h"
 #include "RulesMathLib/RandomAPIMigration.h"
 #include "RulesMathLib/SolverAPIMigration.h"
-#include "RulesMathLib/BLASAPIMigration.h"
-#include "CodePin/GenCodePinHeader.h"
+#include "RulesMathLib/SpBLASAPIMigration.h"
+#include "RulesSHMEM/NVSHMEMAPIMigration.h"
 #include "RulesSecurity/Homoglyph.h"
-#include "RulesLangLib/LIBCUAPIMigration.h"
-#include "RulesLangLib/NvtxAPIMigration.h"
-#include "MigrationRuleManager.h"
 #include "RulesSecurity/MisleadingBidirectional.h"
-#include "RulesCCL/NCCLAPIMigration.h"
-#include "RulesLang/OptimizeMigration.h"
-#include "RulesMathLib/SpBLASAPIMigration.h"
 #include "TextModification.h"
-#include "RulesLangLib/ThrustAPIMigration.h"
 #include "Utility.h"
-#include "RulesLang/WMMAAPIMigration.h"
 
 #include <string>
 #include <unordered_map>
@@ -160,32 +161,41 @@ REGISTER_RULE(GraphicsInteropRule, PassKind::PK_Migration)
 REGISTER_RULE(RulesLangAddrSpaceConvRule, PassKind::PK_Migration)
 
 REGISTER_RULE(BLASEnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_BLas)
-REGISTER_RULE(BLASFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_BLas)
+REGISTER_RULE(BLASFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_BLas)
 
 REGISTER_RULE(SPBLASEnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_Sparse)
-REGISTER_RULE(SPBLASFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_Sparse)
+REGISTER_RULE(SPBLASFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_Sparse)
 
 REGISTER_RULE(RandomEnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_Rng)
-REGISTER_RULE(RandomFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_Rng)
-REGISTER_RULE(DeviceRandomFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_Rng)
+REGISTER_RULE(RandomFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_Rng)
+REGISTER_RULE(DeviceRandomFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_Rng)
 
 REGISTER_RULE(SOLVEREnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_Solver)
-REGISTER_RULE(SOLVERFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_Solver)
+REGISTER_RULE(SOLVERFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_Solver)
 
 REGISTER_RULE(LIBCURule, PassKind::PK_Migration, RuleGroupKind::RK_Libcu)
 REGISTER_RULE(NvtxRule, PassKind::PK_Migration)
 
 REGISTER_RULE(ThrustAPIRule, PassKind::PK_Migration, RuleGroupKind::RK_Thrust)
 REGISTER_RULE(ThrustTypeRule, PassKind::PK_Migration, RuleGroupKind::RK_Thrust)
 
-REGISTER_RULE(ManualMigrateEnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_NCCL)
+REGISTER_RULE(ManualMigrateEnumsRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_NCCL)
 REGISTER_RULE(NCCLRule, PassKind::PK_Migration, RuleGroupKind::RK_NCCL)
 
 REGISTER_RULE(FFTEnumsRule, PassKind::PK_Migration, RuleGroupKind::RK_FFT)
-REGISTER_RULE(FFTFunctionCallRule, PassKind::PK_Migration,RuleGroupKind::RK_FFT)
+REGISTER_RULE(FFTFunctionCallRule, PassKind::PK_Migration,
+              RuleGroupKind::RK_FFT)
 
 REGISTER_RULE(CuDNNTypeRule, PassKind::PK_Migration, RuleGroupKind::RK_DNN)
 REGISTER_RULE(CuDNNAPIRule, PassKind::PK_Migration, RuleGroupKind::RK_DNN)
 
+REGISTER_RULE(NVSHMEMRule, PassKind::PK_Migration, RuleGroupKind::RK_NVSHMEM)
+
 } // namespace dpct
 } // namespace clang

clang/lib/DPCT/CMakeLists.txt

@@ -202,6 +202,7 @@ add_clang_library(DPCT
   RulesLang/CallExprRewriterEvent.cpp
   RulesLang/CallExprRewriterCG.cpp
   RulesLang/CallExprRewriterWmma.cpp
+  RulesSHMEM/CallExprRewriterNvshmem.cpp
   ErrorHandle/CrashRecovery.cpp
   Diagnostics/Diagnostics.cpp
   ErrorHandle/Error.cpp
@@ -240,6 +241,7 @@ add_clang_library(DPCT
   RulesDNN/DNNAPIMigration.cpp
   RulesCCL/NCCLAPIMigration.cpp
   RuleInfra/TypeLocRewriters.cpp
+  RulesSHMEM/NVSHMEMAPIMigration.cpp
   Linux/AutoComplete.cpp
   RulesAsm/AsmMigration.cpp
   QueryAPIMapping/QueryAPIMapping.cpp

clang/lib/DPCT/MigrationReport/Libraries.inc

@@ -15,4 +15,7 @@ LIBRARY(DNN, "oneAPI Deep Neural Network Library (oneDNN)",
 LIBRARY(CCL, "oneAPI Collective Communications Library (oneCCL)",
         RuleGroupKind::RK_NCCL)
 
+LIBRARY(SHMEM, "Intel Shared Memory Library (iSHMEM)",
+        RuleGroupKind::RK_NVSHMEM)
+
 #undef LIBRARY

clang/lib/DPCT/RuleInfra/CallExprRewriter.cpp

@@ -147,6 +147,7 @@ void CallExprRewriterFactoryBase::initRewriterMap() {
   initRewriterMapMemory();
   initRewriterMapMisc();
   initRewriterMapNccl();
+  initRewriterMapNvshmem();
   initRewriterMapStream();
   initRewriterMapTexture();
   initRewriterMapThrust();

clang/lib/DPCT/RuleInfra/CallExprRewriter.h

@@ -69,6 +69,7 @@ class CallExprRewriterFactoryBase {
   static void initRewriterMapMemory();
   static void initRewriterMapMisc();
   static void initRewriterMapNccl();
+  static void initRewriterMapNvshmem();
   static void initRewriterMapStream();
   static void initRewriterMapTexture();
   static void initRewriterMapThrust();

clang/lib/DPCT/RuleInfra/MapNames.cpp

@@ -875,6 +875,11 @@ void MapNames::setExplicitNamespaceMap(
       {"cudaExternalMemoryHandleType",
        std::make_shared<TypeNameRule>(getExpNamespace() +
                                       "external_mem_handle_type")},
+      {"nvshmem_team_t", std::make_shared<TypeNameRule>("ishmem_team_t")},
+      {"nvshmem_team_config_t",
+       std::make_shared<TypeNameRule>("ishmem_team_config_t")},
+      {"nvshmemx_init_attr_t",
+       std::make_shared<TypeNameRule>("ishmemx_attr_t")},
       // ...
   };
   // SYCLcompat unsupport types
@@ -1510,6 +1515,16 @@ void MapNames::setExplicitNamespaceMap(
                ? getExpNamespace() +
                      "external_mem_handle_type::win32_nt_dx12_resource"
                : "cudaExternalMemoryHandleTypeD3D12Resource")},
+      {"NVSHMEM_TEAM_WORLD",
+       std::make_shared<EnumNameRule>("ISHMEM_TEAM_WORLD")},
+      {"NVSHMEM_TEAM_SHARED",
+       std::make_shared<EnumNameRule>("ISHMEM_TEAM_SHARED")},
+      {"NVSHMEM_TEAM_INVALID",
+       std::make_shared<EnumNameRule>("ISHMEM_TEAM_INVALID")},
+      {"NVSHMEMX_INIT_WITH_MPI_COMM",
+       std::make_shared<EnumNameRule>("ISHMEMX_RUNTIME_MPI")},
+      {"NVSHMEMX_INIT_WITH_SHMEM",
+       std::make_shared<EnumNameRule>("ISHMEMX_RUNTIME_OPENSHMEM")},
       // ...
   };
 

clang/lib/DPCT/RulesInclude/HeaderTypes.inc

@@ -50,6 +50,8 @@ STD_HEADER(DL, "<libloaderapi.h>")
 #else
 STD_HEADER(DL, "<dlfcn.h>")
 #endif
+STD_HEADER(SHMEM, "<ishmem.h>")
+STD_HEADER(SHMEMX, "<ishmemx.h>")
 
 ONEDPL_HEADER(Algorithm, "<oneapi/dpl/algorithm>")
 ONEDPL_HEADER(Execution, "<oneapi/dpl/execution>")

clang/lib/DPCT/RulesInclude/InclusionHeaders.h

@@ -35,6 +35,7 @@ enum class RuleGroupKind : uint8_t {
   RK_Thrust,
   RK_CUB,
   RK_WMMA,
+  RK_NVSHMEM,
   NUM
 };
 

clang/lib/DPCT/RulesInclude/InclusionHeaders.inc

@@ -107,3 +107,8 @@ REGIST_INCLUSION("cuda_rutime.h", FullMatch, Libcu, Remove, true)
 
 REGIST_INCLUSION("cublasLt.h", FullMatch, BLas, Replace, false,
                  HeaderType::HT_DPCT_BLAS_GEMM_Utils)
+
+REGIST_INCLUSION("nvshmem.h", FullMatch, NVSHMEM, Replace, false,
+                 HeaderType::HT_SHMEM)
+REGIST_INCLUSION("nvshmemx.h", FullMatch, NVSHMEM, Replace, false,
+                 HeaderType::HT_SHMEMX)

clang/lib/DPCT/RulesSHMEM/APINamesNvshmem.inc

@@ -0,0 +1,93 @@
+//===------------------------ APINamesNvshmem.inc -------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Library Setup, Exit & Query
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_init", CALL("ishmem_init")))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmemx_init_attr",
+                                           CALL("ishmemx_init_attr", ARG(1))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_my_pe",
+                                           CALL("ishmem_my_pe")))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_n_pes",
+                                           CALL("ishmem_n_pes")))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_finalize",
+                                           CALL("ishmem_finalize")))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_ptr",
+                                           CALL("ishmem_ptr", ARG(0), ARG(1))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_info_get_version",
+                                           CALL("ishmem_info_get_version",
+                                                ARG(0), ARG(1))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_info_get_name",
+                                           CALL("ishmem_info_get_name",
+                                                ARG(0))))
+
+// Memory Management
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_malloc",
+                                           CALL("ishmem_malloc", ARG(0))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_free",
+                                           CALL("ishmem_free", ARG(0))))
+
+FEATURE_REQUEST_FACTORY(
+    HelperFeatureEnum::device_ext,
+    CALL_FACTORY_ENTRY("nvshmem_align", CALL("ishmem_align", ARG(0), ARG(1))))
+
+FEATURE_REQUEST_FACTORY(
+    HelperFeatureEnum::device_ext,
+    CALL_FACTORY_ENTRY("nvshmem_calloc", CALL("ishmem_calloc", ARG(0), ARG(1))))
+
+// Team Management
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_my_pe",
+                                           CALL("ishmem_team_my_pe", ARG(0))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_n_pes",
+                                           CALL("ishmem_team_n_pes", ARG(0))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_get_config",
+                                           CALL("ishmem_team_get_config",
+                                                ARG(0), LITERAL("0"), ARG(1))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_translate_pe",
+                                           CALL("ishmem_team_translate_pe",
+                                                ARG(0), ARG(1), ARG(2))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_split_strided",
+                                           CALL("ishmem_team_split_strided",
+                                                ARG(0), ARG(1), ARG(2), ARG(3),
+                                                ARG(4), ARG(5), ARG(6))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_split_2d",
+                                           CALL("ishmem_team_split_2d", ARG(0),
+                                                ARG(1), ARG(2), ARG(3), ARG(4),
+                                                ARG(5), ARG(6), ARG(7))))
+
+FEATURE_REQUEST_FACTORY(HelperFeatureEnum::device_ext,
+                        CALL_FACTORY_ENTRY("nvshmem_team_destroy",
+                                           CALL("ishmem_team_destroy", ARG(0))))

clang/lib/DPCT/RulesSHMEM/CallExprRewriterNvshmem.cpp

@@ -0,0 +1,23 @@
+//===-------------------- CallExprRewriterNvshmem.cpp ---------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "RuleInfra/CallExprRewriter.h"
+#include "RuleInfra/CallExprRewriterCommon.h"
+
+namespace clang {
+namespace dpct {
+void CallExprRewriterFactoryBase::initRewriterMapNvshmem() {
+  RewriterMap->merge(
+      std::unordered_map<std::string,
+                         std::shared_ptr<CallExprRewriterFactoryBase>>({
+#include "APINamesNvshmem.inc"
+      }));
+}
+
+} // namespace dpct
+} // namespace clang