nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 #include <time.h>
+00029 
+00030 #ifdef NL_OS_WINDOWS
+00031 #       include <windows.h>
+00032 #elif defined (NL_OS_UNIX)
+00033 #       include <sys/time.h>
+00034 #       include <unistd.h>
+00035 #endif
+00036 
+00037 #include "nel/misc/time_nl.h"
+00038 
+00039 namespace NLMISC
+00040 {
+00041 
+00042 /*
+00043  *
+00044  */
+00045 uint32 CTime::getSecondsSince1970 ()
+00046 {
+00047         return (uint32) time (NULL);
+00048 }
+00049 
+00050 
+00051 
+00052 /*
+00053  *
+00054  */
+00055 TTime CTime::getLocalTime ()
+00056 {
+00057 #ifdef NL_OS_WINDOWS
+00058 
+00059         static bool byperfcounter;
+00060         static bool initdone = false;
+00061 
+00062         // Initialization
+00063         if ( ! initdone )
+00064         {
+00065                 byperfcounter = (getPerformanceTime() != 0);
+00066                 initdone = true;
+00067         }
+00068 
+00069         /* Retrieve time is ms
+00070      * Why do we prefer getPerformanceTime() to timeGetTime() ? Because on one dual-processor Win2k
+00071          * PC, we have noticed that timeGetTime() slows down when the client is running !!!
+00072          */
+00073 
+00074 
+00075         /* Now we have noticed that on all WinNT4 PC the getPerformanceTime can give us value that
+00076          * are less than previous
+00077          */
+00078 
+00079         //if ( byperfcounter )
+00080         //{
+00081         //      return (TTime)(ticksToSecond(getPerformanceTime()) * 1000.0f);
+00082         //}
+00083         //else
+00084         //{
+00085                 return timeGetTime();
+00086         //}
+00087 
+00088 #elif defined (NL_OS_UNIX)
+00089 
+00090         struct timeval tv;
+00091 
+00092         if ( gettimeofday( &tv, NULL) == -1 )
+00093         {
+00094                 nlerror ("Cannot get time of day.");
+00095         }
+00096         return (TTime)tv.tv_sec * (TTime)1000 + (TTime)tv.tv_usec / (TTime)1000;
+00097 
+00098 #endif
+00099 }
+00100 
+00101 
+00102 /*
+00103  *
+00104  */
+00105 TTicks CTime::getPerformanceTime ()
+00106 {
+00107 #ifdef NL_OS_WINDOWS
+00108         LARGE_INTEGER ret;
+00109         if (QueryPerformanceCounter (&ret))
+00110                 return ret.QuadPart;
+00111         else
+00112                 return 0;
+00113 #else // NL_OS_WINDOWS
+00114 
+00115 #ifdef HAVE_X86
+00116         unsigned long long int x;
+00117         __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
+00118         return x;
+00119 #else HAVE_X86
+00120         static bool firstWarn = true;
+00121         if (firstWarn)
+00122         {
+00123                 nlwarning ("TTicks CTime::getPerformanceTime () is not implemented for your processor, returning 0");
+00124                 firstWarn = false;
+00125         }
+00126         return 0;
+00127 #endif // HAVE_X86
+00128 
+00129 #endif // NL_OS_WINDOWS
+00130 }
+00131 /*
+00132 #define GETTICKS(t) asm volatile ("push %%esi\n\t" "mov %0, %%esi" : : "r" (t)); \
+00133                       asm volatile ("push %eax\n\t" "push %edx"); \
+00134                       asm volatile ("rdtsc"); \
+00135                       asm volatile ("movl %eax, (%esi)\n\t" "movl %edx, 4(%esi)"); \
+00136                       asm volatile ("pop %edx\n\t" "pop %eax\n\t" "pop %esi"); 
+00137 */
+00138 
+00139 
+00140 /*
+00141  *
+00142  */
+00143 double CTime::ticksToSecond (TTicks ticks)
+00144 {
+00145 #ifdef NL_OS_WINDOWS
+00146         LARGE_INTEGER ret;
+00147         if (QueryPerformanceFrequency(&ret))
+00148         {
+00149                 return (double)(sint64)ticks/(double)ret.QuadPart;
+00150         }
+00151         else
+00152 #endif // NL_OS_WINDOWS
+00153         {
+00154                 static bool benchFrequency = true;
+00155                 static sint64 freq = 0;
+00156                 if (benchFrequency)
+00157                 {
+00158                         // try to have an estimation of the cpu frequency
+00159 
+00160                         TTicks tickBefore = getPerformanceTime ();
+00161                         TTicks tickAfter = tickBefore;
+00162                         TTime timeBefore = getLocalTime ();
+00163                         TTime timeAfter = timeBefore;
+00164                         while (true)
+00165                         {
+00166                                 if (timeAfter - timeBefore > 1000)
+00167                                         break;
+00168                                 timeAfter = getLocalTime ();
+00169                                 tickAfter = getPerformanceTime ();
+00170                         }
+00171 
+00172                         TTime timeDelta = timeAfter - timeBefore;
+00173                         TTicks tickDelta = tickAfter - tickBefore;
+00174 
+00175                         freq = 1000 * tickDelta / timeDelta;
+00176                         benchFrequency = false;
+00177                 }
+00178 
+00179                 return (double)(sint64)ticks/(double)freq;
+00180         }
+00181 }
+00182 
+00183 
+00184 } // NLMISC
+
time_nl.cpp
