proxygen: proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp File Reference

#include <algorithm>
#include <folly/Benchmark.h>
#include <proxygen/lib/http/HTTPCommonHeaders.h>
#include <proxygen/lib/utils/PerfectIndexMap.h>
#include <unordered_map>

Go to the source code of this file.

Functions
void	UnorderedMapInsertBench (std::unordered_map< std::string, std::string > &testMap, const std::vector< const std::string * > &keysAndValues, int iters)

void	PerfectIndexMapInsertCodeBench (DefaultPerfectIndexMap &map, const std::vector< HTTPHeaderCode > &keys, const std::vector< const std::string * > &values, int iters)

void	PerfectIndexMapInsertHashBench (DefaultPerfectIndexMap &map, const std::vector< const std::string * > &keysAndValues, int iters)

void	UnorderedMapGetBench (std::unordered_map< std::string, std::string > &testMap, const std::vector< const std::string * > &keys, int iters)

void	PerfectIndexMapGetCodeBench (DefaultPerfectIndexMap &map, const std::vector< HTTPHeaderCode > &keys, int iters)

void	PerfectIndexMapGetStringBench (DefaultPerfectIndexMap &map, const std::vector< const std::string * > &keys, int iters)

	BENCHMARK (UnorderedMapUniqueInserts, iters)

std::unordered_map< std::string, std::string >	getBenchUnorderedMapUniqueGetsTestMap ()

	BENCHMARK (UnorderedMapUniqueGets, iters)

	BENCHMARK (PerfectIndexMapUniqueInsertsCode, iters)

	BENCHMARK (PerfectIndexMapUniqueInsertsHashCodeString, iters)

	BENCHMARK (PerfectIndexMapUniqueInsertsHashOtherString, iters)

DefaultPerfectIndexMap	getBenchPerfectIndexMapUniqueGetsCodeTestMap ()

	BENCHMARK (PerfectIndexMapUniqueGetsCode, iters)

	BENCHMARK (PerfectIndexMapUniqueGetsCodeString, iters)

DefaultPerfectIndexMap	getBenchPerfectIndexMapUniqueGetsOtherStringTestMap ()

	BENCHMARK (PerfectIndexMapUniqueGetsOtherString, iters)

int	main (int argc, char **argv)

Variables
std::unordered_map< std::string, std::string >	bUnorderedMapUniqueInsertsMap

std::unordered_map< std::string, std::string >	bUnorderedMapUniqueGetsMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueInsertsCodeMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueInsertsHashCodeStringTestMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueInsertsHashOtherStringTestMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueGetsCodeMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueGetsCodeStringMap

DefaultPerfectIndexMap	bPerfectIndexMapUniqueGetsOtherStringMap

Function Documentation

BENCHMARK	(	UnorderedMapUniqueInserts	,
		iters
	)

Definition at line 157 of file PerfectIndexMapBenchmark.cpp.

References UnorderedMapInsertBench().

                                             {
   UnorderedMapInsertBench(
     bUnorderedMapUniqueInsertsMap, testHeadersCodeStrings, iters);
 }

BENCHMARK	(	UnorderedMapUniqueGets	,
		iters
	)

Definition at line 170 of file PerfectIndexMapBenchmark.cpp.

