[occt.git] / src / QANCollection / QANCollection_PerfMaps.hxx

// Created on: 2002-04-30
// Created by: Alexander KARTOMIN (akm)
// Copyright (c) 2002-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#ifndef QANCollection_PerfMaps_HeaderFile
#define QANCollection_PerfMaps_HeaderFile

#include <TColStd_MapOfReal.hxx>
#include <TColStd_IndexedMapOfReal.hxx>
#include <QANCollection_DataMapOfRealPnt.hxx>
#include <QANCollection_DoubleMapOfRealInteger.hxx>
#include <QANCollection_IndexedDataMapOfRealPnt.hxx>

// ===================== Test perform of Map type ==========================
void CompMap (const Standard_Integer theRep,
              const Standard_Integer theSize)
{
  Standard_Integer i,j;

  ////////////////////////////////Perf_Meter aNBind ("NCollection_Map adding",0);
  ////////////////////////////////Perf_Meter aTBind ("TCollection_Map adding",0);
  ////////////////////////////////Perf_Meter aNOper ("NCollection_Map operator=",0);
  ////////////////////////////////Perf_Meter aTOper ("TCollection_Map operator=",0);
  ////////////////////////////////Perf_Meter aNFind ("NCollection_Map finding",0);
  ////////////////////////////////Perf_Meter aTFind ("TCollection_Map finding",0);
  ////////////////////////////////Perf_Meter aNClea ("NCollection_Map clearing",0);
  ////////////////////////////////Perf_Meter aTClea ("TCollection_Map clearing",0);
  ////////////////////////////////Perf_Meter aNAssi ("NCollection_Map Assign",0);
  for (i=0; i<theRep; i++)
    {
      ////////////////////////////////QANCollection_Map a1, a2;
      QANCollection_MapPerf a1, a2;
      ////////////////////////////////aNBind.Start();
      PERF_START_METER("NCollection_Map adding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Add(aKey1);
        }
      ////////////////////////////////aNBind.Stop();
      PERF_STOP_METER("NCollection_Map adding")
      ////////////////////////////////aNFind.Start();
      PERF_START_METER("NCollection_Map finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aNFind.Stop();
      PERF_STOP_METER("NCollection_Map finding")
      ////////////////////////////////aNOper.Start();
      PERF_START_METER("NCollection_Map operator=")
      a2 = a1;
      ////////////////////////////////aNOper.Stop();
      PERF_STOP_METER("NCollection_Map operator=")
      ////////////////////////////////aNAssi.Start();
      PERF_START_METER("NCollection_Map Assign")
      a2.Assign(a1);
      ////////////////////////////////aNAssi.Stop();
      PERF_STOP_METER("NCollection_Map Assign")
      ////////////////////////////////aNClea.Start();
      PERF_START_METER("NCollection_Map clearing")
      a2.Clear();
      ////////////////////////////////aNClea.Stop();
      PERF_STOP_METER("NCollection_Map clearing")
    }

  for (i=0; i<theRep; i++)
    {
      TColStd_MapOfReal a1, a2;
      ////////////////////////////////aTBind.Start();
      PERF_START_METER("TCollection_Map adding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Add(aKey1);
        }
      ////////////////////////////////aTBind.Stop();
      PERF_STOP_METER("TCollection_Map adding")
      ////////////////////////////////aTFind.Start();
      PERF_START_METER("TCollection_Map finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aTFind.Stop();
      PERF_STOP_METER("TCollection_Map finding")
      ////////////////////////////////aTOper.Start();
      PERF_START_METER("TCollection_Map operator=")
      a2 = a1;
      ////////////////////////////////aTOper.Stop();
      PERF_STOP_METER("TCollection_Map operator=")
      ////////////////////////////////aTClea.Start();
      PERF_START_METER("TCollection_Map clearing")
      a2.Clear();
      ////////////////////////////////aTClea.Stop();
      PERF_STOP_METER("TCollection_Map clearing")
    }
  PERF_PRINT_ALL
}

// ===================== Test perform of DataMap type ==========================
void CompDataMap (const Standard_Integer theRep,
                  const Standard_Integer theSize)
{
  Standard_Integer i,j;

  ////////////////////////////////Perf_Meter aNBind ("NCollection_DataMap binding",0);
  ////////////////////////////////Perf_Meter aTBind ("TCollection_DataMap binding",0);
  ////////////////////////////////Perf_Meter aNFind ("NCollection_DataMap finding",0);
  ////////////////////////////////Perf_Meter aTFind ("TCollection_DataMap finding",0);
  ////////////////////////////////Perf_Meter aNOper ("NCollection_DataMap operator=",0);
  ////////////////////////////////Perf_Meter aTOper ("TCollection_DataMap operator=",0);
  ////////////////////////////////Perf_Meter aNClea ("NCollection_DataMap clearing",0);
  ////////////////////////////////Perf_Meter aTClea ("TCollection_DataMap clearing",0);
  //////////////////////////////////Perf_Meter aNAssi ("NCollection_DataMap Assign",0);
  for (i=0; i<theRep; i++)
    {
      ////////////////////////////////QANCollection_DataMap a1, a2;
      QANCollection_DataMapPerf a1, a2;
      ////////////////////////////////aNBind.Start();
      PERF_START_METER("NCollection_DataMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          ItemType anItem;
          Random(aKey1);
          Random(anItem);
          a1.Bind(aKey1,anItem);
        }
      ////////////////////////////////aNBind.Stop();
      PERF_STOP_METER("NCollection_DataMap binding")
      ////////////////////////////////aNFind.Start();
      PERF_START_METER("NCollection_DataMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.IsBound(aKey1);
        }
      ////////////////////////////////aNFind.Stop();
      PERF_STOP_METER("NCollection_DataMap finding")
      ////////////////////////////////aNOper.Start();
      PERF_START_METER("NCollection_DataMap operator=")
      a2 = a1;
      ////////////////////////////////aNOper.Stop();
      PERF_STOP_METER("NCollection_DataMap operator=")
      //aNAssi.Start();
      //a2.Assign(a1);
      //aNAssi.Stop();
      ////////////////////////////////aNClea.Start();
      PERF_START_METER("NCollection_DataMap clearing")
      a2.Clear();
      ////////////////////////////////aNClea.Stop();
      PERF_STOP_METER("NCollection_DataMap clearing")
    }

  for (i=0; i<theRep; i++)
    {
      QANCollection_DataMapOfRealPnt a1, a2;
      ////////////////////////////////aTBind.Start();
      PERF_START_METER("TCollection_DataMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          ItemType anItem;
          Random(aKey1);
          Random(anItem);
          a1.Bind(aKey1,anItem);
        }
      ////////////////////////////////aTBind.Stop();
      PERF_STOP_METER("TCollection_DataMap binding")
      ////////////////////////////////aTFind.Start();
      PERF_START_METER("TCollection_DataMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.IsBound(aKey1);
        }
      ////////////////////////////////aTFind.Stop();
      PERF_STOP_METER("TCollection_DataMap finding")
      ////////////////////////////////aTOper.Start();
      PERF_START_METER("TCollection_DataMap operator=")
      a2 = a1;
      ////////////////////////////////aTOper.Stop();
      PERF_STOP_METER("TCollection_DataMap operator=")
      ////////////////////////////////aTClea.Start();
      PERF_START_METER("TCollection_DataMap clearing")
      a2.Clear();
      ////////////////////////////////aTClea.Stop();
      PERF_STOP_METER("TCollection_DataMap clearing")
    }
  PERF_PRINT_ALL
}

// ===================== Test perform of DoubleMap type ==========================
void CompDoubleMap (const Standard_Integer theRep,
                    const Standard_Integer theSize)
{
  Standard_Integer i,j;
  Standard_Integer iFail1=0, iFail2=0;

  ////////////////////////////////Perf_Meter aNBind ("NCollection_DoubleMap binding",0);
  ////////////////////////////////Perf_Meter aTBind ("TCollection_DoubleMap binding",0);
  ////////////////////////////////Perf_Meter aNFind ("NCollection_DoubleMap finding",0);
  ////////////////////////////////Perf_Meter aTFind ("TCollection_DoubleMap finding",0);
  ////////////////////////////////Perf_Meter aNOper ("NCollection_DoubleMap operator=",0);
  ////////////////////////////////Perf_Meter aTOper ("TCollection_DoubleMap operator=",0);
  ////////////////////////////////Perf_Meter aNClea ("NCollection_DoubleMap clearing",0);
  ////////////////////////////////Perf_Meter aTClea ("TCollection_DoubleMap clearing",0);
  //////////////////////////////////Perf_Meter aNAssi ("NCollection_DoubleMap Assign",0);
  for (i=0; i<theRep; i++)
    {
      ////////////////////////////////QANCollection_DoubleMap a1, a2;
      QANCollection_DoubleMapPerf a1, a2;
      ////////////////////////////////aNBind.Start();
      PERF_START_METER("NCollection_DoubleMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Key2Type aKey2;
          do {
            Random(aKey1);
            Random(aKey2);
            iFail1++;
          }
          while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
          iFail1--;
          a1.Bind(aKey1,aKey2);
        }
      ////////////////////////////////aNBind.Stop();
      PERF_STOP_METER("NCollection_DoubleMap binding")
      ////////////////////////////////aNFind.Start();
      PERF_START_METER("NCollection_DoubleMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Key2Type aKey2;
          Random(aKey1);
          Random(aKey2);
          a1.AreBound(aKey1,aKey2);
        }
      ////////////////////////////////aNFind.Stop();
      PERF_STOP_METER("NCollection_DoubleMap finding")
      ////////////////////////////////aNOper.Start();
      PERF_START_METER("NCollection_DoubleMap operator=")
      a2 = a1;
      ////////////////////////////////aNOper.Stop();
      PERF_STOP_METER("NCollection_DoubleMap operator=")
      //aNAssi.Start();
      //a2.Assign(a1);
      //aNAssi.Stop();
      ////////////////////////////////aNClea.Start();
      PERF_START_METER("NCollection_DoubleMap clearing")
      a2.Clear();
      ////////////////////////////////aNClea.Stop();
      PERF_STOP_METER("NCollection_DoubleMap clearing")
    }

  for (i=0; i<theRep; i++)
    {
      QANCollection_DoubleMapOfRealInteger a1, a2;
      ////////////////////////////////aTBind.Start();
      PERF_START_METER("TCollection_DoubleMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Key2Type aKey2;
          do {
            Random(aKey1);
            Random(aKey2);
            iFail2++;
          }
          while (a1.IsBound1(aKey1) || a1.IsBound2(aKey2));
          iFail2--;
          a1.Bind(aKey1,aKey2);
        }
      ////////////////////////////////aTBind.Stop();
      PERF_STOP_METER("TCollection_DoubleMap binding")
      ////////////////////////////////aTFind.Start();
      PERF_START_METER("TCollection_DoubleMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Key2Type aKey2;
          Random(aKey1);
          Random(aKey2);
          a1.AreBound(aKey1,aKey2);
        }
      ////////////////////////////////aTFind.Stop();
      PERF_STOP_METER("TCollection_DoubleMap finding")
      ////////////////////////////////aTOper.Start();
      PERF_START_METER("TCollection_DoubleMap operator=")
      a2 = a1;
      ////////////////////////////////aTOper.Stop();
      PERF_STOP_METER("TCollection_DoubleMap operator=")
      ////////////////////////////////aTClea.Start();
      PERF_START_METER("TCollection_DoubleMap clearing")
      a2.Clear();
      ////////////////////////////////aTClea.Stop();
      PERF_STOP_METER("TCollection_DoubleMap clearing")
    }
  PERF_PRINT_ALL
  if (iFail1 || iFail2)
    cout << "Warning : N map failed " << iFail1 << " times, T map - " << 
      iFail2 << endl;
}

// ===================== Test perform of IndexedMap type ==========================
void CompIndexedMap (const Standard_Integer theRep,
                     const Standard_Integer theSize)
{
  Standard_Integer i,j;

  ////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedMap adding",0);
  ////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedMap adding",0);
  ////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedMap operator=",0);
  ////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedMap operator=",0);
  ////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedMap finding",0);
  ////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedMap finding",0);
  ////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedMap clearing",0);
  ////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedMap clearing",0);
  ////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedMap Assign",0);

  for (i=0; i<theRep; i++)
    {
      ////////////////////////////////QANCollection_IndexedMap a1, a2;
      QANCollection_IndexedMapPerf a1, a2;
      ////////////////////////////////aNBind.Start();
      PERF_START_METER("NCollection_IndexedMap adding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Add(aKey1);
        }
      ////////////////////////////////aNBind.Stop();
      PERF_STOP_METER("NCollection_IndexedMap adding")
      ////////////////////////////////aNFind.Start();
      PERF_START_METER("NCollection_IndexedMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aNFind.Stop();
      PERF_STOP_METER("NCollection_IndexedMap finding")
      ////////////////////////////////aNOper.Start();
      PERF_START_METER("NCollection_IndexedMap operator=")
      a2 = a1;
      ////////////////////////////////aNOper.Stop();
      PERF_STOP_METER("NCollection_IndexedMap operator=")
      ////////////////////////////////aNAssi.Start();
      PERF_START_METER("NCollection_IndexedMap Assign")
      a2.Assign(a1);
      ////////////////////////////////aNAssi.Stop();
      PERF_STOP_METER("NCollection_IndexedMap Assign")
      ////////////////////////////////aNClea.Start();
      PERF_START_METER("NCollection_IndexedMap clearing")
      a2.Clear();
      ////////////////////////////////aNClea.Stop();
      PERF_STOP_METER("NCollection_IndexedMap clearing")
    }

  for (i=0; i<theRep; i++)
    {
      TColStd_IndexedMapOfReal a1, a2;
      ////////////////////////////////aTBind.Start();
      PERF_START_METER("TCollection_IndexedMap adding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Add(aKey1);
        }
      ////////////////////////////////aTBind.Stop();
      PERF_STOP_METER("TCollection_IndexedMap adding")
      ////////////////////////////////aTFind.Start();
      PERF_START_METER("TCollection_IndexedMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aTFind.Stop();
      PERF_STOP_METER("TCollection_IndexedMap finding")
      ////////////////////////////////aTOper.Start();
      PERF_START_METER("TCollection_IndexedMap operator=")
      a2 = a1;
      ////////////////////////////////aTOper.Stop();
      PERF_STOP_METER("TCollection_IndexedMap operator=")
      ////////////////////////////////aTClea.Start();
      PERF_START_METER("TCollection_IndexedMap clearing")
      a2.Clear();
      ////////////////////////////////aTClea.Stop();
      PERF_STOP_METER("TCollection_IndexedMap clearing")
    }
  PERF_PRINT_ALL
}

// ===================== Test perform of IndexedDataMap type ==========================
void CompIndexedDataMap (const Standard_Integer theRep,
                         const Standard_Integer theSize)
{
  Standard_Integer i,j;

  ////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedDataMap binding",0);
  ////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedDataMap binding",0);
  ////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedDataMap finding",0);
  ////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedDataMap finding",0);
  ////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedDataMap operator=",0);
  ////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedDataMap operator=",0);
  ////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedDataMap clearing",0);
  ////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedDataMap clearing",0);
  //////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedDataMap Assign",0);

  for (i=0; i<theRep; i++)
    {
      ////////////////////////////////QANCollection_IDMap a1, a2;
      QANCollection_IDMapPerf a1, a2;
      ////////////////////////////////aNBind.Start();
      PERF_START_METER("NCollection_IndexedDataMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          ItemType anItem;
          Random(aKey1);
          Random(anItem);
          a1.Add(aKey1,anItem);
        }
      ////////////////////////////////aNBind.Stop();
      PERF_STOP_METER("NCollection_IndexedDataMap binding")
      ////////////////////////////////aNFind.Start();
      PERF_START_METER("NCollection_IndexedDataMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aNFind.Stop();
      PERF_STOP_METER("NCollection_IndexedDataMap finding")
      ////////////////////////////////aNOper.Start();
      PERF_START_METER("NCollection_IndexedDataMap operator=")
      a2 = a1;
      ////////////////////////////////aNOper.Stop();
      PERF_STOP_METER("NCollection_IndexedDataMap operator=")
      //aNAssi.Start();
      //a2.Assign(a1);
      //aNAssi.Stop();
      ////////////////////////////////aNClea.Start();
      PERF_START_METER("NCollection_IndexedDataMap clearing")
      a2.Clear();
      ////////////////////////////////aNClea.Stop();
      PERF_STOP_METER("NCollection_IndexedDataMap clearing")
    }

  for (i=0; i<theRep; i++)
    {
      QANCollection_IndexedDataMapOfRealPnt a1, a2;
      ////////////////////////////////aTBind.Start();
      PERF_START_METER("TCollection_IndexedDataMap binding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          ItemType anItem;
          Random(aKey1);
          Random(anItem);
          a1.Add(aKey1,anItem);
        }
      ////////////////////////////////aTBind.Stop();
      PERF_STOP_METER("TCollection_IndexedDataMap binding")
      ////////////////////////////////aTFind.Start();
      PERF_START_METER("TCollection_IndexedDataMap finding")
      for (j=1; j<=theSize; j++)
        {
          Key1Type aKey1;
          Random(aKey1);
          a1.Contains(aKey1);
        }
      ////////////////////////////////aTFind.Stop();
      PERF_STOP_METER("TCollection_IndexedDataMap finding")
      ////////////////////////////////aTOper.Start();
      PERF_START_METER("TCollection_IndexedDataMap operator=")
      a2 = a1;
      ////////////////////////////////aTOper.Stop();
      PERF_STOP_METER("TCollection_IndexedDataMap operator=")
      ////////////////////////////////aTClea.Start();
      PERF_START_METER("TCollection_IndexedDataMap clearing")
      a2.Clear();
      ////////////////////////////////aTClea.Stop();
      PERF_STOP_METER("TCollection_IndexedDataMap clearing")
    }
  PERF_PRINT_ALL
}

#endif
Commit	Line	Data
b311480e	1	// Created on: 2002-04-30
	2	// Created by: Alexander KARTOMIN (akm)
	3	// Copyright (c) 2002-2012 OPEN CASCADE SAS
	4	//
	5	// The content of this file is subject to the Open CASCADE Technology Public
	6	// License Version 6.5 (the "License"). You may not use the content of this file
	7	// except in compliance with the License. Please obtain a copy of the License
	8	// at http://www.opencascade.org and read it completely before using this file.
	9	//
	10	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	11	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	12	//
	13	// The Original Code and all software distributed under the License is
	14	// distributed on an "AS IS" basis, without warranty of any kind, and the
	15	// Initial Developer hereby disclaims all such warranties, including without
	16	// limitation, any warranties of merchantability, fitness for a particular
	17	// purpose or non-infringement. Please see the License for the specific terms
	18	// and conditions governing the rights and limitations under the License.
	19
7fd59977	20
	21
	22	#ifndef QANCollection_PerfMaps_HeaderFile
	23	#define QANCollection_PerfMaps_HeaderFile
	24
	25	#include <TColStd_MapOfReal.hxx>
	26	#include <TColStd_IndexedMapOfReal.hxx>
	27	#include <QANCollection_DataMapOfRealPnt.hxx>
	28	#include <QANCollection_DoubleMapOfRealInteger.hxx>
	29	#include <QANCollection_IndexedDataMapOfRealPnt.hxx>
	30
	31	// ===================== Test perform of Map type ==========================
	32	void CompMap (const Standard_Integer theRep,
	33	const Standard_Integer theSize)
	34	{
	35	Standard_Integer i,j;
	36
	37	////////////////////////////////Perf_Meter aNBind ("NCollection_Map adding",0);
	38	////////////////////////////////Perf_Meter aTBind ("TCollection_Map adding",0);
	39	////////////////////////////////Perf_Meter aNOper ("NCollection_Map operator=",0);
	40	////////////////////////////////Perf_Meter aTOper ("TCollection_Map operator=",0);
	41	////////////////////////////////Perf_Meter aNFind ("NCollection_Map finding",0);
	42	////////////////////////////////Perf_Meter aTFind ("TCollection_Map finding",0);
	43	////////////////////////////////Perf_Meter aNClea ("NCollection_Map clearing",0);
	44	////////////////////////////////Perf_Meter aTClea ("TCollection_Map clearing",0);
	45	////////////////////////////////Perf_Meter aNAssi ("NCollection_Map Assign",0);
	46	for (i=0; i<theRep; i++)
	47	{
	48	////////////////////////////////QANCollection_Map a1, a2;
	49	QANCollection_MapPerf a1, a2;
	50	////////////////////////////////aNBind.Start();
	51	PERF_START_METER("NCollection_Map adding")
	52	for (j=1; j<=theSize; j++)
	53	{
	54	Key1Type aKey1;
	55	Random(aKey1);
	56	a1.Add(aKey1);
	57	}
	58	////////////////////////////////aNBind.Stop();
	59	PERF_STOP_METER("NCollection_Map adding")
	60	////////////////////////////////aNFind.Start();
	61	PERF_START_METER("NCollection_Map finding")
	62	for (j=1; j<=theSize; j++)
	63	{
	64	Key1Type aKey1;
	65	Random(aKey1);
	66	a1.Contains(aKey1);
	67	}
	68	////////////////////////////////aNFind.Stop();
	69	PERF_STOP_METER("NCollection_Map finding")
	70	////////////////////////////////aNOper.Start();
	71	PERF_START_METER("NCollection_Map operator=")
	72	a2 = a1;
	73	////////////////////////////////aNOper.Stop();
	74	PERF_STOP_METER("NCollection_Map operator=")
	75	////////////////////////////////aNAssi.Start();
	76	PERF_START_METER("NCollection_Map Assign")
	77	a2.Assign(a1);
	78	////////////////////////////////aNAssi.Stop();
	79	PERF_STOP_METER("NCollection_Map Assign")
	80	////////////////////////////////aNClea.Start();
	81	PERF_START_METER("NCollection_Map clearing")
	82	a2.Clear();
	83	////////////////////////////////aNClea.Stop();
84	PERF_STOP_METER("NCollection_Map clearing")
85	}
86
87	for (i=0; i<theRep; i++)
88	{
89	TColStd_MapOfReal a1, a2;
90	////////////////////////////////aTBind.Start();
91	PERF_START_METER("TCollection_Map adding")
92	for (j=1; j<=theSize; j++)
93	{
94	Key1Type aKey1;
95	Random(aKey1);
96	a1.Add(aKey1);
97	}
98	////////////////////////////////aTBind.Stop();
99	PERF_STOP_METER("TCollection_Map adding")
100	////////////////////////////////aTFind.Start();
101	PERF_START_METER("TCollection_Map finding")
102	for (j=1; j<=theSize; j++)
103	{
104	Key1Type aKey1;
105	Random(aKey1);
106	a1.Contains(aKey1);
107	}
108	////////////////////////////////aTFind.Stop();
109	PERF_STOP_METER("TCollection_Map finding")
110	////////////////////////////////aTOper.Start();
111	PERF_START_METER("TCollection_Map operator=")
112	a2 = a1;
113	////////////////////////////////aTOper.Stop();
114	PERF_STOP_METER("TCollection_Map operator=")
115	////////////////////////////////aTClea.Start();
116	PERF_START_METER("TCollection_Map clearing")
117	a2.Clear();
118	////////////////////////////////aTClea.Stop();
119	PERF_STOP_METER("TCollection_Map clearing")
120	}
c2ae831c	121	PERF_PRINT_ALL
7fd59977	122	}
	123
	124	// ===================== Test perform of DataMap type ==========================
	125	void CompDataMap (const Standard_Integer theRep,
	126	const Standard_Integer theSize)
	127	{
	128	Standard_Integer i,j;
	129
	130	////////////////////////////////Perf_Meter aNBind ("NCollection_DataMap binding",0);
	131	////////////////////////////////Perf_Meter aTBind ("TCollection_DataMap binding",0);
	132	////////////////////////////////Perf_Meter aNFind ("NCollection_DataMap finding",0);
	133	////////////////////////////////Perf_Meter aTFind ("TCollection_DataMap finding",0);
	134	////////////////////////////////Perf_Meter aNOper ("NCollection_DataMap operator=",0);
	135	////////////////////////////////Perf_Meter aTOper ("TCollection_DataMap operator=",0);
	136	////////////////////////////////Perf_Meter aNClea ("NCollection_DataMap clearing",0);
	137	////////////////////////////////Perf_Meter aTClea ("TCollection_DataMap clearing",0);
	138	//////////////////////////////////Perf_Meter aNAssi ("NCollection_DataMap Assign",0);
	139	for (i=0; i<theRep; i++)
	140	{
	141	////////////////////////////////QANCollection_DataMap a1, a2;
	142	QANCollection_DataMapPerf a1, a2;
	143	////////////////////////////////aNBind.Start();
	144	PERF_START_METER("NCollection_DataMap binding")
	145	for (j=1; j<=theSize; j++)
	146	{
	147	Key1Type aKey1;
	148	ItemType anItem;
	149	Random(aKey1);
	150	Random(anItem);
	151	a1.Bind(aKey1,anItem);
	152	}
	153	////////////////////////////////aNBind.Stop();
	154	PERF_STOP_METER("NCollection_DataMap binding")
	155	////////////////////////////////aNFind.Start();
	156	PERF_START_METER("NCollection_DataMap finding")
	157	for (j=1; j<=theSize; j++)
	158	{
	159	Key1Type aKey1;
	160	Random(aKey1);
	161	a1.IsBound(aKey1);
	162	}
	163	////////////////////////////////aNFind.Stop();
	164	PERF_STOP_METER("NCollection_DataMap finding")
	165	////////////////////////////////aNOper.Start();
	166	PERF_START_METER("NCollection_DataMap operator=")
	167	a2 = a1;
	168	////////////////////////////////aNOper.Stop();
	169	PERF_STOP_METER("NCollection_DataMap operator=")
	170	//aNAssi.Start();
	171	//a2.Assign(a1);
	172	//aNAssi.Stop();
	173	////////////////////////////////aNClea.Start();
	174	PERF_START_METER("NCollection_DataMap clearing")
	175	a2.Clear();
	176	////////////////////////////////aNClea.Stop();
	177	PERF_STOP_METER("NCollection_DataMap clearing")
	178	}
	179
	180	for (i=0; i<theRep; i++)
	181	{
	182	QANCollection_DataMapOfRealPnt a1, a2;
	183	////////////////////////////////aTBind.Start();
	184	PERF_START_METER("TCollection_DataMap binding")
	185	for (j=1; j<=theSize; j++)
186	{
187	Key1Type aKey1;
188	ItemType anItem;
189	Random(aKey1);
190	Random(anItem);
191	a1.Bind(aKey1,anItem);
192	}
193	////////////////////////////////aTBind.Stop();
194	PERF_STOP_METER("TCollection_DataMap binding")
195	////////////////////////////////aTFind.Start();
196	PERF_START_METER("TCollection_DataMap finding")
197	for (j=1; j<=theSize; j++)
198	{
199	Key1Type aKey1;
200	Random(aKey1);
201	a1.IsBound(aKey1);
202	}
203	////////////////////////////////aTFind.Stop();
204	PERF_STOP_METER("TCollection_DataMap finding")
205	////////////////////////////////aTOper.Start();
206	PERF_START_METER("TCollection_DataMap operator=")
207	a2 = a1;
208	////////////////////////////////aTOper.Stop();
209	PERF_STOP_METER("TCollection_DataMap operator=")
210	////////////////////////////////aTClea.Start();
211	PERF_START_METER("TCollection_DataMap clearing")
212	a2.Clear();
213	////////////////////////////////aTClea.Stop();
214	PERF_STOP_METER("TCollection_DataMap clearing")
215	}
c2ae831c	216	PERF_PRINT_ALL
7fd59977	217	}
	218
	219	// ===================== Test perform of DoubleMap type ==========================
	220	void CompDoubleMap (const Standard_Integer theRep,
	221	const Standard_Integer theSize)
	222	{
	223	Standard_Integer i,j;
	224	Standard_Integer iFail1=0, iFail2=0;
	225
	226	////////////////////////////////Perf_Meter aNBind ("NCollection_DoubleMap binding",0);
	227	////////////////////////////////Perf_Meter aTBind ("TCollection_DoubleMap binding",0);
	228	////////////////////////////////Perf_Meter aNFind ("NCollection_DoubleMap finding",0);
	229	////////////////////////////////Perf_Meter aTFind ("TCollection_DoubleMap finding",0);
	230	////////////////////////////////Perf_Meter aNOper ("NCollection_DoubleMap operator=",0);
	231	////////////////////////////////Perf_Meter aTOper ("TCollection_DoubleMap operator=",0);
	232	////////////////////////////////Perf_Meter aNClea ("NCollection_DoubleMap clearing",0);
	233	////////////////////////////////Perf_Meter aTClea ("TCollection_DoubleMap clearing",0);
	234	//////////////////////////////////Perf_Meter aNAssi ("NCollection_DoubleMap Assign",0);
	235	for (i=0; i<theRep; i++)
	236	{
	237	////////////////////////////////QANCollection_DoubleMap a1, a2;
	238	QANCollection_DoubleMapPerf a1, a2;
	239	////////////////////////////////aNBind.Start();
	240	PERF_START_METER("NCollection_DoubleMap binding")
	241	for (j=1; j<=theSize; j++)
	242	{
	243	Key1Type aKey1;
	244	Key2Type aKey2;
	245	do {
	246	Random(aKey1);
	247	Random(aKey2);
	248	iFail1++;
	249	}
	250	while (a1.IsBound1(aKey1) \|\| a1.IsBound2(aKey2));
	251	iFail1--;
	252	a1.Bind(aKey1,aKey2);
	253	}
	254	////////////////////////////////aNBind.Stop();
	255	PERF_STOP_METER("NCollection_DoubleMap binding")
	256	////////////////////////////////aNFind.Start();
	257	PERF_START_METER("NCollection_DoubleMap finding")
	258	for (j=1; j<=theSize; j++)
	259	{
	260	Key1Type aKey1;
	261	Key2Type aKey2;
	262	Random(aKey1);
	263	Random(aKey2);
	264	a1.AreBound(aKey1,aKey2);
	265	}
	266	////////////////////////////////aNFind.Stop();
	267	PERF_STOP_METER("NCollection_DoubleMap finding")
	268	////////////////////////////////aNOper.Start();
	269	PERF_START_METER("NCollection_DoubleMap operator=")
	270	a2 = a1;
	271	////////////////////////////////aNOper.Stop();
	272	PERF_STOP_METER("NCollection_DoubleMap operator=")
	273	//aNAssi.Start();
	274	//a2.Assign(a1);
	275	//aNAssi.Stop();
	276	////////////////////////////////aNClea.Start();
	277	PERF_START_METER("NCollection_DoubleMap clearing")
	278	a2.Clear();
	279	////////////////////////////////aNClea.Stop();
	280	PERF_STOP_METER("NCollection_DoubleMap clearing")
281	}
282
283	for (i=0; i<theRep; i++)
284	{
285	QANCollection_DoubleMapOfRealInteger a1, a2;
286	////////////////////////////////aTBind.Start();
287	PERF_START_METER("TCollection_DoubleMap binding")
288	for (j=1; j<=theSize; j++)
289	{
290	Key1Type aKey1;
291	Key2Type aKey2;
292	do {
293	Random(aKey1);
294	Random(aKey2);
295	iFail2++;
296	}
297	while (a1.IsBound1(aKey1) \|\| a1.IsBound2(aKey2));
298	iFail2--;
299	a1.Bind(aKey1,aKey2);
300	}
301	////////////////////////////////aTBind.Stop();
302	PERF_STOP_METER("TCollection_DoubleMap binding")
303	////////////////////////////////aTFind.Start();
304	PERF_START_METER("TCollection_DoubleMap finding")
305	for (j=1; j<=theSize; j++)
306	{
307	Key1Type aKey1;
308	Key2Type aKey2;
309	Random(aKey1);
310	Random(aKey2);
311	a1.AreBound(aKey1,aKey2);
312	}
313	////////////////////////////////aTFind.Stop();
314	PERF_STOP_METER("TCollection_DoubleMap finding")
315	////////////////////////////////aTOper.Start();
316	PERF_START_METER("TCollection_DoubleMap operator=")
317	a2 = a1;
318	////////////////////////////////aTOper.Stop();
319	PERF_STOP_METER("TCollection_DoubleMap operator=")
320	////////////////////////////////aTClea.Start();
321	PERF_START_METER("TCollection_DoubleMap clearing")
322	a2.Clear();
323	////////////////////////////////aTClea.Stop();
324	PERF_STOP_METER("TCollection_DoubleMap clearing")
325	}
c2ae831c	326	PERF_PRINT_ALL
7fd59977	327	if (iFail1 \|\| iFail2)
	328	cout << "Warning : N map failed " << iFail1 << " times, T map - " <<
	329	iFail2 << endl;
	330	}
	331
	332	// ===================== Test perform of IndexedMap type ==========================
	333	void CompIndexedMap (const Standard_Integer theRep,
	334	const Standard_Integer theSize)
	335	{
	336	Standard_Integer i,j;
	337
	338	////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedMap adding",0);
	339	////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedMap adding",0);
	340	////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedMap operator=",0);
	341	////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedMap operator=",0);
	342	////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedMap finding",0);
	343	////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedMap finding",0);
	344	////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedMap clearing",0);
	345	////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedMap clearing",0);
	346	////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedMap Assign",0);
	347
	348	for (i=0; i<theRep; i++)
	349	{
	350	////////////////////////////////QANCollection_IndexedMap a1, a2;
	351	QANCollection_IndexedMapPerf a1, a2;
	352	////////////////////////////////aNBind.Start();
	353	PERF_START_METER("NCollection_IndexedMap adding")
	354	for (j=1; j<=theSize; j++)
	355	{
	356	Key1Type aKey1;
	357	Random(aKey1);
	358	a1.Add(aKey1);
	359	}
	360	////////////////////////////////aNBind.Stop();
	361	PERF_STOP_METER("NCollection_IndexedMap adding")
	362	////////////////////////////////aNFind.Start();
	363	PERF_START_METER("NCollection_IndexedMap finding")
	364	for (j=1; j<=theSize; j++)
	365	{
	366	Key1Type aKey1;
	367	Random(aKey1);
	368	a1.Contains(aKey1);
	369	}
	370	////////////////////////////////aNFind.Stop();
	371	PERF_STOP_METER("NCollection_IndexedMap finding")
	372	////////////////////////////////aNOper.Start();
	373	PERF_START_METER("NCollection_IndexedMap operator=")
	374	a2 = a1;
	375	////////////////////////////////aNOper.Stop();
	376	PERF_STOP_METER("NCollection_IndexedMap operator=")
	377	////////////////////////////////aNAssi.Start();
	378	PERF_START_METER("NCollection_IndexedMap Assign")
	379	a2.Assign(a1);
	380	////////////////////////////////aNAssi.Stop();
	381	PERF_STOP_METER("NCollection_IndexedMap Assign")
	382	////////////////////////////////aNClea.Start();
	383	PERF_START_METER("NCollection_IndexedMap clearing")
	384	a2.Clear();
	385	////////////////////////////////aNClea.Stop();
	386	PERF_STOP_METER("NCollection_IndexedMap clearing")
	387	}
	388
	389	for (i=0; i<theRep; i++)
	390	{
391	TColStd_IndexedMapOfReal a1, a2;
392	////////////////////////////////aTBind.Start();
393	PERF_START_METER("TCollection_IndexedMap adding")
394	for (j=1; j<=theSize; j++)
395	{
396	Key1Type aKey1;
397	Random(aKey1);
398	a1.Add(aKey1);
399	}
400	////////////////////////////////aTBind.Stop();
401	PERF_STOP_METER("TCollection_IndexedMap adding")
402	////////////////////////////////aTFind.Start();
403	PERF_START_METER("TCollection_IndexedMap finding")
404	for (j=1; j<=theSize; j++)
405	{
406	Key1Type aKey1;
407	Random(aKey1);
408	a1.Contains(aKey1);
409	}
410	////////////////////////////////aTFind.Stop();
411	PERF_STOP_METER("TCollection_IndexedMap finding")
412	////////////////////////////////aTOper.Start();
413	PERF_START_METER("TCollection_IndexedMap operator=")
414	a2 = a1;
415	////////////////////////////////aTOper.Stop();
416	PERF_STOP_METER("TCollection_IndexedMap operator=")
417	////////////////////////////////aTClea.Start();
418	PERF_START_METER("TCollection_IndexedMap clearing")
419	a2.Clear();
420	////////////////////////////////aTClea.Stop();
421	PERF_STOP_METER("TCollection_IndexedMap clearing")
422	}
c2ae831c	423	PERF_PRINT_ALL
7fd59977	424	}
	425
	426	// ===================== Test perform of IndexedDataMap type ==========================
	427	void CompIndexedDataMap (const Standard_Integer theRep,
	428	const Standard_Integer theSize)
	429	{
	430	Standard_Integer i,j;
	431
	432	////////////////////////////////Perf_Meter aNBind ("NCollection_IndexedDataMap binding",0);
	433	////////////////////////////////Perf_Meter aTBind ("TCollection_IndexedDataMap binding",0);
	434	////////////////////////////////Perf_Meter aNFind ("NCollection_IndexedDataMap finding",0);
	435	////////////////////////////////Perf_Meter aTFind ("TCollection_IndexedDataMap finding",0);
	436	////////////////////////////////Perf_Meter aNOper ("NCollection_IndexedDataMap operator=",0);
	437	////////////////////////////////Perf_Meter aTOper ("TCollection_IndexedDataMap operator=",0);
	438	////////////////////////////////Perf_Meter aNClea ("NCollection_IndexedDataMap clearing",0);
	439	////////////////////////////////Perf_Meter aTClea ("TCollection_IndexedDataMap clearing",0);
	440	//////////////////////////////////Perf_Meter aNAssi ("NCollection_IndexedDataMap Assign",0);
	441
	442	for (i=0; i<theRep; i++)
	443	{
	444	////////////////////////////////QANCollection_IDMap a1, a2;
	445	QANCollection_IDMapPerf a1, a2;
	446	////////////////////////////////aNBind.Start();
	447	PERF_START_METER("NCollection_IndexedDataMap binding")
	448	for (j=1; j<=theSize; j++)
	449	{
	450	Key1Type aKey1;
	451	ItemType anItem;
	452	Random(aKey1);
	453	Random(anItem);
	454	a1.Add(aKey1,anItem);
	455	}
	456	////////////////////////////////aNBind.Stop();
	457	PERF_STOP_METER("NCollection_IndexedDataMap binding")
	458	////////////////////////////////aNFind.Start();
	459	PERF_START_METER("NCollection_IndexedDataMap finding")
	460	for (j=1; j<=theSize; j++)
	461	{
	462	Key1Type aKey1;
	463	Random(aKey1);
	464	a1.Contains(aKey1);
	465	}
	466	////////////////////////////////aNFind.Stop();
	467	PERF_STOP_METER("NCollection_IndexedDataMap finding")
	468	////////////////////////////////aNOper.Start();
	469	PERF_START_METER("NCollection_IndexedDataMap operator=")
	470	a2 = a1;
	471	////////////////////////////////aNOper.Stop();
	472	PERF_STOP_METER("NCollection_IndexedDataMap operator=")
	473	//aNAssi.Start();
	474	//a2.Assign(a1);
	475	//aNAssi.Stop();
	476	////////////////////////////////aNClea.Start();
	477	PERF_START_METER("NCollection_IndexedDataMap clearing")
	478	a2.Clear();
	479	////////////////////////////////aNClea.Stop();
	480	PERF_STOP_METER("NCollection_IndexedDataMap clearing")
	481	}
	482
	483	for (i=0; i<theRep; i++)
	484	{
	485	QANCollection_IndexedDataMapOfRealPnt a1, a2;
	486	////////////////////////////////aTBind.Start();
	487	PERF_START_METER("TCollection_IndexedDataMap binding")
488	for (j=1; j<=theSize; j++)
489	{
490	Key1Type aKey1;
491	ItemType anItem;
492	Random(aKey1);
493	Random(anItem);
494	a1.Add(aKey1,anItem);
495	}
496	////////////////////////////////aTBind.Stop();
497	PERF_STOP_METER("TCollection_IndexedDataMap binding")
498	////////////////////////////////aTFind.Start();
499	PERF_START_METER("TCollection_IndexedDataMap finding")
500	for (j=1; j<=theSize; j++)
501	{
502	Key1Type aKey1;
503	Random(aKey1);
504	a1.Contains(aKey1);
505	}
506	////////////////////////////////aTFind.Stop();
507	PERF_STOP_METER("TCollection_IndexedDataMap finding")
508	////////////////////////////////aTOper.Start();
509	PERF_START_METER("TCollection_IndexedDataMap operator=")
510	a2 = a1;
511	////////////////////////////////aTOper.Stop();
512	PERF_STOP_METER("TCollection_IndexedDataMap operator=")
513	////////////////////////////////aTClea.Start();
514	PERF_START_METER("TCollection_IndexedDataMap clearing")
515	a2.Clear();
516	////////////////////////////////aTClea.Stop();
517	PERF_STOP_METER("TCollection_IndexedDataMap clearing")
518	}
c2ae831c	519	PERF_PRINT_ALL
7fd59977	520	}
	521
	522	#endif