├── Mind the cache.pdf
├── README.md
├── aos_vs_soa.cpp
├── compact_aos_vs_soa.cpp
├── filtered_sum.cpp
├── linear_traversal.cpp
├── matrix_sum.cpp
├── parallel_count.cpp
├── perf.xlsx
├── poly_containers.cpp
└── random_access_aos_vs_soa.cpp


/Mind the cache.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/joaquintides/usingstdcpp2015/dfec560c7733ab035e0e9690cb603afa7ee11e9a/Mind the cache.pdf


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | using std::cpp 2015
2 | -------------------
3 | 
4 | Presentation from Joaquín Mª López Muñoz at [using std::cpp 2015](http://usingstdcpp.org/using-stdcpp-2015/) and associated material.
5 | * [Mind the cache](https://github.com/joaquintides/usingstdcpp2015/raw/master/Mind%20the%20cache.pdf) ([video](https://www.youtube.com/watch?v=TipTVUGBFtY) in Spanish): Classical big-O algorithmic complexity analysis proves insufficient to estimate program performance for modern computer architectures: current processors are equipped with several low-level components (hierarchical cache structures, pipelining, branch prediction) that greatly favor certain code and data layout patterns not taken into account by naïve computation models. In this talk we see some examples of the impact these factors have and provide suggestions for performance improvement based on data locality and regularity in code execution.
6 | 


--------------------------------------------------------------------------------
/aos_vs_soa.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: AOS vs SOA.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <iostream>
 63 | #include <vector>
 64 | 
 65 | struct particle
 66 | {
 67 |   int x,y,z;
 68 |   int dx,dy,dz;
 69 | };
 70 | 
 71 | using particle_aos=std::vector<particle>;
 72 | 
 73 | particle_aos create_particle_aos(int n)
 74 | {
 75 |   particle_aos res;
 76 |   res.reserve(n);
 77 |   for(int i=0;i<n;++i)res.push_back({i,i+1,i+2,i+3,i+4,i+5});
 78 |   return res;
 79 | }
 80 | 
 81 | struct particle_soa
 82 | {
 83 |   std::vector<int> x,y,z;
 84 |   std::vector<int> dx,dy,dz;
 85 | };
 86 | 
 87 | particle_soa create_particle_soa(int n)
 88 | {
 89 |   particle_soa res;
 90 |   res.x.reserve(n);
 91 |   res.y.reserve(n);
 92 |   res.z.reserve(n);
 93 |   res.dx.reserve(n);
 94 |   res.dy.reserve(n);
 95 |   res.dz.reserve(n);
 96 |   for(int i=0;i<n;++i){
 97 |     res.x.push_back(i);
 98 |     res.y.push_back(i+1);
 99 |     res.z.push_back(i+2);
100 |     res.dx.push_back(i+3);
101 |     res.dy.push_back(i+4);
102 |     res.dz.push_back(i+5);
103 |   }
104 |   return res;
105 | }
106 | 
107 | int main()
108 | {
109 |   std::size_t n0=10000,n1=40000000,dn=2000;
110 |   double      fdn=1.1;    
111 | 
112 |   std::cout<<"aos vs soa:"<<std::endl;
113 |   std::cout<<"n;aos;soa"<<std::endl;
114 |     
115 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
116 |     std::cout<<n<<";";
117 |     {
118 |       auto ps=create_particle_aos(n);
119 |       std::cout<<measure(n,[&](){
120 |         long int res=0;
121 |         for(std::size_t i=0;i<n;++i)res+=ps[i].x+ps[i].y+ps[i].z;
122 |         return res;
123 |       })<<";";
124 |     }
125 |     {
126 |       auto ps=create_particle_soa(n);
127 |       std::cout<<measure(n,[&](){
128 |         long int res=0;
129 |         for(std::size_t i=0;i<n;++i)res+=ps.x[i]+ps.y[i]+ps.z[i];
130 |         return res;
131 |       })<<"\n";
132 |     }
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/compact_aos_vs_soa.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: compact AOS vs SOA.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <iostream>
 63 | #include <vector>
 64 | 
 65 | struct particle
 66 | {
 67 |   int x,y,z;
 68 | };
 69 | 
 70 | using particle_aos=std::vector<particle>;
 71 | 
 72 | particle_aos create_particle_aos(int n)
 73 | {
 74 |   particle_aos res;
 75 |   res.reserve(n);
 76 |   for(int i=0;i<n;++i)res.push_back({i,i+1,i+2});
 77 |   return res;
 78 | }
 79 | 
 80 | struct particle_soa
 81 | {
 82 |   std::vector<int> x,y,z;
 83 | };
 84 | 
 85 | particle_soa create_particle_soa(int n)
 86 | {
 87 |   particle_soa res;
 88 |   res.x.reserve(n);
 89 |   res.y.reserve(n);
 90 |   res.z.reserve(n);
 91 |   for(int i=0;i<n;++i){
 92 |     res.x.push_back(i);
 93 |     res.y.push_back(i+1);
 94 |     res.z.push_back(i+2);
 95 |   }
 96 |   return res;
 97 | }
 98 | 
 99 | int main()
100 | {
101 |   std::size_t n0=10000,n1=40000000,dn=2000;
102 |   double      fdn=1.1;    
103 | 
104 |   std::cout<<"compact aos vs soa:"<<std::endl;
105 |   std::cout<<"n;aos;soa"<<std::endl;
106 |     
107 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
108 |     std::cout<<n<<";";
109 |     {
110 |       auto ps=create_particle_aos(n);
111 |       std::cout<<measure(n,[&](){
112 |         long int res=0;
113 |         for(std::size_t i=0;i<n;++i)res+=ps[i].x+ps[i].y+ps[i].z;
114 |         return res;
115 |       })<<";";
116 |     }
117 |     {
118 |       auto ps=create_particle_soa(n);
119 |       std::cout<<measure(n,[&](){
120 |         long int res=0;
121 |         for(std::size_t i=0;i<n;++i)res+=ps.x[i]+ps.y[i]+ps.z[i];
122 |         return res;
123 |       })<<"\n";
124 |     }
125 |   }
126 | }
127 | 


--------------------------------------------------------------------------------
/filtered_sum.cpp:
--------------------------------------------------------------------------------
 1 | /* usingstdcpp2015: summing elements over a threshold.
 2 |  *
 3 |  * Copyright 2015 Joaquin M Lopez Munoz.
 4 |  * Distributed under the Boost Software License, Version 1.0.
 5 |  * (See accompanying file LICENSE_1_0.txt or copy at
 6 |  * http://www.boost.org/LICENSE_1_0.txt)
 7 |  */
 8 |  
 9 | #include <algorithm>
10 | #include <array>
11 | #include <chrono>
12 | #include <numeric> 
13 |     
14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
15 |         
16 | template<typename F>
17 | double measure(F f)
18 | {
19 |   using namespace std::chrono;
20 |         
21 |   static const int              num_trials=10;
22 |   static const milliseconds     min_time_per_trial(200);
23 |   std::array<double,num_trials> trials;
24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
25 |         
26 |   for(int i=0;i<num_trials;++i){
27 |     int                               runs=0;
28 |     high_resolution_clock::time_point t2;
29 |         
30 |     measure_start=high_resolution_clock::now();
31 |     do{
32 |       res=f();
33 |       ++runs;
34 |       t2=high_resolution_clock::now();
35 |     }while(t2-measure_start<min_time_per_trial);
36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
37 |   }
38 |   (void)(res); /* var not used warn */
39 |         
40 |   std::sort(trials.begin(),trials.end());
41 |   return std::accumulate(
42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
43 | }
44 |  
45 | template<typename Size,typename F>
46 | double measure(Size n,F f)
47 | {
48 |   return measure(f)/n;
49 | }
50 | 
51 | void pause_timing()
52 | {
53 |   measure_pause=std::chrono::high_resolution_clock::now();
54 | }
55 |         
56 | void resume_timing()
57 | {
58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
59 | }
60 | 
61 | #include <algorithm>
62 | #include <iostream>
63 | #include <random>
64 | #include <vector>
65 | 
66 | int main()
67 | {
68 |   std::size_t n0=10000,n1=40000000,dn=2000;
69 |   double      fdn=1.1;    
70 | 
71 |   std::cout<<"filtered sum:"<<std::endl;
72 |   std::cout<<"n;unsorted;sorted"<<std::endl;
73 |     
74 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
75 |     std::vector<int>                v;
76 |     std::mt19937                    gen;
77 |     std::uniform_int_distribution<> rnd(0,255);
78 |     v.reserve(n);
79 |     for(std::size_t i=0;i<n;++i)v.push_back(rnd(gen));
80 | 
81 |     auto f=[&](){
82 |       long int res=0;
83 |       for(int x:v)if(x>128)res+=x;
84 |       return res;
85 |     };
86 | 
87 |     std::cout<<n<<";";
88 |     std::cout<<measure(n,f)<<";";
89 |     std::sort(v.begin(),v.end());
90 |     std::cout<<measure(n,f)<<"\n";
91 |   }
92 | }
93 | 


--------------------------------------------------------------------------------
/linear_traversal.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: linear traversal performance for two std containers.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <iostream>
 63 | #include <numeric>
 64 | #include <list>
 65 | #include <random>
 66 | #include <vector>
 67 | 
 68 | int main()
 69 | {
 70 |   std::size_t n0=10000,n1=40000000,dn=2000;
 71 |   double      fdn=1.1;    
 72 | 
 73 |   std::cout<<"linear traversal:"<<std::endl;
 74 |   std::cout<<"n;vector;list;shuffled list"<<std::endl;
 75 |     
 76 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
 77 |     std::cout<<n<<";";
 78 |     {
 79 |       std::vector<int> v(n);
 80 |       std::iota(v.begin(),v.end(),0);
 81 |       std::cout<<measure(n,[&](){
 82 |         return std::accumulate(v.begin(),v.end(),0);
 83 |       })<<";";
 84 |     }
 85 |     {
 86 |       std::list<int> l(n);
 87 |       std::iota(l.begin(),l.end(),0);
 88 |       std::cout<<measure(n,[&](){
 89 |         return std::accumulate(l.begin(),l.end(),0);
 90 |       })<<";";
 91 |     }
 92 |     {
 93 |       std::mt19937                    gen;
 94 |       std::uniform_int_distribution<> rnd(0,n-1);
 95 |       std::list<int>                  l;
 96 |       for(std::size_t i=0;i<n;++i)l.push_back(rnd(gen));
 97 |       l.sort();
 98 |       std::iota(l.begin(),l.end(),0);
 99 |       std::cout<<measure(n,[&](){
100 |         return std::accumulate(l.begin(),l.end(),0);
101 |       })<<"\n";
102 |     }
103 |   }
104 | }
105 | 


--------------------------------------------------------------------------------
/matrix_sum.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: matrix sum.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <boost/multi_array.hpp>
 63 | #include <cmath>
 64 | #include <iostream>
 65 | #include <vector>
 66 | 
 67 | int main()
 68 | {
 69 |   std::size_t n0=10000,n1=40000000,dn=2000;
 70 |   double      fdn=1.1;    
 71 | 
 72 |   std::cout<<"matrix sum:"<<std::endl;
 73 |   std::cout<<"n;row_col;col_row"<<std::endl;
 74 |     
 75 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
 76 |     std::size_t               m=static_cast<std::size_t>(std::sqrt(n));
 77 |     boost::multi_array<int,2> a(boost::extents[m][m]);
 78 | 
 79 |     /* fill with some values */
 80 |     for(std::size_t i=0;i<m;++i){
 81 |       for(std::size_t j=0;j<m;++j){
 82 |         a[i][j]=i+j;
 83 |       }
 84 |     }
 85 | 
 86 |     std::cout<<m*m<<";";
 87 |     std::cout<<measure(m*m,[&](){
 88 |       long int res=0;
 89 |       for(std::size_t i=0;i<m;++i){
 90 |         for(std::size_t j=0;j<m;++j){
 91 |           res+=a[i][j];
 92 |         }
 93 |       }
 94 |       return res;
 95 |     })<<";";
 96 | 
 97 |     std::cout<<measure(m*m,[&](){
 98 |       long int res=0;
 99 |       for(std::size_t j=0;j<m;++j){
100 |         for(std::size_t i=0;i<m;++i){
101 |           res+=a[i][j];
102 |         }
103 |       }
104 |       return res;
105 |     })<<"\n";
106 |   }
107 | }
108 | 