References UnorderedMapGetBench().

                                          {
   UnorderedMapGetBench(
     bUnorderedMapUniqueGetsMap, testHeadersCodeStrings, iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueInsertsCode	,
		iters
	)

Definition at line 176 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapInsertCodeBench().

                                                    {
   PerfectIndexMapInsertCodeBench(
     bPerfectIndexMapUniqueInsertsCodeMap, testHeaderCodes,
     testHeadersCodeStrings, iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueInsertsHashCodeString	,
		iters
	)

Definition at line 184 of file PerfectIndexMapBenchmark.cpp.

References bPerfectIndexMapUniqueInsertsHashCodeStringTestMap, and PerfectIndexMapInsertHashBench().

                                                              {
   PerfectIndexMapInsertHashBench(
     bPerfectIndexMapUniqueInsertsHashCodeStringTestMap, testHeadersCodeStrings,
     iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueInsertsHashOtherString	,
		iters
	)

Definition at line 192 of file PerfectIndexMapBenchmark.cpp.

References bPerfectIndexMapUniqueInsertsHashOtherStringTestMap, and PerfectIndexMapInsertHashBench().

                                                               {
   PerfectIndexMapInsertHashBench(
     bPerfectIndexMapUniqueInsertsHashOtherStringTestMap,
     testHeadersOtherStrings, iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueGetsCode	,
		iters
	)

Definition at line 206 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapGetCodeBench().

                                                 {
   PerfectIndexMapGetCodeBench(
     bPerfectIndexMapUniqueGetsCodeMap, testHeaderCodes, iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueGetsCodeString	,
		iters
	)

Definition at line 213 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapGetStringBench().

                                                       {
   PerfectIndexMapGetStringBench(
     bPerfectIndexMapUniqueGetsCodeStringMap, testHeadersCodeStrings, iters);
 }

BENCHMARK	(	PerfectIndexMapUniqueGetsOtherString	,
		iters
	)

Definition at line 225 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapGetStringBench().

                                                        {
   PerfectIndexMapGetStringBench(
     bPerfectIndexMapUniqueGetsOtherStringMap, testHeadersOtherStrings, iters);
 }

DefaultPerfectIndexMap getBenchPerfectIndexMapUniqueGetsCodeTestMap ( )

Definition at line 198 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapInsertCodeBench(), and testMap().

                                                                       {
   DefaultPerfectIndexMap testMap;
   PerfectIndexMapInsertCodeBench(
     testMap, testHeaderCodes, testHeadersCodeStrings, 1);
   return testMap;
 }

DefaultPerfectIndexMap getBenchPerfectIndexMapUniqueGetsOtherStringTestMap ( )

Definition at line 218 of file PerfectIndexMapBenchmark.cpp.

References PerfectIndexMapInsertHashBench(), and testMap().

                                                                              {
   DefaultPerfectIndexMap testMap;
   PerfectIndexMapInsertHashBench(testMap, testHeadersOtherStrings, 1);
   return testMap;
 }

std::unordered_map<std::string, std::string> getBenchUnorderedMapUniqueGetsTestMap ( )

Definition at line 163 of file PerfectIndexMapBenchmark.cpp.

References testMap(), and UnorderedMapInsertBench().

                                             {
   std::unordered_map<std::string, std::string> testMap;
   UnorderedMapInsertBench(testMap, testHeadersCodeStrings, 1);
   return testMap;
 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 230 of file PerfectIndexMapBenchmark.cpp.

References folly::runBenchmarks().

                                 {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
 
   // Not explicitly required but lets free memory we specifically allocated.
   for (auto * testHeaderOtherString: testHeadersOtherStrings) {
     delete testHeaderOtherString;
   }
 
   return 0;
 }

void PerfectIndexMapGetCodeBench	(	DefaultPerfectIndexMap &	map,
		const std::vector< HTTPHeaderCode > &	keys,
		int	iters
	)

Definition at line 136 of file PerfectIndexMapBenchmark.cpp.

References i, and folly::none.

Referenced by BENCHMARK().

                {
   for (int i = 0; i < iters; ++i) {
     for (auto const& key: keys) {
       CHECK(map.getSingleOrNone(key) != folly::none);
     }
   }
 }

void PerfectIndexMapGetStringBench	(	DefaultPerfectIndexMap &	map,
		const std::vector< const std::string * > &	keys,
		int	iters
	)

Definition at line 146 of file PerfectIndexMapBenchmark.cpp.

References i, and folly::none.

Referenced by BENCHMARK().

                {
   for (int i = 0; i < iters; ++i) {
     for (auto const& key: keys) {
       CHECK(map.getSingleOrNone(*key) != folly::none);
     }
   }
 }

void PerfectIndexMapInsertCodeBench	(	DefaultPerfectIndexMap &	map,
		const std::vector< HTTPHeaderCode > &	keys,
		const std::vector< const std::string * > &	values,
		int	iters
	)

Definition at line 101 of file PerfectIndexMapBenchmark.cpp.

References i.

Referenced by BENCHMARK(), and getBenchPerfectIndexMapUniqueGetsCodeTestMap().

                                                            {
   for (int i = 0; i < iters; ++i) {
     for (unsigned long j = 0; j < keys.size(); ++j) {
       map.set(keys[j], *values[j]);
     }
   }
 }

void PerfectIndexMapInsertHashBench	(	DefaultPerfectIndexMap &	map,
		const std::vector< const std::string * > &	keysAndValues,
		int	iters
	)

Definition at line 111 of file PerfectIndexMapBenchmark.cpp.

References i.

Referenced by BENCHMARK(), and getBenchPerfectIndexMapUniqueGetsOtherStringTestMap().

                                                                   {
   for (int i = 0; i < iters; ++i) {
     for (auto const& keyAndValue: keysAndValues) {
       map.set(*keyAndValue, *keyAndValue);
     }
   }
 }

void UnorderedMapGetBench	(	std::unordered_map< std::string, std::string > &	testMap,
		const std::vector< const std::string * > &	keys,
		int	iters
	)

Definition at line 121 of file PerfectIndexMapBenchmark.cpp.

References i, and folly::none.

Referenced by BENCHMARK().

                                                          {
   for (int i = 0; i < iters; ++i) {
     for (auto const& key: keys) {
       // Modeled after old impl of varstore
       auto it = testMap.find(*key);
       folly::Optional<std::string> result = (
         it == testMap.end() ?
         folly::none : (folly::Optional<std::string>)it->second);
       CHECK(result != folly::none);
     }
   }
 }

void UnorderedMapInsertBench	(	std::unordered_map< std::string, std::string > &	testMap,
		const std::vector< const std::string * > &	keysAndValues,
		int	iters
	)

Definition at line 90 of file PerfectIndexMapBenchmark.cpp.

References i.

Referenced by BENCHMARK(), and getBenchUnorderedMapUniqueGetsTestMap().

                                                                   {
   for (int i = 0; i < iters; ++i) {
     for (auto const& keyAndValue: keysAndValues) {
       // Modeled after old impl of varstore
       testMap[*keyAndValue] = *keyAndValue;
     }
   }
 }