将指针传递给Haskell中的数组到C函数

I have the following C code:

我有以下C代码:

#include <sys/times.h>
#include <time.h>


float etime_( float *tarray )
{   struct tms buf;

    times( &buf );

    tarray[0] = 1.0 * buf.tms_utime / CLOCKS_PER_SEC;
    tarray[1] = 1.0 * buf.tms_stime / CLOCKS_PER_SEC;

    return tarray[0] + tarray[1];
}

Trying to port this Fortran code to Haskell:

尝试将此Fortran代码移植到Haskell:

  PROGRAM Test
    IMPLICIT NONE

    REAL t, ta(2), etime

    INTEGER i
    DOUBLE PRECISION x

    do i = 1, 10000
       x = sin( cos( i * 1.0 d0 ) )
       print *, x 
    enddo

    ta(1) = 0.0d0
    ta(2) = 0.0d0

    t = etime( ta )       

    PRINT *, 'user time:    ', ta(1)
    PRINT *, 'system time:  ', ta(2)
    PRINT *, 'process time: ', t

  END

How can I define array and ! or !!! for the below code to work?

我该如何定义数组?要么 !!!以下代码工作?

module Main where

import GHC.Ptr
import GHC.Prim
import System.IO.Unsafe
import Control.Monad

foreign import ccall etime_ :: Ptr Double → IO Double
etime = etime_

main :: IO Int
main = do
  mapM_ (print . sin . cos . (* (1.0 :: Double)) . fromIntegral) [1..10000 :: Int]
  ta ← array 2
  t ← etime ta
  putStrLn $ "user time:    " ++ show (ta !!! 0)
  putStrLn $ "system time:  " ++ show (ta !!! 1)
  putStrLn $ "process time: " ++ show t
  return 0

array :: Int → IO (Ptr a)
array size = undefined

(!) :: Ptr a → Int → IO a
(!) = undefined

(!!!) :: Ptr a → Int → a
(!!!) = undefined

3 个解决方案

#1

I suggest this:

我建议这个:

{-# LANGUAGE ForeignFunctionInterface #-}

import Foreign.Marshal.Array (allocaArray, peekArray)
import Foreign.Ptr (Ptr)

foreign import ccall etime_ :: Ptr Float -> IO Float

main :: IO ()
main = do
  mapM_ (print . sin . cos . (* (1.0 :: Double)) . fromIntegral) [1..10000 :: Int]
  allocaArray 2 $ \ta -> do
    ptime <- etime_ ta
    [utime, stime] <- peekArray 2 ta
    putStrLn $ "user time:    " ++ show utime
    putStrLn $ "system time:  " ++ show stime
    putStrLn $ "process time: " ++ show ptime

but to answer your specific questions:

但要回答您的具体问题:

array :: Storable a => Int -> IO (Ptr a)
array = mallocArray

(!) :: Storable a => Ptr a -> Int -> IO a
(!) = peekElemOff

(!!!) :: Storable a => Ptr a -> Int -> a
(!!!) ptr = unsafePerformIO . peekElemOff ptr

I suggest to use hoogle to find the functions you need.

我建议使用hoogle查找您需要的功能。

#2

Return the sum, user time, and system time as a tuple. Note that etime takes a pointer to float, not double, so make your types agree:

将总和,用户时间和系统时间作为元组返回。请注意,etime将指针指向float,而不是double,因此请使您的类型同意:

{-# LANGUAGE ForeignFunctionInterface #-}

module Main where

import Foreign (Ptr)
import Foreign.Marshal.Array (allocaArray,peekArray)
import Control.Monad (mapM_)

foreign import ccall etime_ :: Ptr Float -> IO Float

etime :: IO (Float, Float, Float)
etime = do
  allocaArray 2 $ \ta -> do
    t <- etime_ ta
    [user,sys] <- peekArray 2 ta
    return (t,user,sys)

main :: IO Int
main = do
  mapM_ (print . sin . cos . (* (1.0 :: Double)) . fromIntegral) [1..10000 :: Int]
  (t,user,sys) <- etime
  putStrLn $ "user time:    " ++ show user
  putStrLn $ "system time:  " ++ show sys
  putStrLn $ "process time: " ++ show t
  return 0

#3

Given the following additional Haskell module:

给出以下额外的Haskell模块:

module AllocSymbols (

  (↑≣), -- mallocArray
  (≣⊠), -- free

  (≣→), -- peekElemOff
  (≣←), -- pokeElemOff

  (⥱), -- peekElemOff unsafe

  (⥅), -- advancePtr

) where

import GHC.Ptr
import System.IO.Unsafe
import Foreign.Storable
import Foreign.Marshal.Alloc (free)
import Foreign.Marshal.Array

(↑≣) :: Storable a ⇒ Int → IO (Ptr a)
(↑≣) = mallocArray

(⥱) :: Storable a ⇒ Ptr a → Int → a
a ⥱ i = unsafePerformIO $ peekElemOff a i

(≣→) :: Storable a ⇒ Ptr a → Int → IO a
(≣→) = peekElemOff

(≣←) :: Storable a ⇒ Ptr a → Int → a → IO ()
(≣←) = pokeElemOff

(⥅) :: Storable a ⇒ Ptr a → Int → Ptr a
(⥅) = advancePtr

(≣⊠) :: Ptr a → IO ()
(≣⊠) = Foreign.Marshal.Alloc.free

And now we can port this piece of Fortran code:

现在我们可以移植这段Fortran代码:

  PROGRAM Test
    IMPLICIT NONE

    REAL t, ta(2), etime

    INTEGER i
    DOUBLE PRECISION x

    do i = 1, 10000
       x = sin( cos( i * 1.0 d0 ) )
       print *, x 
    enddo

    ta(1) = 0.0d0
    ta(2) = 0.0d0

    t = etime( ta )       

    PRINT *, 'user time:    ', ta(1)
    PRINT *, 'system time:  ', ta(2)
    PRINT *, 'process time: ', t

  END

word for word to Haskell:

一字一句地对哈斯克尔:

module Main where

import GHC.Ptr
import AllocSymbols
import Control.Monad

foreign import ccall etime_ :: Ptr Float → IO Float

main :: IO ()
main = do
  mapM_ (print . sin . cos . (* (1.0 :: Double)) . fromIntegral) [1 .. 10000 :: Int]

  ta ← (2 ↑≣) -- ta :: Ptr Float

  (ta ≣← 0) 0.0
  (ta ≣← 1) 0.0

  t ← etime_ ta

  putStrLn $ " user time:    " ++ show (ta ⥱ 0)
  putStrLn $ " system time:  " ++ show (ta ⥱ 1)
  putStrLn $ " process time: " ++ show t

  (ta ≣⊠) -- optional in this case

#1