├── cct.cc
└── mf.cc


/cct.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <stdlib.h>
  3 | #include <chrono>
  4 | #include <vector>
  5 | #include <sys/time.h>
  6 | 
  7 | using namespace std;
  8 | using namespace std::chrono;
  9 | 
 10 | const unsigned long N = 999983L;
 11 | static int vs[N];
 12 | static long counters[10];
 13 | 
 14 | long ms() {
 15 |   struct timeval tv;
 16 |   gettimeofday(&tv, NULL);
 17 |   return (tv.tv_sec % 86400) * 1000 + (tv.tv_usec/1000);
 18 | }
 19 | 
 20 | 
 21 | void do_s(int x) 
 22 | {
 23 |     switch (x) 
 24 |     {
 25 |     case 0: counters[0]++; break;
 26 |     case 3: counters[3]++; break;
 27 |     case 1: counters[1]++; break;
 28 |     case 9: counters[9]++; break;
 29 |     case 4: counters[4]++; break;
 30 |     case 5: counters[5]++; break;
 31 |     case 6: counters[6]++; break;
 32 |     case 2: counters[2]++; break;
 33 |     case 7: counters[7]++; break;
 34 |     case 8: counters[8]++; break;
 35 |     }
 36 | }
 37 | 
 38 | void s_lup(int n) 
 39 | {
 40 |     for (int i = 0; i < n; i++) 
 41 |     {
 42 |         do_s(vs[i % N]);
 43 |     }
 44 | }
 45 | 
 46 | class B 
 47 | {
 48 | public:
 49 |     virtual void inc() = 0;
 50 | };
 51 | 
 52 | static B* bs[N];
 53 | 
 54 | class D0 : public B 
 55 | {
 56 | public:
 57 |     virtual void inc() { counters[0]++; }
 58 | 	
 59 | };
 60 | class D1 : public B 
 61 | {
 62 | public:
 63 |     virtual void inc() { counters[1]++; }
 64 | 	
 65 | };
 66 | class D2 : public B 
 67 | {
 68 | public:
 69 |     virtual void inc() { counters[2]++; }
 70 | 	
 71 | };
 72 | class D3 : public B 
 73 | {
 74 | public:
 75 |     virtual void inc() { counters[3]++; }
 76 | 	
 77 | };
 78 | class D4 : public B 
 79 | {
 80 | public:
 81 |     virtual void inc() { counters[4]++; }
 82 | 	
 83 | };
 84 | class D5 : public B 
 85 | {
 86 | public:
 87 |     virtual void inc() { counters[5]++; }
 88 | 	
 89 | };
 90 | class D6 : public B 
 91 | {
 92 | public:
 93 |     virtual void inc() { counters[6]++; }
 94 | 	
 95 | };
 96 | class D7 : public B 
 97 | {
 98 | public:
 99 |     virtual void inc() { counters[7]++; }
100 | 	
101 | };
102 | class D8 : public B 
103 | {
104 | public:
105 |     virtual void inc() { counters[8]++; }
106 | 	
107 | };
108 | class D9 : public B 
109 | {
110 | public:
111 |     virtual void inc() { counters[9]++; }
112 | 	
113 | };
114 | 
115 | 
116 | void do_c(B* b) 
117 | {
118 |     b->inc();
119 | }
120 | 
121 | void c_lup(int n) 
122 | {
123 |     for (int i = 0; i < n; i++) 
124 |     {
125 |         do_c(bs[i % N]);
126 |     }
127 | }
128 | 
129 | int main(int ac, char** av)
130 | {
131 |     srand(time(nullptr));
132 | 
133 |     const auto n = atol(av[1]);
134 | 
135 |     for (auto i = 0; i < N; i++) 
136 |     {
137 |         auto rnd = rand() % 10;
138 |         vs[i] = rnd;
139 |         switch (rnd) {
140 |         	case 0: bs[i] = new D0();break;
141 |         	case 1: bs[i] = new D1();break;
142 |         	case 2: bs[i] = new D2();break;
143 |         	case 3: bs[i] = new D3();break;
144 |         	case 4: bs[i] = new D4();break;
145 |         	case 5: bs[i] = new D5();break;
146 |         	case 6: bs[i] = new D6();break;
147 |         	case 7: bs[i] = new D7();break;
148 |         	case 8: bs[i] = new D8();break;
149 |         	case 9: bs[i] = new D9();break;
150 | 			
151 |         }
152 | 		
153 |     }
154 | 
155 |    for (int i=0; i<10; i++) counters[i] = 0;
156 |     
157 |     auto start_s = ms();
158 |     s_lup(n);
159 |     auto end_s = ms();
160 | 
161 |     cout << "s-lup counts: " << endl;
162 |     for (const auto &count : counters)
163 |         cout << count << endl;
164 | 
165 |     for (int i=0; i<10; i++) counters[i] = 0;
166 | 
167 |     auto start_c = ms();
168 |     c_lup(n);
169 |     auto end_c = ms();
170 | 
171 |     cout << "c-lup counts: " << endl;
172 |     for (const auto& count : counters)
173 |         cout << count << endl;
174 | 
175 |     auto s_time = (end_s - start_s);
176 |     auto c_time = (end_c - start_c);
177 |     auto diff = (c_time - s_time);
178 |     auto s_ns = (s_time * 1000000.0) / n;
179 |     auto c_ns = (c_time * 1000000.0) / n;
180 |     auto diff_ns = (diff * 1000000.0) / n;
181 | 
182 |     printf("switch-ns: %g, class-ns: %g, diff-ns: %g, factor: %g\n", s_ns, c_ns, diff_ns, c_ns / s_ns);
183 | }


