add rocshmem_barrier() (#61)

* add team-barrier implementation

add a team-barrier API and implementation in the IPC and RO conduit.
Clean up some of the logic in the RO Conduit to distinguish between
sync, sync_all, barrier, and barrier_all.

* add team_barrier_tests to functional tests

tests/functional_tests/team_barrier_tester.cpp

@@ -0,0 +1,115 @@
+/******************************************************************************
+ * Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *****************************************************************************/
+
+
+rocshmem_team_t team_barrier_world_dup;
+
+/******************************************************************************
+ * Device TEST KERNEL
+ *****************************************************************************/
+__global__ void TeamBarrierTest(int loop, int skip, long long int *start_time,
+                                  long long int *end_time,
+                                  ShmemContextType ctx_type,
+                                  rocshmem_team_t *teams) {
+  __shared__ rocshmem_ctx_t ctx;
+  int wg_id = get_flat_grid_id();
+
+  rocshmem_wg_init();
+  rocshmem_wg_team_create_ctx(teams[wg_id], ctx_type, &ctx);
+
+  int n_pes = rocshmem_ctx_n_pes(ctx);
+
+  __syncthreads();
+
+  for (int i = 0; i < loop + skip; i++) {
+    if (i == skip && hipThreadIdx_x == 0) {
+      start_time[wg_id] = wall_clock64();
+    }
+
+    rocshmem_barrier(teams[wg_id]);
+  }
+
+  __syncthreads();
+
+  if (hipThreadIdx_x == 0) {
+    end_time[wg_id] = wall_clock64();
+  }
+
+  rocshmem_wg_ctx_destroy(&ctx);
+  rocshmem_wg_finalize();
+}
+
+/******************************************************************************
+ * HOST TESTER CLASS METHODS
+ *****************************************************************************/
+TeamBarrierTester::TeamBarrierTester(TesterArguments args)
+    : Tester(args){
+  my_pe = rocshmem_team_my_pe(ROCSHMEM_TEAM_WORLD);
+  n_pes = rocshmem_team_n_pes(ROCSHMEM_TEAM_WORLD);
+
+  char* value{nullptr};
+  if ((value = getenv("ROCSHMEM_MAX_NUM_TEAMS"))) {
+    num_teams = atoi(value);
+  }
+
+  CHECK_HIP(hipMalloc(&team_barrier_world_dup,
+                      sizeof(rocshmem_team_t) * num_teams));
+}
+
+TeamBarrierTester::~TeamBarrierTester() {
+  CHECK_HIP(hipFree(team_barrier_world_dup));
+}
+
+void TeamBarrierTester::preLaunchKernel() {
+  for (int team_i = 0; team_i < num_teams; team_i++) {
+    team_barrier_world_dup[team_i] = ROCSHMEM_TEAM_INVALID;
+    rocshmem_team_split_strided(ROCSHMEM_TEAM_WORLD, 0, 1, n_pes, nullptr, 0,
+                                 &team_barrier_world_dup[team_i]);
+    if (team_barrier_world_dup[team_i] == ROCSHMEM_TEAM_INVALID) {
+      printf("Team %d is invalid!\n", team_i);
+      abort();
+    }
+  }
+}
+
+void TeamBarrierTester::launchKernel(dim3 gridSize, dim3 blockSize,
+                                           int loop, uint64_t size) {
+  size_t shared_bytes = 0;
+
+  hipLaunchKernelGGL(TeamBarrierTest, gridSize, blockSize,
+                     shared_bytes, stream, loop, args.skip,
+                     start_time, end_time, _shmem_context,
+		     team_barrier_world_dup);
+
+  num_msgs = (loop + args.skip) * gridSize.x;
+  num_timed_msgs = loop * gridSize.x;
+}
+
+void TeamBarrierTester::postLaunchKernel() {
+  for (int team_i = 0; team_i < num_teams; team_i++) {
+    rocshmem_team_destroy(team_barrier_world_dup[team_i]);
+  }
+}
+
+void TeamBarrierTester::resetBuffers(uint64_t size) {}
+
+void TeamBarrierTester::verifyResults(uint64_t size) {}

tests/functional_tests/team_barrier_tester.hpp

@@ -0,0 +1,66 @@
+/******************************************************************************
+ * Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *****************************************************************************/
+
+#ifndef _TEAM_BARRIER_TESTER_HPP_
+#define _TEAM_BARRIER_TESTER_HPP_
+
+#include <functional>
+#include <utility>
+
+#include "tester.hpp"
+
+using namespace rocshmem;
+
+/************* *****************************************************************
+ * HOST TESTER CLASS
+ *****************************************************************************/
+class TeamBarrierTester : public Tester {
+ public:
+  explicit TeamBarrierTester(TesterArguments args);
+  virtual ~TeamBarrierTester();
+
+ protected:
+  virtual void resetBuffers(uint64_t size) override;
+
+  virtual void preLaunchKernel() override;
+
+  virtual void launchKernel(dim3 gridSize, dim3 blockSize, int loop,
+                            uint64_t size) override;
+
+  virtual void postLaunchKernel() override;
+
+  virtual void verifyResults(uint64_t size) override;
+
+ private:
+  int my_pe = 0;
+  int n_pes = 0;
+  /**
+   * This constant should equal ROCSHMEM_MAX_NUM_TEAMS - 1.
+   * The default value for the maximum number of teams is 40.
+   */
+  int num_teams = 39;
+  rocshmem_team_t *team_barrier_world_dup;
+};
+
+#include "team_barrier_tester.cpp"
+
+#endif

tests/functional_tests/tester.cpp

@@ -45,6 +45,7 @@
 #include "sync_tester.hpp"
 #include "team_alltoall_tester.hpp"
 #include "team_broadcast_tester.hpp"
+#include "team_barrier_tester.hpp"
 #include "team_ctx_infra_tester.hpp"
 #include "team_ctx_primitive_tester.hpp"
 #include "team_fcollect_tester.hpp"
@@ -295,6 +296,10 @@ std::vector<Tester*> Tester::create(TesterArguments args) {
       if (rank == 0) std::cout << "Barrier_All ###" << std::endl;
       testers.push_back(new BarrierAllTester(args));
       return testers;
+    case TeamBarrierTestType:
+      if (rank == 0) std::cout << "Team Barrier Test ###" << std::endl;
+      testers.push_back(new TeamBarrierTester(args));
+      return testers;
     case SyncAllTestType:
       if (rank == 0) std::cout << "SyncAll ###" << std::endl;
       testers.push_back(new SyncTester(args));
@@ -485,7 +490,8 @@ bool Tester::peLaunchesKernel() {
                 (_type == TeamAllToAllTestType) || (_type == TeamFCollectTestType) ||
                 (_type == PingPongTestType) || (_type == BarrierAllTestType) ||
                 (_type == SyncTestType) || (_type == SyncAllTestType) ||
-                (_type == RandomAccessTestType) || (_type == PingAllTestType);
+                (_type == RandomAccessTestType) || (_type == PingAllTestType) ||
+                (_type == TeamBarrierTestType);
 
   return is_launcher;
 }

tests/functional_tests/tester.hpp

@@ -92,6 +92,7 @@ enum TestType {
   SignalFetchTestType = 55,
   WGSignalFetchTestType = 56,
   WAVESignalFetchTestType = 57,
+  TeamBarrierTestType = 58,
 };
 
 enum OpType { PutType = 0, GetType = 1 };

tests/functional_tests/tester_arguments.cpp

@@ -85,6 +85,7 @@ TesterArguments::TesterArguments(int argc, char *argv[]) {
     case AMO_IncTestType:
     case AMO_FetchTestType:
     case BarrierAllTestType:
+    case TeamBarrierTestType:
     case SyncAllTestType:
     case SyncTestType:
     case ShmemPtrTestType:
@@ -135,7 +136,8 @@ void TesterArguments::get_rocshmem_arguments() {
   if ((type != BarrierAllTestType) && (type != SyncAllTestType) &&
       (type != SyncTestType) && (type != TeamAllToAllTestType) &&
       (type != TeamFCollectTestType) && (type != TeamReductionTestType) &&
-      (type != TeamBroadcastTestType) && (type != PingAllTestType)) {
+      (type != TeamBroadcastTestType) && (type != PingAllTestType) &&
+      (type != TeamBarrierTestType)) {
     if (numprocs != 2) {
       if (myid == 0) {
         std::cerr << "This test requires exactly two processes, we have "