admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switched flaky ProfilerTest to use fake clock

Browse Source 
The test was heavily dependent on wall clock timing, so it ended up
being disabled in some build configurations. This CL switches it to use
a fake clock instead.

BUG=webrtc:5947

Review-Url: https://codereview.webrtc.org/2392613003
Cr-Commit-Position: refs/heads/master@{#14507}
This commit is contained in:
skvlad 2016-10-04 12:32:53 -07:00 committed by Commit bot
parent 5adaf735dc
commit cd97b2b943
1 changed files with 19 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
webrtc/base/profiler_unittest.cc
View File

@ -8,19 +8,20 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/fakeclock.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/profiler.h"
#include "webrtc/base/timedelta.h"
#include "webrtc/base/thread.h"
namespace {
const int kWaitMs = 250;
const double kWaitSec = 0.250;
const double kTolerance = 0.1;
const char* TestFunc() {
const char* TestFunc(rtc::FakeClock* clock) {
PROFILE_F();
rtc::Thread::SleepMs(kWaitMs);
clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
return __FUNCTION__;
}
@ -28,33 +29,29 @@ const char* TestFunc() {
namespace rtc {
// Disable this test due to flakiness; see bug 5947.
#if defined(WEBRTC_LINUX)
#define MAYBE_TestFunction DISABLED_TestFunction
#else
#define MAYBE_TestFunction TestFunction
#endif
TEST(ProfilerTest, MAYBE_TestFunction) {
TEST(ProfilerTest, TestFunction) {
rtc::ScopedFakeClock fake_clock;
ASSERT_TRUE(Profiler::Instance()->Clear());
// Profile a long-running function.
const char* function_name = TestFunc();
const char* function_name = TestFunc(&fake_clock);
const ProfilerEvent* event = Profiler::Instance()->GetEvent(function_name);
ASSERT_TRUE(event != NULL);
EXPECT_FALSE(event->is_started());
EXPECT_EQ(1, event->event_count());
EXPECT_NEAR(kWaitSec, event->mean(), kTolerance * 3);
EXPECT_EQ(kWaitSec, event->mean());
// Run it a second time.
TestFunc();
TestFunc(&fake_clock);
EXPECT_FALSE(event->is_started());
EXPECT_EQ(2, event->event_count());
EXPECT_NEAR(kWaitSec, event->mean(), kTolerance);
EXPECT_NEAR(kWaitSec * 2, event->total_time(), kTolerance * 2);
EXPECT_EQ(kWaitSec, event->mean());
EXPECT_EQ(kWaitSec * 2, event->total_time());
EXPECT_DOUBLE_EQ(event->mean(), event->total_time() / event->event_count());
}
TEST(ProfilerTest, TestScopedEvents) {
rtc::ScopedFakeClock fake_clock;
const std::string kEvent1Name = "Event 1";
const std::string kEvent2Name = "Event 2";
const int kEvent2WaitMs = 150;
@ -68,40 +65,39 @@ TEST(ProfilerTest, TestScopedEvents) {
ASSERT_TRUE(event1 != NULL);
EXPECT_TRUE(event1->is_started());
EXPECT_EQ(0, event1->event_count());
rtc::Thread::SleepMs(kWaitMs);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
EXPECT_TRUE(event1->is_started());
}
// Check the result.
EXPECT_FALSE(event1->is_started());
EXPECT_EQ(1, event1->event_count());
EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
EXPECT_EQ(kWaitSec, event1->mean());
{ // Profile a second event.
PROFILE(kEvent2Name);
event2 = Profiler::Instance()->GetEvent(kEvent2Name);
ASSERT_TRUE(event2 != NULL);
EXPECT_FALSE(event1->is_started());
EXPECT_TRUE(event2->is_started());
rtc::Thread::SleepMs(kEvent2WaitMs);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kEvent2WaitMs));
}
// Check the result.
EXPECT_FALSE(event2->is_started());
EXPECT_EQ(1, event2->event_count());
// The difference here can be as much as 0.33, so we need high tolerance.
EXPECT_NEAR(kEvent2WaitSec, event2->mean(), kTolerance * 4);
EXPECT_EQ(kEvent2WaitSec, event2->mean());
// Make sure event1 is unchanged.
EXPECT_FALSE(event1->is_started());
EXPECT_EQ(1, event1->event_count());
{ // Run another event 1.
PROFILE(kEvent1Name);
EXPECT_TRUE(event1->is_started());
rtc::Thread::SleepMs(kWaitMs);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
}
// Check the result.
EXPECT_FALSE(event1->is_started());
EXPECT_EQ(2, event1->event_count());
EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
EXPECT_NEAR(kWaitSec * 2, event1->total_time(), kTolerance * 2);
EXPECT_EQ(kWaitSec, event1->mean());
EXPECT_EQ(kWaitSec * 2, event1->total_time());
EXPECT_DOUBLE_EQ(event1->mean(),
event1->total_time() / event1->event_count());
}