cmCTestMultiProcessHandler.h

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#pragma once

#include "cmConfigure.h" // IWYU pragma: keep

#include <cstddef>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>

#include <cm/optional>
#include <cm/string_view>

#include "cmCTest.h"
#include "cmCTestResourceAllocator.h"
#include "cmCTestResourceSpec.h"
#include "cmCTestTestHandler.h"
#include "cmUVHandlePtr.h"
#include "cmUVJobServerClient.h"

struct cmCTestBinPackerAllocation;
class cmCTestRunTest;

/** \class cmCTestMultiProcessHandler
 * \brief run parallel ctest
 *
 * cmCTestMultiProcessHandler
 */
class cmCTestMultiProcessHandler
{
  friend class TestComparator;
  friend class cmCTestRunTest;

public:
  struct TestSet : public std::set<int>
  {
  };
  struct TestInfo
  {
    TestSet Depends;
  };
  struct TestMap : public std::map<int, TestInfo>
  {
  };
  struct TestList : public std::vector<int>
  {
  };
  struct PropertiesMap
    : public std::map<int, cmCTestTestHandler::cmCTestTestProperties*>
  {
  };
  struct ResourceAllocation
  {
    std::string Id;
    unsigned int Slots;
  };

  cmCTestMultiProcessHandler(cmCTest* ctest, cmCTestTestHandler* handler);
  virtual ~cmCTestMultiProcessHandler();
  // Set the tests
  bool SetTests(TestMap tests, PropertiesMap properties);
  // Set the max number of tests that can be run at the same time.
  void SetParallelLevel(cm::optional<size_t> level);
  void SetTestLoad(unsigned long load);
  virtual void RunTests();
  void PrintOutputAsJson();
  void PrintTestList();
  void PrintLabels();

  void SetPassFailVectors(std::vector<std::string>* passed,
                          std::vector<std::string>* failed)
  {
    this->Passed = passed;
    this->Failed = failed;
  }
  void SetTestResults(std::vector<cmCTestTestHandler::cmCTestTestResult>* r)
  {
    this->TestResults = r;
  }

  cmCTestTestHandler* GetTestHandler() { return this->TestHandler; }

  void SetRepeatMode(cmCTest::Repeat mode, int count)
  {
    this->RepeatMode = mode;
    this->RepeatCount = count;
  }

  void SetResourceSpecFile(std::string const& resourceSpecFile)
  {
    this->ResourceSpecFile = resourceSpecFile;
  }

  void SetQuiet(bool b) { this->Quiet = b; }

  void CheckResourceAvailability();

protected:
  // Start the next test or tests as many as are allowed by
  // ParallelLevel
  void StartNextTests();
  void StartTestProcess(int test);
  void StartTest(int test);
  // Mark the checkpoint for the given test
  void WriteCheckpoint(int index);

  void UpdateCostData();
  void ReadCostData();
  // Return index of a test based on its name
  int SearchByName(cm::string_view name);

  void CreateTestCostList();

  void GetAllTestDependencies(int test, TestList& dependencies);
  void CreateSerialTestCostList();

  void CreateParallelTestCostList();

  // Removes the checkpoint file
  void MarkFinished();
  void FinishTestProcess(std::unique_ptr<cmCTestRunTest> runner, bool started);

  void StartNextTestsOnIdle();
  void StartNextTestsOnTimer();

  void RemoveTest(int index);
  // Check if we need to resume an interrupted test set
  void CheckResume();
  // Check if there are any circular dependencies
  bool CheckCycles();
  int FindMaxIndex();
  inline size_t GetProcessorsUsed(int index);
  std::string GetName(int index);

  bool CheckStopOnFailure();

  bool CheckStopTimePassed();
  void SetStopTimePassed();

  void InitializeLoop();
  void FinalizeLoop();

  bool ResourceLocksAvailable(int test);
  void LockResources(int index);
  void UnlockResources(int index);

  enum class ResourceAvailabilityError
  {
    NoResourceType,
    InsufficientResources,
  };

  bool Complete();
  bool AllocateResources(int index);
  bool TryAllocateResources(
    int index,
    std::map<std::string, std::vector<cmCTestBinPackerAllocation>>&
      allocations,
    std::map<std::string, ResourceAvailabilityError>* errors = nullptr);
  void DeallocateResources(int index);
  bool AllResourcesAvailable();
  bool InitResourceAllocator(std::string& error);
  bool CheckGeneratedResourceSpec();

private:
  cmCTest* CTest;
  cmCTestTestHandler* TestHandler;

  bool UseResourceSpec = false;
  cmCTestResourceSpec ResourceSpec;
  std::string ResourceSpecFile;
  std::string ResourceSpecSetupFixture;
  cm::optional<std::size_t> ResourceSpecSetupTest;
  bool HasInvalidGeneratedResourceSpec = false;

  // Tests pending selection to start.  They may have dependencies.
  TestMap PendingTests;
  // List of pending test indexes, ordered by cost.
  std::list<int> OrderedTests;
  // Total number of tests we'll be running
  size_t Total = 0;
  // Number of tests that are complete
  size_t Completed = 0;
  size_t RunningCount = 0;
  std::set<size_t> ProcessorsAvailable;
  size_t HaveAffinity;
  bool StopTimePassed = false;
  // list of test properties (indices concurrent to the test map)
  PropertiesMap Properties;
  std::map<int, std::string> TestOutput;
  std::vector<std::string>* Passed;
  std::vector<std::string>* Failed;
  std::vector<std::string> LastTestsFailed;
  std::set<std::string> ProjectResourcesLocked;
  std::map<int,
           std::vector<std::map<std::string, std::vector<ResourceAllocation>>>>
    AllocatedResources;
  std::map<int, std::map<std::string, ResourceAvailabilityError>>
    ResourceAvailabilityErrors;
  cmCTestResourceAllocator ResourceAllocator;
  std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;

  // Get the maximum number of processors that may be used at once.
  size_t GetParallelLevel() const;

  // With no '-j' option, default to serial testing.
  cm::optional<size_t> ParallelLevel = 1;

  // Fallback parallelism limit when '-j' is given with no value.
  size_t ParallelLevelDefault;

  // 'make' jobserver client.  If connected, we acquire a token
  // for each test before running its process.
  cm::optional<cmUVJobServerClient> JobServerClient;
  // List of tests that are queued to run when a token is available.
  std::list<int> JobServerQueuedTests;
  // Callback invoked when a token is received.
  void JobServerReceivedToken();

  unsigned long TestLoad = 0;
  unsigned long FakeLoadForTesting = 0;
  cm::uv_loop_ptr Loop;
  cm::uv_idle_ptr StartNextTestsOnIdle_;
  cm::uv_timer_ptr StartNextTestsOnTimer_;
  bool HasCycles = false;
  cmCTest::Repeat RepeatMode = cmCTest::Repeat::Never;
  int RepeatCount = 1;
  bool Quiet = false;
  bool SerialTestRunning = false;
};