mirror-llvm-project/orc-rt/test/unit/TaskGroupTest.cpp

//===- TaskGroupTest.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
//
//===----------------------------------------------------------------------===//
//
// Tests for orc-rt's TaskGroup.h APIs.
//
//===----------------------------------------------------------------------===//

#include "orc-rt/TaskGroup.h"
#include "gtest/gtest.h"

#include <atomic>
#include <chrono>
#include <thread>
#include <vector>

using namespace orc_rt;

TEST(TaskGroupTest, TrivialConstructionAndDestruction) {
  auto TG = TaskGroup::Create();
}

TEST(TaskGroupTest, SingleTokenThenClose) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  {
    TaskGroup::Token T(TG);
    EXPECT_TRUE(T);
    TG->close();
    EXPECT_FALSE(Completed);
  }
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, CloseWithNoTokens) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });
  TG->close();
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, TokenFromClosedGroup) {
  auto TG = TaskGroup::Create();
  TG->close();
  TaskGroup::Token T(TG);
  EXPECT_FALSE(T);
}

TEST(TaskGroupTest, TokenFromNullSharedPtr) {
  std::shared_ptr<TaskGroup> TG;
  TaskGroup::Token T(TG);
  EXPECT_FALSE(T);
}

TEST(TaskGroupTest, CopyToken) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  {
    TaskGroup::Token T1(TG);
    EXPECT_TRUE(T1);
    {
      TaskGroup::Token T2(T1); // Copy increments count
      EXPECT_TRUE(T2);
      TG->close();
      EXPECT_FALSE(Completed);
    }
    EXPECT_FALSE(Completed); // T1 still alive
  }
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, MoveToken) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  TaskGroup::Token T1(TG);
  TaskGroup::Token T2(std::move(T1));
  EXPECT_FALSE(T1);
  EXPECT_TRUE(T2);

  TG->close();
  EXPECT_FALSE(Completed);

  T2 = TaskGroup::Token(); // Release
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, CopyAssignmentReleasesOld) {
  bool Completed1 = false;
  bool Completed2 = false;
  auto TG1 = TaskGroup::Create();
  auto TG2 = TaskGroup::Create();
  TG1->addOnComplete([&]() { Completed1 = true; });
  TG2->addOnComplete([&]() { Completed2 = true; });

  TaskGroup::Token T1(TG1);
  TaskGroup::Token T2(TG2);

  TG1->close();
  TG2->close();

  EXPECT_FALSE(Completed1);
  EXPECT_FALSE(Completed2);

  T1 = T2; // Releases TG1, acquires TG2

  EXPECT_TRUE(Completed1);  // TG1 should complete
  EXPECT_FALSE(Completed2); // TG2 still has T1 and T2
}

TEST(TaskGroupTest, CopyAssignmentFromClosedGroup) {
  bool Completed = false;
  auto TG1 = TaskGroup::Create();
  auto TG2 = TaskGroup::Create();
  TG1->addOnComplete([&]() { Completed = true; });
  TG2->close();

  TaskGroup::Token T1(TG1);
  TaskGroup::Token T2(TG2);
  EXPECT_TRUE(T1);
  EXPECT_FALSE(T2);

  TG1->close();
  EXPECT_FALSE(Completed);

  T1 = T2; // Assign from empty, releases TG1
  EXPECT_FALSE(T1);
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, MoveAssignmentReleasesOld) {
  bool Completed1 = false;
  bool Completed2 = false;
  auto TG1 = TaskGroup::Create();
  auto TG2 = TaskGroup::Create();
  TG1->addOnComplete([&]() { Completed1 = true; });
  TG2->addOnComplete([&]() { Completed2 = true; });

  TaskGroup::Token T1(TG1);
  TaskGroup::Token T2(TG2);

  TG1->close();
  TG2->close();

  EXPECT_FALSE(Completed1);
  EXPECT_FALSE(Completed2);

  T1 = std::move(T2); // Releases TG1, takes TG2 from T2

  EXPECT_TRUE(Completed1);  // TG1 should complete
  EXPECT_FALSE(Completed2); // TG2 now held by T1
  EXPECT_FALSE(T2);         // T2 is now empty
}

TEST(TaskGroupTest, SelfCopyAssignment) {
  auto TG = TaskGroup::Create();
  TaskGroup::Token T(TG);
  EXPECT_TRUE(T);

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
#endif
  T = T; // Self-assign
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

  EXPECT_TRUE(T); // Should still be valid

  TG->close();
}

TEST(TaskGroupTest, SelfMoveAssignment) {
  auto TG = TaskGroup::Create();
  TaskGroup::Token T(TG);
  EXPECT_TRUE(T);

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-move"
#endif
  T = std::move(T); // Self-move-assign
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

  EXPECT_TRUE(T); // Should still be valid

  TG->close();
}

TEST(TaskGroupTest, AddOnCompleteAfterCompletion) {
  auto TG = TaskGroup::Create();
  TG->close();

  bool Completed = false;
  TG->addOnComplete([&]() { Completed = true; });
  EXPECT_TRUE(Completed); // Runs immediately
}

TEST(TaskGroupTest, AddOnCompleteWhileTasksPending) {
  auto TG = TaskGroup::Create();
  TaskGroup::Token T(TG);
  TG->close();

  bool Completed = false;
  TG->addOnComplete([&]() { Completed = true; });
  EXPECT_FALSE(Completed); // Queued, not run yet

  T = TaskGroup::Token(); // Release
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, MultipleCallbacks) {
  std::vector<int> Order;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Order.push_back(1); });
  TG->addOnComplete([&]() { Order.push_back(2); });
  TG->addOnComplete([&]() { Order.push_back(3); });
  TG->close();

  ASSERT_EQ(Order.size(), 3u);
  EXPECT_EQ(Order[0], 1);
  EXPECT_EQ(Order[1], 2);
  EXPECT_EQ(Order[2], 3);
}

