bridges/test/performance/testperformance.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <stdio.h>
  21 #include <math.h>
  22
  23 #include <osl/interlck.h>
  24 #include <osl/mutex.hxx>
  25 #include <osl/semaphor.h>
  26
  27 #include <rtl/string.hxx>
  28 #include <rtl/byteseq.hxx>
  29
  30 #include <com/sun/star/uno/Sequence.hxx>
  31
  32 #ifdef SAL_W32
  33 #include <windows.h>
  34 #else
  35 #include <sys/times.h>
  36 #endif
  37 #ifndef ULONG_MAX
  38 #define ULONG_MAX 0xffffffff
  39 #endif
  40
  41 using namespace ::osl;
  42 using namespace ::com::sun::star::uno;
  43
  44 static inline sal_uInt32 getSystemTicks()
  45 {
  46 #ifdef SAL_W32
  47     return (sal_uInt32)GetTickCount();
  48 #else
  49     static sal_uInt32   nImplTicksPerSecond = 0;
  50     static double       dImplTicksPerSecond;
  51     static double       dImplTicksULONGMAX;
  52
  53     struct tms          aTms;
  54     sal_uInt32 nTicks = (sal_uInt32)times( &aTms );
  55
  56     if ( !nImplTicksPerSecond )
  57     {
  58         nImplTicksPerSecond = CLK_TCK;
  59         dImplTicksPerSecond = nImplTicksPerSecond;
  60         dImplTicksULONGMAX  = (double)(sal_uInt32)ULONG_MAX;
  61     }
  62
  63     double fTicks = nTicks;
  64     fTicks *= 1000;
  65     fTicks /= dImplTicksPerSecond;
  66     fTicks = fmod (fTicks, dImplTicksULONGMAX);
  67
  68     return (sal_uInt32)fTicks;
  69 #endif
  70 }
  71
  72 class MyTimer
  73 {
  74 public:
  75     MyTimer(  const OString &descString ) :
  76         nStart( getSystemTicks() ),
  77         m_descString( descString )
  78         {
  79         }
  80     ~MyTimer( )
  81         {
  82             printf( "%f s : %s\n", (getSystemTicks() -nStart) / 1000., m_descString.getStr() );
  83         }
  84 private:
  85     sal_uInt32 nStart;
  86     OString m_descString;
  87 };
  88
  89 void main()
  90 {
  91     // interlocked count
  92     {
  93         MyTimer timer( "performance - 1000*10000 interlocked count" );
  94         oslInterlockedCount count;
  95         for( int i = 0 ; i < 1000*10000 ; i ++  )
  96         {
  97             osl_atomic_increment( &count );
  98         }
  99     }
 100     {
 101         OString myDummyString( "blubber" );
 102         MyTimer timer( "performance - 1000*10000 acquiring/releasing a refcounted string(without destruction)" );
 103         for( int i = 0 ; i < 1000*10000 ; i ++  )
 104         {
 105             OString myNextDummyString = myDummyString ;
 106         }
 107     }
 108
 109     printf( "--------------------\n" );
 110     {
 111         Mutex mutex;
 112         MyTimer timer( "performance - 1000*10000 acquiring/releasing an osl::Mutex" );
 113         for( int i = 0 ; i < 1000*10000 ; i ++  )
 114         {
 115             MutexGuard guard( mutex );
 116         }
 117     }
 118
 119     {
 120         oslSemaphore sema = osl_createSemaphore(1);
 121         MyTimer timer( "performance - 1000*10000 acquiring/releasing an osl::Semaphore" );
 122         for( int i = 0 ; i < 1000*10000 ; i ++  )
 123         {
 124             osl_acquireSemaphore( sema );
 125             osl_releaseSemaphore( sema );
 126         }
 127     }
 128
 129     printf( "--------------------\n" );
 130     {
 131         MyTimer timer( "performance - 1000*10000 rtl::ByteSequence(500)" );
 132         for( int i = 0 ; i < 1000*1000 ; i ++  )
 133         {
 134             ByteSequence seq(500);
 135         }
 136     }
 137
 138     {
 139         MyTimer timer( "performance - 1000*1000 rtl::ByteSequence(500,BYTESEQ_NODEFAULT)" );
 140         for( int i = 0 ; i < 1000*1000 ; i ++  )
 141         {
 142             ByteSequence seq(500, BYTESEQ_NODEFAULT);
 143         }
 144     }
 145     {
 146         MyTimer timer( "performance - 1000*1000 com::sun::star::uno::Sequence< sal_Int8 > (500)" );
 147         for( int i = 0 ; i < 1000*1000 ; i ++  )
 148         {
 149             Sequence< sal_Int8> seq(500);
 150         }
 151     }
 152     {
 153         MyTimer timer( "performance - 1000*1000 rtl_freeMemory( rtl_allocateMemory( 512 ) )" );
 154         for( int i = 0 ; i < 1000*1000 ; i ++  )
 155         {
 156             rtl_freeMemory( rtl_allocateMemory( 512 ) );
 157         }
 158     }
 159
 160     printf( "--------------------\n" );
 161     {
 162         MyTimer timer( "performance - 1000*1000 byte  string construction/destruction" );
 163         for( int i = 0 ; i < 1000*1000 ; i ++  )
 164         {
 165             OString textEnc( "this is a test string" );
 166         }
 167     }
 168
 169     {
 170         MyTimer timer( "performance - 1000*1000 unicode string construction/destruction" );
 171         for( int i = 0 ; i < 1000*1000 ; i ++  )
 172         {
 173             OUString textEnc( "this is a test string" );
 174         }
 175     }
 176
 177 }
 178
 179 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */