CMake/Source/CTest/cmCTestMultiProcessHandler.h

124 lines
3.9 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2008-07-03 17:31:33 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2008-07-03 17:31:33 +04:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2008-07-03 17:31:33 +04:00
#ifndef cmCTestMultiProcessHandler_h
#define cmCTestMultiProcessHandler_h
#include <cmStandardIncludes.h>
#include <cmCTestTestHandler.h>
#include <cmCTestRunTest.h>
2008-07-03 17:31:33 +04:00
/** \class cmCTestMultiProcessHandler
* \brief run parallel ctest
*
* cmCTestMultiProcessHandler
2008-07-03 17:31:33 +04:00
*/
class cmCTestMultiProcessHandler
2008-07-03 17:31:33 +04:00
{
2010-07-01 22:10:49 +04:00
friend class TestComparator;
2008-07-03 17:31:33 +04:00
public:
struct TestSet : public std::set<int> {};
struct TestMap : public std::map<int, TestSet> {};
2010-07-01 22:10:49 +04:00
struct TestList : public std::vector<int> {};
struct PropertiesMap : public
std::map<int, cmCTestTestHandler::cmCTestTestProperties*> {};
2008-07-03 17:31:33 +04:00
cmCTestMultiProcessHandler();
virtual ~cmCTestMultiProcessHandler();
2008-07-03 17:31:33 +04:00
// Set the tests
void SetTests(TestMap& tests, PropertiesMap& properties);
2008-07-03 17:31:33 +04:00
// Set the max number of tests that can be run at the same time.
void SetParallelLevel(size_t);
virtual void RunTests();
void PrintTestList();
void PrintLabels();
void SetPassFailVectors(std::vector<std::string>* passed,
std::vector<std::string>* failed)
2008-07-03 17:31:33 +04:00
{
this->Passed = passed;
this->Failed = failed;
2008-07-03 17:31:33 +04:00
}
void SetTestResults(std::vector<cmCTestTestHandler::cmCTestTestResult>* r)
{ this->TestResults = r; }
2008-07-03 17:31:33 +04:00
void SetCTest(cmCTest* ctest) { this->CTest = ctest;}
void SetTestHandler(cmCTestTestHandler * handler)
{ this->TestHandler = handler; }
cmCTestTestHandler * GetTestHandler()
{ return this->TestHandler; }
2010-03-02 23:34:37 +03:00
protected:
2008-07-03 17:31:33 +04:00
// Start the next test or tests as many as are allowed by
// ParallelLevel
void StartNextTests();
void StartTestProcess(int test);
bool 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(std::string name);
void CreateTestCostList();
void GetAllTestDependencies(int test, TestList& dependencies);
void CreateSerialTestCostList();
void CreateParallelTestCostList();
// Removes the checkpoint file
void MarkFinished();
void EraseTest(int index);
2008-07-03 17:31:33 +04:00
// Return true if there are still tests running
// check all running processes for output and exit case
bool CheckOutput();
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);
2010-03-02 23:34:37 +03:00
void LockResources(int index);
void UnlockResources(int index);
2008-07-03 17:31:33 +04:00
// map from test number to set of depend tests
TestMap Tests;
2010-07-01 22:10:49 +04:00
TestList SortedTests;
//Total number of tests we'll be running
size_t Total;
//Number of tests that are complete
size_t Completed;
size_t RunningCount;
2010-06-15 18:29:35 +04:00
bool StopTimePassed;
//list of test properties (indices concurrent to the test map)
PropertiesMap Properties;
2008-07-03 17:31:33 +04:00
std::map<int, bool> TestRunningMap;
std::map<int, bool> TestFinishMap;
std::map<int, std::string> TestOutput;
std::vector<std::string>* Passed;
std::vector<std::string>* Failed;
std::vector<std::string> LastTestsFailed;
2010-03-02 23:34:37 +03:00
std::set<std::string> LockedResources;
2008-07-03 17:31:33 +04:00
std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;
size_t ParallelLevel; // max number of process that can be run at once
std::set<cmCTestRunTest*> RunningTests; // current running tests
cmCTestTestHandler * TestHandler;
cmCTest* CTest;
2013-10-19 11:28:18 +04:00
bool HasCycles;
2008-07-03 17:31:33 +04:00
};
#endif