Advertisement
Guest User

Untitled

a guest
Feb 23rd, 2020
115
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 5.33 KB | None | 0 0
  1. #include <iostream>
  2. #include <chrono>
  3. #include <vector>
  4. #include <iomanip>
  5. #include <windows.h>
  6. #include <string>
  7. #include <sstream>
  8. #include <new>
  9. #include <map>
  10. #include <string>
  11. #include <string_view>
  12. #include <fstream>
  13. #include <algorithm>
  14.  
  15.  
  16. constexpr size_t N = 48;
  17. constexpr size_t CYCLES = 10000;
  18. constexpr size_t K = 2;
  19. constexpr size_t L3 = 3 * 1024 * 1024;
  20. constexpr size_t L2 = 256 * 1024;
  21. constexpr size_t L1 = 32 * 1024;
  22.  
  23. __declspec(align(64)) struct u64_8
  24. {
  25. uint64_t u0;
  26. uint64_t u1;
  27. uint64_t u2;
  28. uint64_t u3;
  29. uint64_t u4;
  30. uint64_t u5;
  31. uint64_t u6;
  32. uint64_t u7;
  33. };
  34.  
  35. using duration_t = std::chrono::high_resolution_clock::duration;
  36. using measure_map_t = std::map<std::string,std::vector<duration_t>>;
  37.  
  38. std::vector<duration_t> test_cache(const size_t size)
  39. {
  40. std::vector<duration_t> results;
  41. results.reserve(N - 2);
  42.  
  43. const size_t offset = (size * K) / sizeof(u64_8);
  44. u64_8* const mas = (u64_8*)_aligned_malloc(sizeof(u64_8) * offset * N, 64);
  45.  
  46. for (size_t n = 2; n <= N; ++n)
  47. {
  48. const size_t block_size = (size / sizeof(u64_8)) / n / 2;
  49. for (size_t i = 0; i < n; ++i)
  50. {
  51. for (size_t j = 0; j < block_size; ++j)
  52. {
  53. if (i == n - 1)
  54. {
  55. if (j == block_size - 1)
  56. mas[i * offset + j].u0 = 0;
  57. else
  58. mas[i * offset + j].u0 = j + 1;
  59. }
  60. else
  61. {
  62. mas[i * offset + j].u0 = (i + 1) * offset + j;
  63. }
  64. }
  65. }
  66.  
  67. uint64_t t = 0;
  68. std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
  69. start = std::chrono::high_resolution_clock::now();
  70. for (int i = 0; i < size / sizeof(u64_8) / n / 2 * n * CYCLES; ++i)
  71. {
  72. t = mas[t].u0;
  73. }
  74. end = std::chrono::high_resolution_clock::now();
  75. printf("%d", t);
  76. results.push_back(end - start);
  77. }
  78. _aligned_free(mas);
  79. return results;
  80. }
  81.  
  82. void debug_print_measure(const std::string_view name,const std::vector<duration_t>& measures)
  83. {
  84. std::cout << name << std::endl;
  85. const size_t numMeasures = measures.size();
  86. for (int iMeasure = 0; iMeasure < numMeasures; ++iMeasure)
  87. {
  88. std::cout << "N: " << std::setw(2) << iMeasure + 2 << " Time: " << std::setw(16) << measures[iMeasure].count() << " ns" << std::endl;
  89. }
  90. }
  91.  
  92. void debug_print_measures(const measure_map_t& measureResults)
  93. {
  94. for(const auto&[name, measures] : measureResults)
  95. {
  96. debug_print_measure(name,measures);
  97. }
  98. }
  99.  
  100. void to_csv(const std::string_view path, const measure_map_t& measureResults)
  101. {
  102.  
  103. for(const auto&[name, measures] : measureResults)
  104. {
  105. std::ofstream file;
  106. file.open(path.data()+name+".txt");
  107. file <<"\""<<"N"<<"\""<<","<<"\""<<"Time"<<"\""<<std::endl;
  108. const size_t numMeasures = measures.size();
  109. for (int iMeasure = 0; iMeasure < numMeasures; ++iMeasure)
  110. {
  111. file<<iMeasure + 2 << "," << measures[iMeasure].count() <<std::endl;
  112. }
  113. }
  114. }
  115.  
  116. constexpr size_t veryNiceName = 50;
  117. const std::string L3NAME = "L3";
  118. const std::string L2NAME = "L2";
  119. const std::string L1NAME = "L1";
  120.  
  121. measure_map_t avaragize(const std::vector<measure_map_t>& vec_measures)
  122. {
  123. measure_map_t ret;
  124. const size_t ssssize = vec_measures[0].at(L3NAME).size();
  125. std::vector<duration_t> vec3(ssssize);
  126. std::vector<duration_t> vec2(ssssize);
  127. std::vector<duration_t> vec1(ssssize);
  128.  
  129. std::fill(vec3.begin(), vec3.end(), duration_t(0));
  130. std::fill(vec2.begin(), vec2.end(), duration_t(0));
  131. std::fill(vec1.begin(), vec1.end(), duration_t(0));
  132.  
  133. for (const auto eachMap : vec_measures)
  134. {
  135. auto vec3each = eachMap.at(L3NAME);
  136. auto vec2each = eachMap.at(L2NAME);
  137. auto vec1each = eachMap.at(L1NAME);
  138.  
  139. std::transform (vec1.begin(), vec1.end(), vec1each.begin(), vec1.begin(), [](auto from1, auto from2){return from1+from2/veryNiceName;});
  140. std::transform (vec2.begin(), vec2.end(), vec2each.begin(), vec2.begin(), [](auto from1, auto from2){return from1+from2/veryNiceName;});
  141. std::transform (vec3.begin(), vec3.end(), vec3each.begin(), vec3.begin(), [](auto from1, auto from2){return from1+from2/veryNiceName;});
  142. }
  143.  
  144. ret.insert(std::make_pair(L1NAME,std::move(vec1)));
  145. ret.insert(std::make_pair(L2NAME,std::move(vec2)));
  146. ret.insert(std::make_pair(L3NAME,std::move(vec3)));
  147.  
  148. return ret;
  149. }
  150.  
  151. int main()
  152. {
  153. SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
  154.  
  155. std::vector<measure_map_t> idkHowToNameThis;
  156. idkHowToNameThis.resize(veryNiceName );
  157.  
  158. for (int i = 0 ; i < veryNiceName ; i++)
  159. {
  160.  
  161. measure_map_t measureResults;
  162.  
  163. measureResults.insert(std::make_pair(L3NAME,test_cache(L3)));
  164. measureResults.insert(std::make_pair(L2NAME,test_cache(L2)));
  165. measureResults.insert(std::make_pair(L1NAME,test_cache(L1)));
  166.  
  167. idkHowToNameThis[i]=std::move(measureResults);
  168. }
  169.  
  170. measure_map_t asd = avaragize(idkHowToNameThis);
  171.  
  172. debug_print_measures(asd);
  173. to_csv("c://users//alex//desktop//myfile",asd);
  174. system("pause");
  175. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement