test_CustomStackTrace.cpp 3.4 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
Y
Yu Yang 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */

#include <gtest/gtest.h>
#include <chrono>

#include "paddle/utils/CommandLineParser.h"
Y
Yu Yang 已提交
19
#include "paddle/utils/CustomStackTrace.h"
Y
Yu Yang 已提交
20
#include "paddle/utils/Locks.h"
Y
Yu Yang 已提交
21
#include "paddle/utils/Util.h"
Y
Yu Yang 已提交
22 23 24

P_DEFINE_int32(test_thread_num, 10, "testing thread number");

25 26 27 28 29 30
void testNormalImpl(
    const std::function<void(paddle::CustomStackTrace<std::string>&,
                             size_t,
                             size_t,
                             paddle::ThreadBarrier&,
                             paddle::ThreadBarrier&)>& callback) {
Y
Yu Yang 已提交
31 32 33 34 35 36 37 38
  paddle::CustomStackTrace<std::string> tracer;
  paddle::ThreadBarrier doneBarrier(FLAGS_test_thread_num + 1);
  paddle::ThreadBarrier startBarrier(FLAGS_test_thread_num + 1);
  constexpr size_t countDown = 10;
  constexpr size_t layerSize = 1000;
  std::vector<std::unique_ptr<std::thread>> threads;
  threads.reserve(FLAGS_test_thread_num);

39 40 41 42 43 44 45
  for (int32_t i = 0; i < FLAGS_test_thread_num; ++i) {
    threads.emplace_back(new std::thread([&tracer,
                                          &countDown,
                                          &layerSize,
                                          &startBarrier,
                                          &doneBarrier,
                                          &callback] {
Y
Yu Yang 已提交
46 47 48 49 50 51
      callback(tracer, countDown, layerSize, startBarrier, doneBarrier);
    }));
  }
  size_t cntDown = countDown;
  while (cntDown-- > 0) {
    startBarrier.wait();
52
    sleep(1);
Y
Yu Yang 已提交
53 54 55 56 57 58 59 60 61 62 63
    doneBarrier.wait();
    ASSERT_TRUE(tracer.empty());
  }

  for (auto& thread : threads) {
    thread->join();
  }
}

TEST(CustomStackTrace, normalTrain) {
  testNormalImpl([](paddle::CustomStackTrace<std::string>& tracer,
64 65 66 67
                    size_t countDown,
                    size_t layerSize,
                    paddle::ThreadBarrier& start,
                    paddle::ThreadBarrier& finish) {
Y
Yu Yang 已提交
68 69
    while (countDown-- > 0) {
      start.wait();
70
      for (size_t i = 0; i < layerSize; ++i) {
Y
Yu Yang 已提交
71 72 73
        tracer.push("layer_" + std::to_string(i));
      }
      tracer.pop("");
74
      for (size_t i = 0; i < layerSize; ++i) {
Y
Yu Yang 已提交
75 76 77 78 79 80 81 82
        tracer.pop("layer_" + std::to_string(layerSize - 1 - i));
      }
      finish.wait();
    }
  });
}

TEST(CustomStackTrace, normalTest) {
83 84 85 86 87
  testNormalImpl([](paddle::CustomStackTrace<std::string>& tracer,
                    size_t countDown,
                    size_t layerSize,
                    paddle::ThreadBarrier& start,
                    paddle::ThreadBarrier& finish) {
Y
Yu Yang 已提交
88 89
    while (countDown-- > 0) {
      start.wait();
90
      for (size_t i = 0; i < layerSize; ++i) {
Y
Yu Yang 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103
        tracer.push("layer_" + std::to_string(i));
      }
      tracer.clear();  // in forward test, tracer will clear after forward.
      finish.wait();
    }
  });
}

int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);
  paddle::initMain(argc, argv);
  return RUN_ALL_TESTS();
}