--------------------------------------------------------------------------------
/parallel_count.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: threads acting on shared memory.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <iostream>
 62 | #include <random>
 63 | #include <thread>
 64 | #include <vector>
 65 | 
 66 | int main()
 67 | {
 68 |   std::size_t n0=10000,n1=40000000,dn=2000;
 69 |   double      fdn=1.1;    
 70 | 
 71 |   std::cout<<"parallel count:"<<std::endl;
 72 |   std::cout<<"n;near;far"<<std::endl;
 73 |     
 74 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
 75 |     std::mt19937                    gen;
 76 |     std::uniform_int_distribution<> rnd(0,255);
 77 |     std::vector<int> v;
 78 |     v.reserve(n);
 79 |     
 80 |     /* fill with some values */
 81 |     for(std::size_t i=0;i<n;++i)v.push_back(rnd(gen));
 82 |     
 83 |     int res[49];
 84 | 
 85 |     auto f=[&](int* px,int* py,int* pz,int* pw){
 86 |       auto th=[](int* p,int* first,int* last){
 87 |         *p=0;
 88 |         while(first!=last){
 89 |           int x=*first++;
 90 |           *p+=x%2;
 91 |         }
 92 |       };
 93 | 
 94 |       std::thread t1(th,px,v.data(),v.data()+n/4);
 95 |       std::thread t2(th,py,v.data()+n/4,v.data()+n/2);
 96 |       std::thread t3(th,pz,v.data()+n/2,v.data()+n*3/4);
 97 |       std::thread t4(th,pw,v.data()+n*3/4,v.data()+n);
 98 |       t1.join();
 99 |       t2.join();
100 |       t3.join();
101 |       t4.join();
102 |       return *px+*py+*pz+*pw;
103 |     };
104 | 
105 |     std::cout<<n<<";";
106 |     std::cout<<measure(n,[&](){
107 |       return f(&res[0],&res[1],&res[2],&res[3]);
108 |     })<<";";
109 |     std::cout<<measure(n,[&](){
110 |       return f(&res[0],&res[16],&res[32],&res[48]);
111 |     })<<"\n";
112 |   }
113 | }
114 | 


