0026922: Huge performance issue writing data to the output stream
[occt.git] / src / QANCollection / QANCollection_Perf.cxx
1 // Created on: 2004-03-05
2 // Created by: Mikhail KUZMITCHEV
3 // Copyright (c) 2004-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 <QANCollection_Common.hxx>
18
19 #include <Draw.hxx>
20 #include <Draw_Interpretor.hxx>
21
22 #include <TColgp_Array1OfPnt.hxx>
23 #include <TColgp_Array2OfPnt.hxx>
24 #include <TColStd_MapOfReal.hxx>
25 #include <TColStd_IndexedMapOfReal.hxx>
26 #include <TColgp_SequenceOfPnt.hxx>
27
28 #include <QANCollection_DataMapOfRealPnt.hxx>
29 #include <QANCollection_DoubleMapOfRealInteger.hxx>
30 #include <QANCollection_IndexedDataMapOfRealPnt.hxx>
31 #include <QANCollection_ListOfPnt.hxx>
32
33 #include <NCollection_SparseArray.hxx>
34 #include <NCollection_SparseArrayBase.hxx>
35
36 #define PERF_ENABLE_METERS
37 #include <OSD_PerfMeter.hxx>
38
39 #define ItemType gp_Pnt
40 #define Key1Type Standard_Real
41 #define Key2Type Standard_Integer
42
43 // =====================               INSTANTIATIONS               ===========
44 // ===================== The Types must be defined before this line ===========
45 // These are: TheItemType, TheKey1Type, TheKey2Type
46 // So must be defined ::HashCode and ::IsEqual too
47
48 #include <NCollection_DefineArray1.hxx>
49 #include <NCollection_DefineHArray1.hxx>
50 ////////////////////////////////DEFINE_ARRAY1(QANCollection_Array1,QANCollection_BaseCol,ItemType)
51 ////////////////////////////////DEFINE_HARRAY1(QANCollection_HArray1,QANCollection_Array1)
52 DEFINE_ARRAY1(QANCollection_Array1Perf,QANCollection_BaseColPerf,ItemType)
53 DEFINE_HARRAY1(QANCollection_HArray1Perf,QANCollection_Array1Perf)
54
55 #include <NCollection_DefineArray2.hxx>
56 #include <NCollection_DefineHArray2.hxx>
57 ////////////////////////////////DEFINE_ARRAY2(QANCollection_Array2,QANCollection_BaseCol,ItemType)
58 ////////////////////////////////DEFINE_HARRAY2(QANCollection_HArray2,QANCollection_Array2)
59 DEFINE_ARRAY2(QANCollection_Array2Perf,QANCollection_BaseColPerf,ItemType)
60 DEFINE_HARRAY2(QANCollection_HArray2Perf,QANCollection_Array2Perf)
61
62 #include <NCollection_DefineMap.hxx>
63 #include <NCollection_DefineDataMap.hxx>
64 #include <NCollection_DefineDoubleMap.hxx>
65 #include <NCollection_DefineIndexedMap.hxx>
66 #include <NCollection_DefineIndexedDataMap.hxx>
67 ////////////////////////////////DEFINE_MAP(QANCollection_Map,QANCollection_Key1BaseCol,Key1Type)
68 ////////////////////////////////DEFINE_DATAMAP(QANCollection_DataMap,QANCollection_BaseCol,Key1Type,ItemType)
69 ////////////////////////////////DEFINE_DOUBLEMAP(QANCollection_DoubleMap,QANCollection_Key2BaseCol,Key1Type,Key2Type)
70 ////////////////////////////////DEFINE_INDEXEDMAP(QANCollection_IndexedMap,QANCollection_Key1BaseCol,Key1Type)
71 ////////////////////////////////DEFINE_INDEXEDDATAMAP(QANCollection_IDMap,QANCollection_BaseCol,Key1Type,ItemType)
72 DEFINE_MAP(QANCollection_MapPerf,QANCollection_Key1BaseColPerf,Key1Type)
73 DEFINE_DATAMAP(QANCollection_DataMapPerf,QANCollection_BaseColPerf,Key1Type,ItemType)
74 DEFINE_DOUBLEMAP(QANCollection_DoubleMapPerf,QANCollection_Key2BaseColPerf,Key1Type,Key2Type)
75 DEFINE_INDEXEDMAP(QANCollection_IndexedMapPerf,QANCollection_Key1BaseColPerf,Key1Type)
76 DEFINE_INDEXEDDATAMAP(QANCollection_IDMapPerf,QANCollection_BaseColPerf,Key1Type,ItemType)
77
78 #include <NCollection_DefineList.hxx>
79 ////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
80 DEFINE_LIST(QANCollection_ListPerf,QANCollection_BaseColPerf,ItemType)
81
82 #include <NCollection_DefineSequence.hxx>
83 #include <NCollection_DefineHSequence.hxx>
84 ////////////////////////////////DEFINE_SEQUENCE(QANCollection_Sequence,QANCollection_BaseCol,ItemType)
85 ////////////////////////////////DEFINE_HSEQUENCE(QANCollection_HSequence,QANCollection_Sequence)
86 DEFINE_SEQUENCE(QANCollection_SequencePerf,QANCollection_BaseColPerf,ItemType)
87 DEFINE_HSEQUENCE(QANCollection_HSequencePerf,QANCollection_SequencePerf)
88
89 static void printAllMeters (Draw_Interpretor& theDI)
90 {
91   char buffer[25600];
92   perf_sprint_all_meters (buffer, 25600 - 1, 1);
93   theDI << buffer;
94 }
95
96 // ===================== Test perform of Array1 type ==========================
97 static void CompArray1 (Draw_Interpretor& theDI,
98                         const Standard_Integer theRep,
99                         const Standard_Integer theSize)
100 {
101   Standard_Integer i,j;
102
103   ////////////////////////////////Perf_Meter aNCrea ("NCollection_Array1 creation",0);
104   ////////////////////////////////Perf_Meter aTCrea ("TCollection_Array1 creation",0);
105   ////////////////////////////////Perf_Meter aNFill ("NCollection_Array1 filling",0);
106   ////////////////////////////////Perf_Meter aTFill ("TCollection_Array1 filling",0);
107   ////////////////////////////////Perf_Meter aNFind ("NCollection_Array1 finding",0);
108   ////////////////////////////////Perf_Meter aTFind ("TCollection_Array1 finding",0);
109   ////////////////////////////////Perf_Meter aNOper ("NCollection_Array1 operator=",0);
110   ////////////////////////////////Perf_Meter aTOper ("TCollection_Array1 operator=",0);
111   ////////////////////////////////Perf_Meter aNAssi ("NCollection_Array1 Assign",0);
112   for (i=0; i<theRep; i++)
113     {
114       ////////////////////////////////aNCrea.Start();
115       PERF_START_METER("NCollection_Array1 creation")
116       ////////////////////////////////QANCollection_Array1 a1(1,theSize), a2(1,theSize);
117       QANCollection_Array1Perf a1(1,theSize), a2(1,theSize);
118       ////////////////////////////////aNCrea.Stop();
119       PERF_STOP_METER("NCollection_Array1 creation")
120       ////////////////////////////////aNFill.Start();
121       PERF_START_METER("NCollection_Array1 filling")
122       for (j=1; j<=theSize; j++)
123         Random(a1(j));
124       ////////////////////////////////aNFill.Stop();
125       PERF_STOP_METER("NCollection_Array1 filling")
126       ////////////////////////////////aNFind.Start();
127       PERF_START_METER("NCollection_Array1 finding")
128       for (j=1; j<=theSize; j++)
129         {
130           Standard_Integer iIndex;
131           Random(iIndex,theSize);
132           a1.Value(iIndex+1);
133         }
134       ////////////////////////////////aNFind.Stop();
135       PERF_STOP_METER("NCollection_Array1 finding")
136       ////////////////////////////////aNOper.Start();
137       PERF_START_METER("NCollection_Array1 operator=")
138       a2 = a1;
139       ////////////////////////////////aNOper.Stop();
140       PERF_STOP_METER("NCollection_Array1 operator=")
141       ////////////////////////////////aNAssi.Start();
142       PERF_START_METER("NCollection_Array1 Assign")
143       a2.Assign(a1);
144       ////////////////////////////////aNAssi.Stop();
145       PERF_STOP_METER("NCollection_Array1 Assign")
146     }
147
148   for (i=0; i<theRep; i++)
149     {
150       ////////////////////////////////aTCrea.Start();
151       PERF_START_METER("TCollection_Array1 creation")
152       TColgp_Array1OfPnt a1(1,theSize), a2(1,theSize);
153       ////////////////////////////////aTCrea.Stop();
154       PERF_STOP_METER("TCollection_Array1 creation")
155       ////////////////////////////////aTFill.Start();
156       PERF_START_METER("TCollection_Array1 filling")
157       for (j=1; j<=theSize; j++)
158         Random(a1(j));
159       ////////////////////////////////aTFill.Stop();
160       PERF_STOP_METER("TCollection_Array1 filling")
161       ////////////////////////////////aTFind.Start();
162       PERF_START_METER("TCollection_Array1 finding")
163       for (j=1; j<=theSize; j++)
164         {
165           Standard_Integer iIndex;
166           Random(iIndex,theSize);
167           a1.Value(iIndex+1);
168         }
169       ////////////////////////////////aTFind.Stop();
170       PERF_STOP_METER("TCollection_Array1 finding")
171       ////////////////////////////////aTOper.Start();
172       PERF_START_METER("TCollection_Array1 operator=")
173       a2 = a1;
174       ////////////////////////////////aTOper.Stop();
175       PERF_STOP_METER("TCollection_Array1 operator=")
176     }
177   printAllMeters(theDI);
178 }
179
180 // ===================== Test perform of Array2 type ==========================
181 static void CompArray2 (Draw_Interpretor& theDI,
182                         const Standard_Integer theRep,
183                         const Standard_Integer theSize)
184 {
185   Standard_Integer i,j,k;
186   
187   ////////////////////////////////Perf_Meter aNCrea ("NCollection_Array2 creation",0);
188   ////////////////////////////////Perf_Meter aTCrea ("TCollection_Array2 creation",0);
189   ////////////////////////////////Perf_Meter aNFill ("NCollection_Array2 filling",0);
190   ////////////////////////////////Perf_Meter aTFill ("TCollection_Array2 filling",0);
191   ////////////////////////////////Perf_Meter aNFind ("NCollection_Array2 finding",0);
192   ////////////////////////////////Perf_Meter aTFind ("TCollection_Array2 finding",0);
193   ////////////////////////////////Perf_Meter aNOper ("NCollection_Array2 operator=",0);
194   ////////////////////////////////Perf_Meter aTOper ("TCollection_Array2 operator=",0);
195   ////////////////////////////////Perf_Meter aNAssi ("NCollection_Array2 Assign",0);
196   for (i=0; i<theRep; i++)
197     {
198       ////////////////////////////////aNCrea.Start();
199       PERF_START_METER("NCollection_Array2 creation")
200       ////////////////////////////////QANCollection_Array2 a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
201       QANCollection_Array2Perf a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
202       ////////////////////////////////aNCrea.Stop();
203       PERF_STOP_METER("NCollection_Array2 creation")
204       ////////////////////////////////aNFill.Start();
205       PERF_START_METER("NCollection_Array2 filling")
206       for (j=1; j<=theSize; j++)
207         for (k=1; k<=theSize; k++)
208           Random(a1(j,k));
209       ////////////////////////////////aNFill.Stop();
210       PERF_STOP_METER("NCollection_Array2 filling")
211       ////////////////////////////////aNFind.Start();
212       PERF_START_METER("NCollection_Array2 finding")
213       for (j=1; j<=theSize*theSize; j++)
214         {
215           Standard_Integer m,n;
216           Random(m,theSize);
217           Random(n,theSize);
218           a1.Value(m+1,n+1);
219         }
220       ////////////////////////////////aNFind.Stop();
221       PERF_STOP_METER("NCollection_Array2 finding")
222       ////////////////////////////////aNOper.Start();
223       PERF_START_METER("NCollection_Array2 operator=")
224       a2 = a1;
225       ////////////////////////////////aNOper.Stop();
226       PERF_STOP_METER("NCollection_Array2 operator=")
227       ////////////////////////////////aNAssi.Start();
228       PERF_START_METER("NCollection_Array2 Assign")
229       a2.Assign(a1);
230       ////////////////////////////////aNAssi.Stop();
231       PERF_STOP_METER("NCollection_Array2 Assign")
232     }
233
234   for (i=0; i<theRep; i++)
235     {
236       ////////////////////////////////aTCrea.Start();
237       PERF_START_METER("TCollection_Array2 creation")
238       TColgp_Array2OfPnt a1(1,theSize,1,theSize), a2(1,theSize,1,theSize);
239       ////////////////////////////////aTCrea.Stop();
240       PERF_STOP_METER("TCollection_Array2 creation")
241       ////////////////////////////////aTFill.Start();
242       PERF_START_METER("TCollection_Array2 filling")
243       for (j=1; j<=theSize; j++)
244         for (k=1; k<=theSize; k++)
245           Random(a1(j,k));
246       ////////////////////////////////aTFill.Stop();
247       PERF_STOP_METER("TCollection_Array2 filling")
248       ////////////////////////////////aTFind.Start();
249       PERF_START_METER("TCollection_Array2 finding")
250       for (j=1; j<=theSize*theSize; j++)
251         {
252           Standard_Integer m,n;
253           Random(m,theSize);
254           Random(n,theSize);
255           a1.Value(m+1,n+1);
256         }
257       ////////////////////////////////aTFind.Stop();
258       PERF_STOP_METER("TCollection_Array2 finding")
259       ////////////////////////////////aTOper.Start();
260       PERF_START_METER("TCollection_Array2 operator=")
261       a2 = a1;
262       ////////////////////////////////aTOper.Stop();
263       PERF_STOP_METER("TCollection_Array2 operator=")
264     }
265   printAllMeters(theDI);
266 }
267
268 // ===================== Test perform of List type ==========================
269 static void CompList (Draw_Interpretor& theDI,
270                       const Standard_Integer theRep,
271                       const Standard_Integer theSize)
272 {
273   Standard_Integer i,j;
274
275   ////////////////////////////////Perf_Meter aNAppe ("NCollection_List appending",0);
276   ////////////////////////////////Perf_Meter aTAppe ("TCollection_List appending",0);
277   ////////////////////////////////Perf_Meter aNOper ("NCollection_List operator=",0);
278   ////////////////////////////////Perf_Meter aTOper ("TCollection_List operator=",0);
279   ////////////////////////////////Perf_Meter aNClea ("NCollection_List clearing",0);
280   ////////////////////////////////Perf_Meter aTClea ("TCollection_List clearing",0);
281   ////////////////////////////////Perf_Meter aNAssi ("NCollection_List Assign",0);
282   for (i=0; i<theRep; i++)
283     {
284       ////////////////////////////////QANCollection_List a1, a2;
285       QANCollection_ListPerf a1, a2;
286       ////////////////////////////////aNAppe.Start();
287       PERF_START_METER("NCollection_List appending")
288       for (j=1; j<=theSize; j++)
289         {
290           ItemType anItem;
291           Random(anItem);
292           a1.Append(anItem);
293         }
294       ////////////////////////////////aNAppe.Stop();
295       PERF_STOP_METER("NCollection_List appending")
296       ////////////////////////////////aNOper.Start();
297       PERF_START_METER("NCollection_List operator=")
298       a2 = a1;
299       ////////////////////////////////aNOper.Stop();
300       PERF_STOP_METER("NCollection_List operator=")
301       ////////////////////////////////aNAssi.Start();
302       PERF_START_METER("NCollection_List Assign")
303       a2.Assign(a1);
304       ////////////////////////////////aNAssi.Stop();
305       PERF_STOP_METER("NCollection_List Assign")
306       ////////////////////////////////aNClea.Start();
307       PERF_START_METER("NCollection_List clearing")
308       a2.Clear();
309       ////////////////////////////////aNClea.Stop();
310       PERF_STOP_METER("NCollection_List clearing")
311     }
312
313   for (i=0; i<theRep; i++)
314     {
315       QANCollection_ListOfPnt a1, a2;
316       ////////////////////////////////aTAppe.Start();
317       PERF_START_METER("TCollection_List appending")
318       for (j=1; j<=theSize; j++)
319         {
320           ItemType anItem;
321           Random(anItem);
322           a1.Append(anItem);
323         }
324       ////////////////////////////////aTAppe.Stop();
325       PERF_STOP_METER("TCollection_List appending")
326       ////////////////////////////////aTOper.Start();
327       PERF_START_METER("TCollection_List operator=")
328       a2 = a1;
329       ////////////////////////////////aTOper.Stop();
330       PERF_STOP_METER("TCollection_List operator=")
331       ////////////////////////////////aTClea.Start();
332       PERF_START_METER("TCollection_List clearing")
333       a2.Clear();
334       ////////////////////////////////aTClea.Stop();
335       PERF_STOP_METER("TCollection_List clearing")
336     }
337   printAllMeters(theDI);
338 }
339
340 // ===================== Test perform of Sequence type ==========================
341 static void CompSequence (Draw_Interpretor& theDI,
342                           const Standard_Integer theRep,
343                           const Standard_Integer theSize)
344 {
345   Standard_Integer i,j;
346
347   ////////////////////////////////Perf_Meter aNAppe ("NCollection_Sequence appending",0);
348   ////////////////////////////////Perf_Meter aTAppe ("TCollection_Sequence appending",0);
349   ////////////////////////////////Perf_Meter aNFind ("NCollection_Sequence finding",0);
350   ////////////////////////////////Perf_Meter aTFind ("TCollection_Sequence finding",0);
351   ////////////////////////////////Perf_Meter aNOper ("NCollection_Sequence operator=",0);
352   ////////////////////////////////Perf_Meter aTOper ("TCollection_Sequence operator=",0);
353   ////////////////////////////////Perf_Meter aNClea ("NCollection_Sequence clearing",0);
354   ////////////////////////////////Perf_Meter aTClea ("TCollection_Sequence clearing",0);
355   ////////////////////////////////Perf_Meter aNAssi ("NCollection_Sequence Assign",0);
356   for (i=0; i<theRep; i++)
357     {
358       ////////////////////////////////QANCollection_Sequence a1, a2;
359       QANCollection_SequencePerf a1, a2;
360       ////////////////////////////////aNAppe.Start();
361       PERF_START_METER("NCollection_Sequence appending")
362       for (j=1; j<=theSize; j++)
363         {
364           ItemType anItem;
365           Random(anItem);
366           a1.Append(anItem);
367         }
368       ////////////////////////////////aNAppe.Stop();
369       PERF_STOP_METER("NCollection_Sequence appending")
370       ////////////////////////////////aNFind.Start();
371       PERF_START_METER("NCollection_Sequence finding")
372       for (j=1; j<=theSize; j++)
373         {
374           Standard_Integer iIndex;
375           Random(iIndex,theSize);
376           a1.Value(iIndex+1);
377         }
378       ////////////////////////////////aNFind.Stop();
379       PERF_STOP_METER("NCollection_Sequence finding")
380       ////////////////////////////////aNOper.Start();
381       PERF_START_METER("NCollection_Sequence operator=")
382       a2 = a1;
383       ////////////////////////////////aNOper.Stop();
384       PERF_STOP_METER("NCollection_Sequence operator=")
385       ////////////////////////////////aNAssi.Start();
386       PERF_START_METER("NCollection_Sequence Assign")
387       a2.Assign(a1);
388       ////////////////////////////////aNAssi.Stop();
389       PERF_STOP_METER("NCollection_Sequence Assign")
390       ////////////////////////////////aNClea.Start();
391       PERF_START_METER("NCollection_Sequence clearing")
392       a2.Clear();
393       ////////////////////////////////aNClea.Stop();
394       PERF_STOP_METER("NCollection_Sequence clearing")
395     }
396
397   for (i=0; i<theRep; i++)
398     {
399       TColgp_SequenceOfPnt a1, a2;
400       ////////////////////////////////aTAppe.Start();
401       PERF_START_METER("TCollection_Sequence appending")
402       for (j=1; j<=theSize; j++)
403         {
404           ItemType anItem;
405           Random(anItem);
406           a1.Append(anItem);
407         }
408       ////////////////////////////////aTAppe.Stop();
409       PERF_STOP_METER("TCollection_Sequence appending")
410       ////////////////////////////////aTFind.Start();
411       PERF_START_METER("TCollection_Sequence finding")
412       for (j=1; j<=theSize; j++)
413         {
414           Standard_Integer iIndex;
415           Random(iIndex,theSize);
416           a1.Value(iIndex+1);
417         }
418       ////////////////////////////////aTFind.Stop();
419       PERF_STOP_METER("TCollection_Sequence finding")
420       ////////////////////////////////aTOper.Start();
421       PERF_START_METER("TCollection_Sequence operator=")
422       a2 = a1;
423       ////////////////////////////////aTOper.Stop();
424       PERF_STOP_METER("TCollection_Sequence operator=")
425       ////////////////////////////////aTClea.Start();
426       PERF_START_METER("TCollection_Sequence clearing")
427       a2.Clear();
428       ////////////////////////////////aTClea.Stop();
429       PERF_STOP_METER("TCollection_Sequence clearing")
430     }
431   printAllMeters(theDI);
432 }
433
434 // ===================== Test perform of Map type ==========================
435 static void CompMap (Draw_Interpretor& theDI,
436                      const Standard_Integer theRep,
437                      const Standard_Integer theSize)
438 {
439   Standard_Integer i,j;
440
441   ////////////////////////////////Perf_Meter aNBind ("NCollection_Map adding",0);
442   ////////////////////////////////Perf_Meter aTBind ("TCollection_Map adding",0);
443   ////////////////////////////////Perf_Meter aNOper ("NCollection_Map operator=",0);
444   ////////////////////////////////Perf_Meter aTOper ("TCollection_Map operator=",0);
445   ////////////////////////////////Perf_Meter aNFind ("NCollection_Map finding",0);
446   ////////////////////////////////Perf_Meter aTFind ("TCollection_Map finding",0);
447   ////////////////////////////////Perf_Meter aNClea ("NCollection_Map clearing",0);
448   ////////////////////////////////Perf_Meter aTClea ("TCollection_Map clearing",0);
449   ////////////////////////////////Perf_Meter aNAssi ("NCollection_Map Assign",0);
450   for (i=0; i<theRep; i++)
451     {
452       ////////////////////////////////QANCollection_Map a1, a2;
453       QANCollection_MapPerf a1, a2;
454       ////////////////////////////////aNBind.Start();
455       PERF_START_METER("NCollection_Map adding")
456       for (j=1; j<=theSize; j++)
457         {
458           Key1Type aKey1;
459           Random(aKey1);
460           a1.Add(aKey1);
461         }
462       ////////////////////////////////aNBind.Stop();
463       PERF_STOP_METER("NCollection_Map adding")
464       ////////////////////////////////aNFind.Start();
465       PERF_START_METER("NCollection_Map finding")
466       for (j=1; j<=theSize; j++)
467         {
468           Key1Type aKey1;
469           Random(aKey1);
470           a1.Contains(aKey1);
471         }
472       ////////////////////////////////aNFind.Stop();
473       PERF_STOP_METER("NCollection_Map finding")
474       ////////////////////////////////aNOper.Start();
475       PERF_START_METER("NCollection_Map operator=")
476       a2 = a1;
477       ////////////////////////////////aNOper.Stop();
478       PERF_STOP_METER("NCollection_Map operator=")
479       ////////////////////////////////aNAssi.Start();
480       PERF_START_METER("NCollection_Map Assign")
481       a2.Assign(a1);
482       ////////////////////////////////aNAssi.Stop();
483       PERF_STOP_METER("NCollection_Map Assign")
484       ////////////////////////////////aNClea.Start();
485       PERF_START_METER("NCollection_Map clearing")
486       a2.Clear();
487       ////////////////////////////////aNClea.Stop();
488       PERF_STOP_METER("NCollection_Map clearing")
489     }
490
491   for (i=0; i<theRep; i++)
492     {
493       TColStd_MapOfReal a1, a2;
494       ////////////////////////////////aTBind.Start();
495       PERF_START_METER("TCollection_Map adding")
496       for (j=1; j<=theSize; j++)
497         {
498           Key1Type aKey1;
499           Random(aKey1);
500           a1.Add(aKey1);
501         }
502       ////////////////////////////////aTBind.Stop();
503       PERF_STOP_METER("TCollection_Map adding")
504       ////////////////////////////////aTFind.Start();
505       PERF_START_METER("TCollection_Map finding")
506       for (j=1; j<=theSize; j++)
507         {
508           Key1Type aKey1;
509           Random(aKey1);
510           a1.Contains(aKey1);
511         }
512       ////////////////////////////////aTFind.Stop();
513       PERF_STOP_METER("TCollection_Map finding")
514       ////////////////////////////////aTOper.Start();
515       PERF_START_METER("TCollection_Map operator=")
516       a2 = a1;
517       ////////////////////////////////aTOper.Stop();
518       PERF_STOP_METER("TCollection_Map operator=")
519       ////////////////////////////////aTClea.Start();
520       PERF_START_METER("TCollection_Map clearing")
521       a2.Clear();
522       ////////////////////////////////aTClea.Stop();
523       PERF_STOP_METER("TCollection_Map clearing")
524     }
525   printAllMeters(theDI);
526 }
527
528 // ===================== Test perform of DataMap type ==========================
529 static void CompDataMap (Draw_Interpretor& theDI,
530                          const Standard_Integer theRep,
531                          const Standard_Integer theSize)
532 {
533   Standard_Integer i,j;
534
535   ////////////////////////////////Perf_Meter aNBind ("NCollection_DataMap binding",0);
536   ////////////////////////////////Perf_Meter aTBind ("TCollection_DataMap binding",0);
537   ////////////////////////////////Perf_Meter aNFind ("NCollection_DataMap finding",0);
538   ////////////////////////////////Perf_Meter aTFind ("TCollection_DataMap finding",0);
539   ////////////////////////////////Perf_Meter aNOper ("NCollection_DataMap operator=",0);
540   ////////////////////////////////Perf_Meter aTOper ("TCollection_DataMap operator=",0);
541   ////////////////////////////////Perf_Meter aNClea ("NCollection_DataMap clearing",0);
542   ////////////////////////////////Perf_Meter aTClea ("TCollection_DataMap clearing",0);
543   //////////////////////////////////Perf_Meter aNAssi ("NCollection_DataMap Assign",0);
544   for (i=0; i<theRep; i++)
545     {
546       ////////////////////////////////QANCollection_DataMap a1, a2;
547       QANCollection_DataMapPerf a1, a2;
548       ////////////////////////////////aNBind.Start();
549       PERF_START_METER("NCollection_DataMap binding")
550       for (j=1; j<=theSize; j++)
551         {
552           Key1Type aKey1;
553           ItemType anItem;
554           Random(aKey1);
555           Random(anItem);
556           a1.Bind(aKey1,anItem);
557         }
558       ////////////////////////////////aNBind.Stop();
559       PERF_STOP_METER("NCollection_DataMap binding")
560       ////////////////////////////////aNFind.Start();
561       PERF_START_METER("NCollection_DataMap finding")
562       for (j=1; j<=theSize; j++)
563         {
564           Key1Type aKey1;
565           Random(aKey1);
566           a1.IsBound(aKey1);
567         }
568       ////////////////////////////////aNFind.Stop();
569       PERF_STOP_METER("NCollection_DataMap finding")
570       ////////////////////////////////aNOper.Start();
571       PERF_START_METER("NCollection_DataMap operator=")
572       a2 = a1;
573       ////////////////////////////////aNOper.Stop();
574       PERF_STOP_METER("NCollection_DataMap operator=")
575       //aNAssi.Start();
576       //a2.Assign(a1);
577       //aNAssi.Stop();
578       ////////////////////////////////aNClea.Start();
579       PERF_START_METER("NCollection_DataMap clearing")
580       a2.Clear();
581       ////////////////////////////////aNClea.Stop();
582       PERF_STOP_METER("NCollection_DataMap clearing")
583     }
584
585   for (i=0; i<theRep; i++)
586     {
587       QANCollection_DataMapOfRealPnt a1, a2;
588       ////////////////////////////////aTBind.Start();
589       PERF_START_METER("TCollection_DataMap binding")
590       for (j=1; j<=theSize; j++)
591         {
592           Key1Type aKey1;
593           ItemType anItem;
594           Random(aKey1);
595           Random(anItem);
596           a1.Bind(aKey1,anItem);
597         }
598       ////////////////////////////////aTBind.Stop();
599       PERF_STOP_METER("TCollection_DataMap binding")
600       ////////////////////////////////aTFind.Start();
601       PERF_START_METER("TCollection_DataMap finding")
602       for (j=1; j<=theSize; j++)
603         {
604           Key1Type aKey1;
605           Random(aKey1);
606           a1.IsBound(aKey1);
607         }
608       ////////////////////////////////aTFind.Stop();
609       PERF_STOP_METER("TCollection_DataMap finding")
610       ////////////////////////////////aTOper.Start();
611       PERF_START_METER("TCollection_DataMap operator=")
612       a2 = a1;
613       ////////////////////////////////aTOper.Stop();
614       PERF_STOP_METER("TCollection_DataMap operator=")
615       ////////////////////////////////aTClea.Start();
616       PERF_START_METER("TCollection_DataMap clearing")
617       a2.Clear();
618       ////////////////////////////////aTClea.Stop();
619       PERF_STOP_METER("TCollection_DataMap clearing")
620     }
621   printAllMeters(theDI);
622 }
623
624 // ===================== Test perform of DoubleMap type ==========================
625 static void CompDoubleMap (Draw_Interpretor& theDI,
626                            const Standard_Integer theRep,
627                            const Standard_Integer theSize)
628 {
629   Standard_Integer i,j;
630   Standard_Integer iFail1=0, iFail2=0;
631
632   ////////////////////////////////Perf_Meter aNBind ("NCollection_DoubleMap binding",0);
633   ////////////////////////////////Perf_Meter aTBind ("TCollection_DoubleMap binding",0);
634   ////////////////////////////////Perf_Meter aNFind ("NCollection_DoubleMap finding",0);
635   ////////////////////////////////Perf_Meter aTFind ("TCollection_DoubleMap finding",0);
636   ////////////////////////////////Perf_Meter aNOper ("NCollection_DoubleMap operator=",0);
637   ////////////////////////////////Perf_Meter aTOper ("TCollection_DoubleMap operator=",0);
638   ////////////////////////////////Perf_Meter aNClea ("NCollection_DoubleMap clearing",0);
639   ////////////////////////////////Perf_Meter aTClea ("TCollection_DoubleMap clearing",0);
640   //////////////////////////////////Perf_Meter aNAssi ("NCollection_DoubleMap Assign",0);
641   for (i=0; i<theRep; i++)
642     {
643       ////////////////////////////////QANCollection_DoubleMap a1, a2;
644       QANCollection_DoubleMapPerf a1, a2;
645       ////////////////////////////////aNBind.Start();
646       PERF_START_METER("NCollection_DoubleMap binding")
647       for (j=1; j<=theSize; j++)
648         {
649           Key1Type aKey1;
650           Key2Type aKey2;
651           do {
652             Random(aKey1);
653             Random(aKey2);
654             iFail1++;
655           }
656           while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
657           iFail1--;
658           a1.Bind(aKey1,aKey2);
659         }
660       ////////////////////////////////aNBind.Stop();
661       PERF_STOP_METER("NCollection_DoubleMap binding")
662       ////////////////////////////////aNFind.Start();
663       PERF_START_METER("NCollection_DoubleMap finding")
664       for (j=1; j<=theSize; j++)
665         {
666           Key1Type aKey1;
667           Key2Type aKey2;
668           Random(aKey1);
669           Random(aKey2);
670           a1.AreBound(aKey1,aKey2);
671         }
672       ////////////////////////////////aNFind.Stop();
673       PERF_STOP_METER("NCollection_DoubleMap finding")
674       ////////////////////////////////aNOper.Start();
675       PERF_START_METER("NCollection_DoubleMap operator=")
676       a2 = a1;
677       ////////////////////////////////aNOper.Stop();
678       PERF_STOP_METER("NCollection_DoubleMap operator=")
679       //aNAssi.Start();
680       //a2.Assign(a1);
681       //aNAssi.Stop();
682       ////////////////////////////////aNClea.Start();
683       PERF_START_METER("NCollection_DoubleMap clearing")
684       a2.Clear();
685       ////////////////////////////////aNClea.Stop();
686       PERF_STOP_METER("NCollection_DoubleMap clearing")
687     }
688
689   for (i=0; i<theRep; i++)
690     {
691       QANCollection_DoubleMapOfRealInteger a1, a2;
692       ////////////////////////////////aTBind.Start();
693       PERF_START_METER("TCollection_DoubleMap binding")
694       for (j=1; j<=theSize; j++)
695         {
696           Key1Type aKey1;
697           Key2Type aKey2;
698           do {
699             Random(aKey1);
700             Random(aKey2);
701             iFail2++;
702           }
703           while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
704           iFail2--;
705           a1.Bind(aKey1,aKey2);
706         }
707       ////////////////////////////////aTBind.Stop();
708       PERF_STOP_METER("TCollection_DoubleMap binding")
709       ////////////////////////////////aTFind.Start();
710       PERF_START_METER("TCollection_DoubleMap finding")
711       for (j=1; j<=theSize; j++)
712         {
713           Key1Type aKey1;
714           Key2Type aKey2;
715           Random(aKey1);
716           Random(aKey2);
717           a1.AreBound(aKey1,aKey2);
718         }
719       ////////////////////////////////aTFind.Stop();
720       PERF_STOP_METER("TCollection_DoubleMap finding")
721       ////////////////////////////////aTOper.Start();
722       PERF_START_METER("TCollection_DoubleMap operator=")
723       a2 = a1;
724       ////////////////////////////////aTOper.Stop();
725       PERF_STOP_METER("TCollection_DoubleMap operator=")
726       ////////////////////////////////aTClea.Start();
727       PERF_START_METER("TCollection_DoubleMap clearing")
728       a2.Clear();
729       ////////////////////////////////aTClea.Stop();
730       PERF_STOP_METER("TCollection_DoubleMap clearing")
731     }
732   printAllMeters(theDI);
733   if (iFail1 || iFail2)
734     cout << "Warning : N map failed " << iFail1 << " times, T map - " << 
735       iFail2 << endl;
736 }
737
738 // ===================== Test perform of IndexedMap type ==========================
739 static void CompIndexedMap (Draw_Interpretor& theDI,
740                             const Standard_Integer theRep,
741                             const Standard_Integer theSize)
742 {
743   Standard_Integer i,j;
744
745   ////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedMap adding",0);
746   ////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedMap adding",0);
747   ////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedMap operator=",0);
748   ////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedMap operator=",0);
749   ////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedMap finding",0);
750   ////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedMap finding",0);
751   ////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedMap clearing",0);
752   ////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedMap clearing",0);
753   ////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedMap Assign",0);
754
755   for (i=0; i<theRep; i++)
756     {
757       ////////////////////////////////QANCollection_IndexedMap a1, a2;
758       QANCollection_IndexedMapPerf a1, a2;
759       ////////////////////////////////aNBind.Start();
760       PERF_START_METER("NCollection_IndexedMap adding")
761       for (j=1; j<=theSize; j++)
762         {
763           Key1Type aKey1;
764           Random(aKey1);
765           a1.Add(aKey1);
766         }
767       ////////////////////////////////aNBind.Stop();
768       PERF_STOP_METER("NCollection_IndexedMap adding")
769       ////////////////////////////////aNFind.Start();
770       PERF_START_METER("NCollection_IndexedMap finding")
771       for (j=1; j<=theSize; j++)
772         {
773           Key1Type aKey1;
774           Random(aKey1);
775           a1.Contains(aKey1);
776         }
777       ////////////////////////////////aNFind.Stop();
778       PERF_STOP_METER("NCollection_IndexedMap finding")
779       ////////////////////////////////aNOper.Start();
780       PERF_START_METER("NCollection_IndexedMap operator=")
781       a2 = a1;
782       ////////////////////////////////aNOper.Stop();
783       PERF_STOP_METER("NCollection_IndexedMap operator=")
784       ////////////////////////////////aNAssi.Start();
785       PERF_START_METER("NCollection_IndexedMap Assign")
786       a2.Assign(a1);
787       ////////////////////////////////aNAssi.Stop();
788       PERF_STOP_METER("NCollection_IndexedMap Assign")
789       ////////////////////////////////aNClea.Start();
790       PERF_START_METER("NCollection_IndexedMap clearing")
791       a2.Clear();
792       ////////////////////////////////aNClea.Stop();
793       PERF_STOP_METER("NCollection_IndexedMap clearing")
794     }
795
796   for (i=0; i<theRep; i++)
797     {
798       TColStd_IndexedMapOfReal a1, a2;
799       ////////////////////////////////aTBind.Start();
800       PERF_START_METER("TCollection_IndexedMap adding")
801       for (j=1; j<=theSize; j++)
802         {
803           Key1Type aKey1;
804           Random(aKey1);
805           a1.Add(aKey1);
806         }
807       ////////////////////////////////aTBind.Stop();
808       PERF_STOP_METER("TCollection_IndexedMap adding")
809       ////////////////////////////////aTFind.Start();
810       PERF_START_METER("TCollection_IndexedMap finding")
811       for (j=1; j<=theSize; j++)
812         {
813           Key1Type aKey1;
814           Random(aKey1);
815           a1.Contains(aKey1);
816         }
817       ////////////////////////////////aTFind.Stop();
818       PERF_STOP_METER("TCollection_IndexedMap finding")
819       ////////////////////////////////aTOper.Start();
820       PERF_START_METER("TCollection_IndexedMap operator=")
821       a2 = a1;
822       ////////////////////////////////aTOper.Stop();
823       PERF_STOP_METER("TCollection_IndexedMap operator=")
824       ////////////////////////////////aTClea.Start();
825       PERF_START_METER("TCollection_IndexedMap clearing")
826       a2.Clear();
827       ////////////////////////////////aTClea.Stop();
828       PERF_STOP_METER("TCollection_IndexedMap clearing")
829     }
830   printAllMeters(theDI);
831 }
832
833 // ===================== Test perform of IndexedDataMap type ==========================
834 static void CompIndexedDataMap (Draw_Interpretor& theDI,
835                                 const Standard_Integer theRep,
836                                 const Standard_Integer theSize)
837 {
838   Standard_Integer i,j;
839
840   ////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedDataMap binding",0);
841   ////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedDataMap binding",0);
842   ////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedDataMap finding",0);
843   ////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedDataMap finding",0);
844   ////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedDataMap operator=",0);
845   ////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedDataMap operator=",0);
846   ////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedDataMap clearing",0);
847   ////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedDataMap clearing",0);
848   //////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedDataMap Assign",0);
849
850   for (i=0; i<theRep; i++)
851     {
852       ////////////////////////////////QANCollection_IDMap a1, a2;
853       QANCollection_IDMapPerf a1, a2;
854       ////////////////////////////////aNBind.Start();
855       PERF_START_METER("NCollection_IndexedDataMap binding")
856       for (j=1; j<=theSize; j++)
857         {
858           Key1Type aKey1;
859           ItemType anItem;
860           Random(aKey1);
861           Random(anItem);
862           a1.Add(aKey1,anItem);
863         }
864       ////////////////////////////////aNBind.Stop();
865       PERF_STOP_METER("NCollection_IndexedDataMap binding")
866       ////////////////////////////////aNFind.Start();
867       PERF_START_METER("NCollection_IndexedDataMap finding")
868       for (j=1; j<=theSize; j++)
869         {
870           Key1Type aKey1;
871           Random(aKey1);
872           a1.Contains(aKey1);
873         }
874       ////////////////////////////////aNFind.Stop();
875       PERF_STOP_METER("NCollection_IndexedDataMap finding")
876       ////////////////////////////////aNOper.Start();
877       PERF_START_METER("NCollection_IndexedDataMap operator=")
878       a2 = a1;
879       ////////////////////////////////aNOper.Stop();
880       PERF_STOP_METER("NCollection_IndexedDataMap operator=")
881       //aNAssi.Start();
882       //a2.Assign(a1);
883       //aNAssi.Stop();
884       ////////////////////////////////aNClea.Start();
885       PERF_START_METER("NCollection_IndexedDataMap clearing")
886       a2.Clear();
887       ////////////////////////////////aNClea.Stop();
888       PERF_STOP_METER("NCollection_IndexedDataMap clearing")
889     }
890
891   for (i=0; i<theRep; i++)
892     {
893       QANCollection_IndexedDataMapOfRealPnt a1, a2;
894       ////////////////////////////////aTBind.Start();
895       PERF_START_METER("TCollection_IndexedDataMap binding")
896       for (j=1; j<=theSize; j++)
897         {
898           Key1Type aKey1;
899           ItemType anItem;
900           Random(aKey1);
901           Random(anItem);
902           a1.Add(aKey1,anItem);
903         }
904       ////////////////////////////////aTBind.Stop();
905       PERF_STOP_METER("TCollection_IndexedDataMap binding")
906       ////////////////////////////////aTFind.Start();
907       PERF_START_METER("TCollection_IndexedDataMap finding")
908       for (j=1; j<=theSize; j++)
909         {
910           Key1Type aKey1;
911           Random(aKey1);
912           a1.Contains(aKey1);
913         }
914       ////////////////////////////////aTFind.Stop();
915       PERF_STOP_METER("TCollection_IndexedDataMap finding")
916       ////////////////////////////////aTOper.Start();
917       PERF_START_METER("TCollection_IndexedDataMap operator=")
918       a2 = a1;
919       ////////////////////////////////aTOper.Stop();
920       PERF_STOP_METER("TCollection_IndexedDataMap operator=")
921       ////////////////////////////////aTClea.Start();
922       PERF_START_METER("TCollection_IndexedDataMap clearing")
923       a2.Clear();
924       ////////////////////////////////aTClea.Stop();
925       PERF_STOP_METER("TCollection_IndexedDataMap clearing")
926     }
927   printAllMeters(theDI);
928 }
929
930 // ===================== Test perform of SparseArray type ==========================
931 static void CompSparseArray (Draw_Interpretor& theDI,
932                              const Standard_Integer theRep, 
933                              const Standard_Integer theSize)
934 {
935   Standard_Integer i,j;
936   for (i=0; i<theRep; i++)
937     {
938       PERF_START_METER("NCollection_SparseArray creation")
939
940       NCollection_SparseArray<Standard_Integer> a1(theSize),a2(theSize);
941       
942       PERF_STOP_METER("NCollection_SparseArray creation")
943         
944       PERF_START_METER("NCollection_SparseArray filling")
945       for( j=0;j<theSize;j++ )
946       {
947         Standard_Integer iIndex;
948         Random(iIndex,theSize);
949         a1.SetValue(j,iIndex+1);
950       }
951       
952       PERF_STOP_METER("NCollection_SparseArray filling")
953       
954       PERF_START_METER("NCollection_SparseArray size")
955       Standard_Size sizeSparseArray=a1.Size();
956       (void)sizeSparseArray; // avoid compiler warning on unused variable
957       PERF_STOP_METER("NCollection_SparseArray size")
958       
959       PERF_START_METER("NCollection_Array1 Assign")
960         a2.Assign(a1);
961       PERF_STOP_METER("NCollection_Array1 Assign")
962       PERF_START_METER("NCollection_SparseArray HasValue")
963       for (j=0; j<theSize; j++)
964         {
965           Standard_Integer iIndex;
966           Random(iIndex,theSize);
967           a2.HasValue(iIndex+1);
968         }
969       PERF_STOP_METER("NCollection_SparseArray HasValue")
970       PERF_START_METER("NCollection_SparseArray UnsetValue")
971       for (j=0; j<theSize; j++)
972         {
973           Standard_Integer iIndex;
974           Random(iIndex,theSize);
975           a1.UnsetValue(iIndex+1);
976         }
977       PERF_STOP_METER("NCollection_SparseArray UnsetValue")
978       
979       PERF_START_METER("NCollection_SparseArray Clear")
980         a1.Clear();
981         a2.Clear();
982       PERF_STOP_METER("NCollection_SparseArray Clear")
983       
984     }
985
986   printAllMeters(theDI);
987 }
988
989 //=======================================================================
990 //function : CheckArguments
991 //purpose  : 
992 //=======================================================================
993 Standard_Integer CheckArguments(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& Repeat, Standard_Integer& Size)
994 {
995   if ( argc != 3) {
996     di << "Usage : " << argv[0] << " Repeat Size\n";
997     return 1;
998   }
999   Repeat = Draw::Atoi(argv[1]);
1000   Size   = Draw::Atoi(argv[2]);
1001   if ( Repeat < 1 ) {
1002     di << "Repeat > 0\n";
1003     return 1;
1004   }
1005   if ( Size < 1 ) {
1006     di << "Size > 0\n";
1007     return 1;
1008   }
1009   return 0;
1010 }
1011
1012
1013 //=======================================================================
1014 //function : QANColPerfArray1
1015 //purpose  : 
1016 //=======================================================================
1017 static Standard_Integer QANColPerfArray1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1018 {
1019   Standard_Integer Repeat, Size;
1020   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1021     return 1;
1022   }
1023   CompArray1 (di, Repeat, Size);
1024   return 0;
1025 }
1026
1027 //=======================================================================
1028 //function : QANColPerfArray2
1029 //purpose  : 
1030 //=======================================================================
1031 static Standard_Integer QANColPerfArray2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1032 {
1033   Standard_Integer Repeat, Size;
1034   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1035     return 1;
1036   }
1037   CompArray2 (di, Repeat, Size);
1038   return 0;
1039 }
1040
1041 //=======================================================================
1042 //function : QANColPerfList
1043 //purpose  : 
1044 //=======================================================================
1045 static Standard_Integer QANColPerfList(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1046 {
1047   Standard_Integer Repeat, Size;
1048   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1049     return 1;
1050   }
1051   CompList (di, Repeat, Size);
1052   return 0;
1053 }
1054
1055 //=======================================================================
1056 //function : QANColPerfSequence
1057 //purpose  : 
1058 //=======================================================================
1059 static Standard_Integer QANColPerfSequence(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1060 {
1061   Standard_Integer Repeat, Size;
1062   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1063     return 1;
1064   }
1065   CompSequence (di, Repeat, Size);
1066   return 0;
1067 }
1068
1069 //=======================================================================
1070 //function : QANColPerfMap
1071 //purpose  : 
1072 //=======================================================================
1073 static Standard_Integer QANColPerfMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1074 {
1075   Standard_Integer Repeat, Size;
1076   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1077     return 1;
1078   }
1079   CompMap (di, Repeat, Size);
1080   return 0;
1081 }
1082
1083 //=======================================================================
1084 //function : QANColPerfDataMap
1085 //purpose  : 
1086 //=======================================================================
1087 static Standard_Integer QANColPerfDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1088 {
1089   Standard_Integer Repeat, Size;
1090   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1091     return 1;
1092   }
1093   CompDataMap (di, Repeat, Size);
1094   return 0;
1095 }
1096
1097 //=======================================================================
1098 //function : QANColPerfDoubleMap
1099 //purpose  : 
1100 //=======================================================================
1101 static Standard_Integer QANColPerfDoubleMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1102 {
1103   Standard_Integer Repeat, Size;
1104   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1105     return 1;
1106   }
1107   CompDoubleMap (di, Repeat, Size);
1108   return 0;
1109 }
1110
1111 //=======================================================================
1112 //function : QANColPerfIndexedMap
1113 //purpose  : 
1114 //=======================================================================
1115 static Standard_Integer QANColPerfIndexedMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1116 {
1117   Standard_Integer Repeat, Size;
1118   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1119     return 1;
1120   }
1121   CompIndexedMap (di, Repeat, Size);
1122   return 0;
1123 }
1124
1125 //=======================================================================
1126 //function : QANColPerfIndexedDataMap
1127 //purpose  : 
1128 //=======================================================================
1129 static Standard_Integer QANColPerfIndexedDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1130 {
1131   Standard_Integer Repeat, Size;
1132   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1133     return 1;
1134   }
1135   CompIndexedDataMap (di, Repeat, Size);
1136   return 0;
1137 }
1138
1139 //=======================================================================
1140 //function : QANColCheckSparseArray
1141 //purpose  : 
1142 //=======================================================================
1143 static Standard_Integer QANColCheckSparseArray(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1144 {
1145   Standard_Integer Repeat, Size;
1146   if ( CheckArguments(di, argc, argv, Repeat, Size) ) {
1147     return 1;
1148   }
1149   CompSparseArray (di, Repeat, Size);
1150   return 0;
1151 }
1152
1153 void QANCollection::CommandsPerf(Draw_Interpretor& theCommands) {
1154   const char *group = "QANCollection";
1155
1156   // from agvCollTest/src/CollectionEXE/PerfTestEXE.cxx
1157   theCommands.Add("QANColPerfArray1",         "QANColPerfArray1 Repeat Size",         __FILE__, QANColPerfArray1,         group);  
1158   theCommands.Add("QANColPerfArray2",         "QANColPerfArray2 Repeat Size",         __FILE__, QANColPerfArray2,         group);  
1159   theCommands.Add("QANColPerfList",           "QANColPerfList Repeat Size",           __FILE__, QANColPerfList,           group);  
1160   theCommands.Add("QANColPerfSequence",       "QANColPerfSequence Repeat Size",       __FILE__, QANColPerfSequence,       group);  
1161   theCommands.Add("QANColPerfMap",            "QANColPerfMap Repeat Size",            __FILE__, QANColPerfMap,            group);  
1162   theCommands.Add("QANColPerfDataMap",        "QANColPerfDataMap Repeat Size",        __FILE__, QANColPerfDataMap,        group);  
1163   theCommands.Add("QANColPerfDoubleMap",      "QANColPerfDoubleMap Repeat Size",      __FILE__, QANColPerfDoubleMap,      group);  
1164   theCommands.Add("QANColPerfIndexedMap",     "QANColPerfIndexedMap Repeat Size",     __FILE__, QANColPerfIndexedMap,     group);  
1165   theCommands.Add("QANColPerfIndexedDataMap", "QANColPerfIndexedDataMap Repeat Size", __FILE__, QANColPerfIndexedDataMap, group);  
1166   
1167   theCommands.Add("QANColCheckSparseArray",   "QANColCheckSparseArray Repeat Size",   __FILE__, QANColCheckSparseArray,   group);
1168   
1169   return;
1170 }
1171