79a35943 |
1 | // Created on: 2014-04-16 |
2 | // Created by: Denis BOGOLEPOV |
3 | // Copyright (c) 2014 OPEN CASCADE SAS |
4 | // |
5 | // This file is part of Open CASCADE Technology software library. |
6 | // |
7 | // This library is free software; you can redistribute it and/or modify it under |
8 | // the terms of the GNU Lesser General Public License version 2.1 as published |
9 | // by the Free Software Foundation, with special exception defined in the file |
10 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
11 | // distribution for complete text of the license and disclaimer of any warranty. |
12 | // |
13 | // Alternatively, this file may be used under the terms of Open CASCADE |
14 | // commercial license or contractual agreement. |
15 | |
16 | #include <QANCollection.hxx> |
17 | #include <Draw_Interpretor.hxx> |
18 | |
19 | #include <NCollection_Array1.hxx> |
20 | #include <NCollection_List.hxx> |
21 | #include <NCollection_Sequence.hxx> |
22 | #include <NCollection_Vector.hxx> |
23 | #include <NCollection_Map.hxx> |
24 | #include <NCollection_DataMap.hxx> |
25 | #include <NCollection_IndexedMap.hxx> |
26 | #include <NCollection_IndexedDataMap.hxx> |
27 | #include <Standard_Assert.hxx> |
28 | #include <OSD_Timer.hxx> |
29 | |
30 | #ifdef HAVE_TBB |
31 | // On Windows, function TryEnterCriticalSection has appeared in Windows NT |
32 | // and is surrounded by #ifdef in MS VC++ 7.1 headers. |
33 | // Thus to use it we need to define appropriate macro saying that we will |
34 | // run on Windows NT 4.0 at least |
35 | #if ((defined(_WIN32) || defined(__WIN32__)) && !defined(_WIN32_WINNT)) |
36 | #define _WIN32_WINNT 0x0501 |
37 | #endif |
38 | |
39 | #include <tbb/tbb.h> |
40 | #include <tbb/parallel_for.h> |
41 | #endif |
42 | |
43 | #include <algorithm> |
44 | #include <list> |
45 | #include <set> |
46 | #include <typeinfo> |
47 | #include <vector> |
48 | |
49 | //! Size of test data sets. |
50 | const int THE_TEST_SIZE = 5000; |
51 | |
52 | namespace { |
53 | // Auxiliary class to use in std::random_shuffle() |
54 | struct RandomGenerator { |
55 | RandomGenerator () { srand(1); } |
56 | int operator () (int upper) const { return rand() % upper; } |
57 | }; |
58 | } |
59 | |
60 | template<class CollectionType, class StlType> |
61 | struct CollectionFiller |
62 | { |
63 | static void Perform (CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE) |
64 | { |
65 | *theCollec = new CollectionType(); |
66 | srand(1); |
67 | for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx) |
68 | { |
69 | (*theCollec)->Append (rand()); |
70 | } |
71 | } |
72 | |
73 | static void Perform (StlType** theVector, |
74 | CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE) |
75 | { |
76 | CollectionFiller::Perform (theCollec, theSize); |
77 | |
78 | *theVector = new StlType ((*theCollec)->begin(), (*theCollec)->end()); |
79 | } |
80 | }; |
81 | |
82 | template<class T, typename StlType> |
83 | struct CollectionFiller<NCollection_Array1<T>, StlType> |
84 | { |
85 | static void Perform (NCollection_Array1<T>** theCollec, |
86 | Standard_Integer theSize = THE_TEST_SIZE) |
87 | { |
88 | *theCollec = new NCollection_Array1<T> (0, theSize - 1); |
89 | srand (1); |
90 | for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx) |
91 | { |
92 | (*theCollec)->ChangeValue (anIdx) = rand(); |
93 | } |
94 | } |
95 | |
96 | static void Perform (StlType** theVector, |
97 | NCollection_Array1<T>** theCollec, Standard_Integer theSize = THE_TEST_SIZE) |
98 | { |
99 | CollectionFiller<NCollection_Array1<T>, StlType >::Perform (theCollec, theSize); |
100 | |
101 | *theVector = new StlType ((*theCollec)->begin(), (*theCollec)->end()); |
102 | } |
103 | }; |
104 | |
105 | template<class CollectionType, class T> |
106 | struct MapFiller |
107 | { |
108 | static void Perform (CollectionType** theCollec, Standard_Integer theSize = THE_TEST_SIZE) |
109 | { |
110 | *theCollec = new CollectionType(); |
111 | srand(1); |
112 | for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx) |
113 | { |
114 | (*theCollec)->Add (rand()); |
115 | } |
116 | } |
117 | }; |
118 | |
119 | template<class T> |
120 | struct MapFiller<NCollection_DataMap<T, T>, T> |
121 | { |
122 | static void Perform (NCollection_DataMap<T, T>** theCollec1, |
123 | NCollection_DataMap<T, T>** theCollec2 = NULL, Standard_Integer theSize = THE_TEST_SIZE) |
124 | { |
125 | *theCollec1 = new NCollection_DataMap<T, T>(); |
126 | |
127 | if (theCollec2 != NULL) |
128 | *theCollec2 = new NCollection_DataMap<T, T>(); |
129 | srand(1); |
130 | for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx) |
131 | { |
132 | const T aVal1 = rand(); |
133 | const T aVal2 = rand(); |
134 | |
135 | (*theCollec1)->Bind (aVal1, aVal2); |
136 | |
137 | if (theCollec2 != NULL) |
138 | (*theCollec2)->Bind (aVal1, aVal2); |
139 | } |
140 | } |
141 | }; |
142 | |
143 | template<class T> |
144 | struct MapFiller<NCollection_IndexedDataMap<T, T>, T> |
145 | { |
146 | static void Perform (NCollection_IndexedDataMap<T, T>** theCollec1, |
147 | NCollection_IndexedDataMap<T, T>** theCollec2 = NULL, Standard_Integer theSize = THE_TEST_SIZE) |
148 | { |
149 | *theCollec1 = new NCollection_IndexedDataMap<T, T>(); |
150 | |
151 | if (theCollec2 != NULL) |
152 | *theCollec2 = new NCollection_IndexedDataMap<T, T>(); |
153 | srand(1); |
154 | for (Standard_Integer anIdx = 0; anIdx < theSize; ++anIdx) |
155 | { |
156 | const T aVal1 = rand(); |
157 | const T aVal2 = rand(); |
158 | |
159 | (*theCollec1)->Add (aVal1, aVal2); |
160 | |
161 | if (theCollec2 != NULL) |
162 | (*theCollec2)->Add (aVal1, aVal2); |
163 | } |
164 | } |
165 | }; |
166 | |
167 | //======================================================================= |
168 | //function : TestIteration |
169 | //purpose : |
170 | //======================================================================= |
171 | template<class CollectionType, class StlType> |
172 | Standard_Boolean TestIteration() |
173 | { |
174 | StlType* aVector (NULL); |
175 | CollectionType* aCollec (NULL); |
176 | |
177 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
178 | |
179 | typename StlType::iterator aVecIter = aVector->begin(); |
180 | typename CollectionType::iterator aColIter = aCollec->begin(); |
181 | |
182 | Standard_Boolean aResult (Standard_True); |
183 | |
184 | for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter) |
185 | { |
186 | if (*aVecIter != *aColIter) |
187 | aResult = Standard_False; |
188 | } |
189 | |
190 | if (aColIter != aCollec->end()) |
191 | { |
192 | aResult = Standard_False; |
193 | } |
194 | |
195 | delete aVector; |
196 | delete aCollec; |
197 | |
198 | return aResult; |
199 | } |
200 | |
201 | //======================================================================= |
202 | //function : TestMinMax |
203 | //purpose : |
204 | //======================================================================= |
205 | template<class CollectionType, class StlType> |
206 | Standard_Boolean TestMinMax() |
207 | { |
208 | StlType* aVector (NULL); |
209 | CollectionType* aCollec (NULL); |
210 | |
211 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
212 | |
213 | typename StlType::value_type aValue1 = *std::min_element (aVector->begin(), aVector->end()); |
214 | typename CollectionType::value_type aValue2 = *std::min_element (aCollec->begin(), aCollec->end()); |
215 | |
216 | Standard_Boolean aResult (Standard_True); |
217 | |
218 | if (aValue1 != aValue2) |
219 | aResult = Standard_False; |
220 | |
221 | aValue1 = *std::max_element (aVector->begin(), aVector->end()); |
222 | aValue2 = *std::max_element (aCollec->begin(), aCollec->end()); |
223 | |
224 | if (aValue1 != aValue2) |
225 | aResult = Standard_False; |
226 | |
227 | delete aVector; |
228 | delete aCollec; |
229 | |
230 | return aResult; |
231 | } |
232 | |
233 | //======================================================================= |
234 | //function : TestReplace |
235 | //purpose : |
236 | //======================================================================= |
237 | template<class CollectionType, class StlType> |
238 | Standard_Boolean TestReplace() |
239 | { |
240 | StlType* aVector (NULL); |
241 | CollectionType* aCollec (NULL); |
242 | |
243 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
244 | |
245 | const typename StlType::value_type aValue = aVector->back(); |
246 | |
247 | std::replace (aVector->begin(), aVector->end(), aValue, static_cast<typename StlType::value_type> (-1)); |
248 | std::replace (aCollec->begin(), aCollec->end(), aValue, static_cast<typename CollectionType::value_type> (-1)); |
249 | |
250 | typename StlType::iterator aVecIter = aVector->begin(); |
251 | typename CollectionType::iterator aColIter = aCollec->begin(); |
252 | |
253 | Standard_Boolean aResult (Standard_True); |
254 | |
255 | for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter) |
256 | { |
257 | if (*aVecIter != *aColIter) |
258 | aResult = Standard_False; |
259 | } |
260 | |
261 | if (aColIter != aCollec->end()) |
262 | { |
263 | aResult = Standard_False; |
264 | } |
265 | |
266 | delete aVector; |
267 | delete aCollec; |
268 | |
269 | return aResult; |
270 | } |
271 | |
272 | //======================================================================= |
273 | //function : TestReverse |
274 | //purpose : |
275 | //======================================================================= |
276 | template<class CollectionType, class StlType> |
277 | Standard_Boolean TestReverse() |
278 | { |
279 | StlType* aVector (NULL); |
280 | CollectionType* aCollec (NULL); |
281 | |
282 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
283 | |
284 | std::reverse (aVector->begin(), aVector->end()); |
285 | std::reverse (aCollec->begin(), aCollec->end()); |
286 | |
287 | typename StlType::iterator aVecIter = aVector->begin(); |
288 | typename CollectionType::iterator aColIter = aCollec->begin(); |
289 | |
290 | Standard_Boolean aResult (Standard_True); |
291 | |
292 | for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter) |
293 | { |
294 | if (*aVecIter != *aColIter) |
295 | aResult = Standard_False; |
296 | } |
297 | |
298 | if (aColIter != aCollec->end()) |
299 | { |
300 | aResult = Standard_False; |
301 | } |
302 | |
303 | delete aVector; |
304 | delete aCollec; |
305 | |
306 | return aResult; |
307 | } |
308 | |
309 | //======================================================================= |
310 | //function : TestSort |
311 | //purpose : |
312 | //======================================================================= |
313 | template<class CollectionType, class StlType> |
314 | Standard_Boolean TestSort() |
315 | { |
316 | StlType* aVector (NULL); |
317 | CollectionType* aCollec (NULL); |
318 | |
319 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
320 | |
321 | std::sort (aVector->begin(), aVector->end()); |
322 | std::sort (aCollec->begin(), aCollec->end()); |
323 | |
324 | typename StlType::iterator aVecIter = aVector->begin(); |
325 | typename CollectionType::iterator aColIter = aCollec->begin(); |
326 | |
327 | Standard_Boolean aResult (Standard_True); |
328 | |
329 | for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter) |
330 | { |
331 | if (*aVecIter != *aColIter) |
332 | aResult = Standard_False; |
333 | } |
334 | |
335 | if (aColIter != aCollec->end()) |
336 | { |
337 | aResult = Standard_False; |
338 | } |
339 | |
340 | delete aVector; |
341 | delete aCollec; |
342 | |
343 | return aResult; |
344 | } |
345 | |
346 | #ifdef HAVE_TBB |
347 | |
348 | template <typename T> |
349 | struct Invoker |
350 | { |
351 | void operator()(T& theValue) const |
352 | { |
353 | theValue *= 2; |
354 | } |
355 | }; |
356 | |
357 | //======================================================================= |
358 | //function : TestTBB |
359 | //purpose : |
360 | //======================================================================= |
361 | template<class CollectionType, class StlType> |
362 | Standard_Boolean TestTBB() |
363 | { |
364 | StlType* aVector (NULL); |
365 | CollectionType* aCollec (NULL); |
366 | |
367 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec); |
368 | |
369 | tbb::parallel_for_each (aVector->begin(), aVector->end(), Invoker<typename StlType::value_type>()); |
370 | tbb::parallel_for_each (aCollec->begin(), aCollec->end(), Invoker<typename CollectionType::value_type>()); |
371 | |
372 | typename StlType::iterator aVecIter = aVector->begin(); |
373 | typename CollectionType::iterator aColIter = aCollec->begin(); |
374 | |
375 | Standard_Boolean aResult (Standard_True); |
376 | |
377 | for (; aVecIter != aVector->end(); ++aVecIter, ++aColIter) |
378 | { |
379 | if (*aVecIter != *aColIter) |
380 | aResult = Standard_False; |
381 | } |
382 | |
383 | if (aColIter != aCollec->end()) |
384 | { |
385 | aResult = Standard_False; |
386 | } |
387 | |
388 | delete aVector; |
389 | delete aCollec; |
390 | |
391 | return aResult; |
392 | } |
393 | |
394 | //======================================================================= |
395 | //function : TestDataMapTBB |
396 | //purpose : |
397 | //======================================================================= |
398 | template<class CollectionType, class T> |
399 | Standard_Boolean TestDataMapTBB() |
400 | { |
401 | CollectionType* aCollec1 (NULL); |
402 | CollectionType* aCollec2 (NULL); |
403 | |
404 | MapFiller<CollectionType, T>::Perform (&aCollec1, &aCollec2); |
405 | |
406 | tbb::parallel_for_each (aCollec1->begin(), aCollec1->end(), Invoker<T>()); |
407 | |
408 | // create OCCT-style iterator |
409 | typename CollectionType::Iterator aOccIter (*aCollec2); |
410 | |
411 | // create STL-compatible iterator |
412 | typename CollectionType::const_iterator aStlIter = aCollec1->cbegin(); |
413 | |
414 | Standard_Boolean aResult (Standard_True); |
415 | |
416 | for (; aStlIter != aCollec1->cend(); ++aStlIter, aOccIter.Next()) |
417 | { |
418 | if (static_cast<T> (2) * aOccIter.Value() != *aStlIter) |
419 | aResult = Standard_False; |
420 | } |
421 | |
422 | if (aOccIter.More()) |
423 | { |
424 | aResult = Standard_False; |
425 | } |
426 | |
427 | delete aCollec1; |
428 | delete aCollec2; |
429 | |
430 | return aResult; |
431 | } |
432 | |
433 | #endif |
434 | |
435 | //======================================================================= |
436 | //function : TestMapIteration |
437 | //purpose : |
438 | //======================================================================= |
439 | template<class CollectionType, class T> |
440 | Standard_Boolean TestMapIteration() |
441 | { |
442 | CollectionType* aCollec (NULL); |
443 | |
444 | MapFiller<CollectionType, T>::Perform (&aCollec); |
445 | |
446 | // create OCCT-style iterator |
447 | typename CollectionType::Iterator aOccIter (*aCollec); |
448 | |
449 | // create STL-compatible iterator |
450 | typename CollectionType::const_iterator aStlIter = aCollec->cbegin(); |
451 | |
452 | Standard_Boolean aResult (Standard_True); |
453 | |
454 | for (; aStlIter != aCollec->cend(); ++aStlIter, aOccIter.Next()) |
455 | { |
456 | if (aOccIter.Value() != *aStlIter) |
457 | aResult = Standard_False; |
458 | } |
459 | |
460 | if (aOccIter.More()) |
461 | { |
462 | aResult = Standard_False; |
463 | } |
464 | |
465 | delete aCollec; |
466 | |
467 | return aResult; |
468 | } |
469 | |
470 | //======================================================================= |
471 | //function : TestForwardIterator |
472 | //purpose : test basic features of iterator (forward) |
473 | //======================================================================= |
474 | template <class CollectionType> |
475 | void TestForwardIterator () |
476 | { |
477 | CollectionType* aCollec (NULL); |
478 | |
479 | CollectionFiller<CollectionType, void>::Perform (&aCollec); |
480 | |
481 | // test non-const iteration |
482 | typename CollectionType::iterator it = aCollec->begin(); // copy construction |
483 | typename CollectionType::iterator it2; // default constructor |
484 | it2 = it; // assignment |
485 | it2 = it++; // postfix increment |
486 | if (it2 == it || ! (it2 != it)) |
487 | std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl; |
488 | it2 = ++it; // prefix increment |
489 | if (it2 != it || ! (it2 == it)) |
490 | std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl; |
491 | |
492 | typename CollectionType::iterator::value_type t = *it; |
493 | *it2 = t; |
494 | *(it2.operator-> ()) = t; |
495 | |
496 | // test const iteration |
497 | typename CollectionType::const_iterator cit = aCollec->cbegin(); // copy construction |
498 | typename CollectionType::const_iterator cit2; // default constructor |
499 | cit2 = cit; // assignment |
500 | cit2 = cit++; // postfix increment |
501 | if (cit2 == cit || ! (cit2 != cit)) |
502 | std::cout << "Failed " << typeid(cit).name() << " equality check" << std::endl; |
503 | cit2 = ++cit; // prefix increment |
504 | if (cit2 != it || ! (cit2 == cit)) |
505 | std::cout << "Failed " << typeid(cit).name() << " equality check" << std::endl; |
506 | |
507 | typename CollectionType::const_iterator::value_type ct = *cit; |
508 | ct = *cit; |
509 | // *cit2 = ct; |
510 | // *(cit2.operator-> ()) = t; |
511 | |
512 | delete aCollec; |
513 | } |
514 | |
515 | //======================================================================= |
516 | //function : TestBidirIterator |
517 | //purpose : test features of bidirectional iterator |
518 | //======================================================================= |
519 | template <class CollectionType> |
520 | void TestBidirIterator () |
521 | { |
522 | CollectionType* aCollec (NULL); |
523 | |
524 | CollectionFiller<CollectionType, void>::Perform (&aCollec); |
525 | |
526 | // test non-const iteration |
527 | typename CollectionType::iterator it = aCollec->end(); // copy construction |
528 | typename CollectionType::iterator it2 = it--; // postfix decrement |
529 | if (it2 == it || ! (it2 != it)) |
530 | std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl; |
531 | it2 = --it; // prefix decrement |
532 | if (it2 != it || ! (it2 == it)) |
533 | std::cout << "Failed " << typeid(it).name() << " equality check" << std::endl; |
534 | |
535 | delete aCollec; |
536 | } |
537 | |
538 | //======================================================================= |
539 | //function : TestRandomIterator |
540 | //purpose : test features of random iterator |
541 | //======================================================================= |
542 | template <class CollectionType> |
543 | void TestRandomIterator () |
544 | { |
545 | CollectionType* aCollec (NULL); |
546 | |
547 | CollectionFiller<CollectionType, void>::Perform (&aCollec); |
548 | |
549 | // test non-const iteration |
550 | typename CollectionType::iterator it = aCollec->begin(); // copy construction |
551 | typename CollectionType::iterator it2 = it + 5; |
552 | if ((it2 - it) != 5) |
553 | std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl; |
554 | if (it2 < it || it2 <= it || ! (it2 > it) || ! (it2 >= it)) |
555 | std::cout << "Failed " << typeid(it).name() << " comparison" << std::endl; |
556 | it += 5; |
557 | if (it2 != it) |
558 | std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl; |
559 | it2 = it - 5; |
560 | if ((it2 - it) != -5) |
561 | std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl; |
562 | if (it2 > it || it2 >= it || ! (it2 < it) || ! (it2 <= it)) |
563 | std::cout << "Failed " << typeid(it).name() << " comparison" << std::endl; |
564 | it -= 5; |
565 | if (it2 != it) |
566 | std::cout << "Failed " << typeid(it).name() << " arithmetics" << std::endl; |
567 | |
568 | typename CollectionType::value_type t = it[5]; // offset dereference |
569 | *it = t; |
570 | |
571 | delete aCollec; |
572 | } |
573 | |
574 | //======================================================================= |
575 | //function : QANListStlIterator |
576 | //purpose : |
577 | //======================================================================= |
578 | static Standard_Integer QANListStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
579 | { |
580 | // compile-time tests |
581 | TestForwardIterator <NCollection_List<Standard_Integer> >(); |
582 | |
583 | // run-time tests |
584 | Standard_Boolean aResult = TestIteration<NCollection_List<int>, std::list<int> >(); |
585 | std::cout << "NCollection_List<int> Iteration: " << |
586 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
587 | |
588 | aResult = TestIteration<NCollection_List<double>, std::list<double> >(); |
589 | std::cout << "NCollection_List<double> Iteration: " << |
590 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
591 | |
592 | aResult = TestMinMax<NCollection_List<int>, std::list<int> >(); |
593 | std::cout << "NCollection_List<int> Min-Max: " << |
594 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
595 | |
596 | aResult = TestMinMax<NCollection_List<double>, std::list<double> >(); |
597 | std::cout << "NCollection_List<double> Min-Max: " << |
598 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
599 | |
600 | aResult = TestReplace<NCollection_List<int>, std::list<int> >(); |
601 | std::cout << "NCollection_List<int> Replace: " << |
602 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
603 | |
604 | aResult = TestReplace<NCollection_List<double>, std::list<double> >(); |
605 | std::cout << "NCollection_List<double> Replace: " << |
606 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
607 | |
608 | #ifdef HAVE_TBB |
609 | |
610 | aResult = TestTBB<NCollection_List<int>, std::list<int> >(); |
611 | std::cout << "NCollection_List<int> TBB: " << |
612 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
613 | |
614 | aResult = TestTBB<NCollection_List<double>, std::list<double> >(); |
615 | std::cout << "NCollection_List<double> TBB: " << |
616 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
617 | |
618 | #endif |
619 | |
620 | return 0; |
621 | } |
622 | |
623 | //======================================================================= |
624 | //function : QANMapStlIterator |
625 | //purpose : |
626 | //======================================================================= |
627 | static Standard_Integer QANMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
628 | { |
629 | // compile-time tests |
630 | // TestForwardIterator <NCollection_Map<Standard_Integer> >(); |
631 | |
632 | // run-time tests |
633 | Standard_Boolean aResult = TestMapIteration<NCollection_Map<Standard_Integer>, Standard_Integer>(); |
634 | std::cout << "NCollection_Map<int> Iteration: " << |
635 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
636 | |
637 | aResult = TestMapIteration<NCollection_Map<Standard_Real>, Standard_Real>(); |
638 | std::cout << "NCollection_Map<double> Iteration: " << |
639 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
640 | |
641 | return 0; |
642 | } |
643 | |
644 | //======================================================================= |
645 | //function : QANIndexedMapStlIterator |
646 | //purpose : |
647 | //======================================================================= |
648 | static Standard_Integer QANIndexedMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
649 | { |
650 | // compile-time tests |
651 | // TestForwardIterator <NCollection_IndexedMap<Standard_Integer> >(); |
652 | // TestBidirIterator <NCollection_IndexedMap<Standard_Integer> >(); |
653 | |
654 | // run-time tests |
655 | Standard_Boolean aResult = TestMapIteration<NCollection_IndexedMap<Standard_Integer>, Standard_Integer>(); |
656 | std::cout << "NCollection_IndexedMap<int> Iteration: " << |
657 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
658 | |
659 | aResult = TestMapIteration<NCollection_IndexedMap<Standard_Real>, Standard_Real>(); |
660 | std::cout << "NCollection_IndexedMap<double> Iteration: " << |
661 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
662 | |
663 | return 0; |
664 | } |
665 | |
666 | //======================================================================= |
667 | //function : QANDataMapStlIterator |
668 | //purpose : |
669 | //======================================================================= |
670 | static Standard_Integer QANDataMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
671 | { |
672 | // compile-time tests |
673 | // TestForwardIterator <NCollection_DataMap<int, int> >(); |
674 | // TestBidirIterator <NCollection_DataMap<int, int> >(); |
675 | |
676 | // run-time tests |
677 | Standard_Boolean aResult = TestMapIteration<NCollection_DataMap<Standard_Integer, Standard_Integer>, Standard_Integer>(); |
678 | std::cout << "NCollection_DataMap<int> Iteration: " << |
679 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
680 | |
681 | aResult = TestMapIteration<NCollection_DataMap<Standard_Real, Standard_Real>, Standard_Real>(); |
682 | std::cout << "NCollection_DataMap<double> Iteration: " << |
683 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
684 | |
685 | #ifdef HAVE_TBB |
686 | |
687 | aResult = TestDataMapTBB<NCollection_DataMap<Standard_Integer, Standard_Integer>, Standard_Integer>(); |
688 | std::cout << "NCollection_DataMap<int> TBB: " << |
689 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
690 | |
691 | aResult = TestDataMapTBB<NCollection_DataMap<Standard_Real, Standard_Real>, Standard_Real>(); |
692 | std::cout << "NCollection_DataMap<double> TBB: " << |
693 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
694 | |
695 | #endif |
696 | |
697 | return 0; |
698 | } |
699 | |
700 | //======================================================================= |
701 | //function : QANIndexedDataMapStlIterator |
702 | //purpose : |
703 | //======================================================================= |
704 | static Standard_Integer QANIndexedDataMapStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
705 | { |
706 | // compile-time tests |
707 | // TestForwardIterator <NCollection_IndexedDataMap<int, int> >(); |
708 | // TestBidirIterator <NCollection_IndexedDataMap<int, int> >(); |
709 | |
710 | // run-time tests |
711 | Standard_Boolean aResult = TestMapIteration<NCollection_IndexedDataMap<Standard_Integer, Standard_Integer>, Standard_Integer>(); |
712 | std::cout << "NCollection_IndexedDataMap<int> Iteration: " << |
713 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
714 | |
715 | aResult = TestMapIteration<NCollection_IndexedDataMap<Standard_Real, Standard_Real>, Standard_Real>(); |
716 | std::cout << "NCollection_IndexedDataMap<double> Iteration: " << |
717 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
718 | |
719 | #ifdef HAVE_TBB |
720 | |
721 | aResult = TestDataMapTBB<NCollection_IndexedDataMap<Standard_Integer, Standard_Integer>, Standard_Integer>(); |
722 | std::cout << "NCollection_IndexedDataMap<int> TBB: " << |
723 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
724 | |
725 | aResult = TestDataMapTBB<NCollection_IndexedDataMap<Standard_Real, Standard_Real>, Standard_Real>(); |
726 | std::cout << "NCollection_IndexedDataMap<double> TBB: " << |
727 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
728 | |
729 | #endif |
730 | |
731 | return 0; |
732 | } |
733 | |
734 | //======================================================================= |
735 | //function : QANSequenceStlIterator |
736 | //purpose : |
737 | //======================================================================= |
738 | static Standard_Integer QANSequenceStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
739 | { |
740 | // compile-time tests |
741 | TestForwardIterator <NCollection_Sequence<int> >(); |
742 | TestBidirIterator <NCollection_Sequence<int> >(); |
743 | |
744 | // run-time tests |
745 | Standard_Boolean aResult = TestIteration<NCollection_Sequence<int>, std::list<int> >(); |
746 | std::cout << "NCollection_Sequence<int> Iteration: " << |
747 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
748 | |
749 | aResult = TestIteration<NCollection_Sequence<double>, std::list<double> >(); |
750 | std::cout << "NCollection_Sequence<double> Iteration: " << |
751 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
752 | |
753 | aResult = TestMinMax<NCollection_Sequence<int>, std::list<int> >(); |
754 | std::cout << "NCollection_Sequence<int> Min-Max: " << |
755 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
756 | |
757 | aResult = TestMinMax<NCollection_Sequence<double>, std::list<double> >(); |
758 | std::cout << "NCollection_Sequence<double> Min-Max: " << |
759 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
760 | |
761 | aResult = TestReplace<NCollection_Sequence<int>, std::list<int> >(); |
762 | std::cout << "NCollection_Sequence<int> Replace: " << |
763 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
764 | |
765 | aResult = TestReplace<NCollection_Sequence<double>, std::list<double> >(); |
766 | std::cout << "NCollection_Sequence<double> Replace: " << |
767 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
768 | |
769 | aResult = TestReverse<NCollection_Sequence<int>, std::list<int> >(); |
770 | std::cout << "NCollection_Sequence<int> Reverse: " << |
771 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
772 | |
773 | aResult = TestReverse<NCollection_Sequence<double>, std::list<double> >(); |
774 | std::cout << "NCollection_Sequence<double> Reverse: " << |
775 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
776 | |
777 | #ifdef HAVE_TBB |
778 | |
779 | aResult = TestTBB<NCollection_Sequence<int>, std::list<int> >(); |
780 | std::cout << "NCollection_Sequence<int> TBB: " << |
781 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
782 | |
783 | aResult = TestTBB<NCollection_Sequence<double>, std::list<double> >(); |
784 | std::cout << "NCollection_Sequence<double> TBB: " << |
785 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
786 | |
787 | #endif |
788 | |
789 | return 0; |
790 | } |
791 | |
792 | //======================================================================= |
793 | //function : QANVectorStlIterator |
794 | //purpose : |
795 | //======================================================================= |
796 | static Standard_Integer QANVectorStlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
797 | { |
798 | // compile-time tests |
799 | TestForwardIterator <NCollection_Vector<int> >(); |
800 | TestBidirIterator <NCollection_Vector<int> >(); |
801 | TestRandomIterator <NCollection_Vector<int> >(); |
802 | |
803 | // run-time tests |
804 | Standard_Boolean aResult = TestIteration<NCollection_Vector<int>, std::vector<int> >(); |
805 | std::cout << "NCollection_Vector<int> Iteration: " << |
806 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
807 | |
808 | aResult = TestIteration<NCollection_Vector<double>, std::vector<double> >(); |
809 | std::cout << "NCollection_Vector<double> Iteration: " << |
810 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
811 | |
812 | aResult = TestMinMax<NCollection_Vector<int>, std::vector<int> >(); |
813 | std::cout << "NCollection_Vector<int> Min-Max: " << |
814 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
815 | |
816 | aResult = TestMinMax<NCollection_Vector<double>, std::vector<double> >(); |
817 | std::cout << "NCollection_Vector<double> Min-Max: " << |
818 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
819 | |
820 | aResult = TestReplace<NCollection_Vector<int>, std::vector<int> >(); |
821 | std::cout << "NCollection_Vector<int> Replace: " << |
822 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
823 | |
824 | aResult = TestReplace<NCollection_Vector<double>, std::vector<double> >(); |
825 | std::cout << "NCollection_Vector<double> Replace: " << |
826 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
827 | |
828 | aResult = TestReverse<NCollection_Vector<int>, std::vector<int> >(); |
829 | std::cout << "NCollection_Vector<int> Reverse: " << |
830 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
831 | |
832 | aResult = TestReverse<NCollection_Vector<double>, std::vector<double> >(); |
833 | std::cout << "NCollection_Vector<double> Reverse: " << |
834 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
835 | |
836 | aResult = TestSort<NCollection_Vector<int>, std::vector<int> >(); |
837 | std::cout << "NCollection_Vector<int> Sort: " << |
838 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
839 | |
840 | aResult = TestSort<NCollection_Vector<double>, std::vector<double> >(); |
841 | std::cout << "NCollection_Vector<double> Sort: " << |
842 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
843 | |
844 | #ifdef HAVE_TBB |
845 | |
846 | aResult = TestTBB<NCollection_Vector<int>, std::vector<int> >(); |
847 | std::cout << "NCollection_Vector<int> TBB: " << |
848 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
849 | |
850 | aResult = TestTBB<NCollection_Vector<double>, std::vector<double> >(); |
851 | std::cout << "NCollection_Vector<double> TBB: " << |
852 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
853 | |
854 | #endif |
855 | |
856 | return 0; |
857 | } |
858 | |
859 | //======================================================================= |
860 | //function : QANArray1StlIterator |
861 | //purpose : |
862 | //======================================================================= |
863 | static Standard_Integer QANArray1StlIterator (Draw_Interpretor&, Standard_Integer, const char**) |
864 | { |
865 | // compile-time tests |
866 | TestForwardIterator <NCollection_Vector<int> >(); |
867 | TestBidirIterator <NCollection_Vector<int> >(); |
868 | TestRandomIterator <NCollection_Vector<int> >(); |
869 | |
870 | // run-time tests |
871 | Standard_Boolean aResult = TestIteration<NCollection_Array1<int>, std::vector<int> >(); |
872 | std::cout << "NCollection_Array1<int> Iteration: " << |
873 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
874 | |
875 | aResult = TestIteration<NCollection_Array1<double>, std::vector<double> >(); |
876 | std::cout << "NCollection_Array1<double> Iteration: " << |
877 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
878 | |
879 | aResult = TestMinMax<NCollection_Array1<int>, std::vector<int> >(); |
880 | std::cout << "NCollection_Array1<int> Min-Max: " << |
881 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
882 | |
883 | aResult = TestMinMax<NCollection_Array1<double>, std::vector<double> >(); |
884 | std::cout << "NCollection_Array1<double> Min-Max: " << |
885 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
886 | |
887 | aResult = TestReplace<NCollection_Array1<int>, std::vector<int> >(); |
888 | std::cout << "NCollection_Array1<int> Replace: " << |
889 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
890 | |
891 | aResult = TestReplace<NCollection_Array1<double>, std::vector<double> >(); |
892 | std::cout << "NCollection_Array1<double> Replace: " << |
893 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
894 | |
895 | aResult = TestReverse<NCollection_Array1<int>, std::vector<int> >(); |
896 | std::cout << "NCollection_Array1<int> Reverse: " << |
897 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
898 | |
899 | aResult = TestReverse<NCollection_Array1<double>, std::vector<double> >(); |
900 | std::cout << "NCollection_Array1<double> Reverse: " << |
901 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
902 | |
903 | aResult = TestSort<NCollection_Array1<int>, std::vector<int> >(); |
904 | std::cout << "NCollection_Array1<int> Sort: " << |
905 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
906 | |
907 | aResult = TestSort<NCollection_Array1<double>, std::vector<double> >(); |
908 | std::cout << "NCollection_Array1<double> Sort: " << |
909 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
910 | |
911 | #ifdef HAVE_TBB |
912 | |
913 | aResult = TestTBB<NCollection_Array1<int>, std::vector<int> >(); |
914 | std::cout << "NCollection_Array1<int> TBB: " << |
915 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
916 | |
917 | aResult = TestTBB<NCollection_Array1<double>, std::vector<double> >(); |
918 | std::cout << "NCollection_Array1<double> TBB: " << |
919 | (aResult ? "SUCCESS" : "FAIL") << std::endl; |
920 | |
921 | #endif |
922 | |
923 | return 0; |
924 | } |
925 | |
926 | //======================================================================= |
927 | //function : QANTestStlIterators |
928 | //purpose : |
929 | //======================================================================= |
930 | static Standard_Integer QANTestStlIterators ( |
931 | Draw_Interpretor& theInterpretor, Standard_Integer, const char**) |
932 | { |
933 | QANListStlIterator (theInterpretor, 0, NULL); |
934 | QANArray1StlIterator (theInterpretor, 0, NULL); |
935 | QANVectorStlIterator (theInterpretor, 0, NULL); |
936 | QANSequenceStlIterator (theInterpretor, 0, NULL); |
937 | QANMapStlIterator (theInterpretor, 0, NULL); |
938 | QANDataMapStlIterator (theInterpretor, 0, NULL); |
939 | QANIndexedMapStlIterator (theInterpretor, 0, NULL); |
940 | QANIndexedDataMapStlIterator (theInterpretor, 0, NULL); |
941 | |
942 | return 0; |
943 | } |
944 | |
945 | //======================================================================= |
946 | //function : TestPerformanceRandomIterator |
947 | //purpose : |
948 | //======================================================================= |
949 | template<class CollectionType, class StlType> |
950 | void TestPerformanceRandomIterator() |
951 | { |
952 | OSD_Timer aTimer; |
953 | |
954 | StlType* aVector (NULL); |
955 | CollectionType* aCollec (NULL); |
956 | |
957 | for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2) |
958 | { |
959 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize); |
960 | |
961 | aTimer.Reset(); |
962 | aTimer.Start(); |
963 | { |
964 | RandomGenerator aRandomGen; |
965 | for (Standard_Integer anIdx = 0; anIdx < 10; ++anIdx) |
966 | { |
967 | std::sort (aVector->begin(), aVector->end()); |
968 | std::random_shuffle (aVector->begin(), aVector->end(), aRandomGen); |
969 | } |
970 | } |
971 | aTimer.Stop(); |
972 | |
973 | Standard_Real aStlTime = aTimer.ElapsedTime(); |
974 | |
975 | aTimer.Reset(); |
976 | aTimer.Start(); |
977 | { |
978 | RandomGenerator aRandomGen; |
979 | for (Standard_Integer anIdx = 0; anIdx < 10; ++anIdx) |
980 | { |
981 | std::sort (aCollec->begin(), aCollec->end()); |
982 | std::random_shuffle (aCollec->begin(), aCollec->end(), aRandomGen); |
983 | } |
984 | } |
985 | aTimer.Stop(); |
986 | |
987 | Standard_Real aOccTime = aTimer.ElapsedTime(); |
988 | |
989 | std::cout << aSize << "\t" << aStlTime << "\t" << |
990 | aOccTime << "\t" << aOccTime / aStlTime << std::endl; |
991 | |
992 | // check that result is the same |
993 | if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) ) |
994 | std::cout << "Error: sequences are not the same at the end!" << std::endl; |
995 | |
996 | delete aVector; |
997 | delete aCollec; |
998 | } |
999 | } |
1000 | |
1001 | //======================================================================= |
1002 | //function : TestPerformanceForwardIterator |
1003 | //purpose : |
1004 | //======================================================================= |
1005 | template<class CollectionType, class StlType> |
1006 | void TestPerformanceForwardIterator() |
1007 | { |
1008 | OSD_Timer aTimer; |
1009 | |
1010 | StlType* aVector = 0; |
1011 | CollectionType* aCollec = 0; |
1012 | |
1013 | for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2) |
1014 | { |
1015 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize); |
1016 | |
1017 | aTimer.Reset(); |
1018 | aTimer.Start(); |
1019 | { |
1020 | for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx) |
1021 | { |
1022 | std::replace (aVector->begin(), aVector->end(), *aVector->begin(), static_cast<typename StlType::value_type> (anIdx)); |
1023 | } |
1024 | } |
1025 | aTimer.Stop(); |
1026 | |
1027 | Standard_Real aStlTime = aTimer.ElapsedTime(); |
1028 | |
1029 | aTimer.Reset(); |
1030 | aTimer.Start(); |
1031 | { |
1032 | for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx) |
1033 | { |
1034 | std::replace (aCollec->begin(), aCollec->end(), *aCollec->begin(), static_cast<typename CollectionType::value_type> (anIdx)); |
1035 | } |
1036 | } |
1037 | aTimer.Stop(); |
1038 | |
1039 | Standard_Real aOccTime = aTimer.ElapsedTime(); |
1040 | |
1041 | std::cout << aSize << "\t" << aStlTime << "\t" << |
1042 | aOccTime << "\t" << aOccTime / aStlTime << std::endl; |
1043 | |
1044 | // check that result is the same |
1045 | if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) ) |
1046 | std::cout << "Error: sequences are not the same at the end!" << std::endl; |
1047 | |
1048 | delete aVector; |
1049 | delete aCollec; |
1050 | } |
1051 | } |
1052 | |
1053 | //======================================================================= |
1054 | //function : TestPerformanceBidirIterator |
1055 | //purpose : |
1056 | //======================================================================= |
1057 | template<class CollectionType, class StlType> |
1058 | void TestPerformanceBidirIterator() |
1059 | { |
1060 | OSD_Timer aTimer; |
1061 | |
1062 | StlType* aVector = 0; |
1063 | CollectionType* aCollec = 0; |
1064 | |
1065 | for (Standard_Integer aSize = 10000; aSize <= 1280000; aSize *= 2) |
1066 | { |
1067 | CollectionFiller<CollectionType, StlType>::Perform (&aVector, &aCollec, aSize); |
1068 | |
1069 | aTimer.Reset(); |
1070 | aTimer.Start(); |
1071 | { |
1072 | for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx) |
1073 | { |
1074 | std::reverse (aVector->begin(), aVector->end()); |
1075 | } |
1076 | } |
1077 | aTimer.Stop(); |
1078 | |
1079 | Standard_Real aStlTime = aTimer.ElapsedTime(); |
1080 | |
1081 | aTimer.Reset(); |
1082 | aTimer.Start(); |
1083 | { |
1084 | for (Standard_Integer anIdx = 0; anIdx < 1000; ++anIdx) |
1085 | { |
1086 | std::reverse (aCollec->begin(), aCollec->end()); |
1087 | } |
1088 | } |
1089 | aTimer.Stop(); |
1090 | |
1091 | Standard_Real aOccTime = aTimer.ElapsedTime(); |
1092 | |
1093 | std::cout << aSize << "\t" << aStlTime << "\t" << |
1094 | aOccTime << "\t" << aOccTime / aStlTime << std::endl; |
1095 | |
1096 | // check that result is the same |
1097 | if ( ! std::equal (aVector->begin(), aVector->end(), aCollec->begin()) ) |
1098 | std::cout << "Error: sequences are not the same at the end!" << std::endl; |
1099 | |
1100 | delete aVector; |
1101 | delete aCollec; |
1102 | } |
1103 | } |
1104 | |
1105 | //======================================================================= |
1106 | //function : TestPerformanceMapAccess |
1107 | //purpose : |
1108 | //======================================================================= |
1109 | template<class CollectionType, class T> |
1110 | void TestPerformanceMapAccess() |
1111 | { |
1112 | OSD_Timer aTimer; |
1113 | |
1114 | CollectionType* aCollec (NULL); |
1115 | |
1116 | for (Standard_Integer aSize = 100000; aSize <= 3200000; aSize *= 2) |
1117 | { |
1118 | MapFiller<CollectionType, T>::Perform (&aCollec, aSize); |
1119 | |
1120 | std::set<T> aSet (aCollec->cbegin(), aCollec->cend()); |
1121 | std::vector<T> aVec (aCollec->cbegin(), aCollec->cend()); |
1122 | |
1123 | Standard_Boolean aResult = Standard_True; |
1124 | |
1125 | aTimer.Reset(); |
1126 | aTimer.Start(); |
1127 | { |
1128 | for (Standard_Integer anIdx = 0; anIdx < 10000; ++anIdx) |
1129 | { |
1130 | if (aSet.find (aVec[anIdx + 1000]) == aSet.end()) |
1131 | aResult = Standard_False; |
1132 | if (aSet.find (aVec[anIdx + 2000]) == aSet.end()) |
1133 | aResult = Standard_False; |
1134 | if (aSet.find (aVec[anIdx + 3000]) == aSet.end()) |
1135 | aResult = Standard_False; |
1136 | if (aSet.find (aVec[anIdx + 4000]) == aSet.end()) |
1137 | aResult = Standard_False; |
1138 | if (aSet.find (aVec[anIdx + 5000]) == aSet.end()) |
1139 | aResult = Standard_False; |
1140 | } |
1141 | } |
1142 | aTimer.Stop(); |
1143 | |
1144 | Standard_Real aStlTime = aTimer.ElapsedTime(); |
1145 | |
1146 | aTimer.Reset(); |
1147 | aTimer.Start(); |
1148 | { |
1149 | for (Standard_Integer anIdx = 0; anIdx < 10000; ++anIdx) |
1150 | { |
1151 | if (!aCollec->Contains (aVec[anIdx + 1000])) |
1152 | aResult = Standard_False; |
1153 | if (!aCollec->Contains (aVec[anIdx + 2000])) |
1154 | aResult = Standard_False; |
1155 | if (!aCollec->Contains (aVec[anIdx + 3000])) |
1156 | aResult = Standard_False; |
1157 | if (!aCollec->Contains (aVec[anIdx + 4000])) |
1158 | aResult = Standard_False; |
1159 | if (!aCollec->Contains (aVec[anIdx + 5000])) |
1160 | aResult = Standard_False; |
1161 | } |
1162 | } |
1163 | aTimer.Stop(); |
1164 | |
1165 | Standard_Real aOccTime = aTimer.ElapsedTime(); |
1166 | |
1167 | if (aResult) |
1168 | { |
1169 | std::cout << aSize << "\t" << aStlTime << "\t" << |
1170 | aOccTime << "\t" << (aStlTime > 1e-16 ? aOccTime / aStlTime : -1) << std::endl; |
1171 | } |
1172 | |
1173 | delete aCollec; |
1174 | } |
1175 | } |
1176 | |
1177 | //======================================================================= |
1178 | //function : QANTestNCollectionPerformance |
1179 | //purpose : |
1180 | //======================================================================= |
1181 | static Standard_Integer QANTestNCollectionPerformance ( |
1182 | Draw_Interpretor& /*theInterpretor*/, Standard_Integer, const char**) |
1183 | { |
1184 | std::cout.precision (8); |
1185 | |
1186 | std::cout << "Testing performance (Size | STL time | OCCT time | STL/OCCT boost)\n"; |
1187 | |
1188 | std::cout << std::endl << "std::vector vs NCollection_Array1 (sort):\n" << std::endl; |
1189 | TestPerformanceRandomIterator<NCollection_Array1<double>, std::vector<double> >(); |
1190 | |
1191 | std::cout << std::endl << "std::vector vs NCollection_Vector (sort):\n" << std::endl; |
1192 | TestPerformanceRandomIterator<NCollection_Vector<double>, std::vector<double> >(); |
1193 | |
1194 | std::cout << std::endl << "std::vector vs NCollection_Array1 (replace):\n" << std::endl; |
1195 | TestPerformanceForwardIterator<NCollection_Array1<double>, std::vector<double> >(); |
1196 | |
1197 | std::cout << std::endl << "std::vector vs NCollection_Vector (replace):\n" << std::endl; |
1198 | TestPerformanceForwardIterator<NCollection_Vector<double>, std::vector<double> >(); |
1199 | |
1200 | std::cout << std::endl << "std::list vs NCollection_List (replace):\n" << std::endl; |
1201 | TestPerformanceForwardIterator<NCollection_List<double>, std::list<double> >(); |
1202 | |
1203 | std::cout << std::endl << "std::list vs NCollection_Sequence (replace):\n" << std::endl; |
1204 | TestPerformanceForwardIterator<NCollection_Sequence<double>, std::list<double> >(); |
1205 | |
1206 | std::cout << std::endl << "std::list vs NCollection_Sequence (reverse):\n" << std::endl; |
1207 | TestPerformanceBidirIterator<NCollection_Sequence<double>, std::list<double> >(); |
1208 | |
1209 | std::cout << std::endl << "std::set vs NCollection_Map (search):\n" << std::endl; |
1210 | TestPerformanceMapAccess<NCollection_Map<int>, int>(); |
1211 | |
1212 | std::cout << std::endl << "std::set vs NCollection_IndexedMap (search):\n" << std::endl; |
1213 | TestPerformanceMapAccess<NCollection_IndexedMap<int>, int>(); |
1214 | |
1215 | std::cout.unsetf (std::ios::floatfield); |
1216 | |
1217 | return 0; |
1218 | } |
1219 | |
1220 | //======================================================================= |
1221 | //function : CommandsStl |
1222 | //purpose : |
1223 | //======================================================================= |
1224 | void QANCollection::CommandsStl (Draw_Interpretor& theCommands) |
1225 | { |
1226 | const char* aGroup = "QANCollection"; |
1227 | |
1228 | theCommands.Add ("QANArray1StlIterator", |
1229 | "QANArray1StlIterator", |
1230 | __FILE__, |
1231 | QANArray1StlIterator, |
1232 | aGroup); |
1233 | |
1234 | theCommands.Add ("QANListStlIterator", |
1235 | "QANListStlIterator", |
1236 | __FILE__, |
1237 | QANListStlIterator, |
1238 | aGroup); |
1239 | |
1240 | theCommands.Add ("QANSequenceStlIterator", |
1241 | "QANSequenceStlIterator", |
1242 | __FILE__, |
1243 | QANSequenceStlIterator, |
1244 | aGroup); |
1245 | |
1246 | theCommands.Add ("QANVectorStlIterator", |
1247 | "QANVectorStlIterator", |
1248 | __FILE__, |
1249 | QANVectorStlIterator, |
1250 | aGroup); |
1251 | |
1252 | theCommands.Add ("QANMapStlIterator", |
1253 | "QANMapStlIterator", |
1254 | __FILE__, |
1255 | QANMapStlIterator, |
1256 | aGroup); |
1257 | |
1258 | theCommands.Add ("QANDataMapStlIterator", |
1259 | "QANDataMapStlIterator", |
1260 | __FILE__, |
1261 | QANDataMapStlIterator, |
1262 | aGroup); |
1263 | |
1264 | theCommands.Add ("QANIndexedMapStlIterator", |
1265 | "QANIndexedMapStlIterator", |
1266 | __FILE__, |
1267 | QANIndexedMapStlIterator, |
1268 | aGroup); |
1269 | |
1270 | theCommands.Add ("QANIndexedDataMapStlIterator", |
1271 | "QANIndexedDataMapStlIterator", |
1272 | __FILE__, |
1273 | QANIndexedDataMapStlIterator, |
1274 | aGroup); |
1275 | |
1276 | theCommands.Add ("QANTestStlIterators", |
1277 | "QANTestStlIterators", |
1278 | __FILE__, |
1279 | QANTestStlIterators, |
1280 | aGroup); |
1281 | |
1282 | theCommands.Add ("QANTestNCollectionPerformance", |
1283 | "QANTestNCollectionPerformance", |
1284 | __FILE__, |
1285 | QANTestNCollectionPerformance, |
1286 | aGroup); |
1287 | |
1288 | return; |
1289 | } |