{-# LINE 1 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
{-# LANGUAGE CPP, CApiFFI, NondecreasingIndentation, NumDecimals #-}




module System.CPUTime.Windows
    ( getCPUTime
    , getCpuTimePrecision
    ) where

import GHC.Internal.Foreign.Ptr
import GHC.Internal.Foreign.Marshal.Alloc
import GHC.Internal.Foreign.Marshal.Utils
import GHC.Internal.Foreign.Storable
import GHC.Internal.Foreign.C.Types
import GHC.Internal.Word
import Prelude

-- For FILETIME etc. on Windows


{-# LINE 21 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}


{-# LINE 23 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}

getCPUTime :: IO Integer
getCPUTime :: IO Integer
getCPUTime = do
     -- NOTE: GetProcessTimes() is only supported on NT-based OSes.

     -- The counts reported by GetProcessTimes() are in 100-ns (10^-7) units.

    Int -> (Ptr FILETIME -> IO Integer) -> IO Integer
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes (Int
8) ((Ptr FILETIME -> IO Integer) -> IO Integer)
-> (Ptr FILETIME -> IO Integer) -> IO Integer
forall a b. (a -> b) -> a -> b
$ \ Ptr FILETIME
p_creationTime -> do
{-# LINE 29 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
    allocaBytes (8) $ \ p_exitTime -> do
{-# LINE 30 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
    allocaBytes (8) $ \ p_kernelTime -> do
{-# LINE 31 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
    allocaBytes (8) $ \ p_userTime -> do
{-# LINE 32 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
    pid <- getCurrentProcess
    ok <- getProcessTimes pid p_creationTime p_exitTime p_kernelTime p_userTime
    if toBool ok then do
      ut <- ft2psecs p_userTime
      kt <- ft2psecs p_kernelTime
      return (ut + kt)
     else return 0
  where
        ft2psecs :: Ptr FILETIME -> IO Integer
        ft2psecs :: Ptr FILETIME -> IO Integer
ft2psecs Ptr FILETIME
ft = do
          high <- ((\Ptr FILETIME
hsc_ptr -> Ptr FILETIME -> Int -> IO Word32
forall b. Ptr b -> Int -> IO Word32
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr FILETIME
hsc_ptr Int
4)) Ptr FILETIME
ft :: IO Word32
{-# LINE 43 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
          low  <- ((\Ptr FILETIME
hsc_ptr -> Ptr FILETIME -> Int -> IO Word32
forall b. Ptr b -> Int -> IO Word32
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr FILETIME
hsc_ptr Int
0))  ft :: IO Word32
{-# LINE 44 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
            -- Convert 100-ns units to picosecs (10^-12)

            -- => multiply by 10^5.

          return (((fromIntegral high) * (2^(32::Int)) + (fromIntegral low)) * 100000)

    -- ToDo: pin down elapsed times to just the OS thread(s) that

    -- are evaluating/managing Haskell code.


-- While it's hard to get reliable numbers, the consensus is that Windows only provides

-- 16 millisecond resolution in GetProcessTimes (see Python PEP 0418)

getCpuTimePrecision :: IO Integer
getCpuTimePrecision :: IO Integer
getCpuTimePrecision = Integer -> IO Integer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
16e9

type FILETIME = ()
type HANDLE = ()

-- need proper Haskell names (initial lower-case character)


{-# LINE 64 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}
foreign import ccall unsafe "GetCurrentProcess" getCurrentProcess :: IO (Ptr HANDLE)
foreign import ccall unsafe "GetProcessTimes" getProcessTimes :: Ptr HANDLE -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> Ptr FILETIME -> IO CInt

{-# LINE 69 "libraries\\base\\src\\System\\CPUTime\\Windows.hsc" #-}