--------------------------------------------------------------------------------
/perf.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/joaquintides/usingstdcpp2015/dfec560c7733ab035e0e9690cb603afa7ee11e9a/perf.xlsx


--------------------------------------------------------------------------------
/poly_containers.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: processing polymorphic containers.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <cstddef>
 63 | #include <iostream>
 64 | #include <map>
 65 | #include <memory>
 66 | #include <random>
 67 | #include <typeindex>
 68 | #include <type_traits>
 69 | #include <vector>
 70 | 
 71 | template<class Base>
 72 | class poly_collection_segment_base
 73 | {
 74 | public:
 75 |   virtual ~poly_collection_segment_base(){};
 76 | 
 77 |   void insert(const Base& x)
 78 |   {
 79 |     this->insert_(x);
 80 |   }
 81 | 
 82 |   template<typename F>
 83 |   void for_each(F& f)
 84 |   {
 85 |     std::size_t s=this->element_size_();
 86 |     for(auto it=this->begin_(),end=it+this->size_()*s;it!=end;it+=s){
 87 |       f(*reinterpret_cast<Base*>(it));
 88 |     }
 89 |   }
 90 |   
 91 |   template<typename F>
 92 |   void for_each(F& f)const
 93 |   {
 94 |     std::size_t s=this->element_size_();
 95 |     for(auto it=this->begin_(),end=it+this->size_()*s;it!=end;it+=s){
 96 |       f(*reinterpret_cast<const Base*>(it));
 97 |     }
 98 |   }
 99 | 
100 | private:  
101 |   virtual void insert_(const Base& x)=0;
102 |   virtual char* begin_()=0;
103 |   virtual const char* begin_()const=0;
104 |   virtual std::size_t size_()const=0;
105 |   virtual std::size_t element_size_()const=0;
106 | };
107 | 
108 | template<class Derived,class Base>
109 | class poly_collection_segment:
110 |   public poly_collection_segment_base<Base>
111 | {
112 | private:
113 |   virtual void insert_(const Base& x)
114 |   {
115 |     store.push_back(static_cast<const Derived&>(x));
116 |   }
117 | 
118 |   virtual char* begin_()
119 |   {
120 |     return reinterpret_cast<char*>(
121 |       static_cast<Base*>(const_cast<Derived*>(store.data())));
122 |   }
123 | 
124 |   virtual const char* begin_()const
125 |   {
126 |     return reinterpret_cast<const char*>(
127 |       static_cast<const Base*>(store.data()));
128 |   }
129 | 
130 |   virtual std::size_t size_()const{return store.size();}
131 |   virtual std::size_t element_size_()const{return sizeof(Derived);}
132 | 
133 |   std::vector<Derived> store;
134 | };
135 | 
136 | template<class Base>
137 | class poly_collection
138 | {
139 | public:
140 |   template<class Derived>
141 |   void insert(
142 |     const Derived& x,
143 |     typename std::enable_if<std::is_base_of<Base,Derived>::value>::type* =0)
144 |   {
145 |     auto& pchunk=chunks[typeid(x)];
146 |     if(!pchunk)pchunk.reset(new poly_collection_segment<Derived,Base>());
147 |     pchunk->insert(x);
148 |   }
149 |  
150 |   template<typename F>
151 |   F for_each(F f)
152 |   {
153 |     for(const auto& p:chunks)p.second->for_each(f);
154 |     return std::move(f);
155 |   }
156 | 
157 |   template<typename F>
158 |   F for_each(F f)const
159 |   {
160 |     for(const auto& p:chunks)
161 |       const_cast<const segment&>(*p.second).for_each(f);
162 |     return std::move(f);
163 |   }
164 | 
165 | private:
166 |   typedef poly_collection_segment_base<Base> segment;
167 |   typedef std::unique_ptr<segment>           pointer;
168 | 
169 |   std::map<std::type_index,pointer> chunks;
170 | };
171 | 
172 | struct base
173 | {
174 |   virtual int f()const=0;
175 |   virtual ~base(){}
176 | };
177 | 
178 | struct derived1:base
179 | {
180 |   virtual int f()const{return 1;};  
181 | };
182 | 
183 | struct derived2:base
184 | {
185 |   virtual int f()const{return 2;};  
186 | };
187 | 
188 | struct derived3:base
189 | {
190 |   virtual int f()const{return 3;};  
191 | };
192 | 
193 | int main()
194 | {
195 |   std::size_t n0=10000,n1=40000000,dn=2000;
196 |   double      fdn=1.1;    
197 | 
198 |   std::cout<<"polymorphic containers:"<<std::endl;
199 |   std::cout<<"n;unsorted;sorted;poly_collection"<<std::endl;
200 |     
201 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
202 |     std::cout<<n<<";";
203 |     {
204 |       using pointer=std::shared_ptr<base>;
205 |       std::vector<pointer>            v;
206 |       std::mt19937                    gen;
207 |       std::uniform_int_distribution<> rnd(1,3);
208 |       v.reserve(n);
209 |       for(std::size_t i=0;i<n;++i){
210 |         switch(rnd(gen)){
211 |           case 1:  v.push_back(std::make_shared<derived1>());break;
212 |           case 2:  v.push_back(std::make_shared<derived2>());break;
213 |           case 3: 
214 |           default: v.push_back(std::make_shared<derived3>());break;
215 |         }
216 |       }
217 |       std::shuffle(v.begin(),v.end(),gen);
218 | 
219 |       auto f=[&](){
220 |         long int res=0;
221 |         for(const auto& p:v)res+=p->f();
222 |         return res;
223 |       };
224 | 
225 |       std::cout<<measure(n,f)<<";";
226 |       std::sort(v.begin(),v.end(),[](const pointer& p,const pointer& q){
227 |         return std::type_index(typeid(*p))<std::type_index(typeid(*q));
228 |       });
229 |       std::cout<<measure(n,f)<<";";
230 |     }
231 |     {
232 |       poly_collection<base>           v;
233 |       std::mt19937                    gen;
234 |       std::uniform_int_distribution<> rnd(1,3);
235 |       for(std::size_t i=0;i<n;++i){
236 |         switch(rnd(gen)){
237 |           case 1:  v.insert(derived1());break;
238 |           case 2:  v.insert(derived2());break;
239 |           case 3: 
240 |           default: v.insert(derived3());break;
241 |         }
242 |       }
243 | 
244 |       std::cout<<measure(n,[&](){
245 |         long int res=0;
246 |         v.for_each([&](const base& x){res+=x.f();});
247 |         return res;
248 |       })<<"\n";
249 |     }
250 |   }
251 | }
252 | 