TEST(TaskGroupTest, MultipleTokens) {
  int CompletionCount = 0;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { CompletionCount++; });

  {
    TaskGroup::Token T1(TG);
    TaskGroup::Token T2(TG);
    TaskGroup::Token T3(TG);
    TG->close();
    EXPECT_EQ(CompletionCount, 0);
  }
  EXPECT_EQ(CompletionCount, 1); // Only fires once
}

TEST(TaskGroupTest, CloseIsIdempotent) {
  int CompletionCount = 0;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { CompletionCount++; });

  TG->close();
  TG->close();
  TG->close();

  EXPECT_EQ(CompletionCount, 1);
}

TEST(TaskGroupTest, AcquireAfterCloseViaDirectAPI) {
  auto TG = TaskGroup::Create();
  EXPECT_TRUE(TG->acquireToken());
  TG->close();
  EXPECT_FALSE(TG->acquireToken());
  TG->releaseToken(); // Release the one we acquired
}

TEST(TaskGroupTest, DirectAPIMatchesRAII) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  TG->acquireToken();
  TG->acquireToken();
  TG->close();

  EXPECT_FALSE(Completed);
  TG->releaseToken();
  EXPECT_FALSE(Completed);
  TG->releaseToken();
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, TokenKeepsTaskGroupAlive) {
  TaskGroup::Token T;
  bool Completed = false;

  {
    auto TG = TaskGroup::Create();
    TG->addOnComplete([&]() { Completed = true; });
    T = TaskGroup::Token(TG);
    TG->close();
    // TG goes out of scope here, but T holds a shared_ptr
  }

  EXPECT_FALSE(Completed); // Still pending - T keeps TG alive
  T = TaskGroup::Token();  // Release
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, TokenFromTokenSource) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  TaskGroup::TokenSource TS(TG);
  {
    TaskGroup::Token T(TS);
    EXPECT_TRUE(T);
    TG->close();
    EXPECT_FALSE(Completed);
  }
  EXPECT_TRUE(Completed);
}

TEST(TaskGroupTest, TokenFromClosedGroupViaTokenSource) {
  auto TG = TaskGroup::Create();
  TaskGroup::TokenSource TS(TG);
  TG->close();
  TaskGroup::Token T(TS);
  EXPECT_FALSE(T);
}

// The point of the strong handle: it keeps the group alive so a later
// acquisition attempt is well-defined even after the original ref is gone.
TEST(TaskGroupTest, TokenSourceKeepsTaskGroupAlive) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  TaskGroup::TokenSource TS(TG);
  TG->close();
  TG.reset(); // Only TS holds the group now.

  TaskGroup::Token T(TS); // Group still exists; acquire fails only b/c closed.
  EXPECT_FALSE(T);
  EXPECT_TRUE(Completed); // Nothing kept a token, so it completed.
}

// A TokenSource is not a Token: holding one must not defer completion.
TEST(TaskGroupTest, TokenSourceDoesNotHoldToken) {
  bool Completed = false;
  auto TG = TaskGroup::Create();
  TG->addOnComplete([&]() { Completed = true; });

  TaskGroup::TokenSource TS(TG); // Alive across the close below.
  TG->close();
  EXPECT_TRUE(Completed); // Completes immediately; TS holds no token.
}

TEST(TaskGroupTest, ConcurrentTokens) {
  for (int Iter = 0; Iter < 100; ++Iter) {
    std::atomic<int> Count{0};
    auto TG = TaskGroup::Create();
    TG->addOnComplete([&]() { Count++; });

    std::vector<std::thread> Threads;
    for (int I = 0; I < 10; ++I) {
      TaskGroup::Token T(TG);
      Threads.emplace_back([T = std::move(T)]() {
        std::this_thread::sleep_for(std::chrono::microseconds(10));
      });
    }

    TG->close();
    for (auto &T : Threads)
      T.join();

    EXPECT_EQ(Count, 1);
  }
}

TEST(TaskGroupTest, ConcurrentAddOnCompleteAndClose) {
  for (int Iter = 0; Iter < 100; ++Iter) {
    std::atomic<int> Count{0};
    auto TG = TaskGroup::Create();

    std::thread Closer([&]() { TG->close(); });

    std::thread Registerer([&]() { TG->addOnComplete([&]() { Count++; }); });

    Closer.join();
    Registerer.join();

    // Callback should have run exactly once regardless of order
    EXPECT_EQ(Count, 1);
  }
}

TEST(TaskGroupTest, ConcurrentAcquireAndClose) {
  for (int Iter = 0; Iter < 100; ++Iter) {
    std::atomic<int> SuccessfulAcquires{0};
    std::atomic<int> CompletionCount{0};
    auto TG = TaskGroup::Create();
    TG->addOnComplete([&]() { CompletionCount++; });

    std::vector<std::thread> Threads;

    // Multiple threads trying to acquire
    for (int I = 0; I < 5; ++I) {
      Threads.emplace_back([&, T = TaskGroup::Token(TG)]() {
        if (T)
          SuccessfulAcquires++;
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
      });
    }

    // One thread closing
    Threads.emplace_back([&]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(2));
      TG->close();
    });

    for (auto &T : Threads)
      T.join();

    // Should complete exactly once
    EXPECT_EQ(CompletionCount, 1);
    // At least some acquires should have succeeded before close
    EXPECT_EQ(SuccessfulAcquires, 5);
  }
}