[project @ 2005-01-28 13:36:25 by simonmar]

[ghc-base.git] / System / CPUTime.hsc

diff --git a/System/CPUTime.hsc b/System/CPUTime.hsc
index 25098fe..603afce 100644 (file)
--- a/System/CPUTime.hsc
+++ b/System/CPUTime.hsc
@@ -1,15 +1,13 @@
 -----------------------------------------------------------------------------
--- 
+-- |
 -- Module      :  System.CPUTime
 -- Copyright   :  (c) The University of Glasgow 2001
--- License     :  BSD-style (see the file libraries/core/LICENSE)
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
 -- 
 -- Maintainer  :  libraries@haskell.org
 -- Stability   :  provisional
 -- Portability :  portable
 --
--- $Id: CPUTime.hsc,v 1.7 2002/04/24 16:03:39 simonmar Exp $
---
 -- The standard CPUTime library.
 --
 -----------------------------------------------------------------------------
@@ -22,26 +20,33 @@ module System.CPUTime
 
 import Prelude
 
+import Data.Ratio
+
+#ifdef __HUGS__
+import Hugs.Time ( getCPUTime, clockTicks )
+#endif
+
+#ifdef __NHC__
+import CPUTime ( getCPUTime, cpuTimePrecision )
+#endif
+
+#ifdef __GLASGOW_HASKELL__
 import Foreign
 import Foreign.C
 
-import Data.Ratio
-
 #include "HsBase.h"
+#endif
 
+#ifdef __GLASGOW_HASKELL__
 -- -----------------------------------------------------------------------------
--- Computation `getCPUTime' returns the number of picoseconds CPU time
+-- |Computation 'getCPUTime' returns the number of picoseconds CPU time
 -- used by the current program.  The precision of this result is
 -- implementation-dependent.
 
--- The `cpuTimePrecision' constant is the smallest measurable difference
--- in CPU time that the implementation can record, and is given as an
--- integral number of picoseconds.
-
 getCPUTime :: IO Integer
 getCPUTime = do
 
-#if !defined(mingw32_TARGET_OS) && !defined(cygwin32_TARGET_OS)
+#if !defined(mingw32_HOST_OS) && !defined(cygwin32_HOST_OS)
 -- getrusage() is right royal pain to deal with when targetting multiple
 -- versions of Solaris, since some versions supply it in libc (2.3 and 2.5),
 -- while 2.4 has got it in libucb (I wouldn't be too surprised if it was back
@@ -49,7 +54,7 @@ getCPUTime = do
 --
 -- Avoid the problem by resorting to times() instead.
 --
-#if defined(HAVE_GETRUSAGE) && ! irix_TARGET_OS && ! solaris2_TARGET_OS
+#if defined(HAVE_GETRUSAGE) && ! irix_HOST_OS && ! solaris2_HOST_OS
     allocaBytes (#const sizeof(struct rusage)) $ \ p_rusage -> do
     getrusage (#const RUSAGE_SELF) p_rusage
 
@@ -59,9 +64,9 @@ getCPUTime = do
     u_usec <- (#peek struct timeval,tv_usec) ru_utime :: IO CTime
     s_sec  <- (#peek struct timeval,tv_sec)  ru_stime :: IO CTime
     s_usec <- (#peek struct timeval,tv_usec) ru_stime :: IO CTime
-
-    return ((fromIntegral u_sec * 1000000 + fromIntegral u_usec + 
-             fromIntegral s_sec * 1000000 + fromIntegral s_usec) 
+    let realToInteger = round . realToFrac :: Real a => a -> Integer
+    return ((realToInteger u_sec * 1000000 + realToInteger u_usec + 
+             realToInteger s_sec * 1000000 + realToInteger s_usec) 
                * 1000000)
 
 type CRUsage = ()
@@ -72,7 +77,8 @@ foreign import ccall unsafe getrusage :: CInt -> Ptr CRUsage -> IO CInt
     times p_tms
     u_ticks  <- (#peek struct tms,tms_utime) p_tms :: IO CClock
     s_ticks  <- (#peek struct tms,tms_stime) p_tms :: IO CClock
-    return (( (fromIntegral u_ticks + fromIntegral s_ticks) * 1000000000000) 
+    let realToInteger = round . realToFrac :: Real a => a -> Integer
+    return (( (realToInteger u_ticks + realToInteger s_ticks) * 1000000000000) 
                        `div` fromIntegral clockTicks)
 
 type CTms = ()
@@ -86,6 +92,8 @@ foreign import ccall unsafe times :: Ptr CTms -> IO CClock
 #endif
 
 #else /* win32 */
+     -- NOTE: GetProcessTimes() is only supported on NT-based OSes.
+     -- The counts reported by GetProcessTimes() are in 100-ns (10^-7) units.
     allocaBytes (#const sizeof(FILETIME)) $ \ p_creationTime -> do
     allocaBytes (#const sizeof(FILETIME)) $ \ p_exitTime -> do
     allocaBytes (#const sizeof(FILETIME)) $ \ p_kernelTime -> do
@@ -95,11 +103,15 @@ foreign import ccall unsafe times :: Ptr CTms -> IO CClock
     if toBool ok then do
       ut <- ft2psecs p_userTime
       kt <- ft2psecs p_kernelTime
-      return (fromIntegral (ut + kt))
+      return (ut + kt)
      else return 0
-  where ft2psecs ft = do
+  where 
+       ft2psecs :: Ptr FILETIME -> IO Integer
+        ft2psecs ft = do
           high <- (#peek FILETIME,dwHighDateTime) ft :: IO CLong
           low <- (#peek FILETIME,dwLowDateTime) ft :: IO CLong
+           -- Convert 100-ns units to picosecs (10^-12) 
+           -- => multiply by 10^5.
           return (((fromIntegral high) * (2^32) + (fromIntegral low)) * 100000)
 
     -- ToDo: pin down elapsed times to just the OS thread(s) that
@@ -112,10 +124,18 @@ foreign import ccall unsafe "GetCurrentProcess" getCurrentProcess :: IO (Ptr HAN
 foreign import ccall unsafe "GetProcessTimes" getProcessTimes :: Ptr HANDLE -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> IO CInt
 
 #endif /* not _WIN32 */
+#endif /* __GLASGOW_HASKELL__ */
 
+-- |The 'cpuTimePrecision' constant is the smallest measurable difference
+-- in CPU time that the implementation can record, and is given as an
+-- integral number of picoseconds.
+
+#ifndef __NHC__
 cpuTimePrecision :: Integer
 cpuTimePrecision = round ((1000000000000::Integer) % fromIntegral (clockTicks))
+#endif
 
+#ifdef __GLASGOW_HASKELL__
 clockTicks :: Int
 clockTicks =
 #if defined(CLK_TCK)
@@ -124,3 +144,4 @@ clockTicks =
     unsafePerformIO (sysconf (#const _SC_CLK_TCK) >>= return . fromIntegral)
 foreign import ccall unsafe sysconf :: CInt -> IO CLong
 #endif
+#endif /* __GLASGOW_HASKELL__ */