--------------------------------------------------------------------------------
/random_access_aos_vs_soa.cpp:
--------------------------------------------------------------------------------
  1 | /* usingstdcpp2015: random access performance, AOS vs SOA.
  2 |  *
  3 |  * Copyright 2015 Joaquin M Lopez Munoz.
  4 |  * Distributed under the Boost Software License, Version 1.0.
  5 |  * (See accompanying file LICENSE_1_0.txt or copy at
  6 |  * http://www.boost.org/LICENSE_1_0.txt)
  7 |  */
  8 |  
  9 | #include <algorithm>
 10 | #include <array>
 11 | #include <chrono>
 12 | #include <numeric> 
 13 |     
 14 | std::chrono::high_resolution_clock::time_point measure_start,measure_pause;
 15 |         
 16 | template<typename F>
 17 | double measure(F f)
 18 | {
 19 |   using namespace std::chrono;
 20 |         
 21 |   static const int              num_trials=10;
 22 |   static const milliseconds     min_time_per_trial(200);
 23 |   std::array<double,num_trials> trials;
 24 |   volatile decltype(f())        res; /* to avoid optimizing f() away */
 25 |         
 26 |   for(int i=0;i<num_trials;++i){
 27 |     int                               runs=0;
 28 |     high_resolution_clock::time_point t2;
 29 |         
 30 |     measure_start=high_resolution_clock::now();
 31 |     do{
 32 |       res=f();
 33 |       ++runs;
 34 |       t2=high_resolution_clock::now();
 35 |     }while(t2-measure_start<min_time_per_trial);
 36 |     trials[i]=duration_cast<duration<double>>(t2-measure_start).count()/runs;
 37 |   }
 38 |   (void)(res); /* var not used warn */
 39 |         
 40 |   std::sort(trials.begin(),trials.end());
 41 |   return std::accumulate(
 42 |     trials.begin()+2,trials.end()-2,0.0)/(trials.size()-4)*1E6;
 43 | }
 44 |  
 45 | template<typename Size,typename F>
 46 | double measure(Size n,F f)
 47 | {
 48 |   return measure(f)/n;
 49 | }
 50 | 
 51 | void pause_timing()
 52 | {
 53 |   measure_pause=std::chrono::high_resolution_clock::now();
 54 | }
 55 |         
 56 | void resume_timing()
 57 | {
 58 |   measure_start+=std::chrono::high_resolution_clock::now()-measure_pause;
 59 | }
 60 | 
 61 | #include <algorithm>
 62 | #include <iostream>
 63 | #include <random>
 64 | 
 65 | struct particle
 66 | {
 67 |   int x,y,z;
 68 | };
 69 | 
 70 | using particle_aos=std::vector<particle>;
 71 | 
 72 | particle_aos create_particle_aos(int n)
 73 | {
 74 |   particle_aos res;
 75 |   res.reserve(n);
 76 |   for(int i=0;i<n;++i)res.push_back({i,i+1,i+2});
 77 |   return res;
 78 | }
 79 | 
 80 | struct particle_soa
 81 | {
 82 |   std::vector<int> x,y,z;
 83 | };
 84 | 
 85 | particle_soa create_particle_soa(int n)
 86 | {
 87 |   particle_soa res;
 88 |   res.x.reserve(n);
 89 |   res.y.reserve(n);
 90 |   res.z.reserve(n);
 91 |   for(int i=0;i<n;++i){
 92 |     res.x.push_back(i);
 93 |     res.y.push_back(i+1);
 94 |     res.z.push_back(i+2);
 95 |   }
 96 |   return res;
 97 | }
 98 | 
 99 | int main()
