C++ (Cpp) make_timer 예제들

예제 #1

파일: TemporaryStrings.cpp 프로젝트: MattHulse/CppSandbox

int main(int argc, char* argv[])
{
  size_t repeat = 1000000;

  {
    auto t = make_timer("Const Big String");
    for (int i = 0; i < repeat; ++i)
    {
      std::string s = GetConstBigString();
      if (s.empty())
      {
        return -1;
      }
    }
  }
  {
    auto t = make_timer("Const Big String c_str");
    for (int i = 0; i < repeat; ++i)
    {
      std::string s = GetConstBigString().c_str();
      if (s.empty())
      {
        return -1;
      }
    }
  }

  {
    auto t = make_timer("Big String");
    for (int i = 0; i < repeat; ++i)
    {
      std::string s = GetBigString();
      if (s.empty())
      {
        return -1;
      }
    }
  }
  {
    auto t = make_timer("Big String c_str");
    for (int i = 0; i < repeat; ++i)
    {
      std::string s = GetBigString().c_str();
      if (s.empty())
      {
        return -1;
      }
    }
  }
  return 0;
}

예제 #2

파일: ckpttimer.cpp 프로젝트: dmtcp/dmtcp

static void
ckpttimer_event_hook(DmtcpEvent_t event, DmtcpEventData_t *data)
{
  sigset_t mask;

  switch (event) {
  case DMTCP_EVENT_INIT:
  {
    if (!doneInitialization) {
      get_and_save_envvars();

      /* Create a timer */
      timerid = make_timer();
      sigemptyset(&mask);
      sigaddset(&mask, g_sig_num);
      doneInitialization = 1;
    }

    JTRACE("The plugin has been initialized.");
    break;
  }
  default:
    break;
  }
}

예제 #3

파일: StreamsAndConcurrency.cpp 프로젝트: MattHulse/CppSandbox

void RunTasks(size_t tasks, TaskGenerator_t gen)
{

  long firstRunTime = 0;

  for (size_t i = 1; i <= 16; ++i)
  {
    auto t = make_timer([&firstRunTime, i](long t)
                        {
                          if (i == 1)
                          {
                            firstRunTime = t;
                          }
                          std::cout << i << ' ' << (double)firstRunTime / t
                                    << std::endl;
                        });

    tbb::task_scheduler_init tsInit(i);
    tbb::task_group tg;
    for (size_t task = 0; task < tasks; ++task)
    {
      tg.run(gen());
    }
    tg.wait();
  }
  std::cout << std::endl;
}

예제 #4

파일: CacheMisses.cpp 프로젝트: PureAbstract/CppSandbox

int main(int argc, char* argv[])
{
  size_t multiplier = 1;
  if (argc > 1)
  {
    multiplier = std::stoi(argv[1]);
  }

  size_t numbers{100000 * multiplier};

  {
    std::vector<int> ints;
    auto t = make_timer("vector");
    RandomOrderedFill(ints, 100, numbers);
  }

  {
    std::list<int> ints;
    auto t = make_timer("list");
    RandomOrderedFill(ints, 100, numbers);
  }
}

예제 #5

파일: BranchPrediction.cpp 프로젝트: jbcoe/CppSandbox

int SumOfBigNumbers(const Ints_t& ints, const size_t iterations,
                    const char* message)
{
  auto t = make_timer(message);
  int bigSum = 0;
  for (size_t iterate = 0; iterate < iterations; ++iterate)
  {
    std::for_each(ints.begin(), ints.end(), [&](int i)
                  {
                    if (i > BIG)
                    {
                      bigSum += i;
                    }
                  });
  }
  return bigSum;
}

예제 #6

파일: main.c 프로젝트: ccancellieri/psentinel

int initialize_timers(configuration * connections)
{
	int configured_ports = connections->last_slot;
	int i;
	int status = 0;

	for (i = 0; i <= configured_ports; i++)
	{

		if (connections->single_conn[i].timer.chk_function)
		{
			status = make_timer(&(connections->single_conn[i]));
			if (status)
			{
				Log(LOG_ERR, "Error creating timer for service %s", connections->single_conn[i].service_name);

			}
		}
	}

	return status;
}

예제 #7

파일: SharedAndIntrusivePointers.cpp 프로젝트: PureAbstract/CppSandbox

void RunDefaultConstructableObjectTimings(size_t objectCount,
                                          const char* objectName)
{
  std::cout << objectName << std::endl;

  {
    // No timing, warm up the heap
    for (int i = 0; i < 1; ++i)
    {
      std::vector<std::shared_ptr<T>> objects;
      std::generate_n(std::back_inserter(objects), objectCount, []
                      { return std::shared_ptr<T>(new T()); });
    }
  }

  {
    auto t =
        make_timer("std::shared_ptr and new : ", objectName, " ", objectCount);
    std::vector<std::shared_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return std::shared_ptr<T>(new T()); });
  }

  {
    auto t = make_timer("std::shared_ptr and make_shared : ", objectName, " ",
                        objectCount);
    std::vector<std::shared_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return std::make_shared<T>(); });
  }

  {
    auto t =
        make_timer("std::unique_ptr and new : ", objectName, " ", objectCount);
    std::vector<std::unique_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return std::unique_ptr<T>(new T()); });
  }

  {
    auto t = make_timer("boost::shared_ptr and new : ", objectName, " ",
                        objectCount);
    std::vector<boost::shared_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return boost::shared_ptr<T>(new T()); });
  }

  {
    auto t = make_timer("boost::shared_ptr and make_shared : ", objectName, " ",
                        objectCount);
    std::vector<boost::shared_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return boost::make_shared<T>(); });
  }

  {
    auto t =
        make_timer("boost::intrusive_ptr : ", objectName, " ", objectCount);
    std::vector<boost::intrusive_ptr<T>> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return boost::intrusive_ptr<T>(new T()); });
  }

  {
    auto t = make_timer(objectName, "*  ", objectCount);
    std::vector<T*> objects;
    std::generate_n(std::back_inserter(objects), objectCount, []
                    { return new T(); });
    for (auto o : objects) delete o;
  }

  std::cout << std::endl;
}