--------------------------------------------------------------------------------
/mf.cc:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <stdlib.h>
  3 | #include <chrono>
  4 | #include <vector>
  5 | #include <sys/time.h>
  6 | 
  7 | using namespace std;
  8 | using namespace std::chrono;
  9 | 
 10 | const unsigned long N = 999983L;
 11 | 
 12 | long ms() {
 13 |   struct timeval tv;
 14 |   gettimeofday(&tv, NULL);
 15 |   return (tv.tv_sec % 86400) * 1000 + (tv.tv_usec/1000);
 16 | }
 17 | 
 18 | long counter[16];
 19 | 
 20 | void clearCounters() {
 21 | 	for (int i=0; i<16; i++)
 22 | 		counter[i] = 0;
 23 | }
 24 | 
 25 | enum Type {a,b,c,d};
 26 | 
 27 | class B {
 28 | public:
 29 | 	virtual void op1() = 0;
 30 | 	virtual void op2() = 0;
 31 | 	virtual void op3() = 0;
 32 | 	virtual void op4() = 0;	
 33 | };
 34 | 
 35 | static B* bs[N];
 36 | static Type ts[N];
 37 | 
 38 | 
 39 | class D0 : public B {
 40 | 	virtual void op1() {counter[0]++;}
 41 | 	virtual void op2() {counter[4]++;}
 42 | 	virtual void op3() {counter[8]++;}
 43 | 	virtual void op4() {counter[12]++;}
 44 | };
 45 | 
 46 | class D1 : public B {
 47 | 	virtual void op1() {counter[1]++;}
 48 | 	virtual void op2() {counter[5]++;}
 49 | 	virtual void op3() {counter[9]++;}
 50 | 	virtual void op4() {counter[13]++;}
 51 | };
 52 | 
 53 | class D2 : public B {
 54 | 	virtual void op1() {counter[2]++;}
 55 | 	virtual void op2() {counter[6]++;}
 56 | 	virtual void op3() {counter[10]++;}
 57 | 	virtual void op4() {counter[14]++;}
 58 | };
 59 | 
 60 | class D3 : public B {
 61 | 	virtual void op1() {counter[3]++;}
 62 | 	virtual void op2() {counter[7]++;}
 63 | 	virtual void op3() {counter[11]++;}
 64 | 	virtual void op4() {counter[15]++;}
 65 | };
 66 | 
 67 | void inline switchOp1(Type t) {
 68 | 	switch(t) {
 69 | 		case a: counter[0]++;break;
 70 | 		case b: counter[1]++;break;
 71 | 		case c: counter[2]++;break;
 72 | 		case d: counter[3]++;break;
 73 | 	}
 74 | }
 75 | 
 76 | void inline switchOp2(Type t) {
 77 | 	switch(t) {
 78 | 		case a: counter[4]++;break;
 79 | 		case b: counter[5]++;break;
 80 | 		case c: counter[6]++;break;
 81 | 		case d: counter[7]++;break;
 82 | 	}
 83 | }
 84 | 
 85 | void inline switchOp3(Type t) {
 86 | 	switch(t) {
 87 | 		case a: counter[8]++;break;
 88 | 		case b: counter[9]++;break;
 89 | 		case c: counter[10]++;break;
 90 | 		case d: counter[11]++;break;
 91 | 	}
 92 | }
 93 | 
 94 | void inline switchOp4(Type t) {
 95 | 	switch(t) {
 96 | 		case a: counter[12]++;break;
 97 | 		case b: counter[13]++;break;
 98 | 		case c: counter[14]++;break;
 99 | 		case d: counter[15]++;break;
100 | 	}
101 | }
102 | 
103 | void do_s(Type t) {
104 | 	switchOp1(t);
105 | 	switchOp2(t);
106 | 	switchOp3(t);
107 | 	switchOp4(t);
108 | }
109 | 
110 | void do_c(B* b) {
111 | 	b->op1();
112 | 	b->op2();
113 | 	b->op3();
114 | 	b->op4();
115 | }
116 | 
117 | void loadBsArray() {
118 | 	for (int i=0; i<N; i++) {
119 | 		int r = rand() % 4;
120 | 		switch(r) {
121 | 			case 0: bs[i] = new D0();break;
122 | 			case 1: bs[i] = new D1();break;
123 | 			case 2: bs[i] = new D2();break;
124 | 			case 3: bs[i] = new D3();break;
125 | 		}
126 | 	}
127 | }
128 | 
129 | void loadTsArray() {
130 | 	for (int i=0; i<N; i++) {
131 | 		int r = rand() % 4;
132 | 		switch(r) {
133 | 			case 0: ts[i] = a;break;
134 | 			case 1: ts[i] = b;break;
135 | 			case 2: ts[i] = c;break;
136 | 			case 3: ts[i] = d;break;
137 | 		}
138 | 	}
139 | }
140 | 
141 | void s_lup(int n) 
142 | {
143 |     for (int i = 0; i < n; i++) 
144 |     {
145 |         do_s(ts[i % N]);
146 |     }
147 | }
148 | 
149 | void c_lup(int n) 
150 | {
151 |     for (int i = 0; i < n; i++) 
152 |     {
153 |         do_c(bs[i % N]);
154 |     }
155 | }
156 | 
157 | int main(int ac, char** av)
158 | {
159 | 	srand(time(nullptr));
160 | 
161 |     const auto n = atol(av[1]);
162 | 
163 | 	loadBsArray();
164 | 	loadTsArray();
165 |    
166 |    	clearCounters();
167 |     
168 |     auto start_s = ms();
169 |     s_lup(n);
170 |     auto end_s = ms();
171 | 
172 |     cout << "s-lup counts: " << endl;
173 |     for (const auto &count : counter)
174 |         cout << count << endl;
175 | 
176 |     clearCounters();
177 | 
178 |     auto start_c = ms();
179 |     c_lup(n);
180 |     auto end_c = ms();
181 | 
182 |     cout << "c-lup counts: " << endl;
183 |     for (const auto& count : counter)
184 |         cout << count << endl;
185 | 
186 |     auto s_time = (end_s - start_s);
187 |     auto c_time = (end_c - start_c);
188 |     auto diff = (c_time - s_time);
189 |     auto s_ns = (s_time * 1000000.0) / n;
190 |     auto c_ns = (c_time * 1000000.0) / n;
191 |     auto diff_ns = (diff * 1000000.0) / n;
192 | 
193 |     printf("switch-ns: %g, class-ns: %g, diff-ns: %g, factor: %g\n", s_ns, c_ns, diff_ns, c_ns / s_ns);
194 | }
195 | 


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