summaryrefslogtreecommitdiffstats
path: root/Source/CTest/cmCTestMultiProcessHandler.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/CTest/cmCTestMultiProcessHandler.cxx')
-rw-r--r--Source/CTest/cmCTestMultiProcessHandler.cxx701
1 files changed, 298 insertions, 403 deletions
diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx
index d92ac77..d155023 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.cxx
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -27,15 +27,18 @@
class TestComparator
{
public:
- TestComparator(cmCTestMultiProcessHandler* handler) : Handler(handler) {}
+ TestComparator(cmCTestMultiProcessHandler* handler)
+ : Handler(handler)
+ {
+ }
~TestComparator() {}
// Sorts tests in descending order of cost
- bool operator() (int index1, int index2) const
- {
+ bool operator()(int index1, int index2) const
+ {
return Handler->Properties[index1]->Cost >
Handler->Properties[index2]->Cost;
- }
+ }
private:
cmCTestMultiProcessHandler* Handler;
@@ -56,34 +59,30 @@ cmCTestMultiProcessHandler::~cmCTestMultiProcessHandler()
{
}
- // Set the tests
-void
-cmCTestMultiProcessHandler::SetTests(TestMap& tests,
- PropertiesMap& properties)
+// Set the tests
+void cmCTestMultiProcessHandler::SetTests(TestMap& tests,
+ PropertiesMap& properties)
{
this->Tests = tests;
this->Properties = properties;
this->Total = this->Tests.size();
// set test run map to false for all
- for(TestMap::iterator i = this->Tests.begin();
- i != this->Tests.end(); ++i)
- {
+ for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
+ ++i) {
this->TestRunningMap[i->first] = false;
this->TestFinishMap[i->first] = false;
- }
- if(!this->CTest->GetShowOnly())
- {
+ }
+ if (!this->CTest->GetShowOnly()) {
this->ReadCostData();
this->HasCycles = !this->CheckCycles();
- if(this->HasCycles)
- {
+ if (this->HasCycles) {
return;
- }
- this->CreateTestCostList();
}
+ this->CreateTestCostList();
+ }
}
- // Set the max number of tests that can be run at the same time.
+// Set the max number of tests that can be run at the same time.
void cmCTestMultiProcessHandler::SetParallelLevel(size_t level)
{
this->ParallelLevel = level < 1 ? 1 : level;
@@ -97,25 +96,21 @@ void cmCTestMultiProcessHandler::SetTestLoad(unsigned long load)
void cmCTestMultiProcessHandler::RunTests()
{
this->CheckResume();
- if(this->HasCycles)
- {
+ if (this->HasCycles) {
return;
- }
+ }
this->TestHandler->SetMaxIndex(this->FindMaxIndex());
this->StartNextTests();
- while(!this->Tests.empty())
- {
- if(this->StopTimePassed)
- {
+ while (!this->Tests.empty()) {
+ if (this->StopTimePassed) {
return;
- }
+ }
this->CheckOutput();
this->StartNextTests();
- }
+ }
// let all running tests finish
- while(this->CheckOutput())
- {
- }
+ while (this->CheckOutput()) {
+ }
this->MarkFinished();
this->UpdateCostData();
}
@@ -123,18 +118,17 @@ void cmCTestMultiProcessHandler::RunTests()
void cmCTestMultiProcessHandler::StartTestProcess(int test)
{
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
- "test " << test << "\n", this->Quiet);
+ "test " << test << "\n", this->Quiet);
this->TestRunningMap[test] = true; // mark the test as running
// now remove the test itself
this->EraseTest(test);
this->RunningCount += GetProcessorsUsed(test);
cmCTestRunTest* testRun = new cmCTestRunTest(this->TestHandler);
- if(this->CTest->GetRepeatUntilFail())
- {
+ if (this->CTest->GetRepeatUntilFail()) {
testRun->SetRunUntilFailOn();
testRun->SetNumberOfRuns(this->CTest->GetTestRepeat());
- }
+ }
testRun->SetIndex(test);
testRun->SetTestProperties(this->Properties[test]);
@@ -144,24 +138,18 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test)
// Lock the resources we'll be using
this->LockResources(test);
- if(testRun->StartTest(this->Total))
- {
+ if (testRun->StartTest(this->Total)) {
this->RunningTests.insert(testRun);
- }
- else if(testRun->IsStopTimePassed())
- {
+ } else if (testRun->IsStopTimePassed()) {
this->StopTimePassed = true;
delete testRun;
return;
- }
- else
- {
+ } else {
- for(TestMap::iterator j = this->Tests.begin();
- j != this->Tests.end(); ++j)
- {
+ for (TestMap::iterator j = this->Tests.begin(); j != this->Tests.end();
+ ++j) {
j->second.erase(test);
- }
+ }
this->UnlockResources(test);
this->Completed++;
@@ -171,34 +159,31 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test)
testRun->EndTest(this->Completed, this->Total, false);
this->Failed->push_back(this->Properties[test]->Name);
delete testRun;
- }
+ }
cmSystemTools::ChangeDirectory(current_dir);
}
void cmCTestMultiProcessHandler::LockResources(int index)
{
this->LockedResources.insert(
- this->Properties[index]->LockedResources.begin(),
- this->Properties[index]->LockedResources.end());
+ this->Properties[index]->LockedResources.begin(),
+ this->Properties[index]->LockedResources.end());
- if (this->Properties[index]->RunSerial)
- {
+ if (this->Properties[index]->RunSerial) {
this->SerialTestRunning = true;
- }
+ }
}
void cmCTestMultiProcessHandler::UnlockResources(int index)
{
- for(std::set<std::string>::iterator i =
- this->Properties[index]->LockedResources.begin();
- i != this->Properties[index]->LockedResources.end(); ++i)
- {
+ for (std::set<std::string>::iterator i =
+ this->Properties[index]->LockedResources.begin();
+ i != this->Properties[index]->LockedResources.end(); ++i) {
this->LockedResources.erase(*i);
- }
- if (this->Properties[index]->RunSerial)
- {
+ }
+ if (this->Properties[index]->RunSerial) {
this->SerialTestRunning = false;
- }
+ }
}
void cmCTestMultiProcessHandler::EraseTest(int test)
@@ -210,14 +195,12 @@ void cmCTestMultiProcessHandler::EraseTest(int test)
inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test)
{
- size_t processors =
- static_cast<int>(this->Properties[test]->Processors);
- //If processors setting is set higher than the -j
- //setting, we default to using all of the process slots.
- if (processors > this->ParallelLevel)
- {
+ size_t processors = static_cast<int>(this->Properties[test]->Processors);
+ // If processors setting is set higher than the -j
+ // setting, we default to using all of the process slots.
+ if (processors > this->ParallelLevel) {
processors = this->ParallelLevel;
- }
+ }
return processors;
}
@@ -228,23 +211,20 @@ std::string cmCTestMultiProcessHandler::GetName(int test)
bool cmCTestMultiProcessHandler::StartTest(int test)
{
- //Check for locked resources
- for(std::set<std::string>::iterator i =
- this->Properties[test]->LockedResources.begin();
- i != this->Properties[test]->LockedResources.end(); ++i)
- {
- if(this->LockedResources.find(*i) != this->LockedResources.end())
- {
+ // Check for locked resources
+ for (std::set<std::string>::iterator i =
+ this->Properties[test]->LockedResources.begin();
+ i != this->Properties[test]->LockedResources.end(); ++i) {
+ if (this->LockedResources.find(*i) != this->LockedResources.end()) {
return false;
- }
}
+ }
// if there are no depends left then run this test
- if(this->Tests[test].empty())
- {
+ if (this->Tests[test].empty()) {
this->StartTestProcess(test);
return true;
- }
+ }
// This test was not able to start because it is waiting
// on depends to run
return false;
@@ -253,22 +233,19 @@ bool cmCTestMultiProcessHandler::StartTest(int test)
void cmCTestMultiProcessHandler::StartNextTests()
{
size_t numToStart = 0;
- if(this->RunningCount < this->ParallelLevel)
- {
+ if (this->RunningCount < this->ParallelLevel) {
numToStart = this->ParallelLevel - this->RunningCount;
- }
+ }
- if(numToStart == 0)
- {
+ if (numToStart == 0) {
return;
- }
+ }
// Don't start any new tests if one with the RUN_SERIAL property
// is already running.
- if (this->SerialTestRunning)
- {
+ if (this->SerialTestRunning) {
return;
- }
+ }
bool allTestsFailedTestLoadCheck = false;
bool usedFakeLoadForTesting = false;
@@ -279,101 +256,79 @@ void cmCTestMultiProcessHandler::StartNextTests()
unsigned long systemLoad = 0;
size_t spareLoad = 0;
- if (this->TestLoad > 0)
- {
+ if (this->TestLoad > 0) {
// Activate possible wait.
allTestsFailedTestLoadCheck = true;
// Check for a fake load average value used in testing.
if (const char* fake_load_value =
- cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING"))
- {
+ cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING")) {
usedFakeLoadForTesting = true;
- if (!cmSystemTools::StringToULong(fake_load_value, &systemLoad))
- {
+ if (!cmSystemTools::StringToULong(fake_load_value, &systemLoad)) {
cmSystemTools::Error("Failed to parse fake load value: ",
fake_load_value);
- }
}
+ }
// If it's not set, look up the true load average.
- else
- {
+ else {
systemLoad = static_cast<unsigned long>(ceil(info.GetLoadAverage()));
- }
- spareLoad = (this->TestLoad > systemLoad ?
- this->TestLoad - systemLoad : 0);
+ }
+ spareLoad =
+ (this->TestLoad > systemLoad ? this->TestLoad - systemLoad : 0);
// Don't start more tests than the spare load can support.
- if (numToStart > spareLoad)
- {
+ if (numToStart > spareLoad) {
numToStart = spareLoad;
- }
}
+ }
TestList copy = this->SortedTests;
- for(TestList::iterator test = copy.begin(); test != copy.end(); ++test)
- {
+ for (TestList::iterator test = copy.begin(); test != copy.end(); ++test) {
// Take a nap if we're currently performing a RUN_SERIAL test.
- if (this->SerialTestRunning)
- {
+ if (this->SerialTestRunning) {
break;
- }
+ }
// We can only start a RUN_SERIAL test if no other tests are also running.
- if (this->Properties[*test]->RunSerial && this->RunningCount > 0)
- {
+ if (this->Properties[*test]->RunSerial && this->RunningCount > 0) {
continue;
- }
+ }
size_t processors = GetProcessorsUsed(*test);
bool testLoadOk = true;
- if (this->TestLoad > 0)
- {
- if (processors <= spareLoad)
- {
- cmCTestLog(this->CTest, DEBUG,
- "OK to run " << GetName(*test) <<
- ", it requires " << processors <<
- " procs & system load is: " <<
- systemLoad << std::endl);
+ if (this->TestLoad > 0) {
+ if (processors <= spareLoad) {
+ cmCTestLog(this->CTest, DEBUG, "OK to run "
+ << GetName(*test) << ", it requires " << processors
+ << " procs & system load is: " << systemLoad
+ << std::endl);
allTestsFailedTestLoadCheck = false;
- }
- else
- {
+ } else {
testLoadOk = false;
- }
}
+ }
- if (processors <= minProcessorsRequired)
- {
+ if (processors <= minProcessorsRequired) {
minProcessorsRequired = processors;
testWithMinProcessors = GetName(*test);
- }
+ }
- if(testLoadOk && processors <= numToStart && this->StartTest(*test))
- {
- if(this->StopTimePassed)
- {
+ if (testLoadOk && processors <= numToStart && this->StartTest(*test)) {
+ if (this->StopTimePassed) {
return;
- }
+ }
numToStart -= processors;
- }
- else if(numToStart == 0)
- {
+ } else if (numToStart == 0) {
break;
- }
}
+ }
- if (allTestsFailedTestLoadCheck)
- {
+ if (allTestsFailedTestLoadCheck) {
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***** WAITING, ");
- if (this->SerialTestRunning)
- {
+ if (this->SerialTestRunning) {
cmCTestLog(this->CTest, HANDLER_OUTPUT,
"Waiting for RUN_SERIAL test to finish.");
- }
- else
- {
+ } else {
/* clang-format off */
cmCTestLog(this->CTest, HANDLER_OUTPUT,
"System Load: " << systemLoad << ", "
@@ -381,68 +336,57 @@ void cmCTestMultiProcessHandler::StartNextTests()
"Smallest test " << testWithMinProcessors <<
" requires " << minProcessorsRequired);
/* clang-format on */
- }
+ }
cmCTestLog(this->CTest, HANDLER_OUTPUT, "*****" << std::endl);
- if (usedFakeLoadForTesting)
- {
+ if (usedFakeLoadForTesting) {
// Break out of the infinite loop of waiting for our fake load
// to come down.
this->StopTimePassed = true;
- }
- else
- {
+ } else {
// Wait between 1 and 5 seconds before trying again.
- cmCTestScriptHandler::SleepInSeconds(
- cmSystemTools::RandomSeed() % 5 + 1);
- }
+ cmCTestScriptHandler::SleepInSeconds(cmSystemTools::RandomSeed() % 5 +
+ 1);
}
+ }
}
bool cmCTestMultiProcessHandler::CheckOutput()
{
// no more output we are done
- if(this->RunningTests.empty())
- {
+ if (this->RunningTests.empty()) {
return false;
- }
+ }
std::vector<cmCTestRunTest*> finished;
std::string out, err;
- for(std::set<cmCTestRunTest*>::const_iterator i = this->RunningTests.begin();
- i != this->RunningTests.end(); ++i)
- {
+ for (std::set<cmCTestRunTest*>::const_iterator i =
+ this->RunningTests.begin();
+ i != this->RunningTests.end(); ++i) {
cmCTestRunTest* p = *i;
- if(!p->CheckOutput())
- {
+ if (!p->CheckOutput()) {
finished.push_back(p);
- }
}
- for( std::vector<cmCTestRunTest*>::iterator i = finished.begin();
- i != finished.end(); ++i)
- {
+ }
+ for (std::vector<cmCTestRunTest*>::iterator i = finished.begin();
+ i != finished.end(); ++i) {
this->Completed++;
cmCTestRunTest* p = *i;
int test = p->GetIndex();
bool testResult = p->EndTest(this->Completed, this->Total, true);
- if(p->StartAgain())
- {
+ if (p->StartAgain()) {
this->Completed--; // remove the completed test because run again
continue;
- }
- if(testResult)
- {
+ }
+ if (testResult) {
this->Passed->push_back(p->GetTestProperties()->Name);
- }
- else
- {
+ } else {
this->Failed->push_back(p->GetTestProperties()->Name);
- }
- for(TestMap::iterator j = this->Tests.begin();
- j != this->Tests.end(); ++j)
- {
+ }
+ for (TestMap::iterator j = this->Tests.begin(); j != this->Tests.end();
+ ++j) {
j->second.erase(test);
- }
+ }
this->TestFinishMap[test] = true;
this->TestRunningMap[test] = false;
this->RunningTests.erase(p);
@@ -450,7 +394,7 @@ bool cmCTestMultiProcessHandler::CheckOutput()
this->UnlockResources(test);
this->RunningCount -= GetProcessorsUsed(test);
delete p;
- }
+ }
return true;
}
@@ -463,56 +407,50 @@ void cmCTestMultiProcessHandler::UpdateCostData()
PropertiesMap temp = this->Properties;
- if(cmSystemTools::FileExists(fname.c_str()))
- {
+ if (cmSystemTools::FileExists(fname.c_str())) {
cmsys::ifstream fin;
fin.open(fname.c_str());
std::string line;
- while(std::getline(fin, line))
- {
- if(line == "---") break;
- std::vector<cmsys::String> parts =
- cmSystemTools::SplitString(line, ' ');
- //Format: <name> <previous_runs> <avg_cost>
- if(parts.size() < 3) break;
+ while (std::getline(fin, line)) {
+ if (line == "---")
+ break;
+ std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
+ // Format: <name> <previous_runs> <avg_cost>
+ if (parts.size() < 3)
+ break;
std::string name = parts[0];
int prev = atoi(parts[1].c_str());
float cost = static_cast<float>(atof(parts[2].c_str()));
int index = this->SearchByName(name);
- if(index == -1)
- {
+ if (index == -1) {
// This test is not in memory. We just rewrite the entry
fout << name << " " << prev << " " << cost << "\n";
- }
- else
- {
+ } else {
// Update with our new average cost
fout << name << " " << this->Properties[index]->PreviousRuns << " "
- << this->Properties[index]->Cost << "\n";
+ << this->Properties[index]->Cost << "\n";
temp.erase(index);
- }
}
+ }
fin.close();
cmSystemTools::RemoveFile(fname);
- }
+ }
// Add all tests not previously listed in the file
- for(PropertiesMap::iterator i = temp.begin(); i != temp.end(); ++i)
- {
+ for (PropertiesMap::iterator i = temp.begin(); i != temp.end(); ++i) {
fout << i->second->Name << " " << i->second->PreviousRuns << " "
- << i->second->Cost << "\n";
- }
+ << i->second->Cost << "\n";
+ }
// Write list of failed tests
fout << "---\n";
- for(std::vector<std::string>::iterator i = this->Failed->begin();
- i != this->Failed->end(); ++i)
- {
+ for (std::vector<std::string>::iterator i = this->Failed->begin();
+ i != this->Failed->end(); ++i) {
fout << i->c_str() << "\n";
- }
+ }
fout.close();
cmSystemTools::RenameFile(tmpout.c_str(), fname.c_str());
}
@@ -521,78 +459,67 @@ void cmCTestMultiProcessHandler::ReadCostData()
{
std::string fname = this->CTest->GetCostDataFile();
- if(cmSystemTools::FileExists(fname.c_str(), true))
- {
+ if (cmSystemTools::FileExists(fname.c_str(), true)) {
cmsys::ifstream fin;
fin.open(fname.c_str());
std::string line;
- while(std::getline(fin, line))
- {
- if(line == "---") break;
+ while (std::getline(fin, line)) {
+ if (line == "---")
+ break;
- std::vector<cmsys::String> parts =
- cmSystemTools::SplitString(line, ' ');
+ std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
// Probably an older version of the file, will be fixed next run
- if(parts.size() < 3)
- {
+ if (parts.size() < 3) {
fin.close();
return;
- }
+ }
std::string name = parts[0];
int prev = atoi(parts[1].c_str());
float cost = static_cast<float>(atof(parts[2].c_str()));
int index = this->SearchByName(name);
- if(index == -1) continue;
+ if (index == -1)
+ continue;
this->Properties[index]->PreviousRuns = prev;
// When not running in parallel mode, don't use cost data
- if(this->ParallelLevel > 1 &&
- this->Properties[index] &&
- this->Properties[index]->Cost == 0)
- {
+ if (this->ParallelLevel > 1 && this->Properties[index] &&
+ this->Properties[index]->Cost == 0) {
this->Properties[index]->Cost = cost;
- }
}
+ }
// Next part of the file is the failed tests
- while(std::getline(fin, line))
- {
- if(line != "")
- {
+ while (std::getline(fin, line)) {
+ if (line != "") {
this->LastTestsFailed.push_back(line);
- }
}
- fin.close();
}
+ fin.close();
+ }
}
int cmCTestMultiProcessHandler::SearchByName(std::string name)
{
int index = -1;
- for(PropertiesMap::iterator i = this->Properties.begin();
- i != this->Properties.end(); ++i)
- {
- if(i->second->Name == name)
- {
+ for (PropertiesMap::iterator i = this->Properties.begin();
+ i != this->Properties.end(); ++i) {
+ if (i->second->Name == name) {
index = i->first;
- }
}
+ }
return index;
}
void cmCTestMultiProcessHandler::CreateTestCostList()
{
- if(this->ParallelLevel > 1)
- {
+ if (this->ParallelLevel > 1) {
CreateParallelTestCostList();
- }
- else
- {
+ } else {
CreateSerialTestCostList();
- }
+ }
}
void cmCTestMultiProcessHandler::CreateParallelTestCostList()
@@ -601,140 +528,125 @@ void cmCTestMultiProcessHandler::CreateParallelTestCostList()
std::list<TestSet> priorityStack;
priorityStack.push_back(TestSet());
- TestSet &topLevel = priorityStack.back();
+ TestSet& topLevel = priorityStack.back();
// In parallel test runs add previously failed tests to the front
// of the cost list and queue other tests for further sorting
- for(TestMap::const_iterator i = this->Tests.begin();
- i != this->Tests.end(); ++i)
- {
- if(std::find(this->LastTestsFailed.begin(), this->LastTestsFailed.end(),
- this->Properties[i->first]->Name) != this->LastTestsFailed.end())
- {
- //If the test failed last time, it should be run first.
+ for (TestMap::const_iterator i = this->Tests.begin(); i != this->Tests.end();
+ ++i) {
+ if (std::find(this->LastTestsFailed.begin(), this->LastTestsFailed.end(),
+ this->Properties[i->first]->Name) !=
+ this->LastTestsFailed.end()) {
+ // If the test failed last time, it should be run first.
this->SortedTests.push_back(i->first);
alreadySortedTests.insert(i->first);
- }
- else
- {
+ } else {
topLevel.insert(i->first);
- }
}
+ }
// In parallel test runs repeatedly move dependencies of the tests on
// the current dependency level to the next level until no
// further dependencies exist.
- while(priorityStack.back().size())
- {
- TestSet &previousSet = priorityStack.back();
+ while (priorityStack.back().size()) {
+ TestSet& previousSet = priorityStack.back();
priorityStack.push_back(TestSet());
- TestSet &currentSet = priorityStack.back();
+ TestSet& currentSet = priorityStack.back();
- for(TestSet::const_iterator i = previousSet.begin();
- i != previousSet.end(); ++i)
- {
+ for (TestSet::const_iterator i = previousSet.begin();
+ i != previousSet.end(); ++i) {
TestSet const& dependencies = this->Tests[*i];
currentSet.insert(dependencies.begin(), dependencies.end());
- }
+ }
- for(TestSet::const_iterator i = currentSet.begin();
- i != currentSet.end(); ++i)
- {
+ for (TestSet::const_iterator i = currentSet.begin(); i != currentSet.end();
+ ++i) {
previousSet.erase(*i);
- }
}
+ }
// Remove the empty dependency level
priorityStack.pop_back();
// Reverse iterate over the different dependency levels (deepest first).
// Sort tests within each level by COST and append them to the cost list.
- for(std::list<TestSet>::reverse_iterator i = priorityStack.rbegin();
- i != priorityStack.rend(); ++i)
- {
+ for (std::list<TestSet>::reverse_iterator i = priorityStack.rbegin();
+ i != priorityStack.rend(); ++i) {
TestSet const& currentSet = *i;
TestComparator comp(this);
TestList sortedCopy;
- sortedCopy.insert(sortedCopy.end(),
- currentSet.begin(), currentSet.end());
+ sortedCopy.insert(sortedCopy.end(), currentSet.begin(), currentSet.end());
std::stable_sort(sortedCopy.begin(), sortedCopy.end(), comp);
- for(TestList::const_iterator j = sortedCopy.begin();
- j != sortedCopy.end(); ++j)
- {
- if(alreadySortedTests.find(*j) == alreadySortedTests.end())
- {
+ for (TestList::const_iterator j = sortedCopy.begin();
+ j != sortedCopy.end(); ++j) {
+ if (alreadySortedTests.find(*j) == alreadySortedTests.end()) {
this->SortedTests.push_back(*j);
alreadySortedTests.insert(*j);
- }
}
}
+ }
}
-void cmCTestMultiProcessHandler::GetAllTestDependencies(
- int test, TestList& dependencies)
+void cmCTestMultiProcessHandler::GetAllTestDependencies(int test,
+ TestList& dependencies)
{
TestSet const& dependencySet = this->Tests[test];
- for(TestSet::const_iterator i = dependencySet.begin();
- i != dependencySet.end(); ++i)
- {
+ for (TestSet::const_iterator i = dependencySet.begin();
+ i != dependencySet.end(); ++i) {
GetAllTestDependencies(*i, dependencies);
dependencies.push_back(*i);
- }
+ }
}
void cmCTestMultiProcessHandler::CreateSerialTestCostList()
{
TestList presortedList;
- for(TestMap::iterator i = this->Tests.begin();
- i != this->Tests.end(); ++i)
- {
+ for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
+ ++i) {
presortedList.push_back(i->first);
- }
+ }
TestComparator comp(this);
std::stable_sort(presortedList.begin(), presortedList.end(), comp);
TestSet alreadySortedTests;
- for(TestList::const_iterator i = presortedList.begin();
- i != presortedList.end(); ++i)
- {
- int test = *i;
+ for (TestList::const_iterator i = presortedList.begin();
+ i != presortedList.end(); ++i) {
+ int test = *i;
- if(alreadySortedTests.find(test) != alreadySortedTests.end())
- {
- continue;
- }
-
- TestList dependencies;
- GetAllTestDependencies(test, dependencies);
+ if (alreadySortedTests.find(test) != alreadySortedTests.end()) {
+ continue;
+ }
- for(TestList::const_iterator j = dependencies.begin();
- j != dependencies.end(); ++j)
- {
- int testDependency = *j;
+ TestList dependencies;
+ GetAllTestDependencies(test, dependencies);
- if(alreadySortedTests.find(testDependency) == alreadySortedTests.end())
- {
- alreadySortedTests.insert(testDependency);
- this->SortedTests.push_back(testDependency);
- }
- }
+ for (TestList::const_iterator j = dependencies.begin();
+ j != dependencies.end(); ++j) {
+ int testDependency = *j;
- alreadySortedTests.insert(test);
- this->SortedTests.push_back(test);
+ if (alreadySortedTests.find(testDependency) ==
+ alreadySortedTests.end()) {
+ alreadySortedTests.insert(testDependency);
+ this->SortedTests.push_back(testDependency);
+ }
}
+
+ alreadySortedTests.insert(test);
+ this->SortedTests.push_back(test);
+ }
}
void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
{
- std::string fname = this->CTest->GetBinaryDir()
- + "/Testing/Temporary/CTestCheckpoint.txt";
+ std::string fname =
+ this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
cmsys::ofstream fout;
fout.open(fname.c_str(), std::ios::app);
fout << index << "\n";
@@ -743,130 +655,118 @@ void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
void cmCTestMultiProcessHandler::MarkFinished()
{
- std::string fname = this->CTest->GetBinaryDir()
- + "/Testing/Temporary/CTestCheckpoint.txt";
+ std::string fname =
+ this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
cmSystemTools::RemoveFile(fname);
}
-//For ShowOnly mode
+// For ShowOnly mode
void cmCTestMultiProcessHandler::PrintTestList()
{
this->TestHandler->SetMaxIndex(this->FindMaxIndex());
int count = 0;
for (PropertiesMap::iterator it = this->Properties.begin();
- it != this->Properties.end(); ++it)
- {
+ it != this->Properties.end(); ++it) {
count++;
cmCTestTestHandler::cmCTestTestProperties& p = *it->second;
- //push working dir
+ // push working dir
std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ChangeDirectory(p.Directory);
cmCTestRunTest testRun(this->TestHandler);
testRun.SetIndex(p.Index);
testRun.SetTestProperties(&p);
- testRun.ComputeArguments(); //logs the command in verbose mode
+ testRun.ComputeArguments(); // logs the command in verbose mode
- if(!p.Labels.empty()) //print the labels
- {
+ if (!p.Labels.empty()) // print the labels
+ {
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:",
- this->Quiet);
- }
- for(std::vector<std::string>::iterator label = p.Labels.begin();
- label != p.Labels.end(); ++label)
- {
+ this->Quiet);
+ }
+ for (std::vector<std::string>::iterator label = p.Labels.begin();
+ label != p.Labels.end(); ++label) {
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << *label,
- this->Quiet);
- }
- if(!p.Labels.empty()) //print the labels
- {
+ this->Quiet);
+ }
+ if (!p.Labels.empty()) // print the labels
+ {
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
- this->Quiet);
- }
+ this->Quiet);
+ }
- if (this->TestHandler->MemCheck)
- {
+ if (this->TestHandler->MemCheck) {
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " Memory Check",
- this->Quiet);
- }
- else
- {
+ this->Quiet);
+ } else {
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " Test", this->Quiet);
- }
+ }
std::ostringstream indexStr;
indexStr << " #" << p.Index << ":";
- cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+ cmCTestOptionalLog(
+ this->CTest, HANDLER_OUTPUT,
std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
- << indexStr.str(), this->Quiet);
+ << indexStr.str(),
+ this->Quiet);
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " ", this->Quiet);
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
- p.Name.c_str() << std::endl, this->Quiet);
- //pop working dir
+ p.Name.c_str() << std::endl, this->Quiet);
+ // pop working dir
cmSystemTools::ChangeDirectory(current_dir);
- }
+ }
- cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl << "Total Tests: "
- << this->Total << std::endl, this->Quiet);
+ cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl
+ << "Total Tests: " << this->Total << std::endl,
+ this->Quiet);
}
void cmCTestMultiProcessHandler::PrintLabels()
{
std::set<std::string> allLabels;
for (PropertiesMap::iterator it = this->Properties.begin();
- it != this->Properties.end(); ++it)
- {
+ it != this->Properties.end(); ++it) {
cmCTestTestHandler::cmCTestTestProperties& p = *it->second;
allLabels.insert(p.Labels.begin(), p.Labels.end());
- }
+ }
- if(!allLabels.empty())
- {
+ if (!allLabels.empty()) {
+ cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "All Labels:" << std::endl,
+ this->Quiet);
+ } else {
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
- "All Labels:" << std::endl, this->Quiet);
- }
- else
- {
- cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
- "No Labels Exist" << std::endl, this->Quiet);
- }
- for(std::set<std::string>::iterator label = allLabels.begin();
- label != allLabels.end(); ++label)
- {
+ "No Labels Exist" << std::endl, this->Quiet);
+ }
+ for (std::set<std::string>::iterator label = allLabels.begin();
+ label != allLabels.end(); ++label) {
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
- " " << *label << std::endl, this->Quiet);
- }
+ " " << *label << std::endl, this->Quiet);
+ }
}
void cmCTestMultiProcessHandler::CheckResume()
{
- std::string fname = this->CTest->GetBinaryDir()
- + "/Testing/Temporary/CTestCheckpoint.txt";
- if(this->CTest->GetFailover())
- {
- if(cmSystemTools::FileExists(fname.c_str(), true))
- {
- *this->TestHandler->LogFile << "Resuming previously interrupted test set"
- << std::endl
+ std::string fname =
+ this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
+ if (this->CTest->GetFailover()) {
+ if (cmSystemTools::FileExists(fname.c_str(), true)) {
+ *this->TestHandler->LogFile
+ << "Resuming previously interrupted test set" << std::endl
<< "----------------------------------------------------------"
<< std::endl;
cmsys::ifstream fin;
fin.open(fname.c_str());
std::string line;
- while(std::getline(fin, line))
- {
+ while (std::getline(fin, line)) {
int index = atoi(line.c_str());
this->RemoveTest(index);
- }
- fin.close();
}
+ fin.close();
}
- else if(cmSystemTools::FileExists(fname.c_str(), true))
- {
+ } else if (cmSystemTools::FileExists(fname.c_str(), true)) {
cmSystemTools::RemoveFile(fname);
- }
+ }
}
void cmCTestMultiProcessHandler::RemoveTest(int index)
@@ -882,56 +782,51 @@ int cmCTestMultiProcessHandler::FindMaxIndex()
{
int max = 0;
cmCTestMultiProcessHandler::TestMap::iterator i = this->Tests.begin();
- for(; i != this->Tests.end(); ++i)
- {
- if(i->first > max)
- {
+ for (; i != this->Tests.end(); ++i) {
+ if (i->first > max) {
max = i->first;
- }
}
+ }
return max;
}
-//Returns true if no cycles exist in the dependency graph
+// Returns true if no cycles exist in the dependency graph
bool cmCTestMultiProcessHandler::CheckCycles()
{
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
- "Checking test dependency graph..." << std::endl, this->Quiet);
- for(TestMap::iterator it = this->Tests.begin();
- it != this->Tests.end(); ++it)
- {
- //DFS from each element to itself
+ "Checking test dependency graph..." << std::endl,
+ this->Quiet);
+ for (TestMap::iterator it = this->Tests.begin(); it != this->Tests.end();
+ ++it) {
+ // DFS from each element to itself
int root = it->first;
std::set<int> visited;
std::stack<int> s;
s.push(root);
- while(!s.empty())
- {
+ while (!s.empty()) {
int test = s.top();
s.pop();
- if(visited.insert(test).second)
- {
- for(TestSet::iterator d = this->Tests[test].begin();
- d != this->Tests[test].end(); ++d)
- {
- if(*d == root)
- {
- //cycle exists
- cmCTestLog(this->CTest, ERROR_MESSAGE,
- "Error: a cycle exists in the test dependency graph "
- "for the test \"" << this->Properties[root]->Name <<
- "\".\nPlease fix the cycle and run ctest again.\n");
+ if (visited.insert(test).second) {
+ for (TestSet::iterator d = this->Tests[test].begin();
+ d != this->Tests[test].end(); ++d) {
+ if (*d == root) {
+ // cycle exists
+ cmCTestLog(
+ this->CTest, ERROR_MESSAGE,
+ "Error: a cycle exists in the test dependency graph "
+ "for the test \""
+ << this->Properties[root]->Name
+ << "\".\nPlease fix the cycle and run ctest again.\n");
return false;
- }
- else
- {
+ } else {
s.push(*d);
- }
}
}
}
}
+ }
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
- "Checking test dependency graph end" << std::endl, this->Quiet);
+ "Checking test dependency graph end" << std::endl,
+ this->Quiet);
return true;
}
generated by cgit v0.12 at 2024-09-21 23:32:58 (GMT)