100 | {
101 |   std::size_t n0=10000,n1=40000000,dn=2000;
102 |   double      fdn=1.1;    
103 | 
104 |   std::cout<<"random access aos vs soa:"<<std::endl;
105 |   std::cout<<"n;aos;soa"<<std::endl;
106 |     
107 |   for(std::size_t n=n0;n<=n1;n+=dn,dn=(unsigned int)(dn*fdn)){
108 |     std::cout<<n<<";";
109 |     {
110 |       auto ps=create_particle_aos(n);
111 |       std::cout<<measure(n,[&](){
112 |         std::mt19937                    gen;
113 |         std::uniform_int_distribution<> rnd(0,n-1);
114 |         long int                        res=0;
115 |         for(std::size_t i=0;i<n;++i){
116 |           auto idx=rnd(gen);
117 |           res+=ps[idx].x+ps[idx].y+ps[idx].z;
118 |         }
119 |         return res;
120 |       })<<";";
121 |     }
122 |     {
123 |       auto ps=create_particle_soa(n);
124 |       std::cout<<measure(n,[&](){
125 |         std::mt19937                    gen;
126 |         std::uniform_int_distribution<> rnd(0,n-1);
127 |         long int                        res=0;
128 |         for(std::size_t i=0;i<n;++i){
129 |           auto idx=rnd(gen);
130 |           res+=ps.x[idx]+ps.y[idx]+ps.z[idx];
131 |         }
132 |         return res;
133 |       })<<"\n";
134 |     }
135 |   }
136 | }
137 | 


--------------------------------------------------------------------------------