date:20070126

RE: [Haskell-cafe] proposal: HaBench, a Haskell Benchmark Suite

2007-01-26 Thread Simon Peyton-Jones

| Following up and the threads on haskell and haskell-cafe, I'd like to
| gather ideas, comments and suggestions for a standarized Haskell
| Benchmark Suite.

Great idea.  Maybe this can subsume nofib.  I recommend reading the nofib paper 
though:
http://citeseer.ist.psu.edu/partain93nofib.html

Simon
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

hrm...

2007-01-26 Thread John Meacham

so I have this simple bit of code, which should be fast but seems to be
being compiled to something very slow.

 import Data.Word
 import Data.Bits
 
 fhb :: Word - Word
 fhb w = b1 .|. b2  where
 b2 = if 0x .. w /= 0 then 0x2 else 0
 b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0

what it compiles to is something involving Integers, lots of coercions
and other nasty stuff when it should consist of a couple of primitive
operations.

John

-- 
John Meacham - ⑆repetae.net⑆john⑈
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: hrm...

2007-01-26 Thread Donald Bruce Stewart

john:
 so I have this simple bit of code, which should be fast but seems to be
 being compiled to something very slow.
 
  import Data.Word
  import Data.Bits
  
  fhb :: Word - Word
  fhb w = b1 .|. b2  where
  b2 = if 0x .. w /= 0 then 0x2 else 0
  b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0
 
 what it compiles to is something involving Integers, lots of coercions
 and other nasty stuff when it should consist of a couple of primitive
 operations.

looks suspicous!

Ideally I'd want something like this produced:

fhb_ideal :: Word - Word
fhb_ideal (W# w) =
W# ((int2Word# (case word2Int# (int2Word# 0xFF00FF00# `and#` w) of 0# 
- 0#; _ - 1#))
`or#`
(int2Word# (case word2Int# (int2Word# 0x# `and#` w) of 0# 
- 0#; _ - 2#)))

which generates the core:

M.$wfhb_ideal =
  \ (ww_sP7 :: GHC.Prim.Word#) -
GHC.Prim.or#
  (GHC.Prim.int2Word#
 (case GHC.Prim.word2Int# (GHC.Prim.and# __word 4278255360 ww_sP7) 
of ds_dMF {
__DEFAULT - 1; 0 - 0
  }))
  (GHC.Prim.int2Word#
 (case GHC.Prim.word2Int# (GHC.Prim.and# __word 4294901760 ww_sP7) 
of ds_dMI {
__DEFAULT - 2; 0 - 0

  }))


Whereas the test example:

fhb_boxed :: Word - Word
fhb_boxed w = b1 .|. b2  where
b2 = if 0x .. w /= 0 then 0x2 else 0
b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0

Turns into some nasty:

M.lit =
  case GHC.Prim.addIntC# 2147418113 2147483647
  of wild2_aN5 { (# r_aN7, c_aN8 #) -
  case case c_aN8 of wild3_aN9 {
 __DEFAULT -
   case GHC.Prim.int2Integer# 2147418113 of wild4_aNa { (# s_aNc, 
d_aNd #) -
   case GHC.Prim.int2Integer# 2147483647 of wild5_aNe { (# s1_aNg, 
d1_aNh #) -
   case GHC.Prim.plusInteger# s_aNc d_aNd s1_aNg d1_aNh
   of wild_aO8 { (# s2_aOa, d2_aOb #) -
   GHC.Prim.integer2Word# s2_aOa d2_aOb
   }
   }
   };
 0 - GHC.Prim.int2Word# r_aN7
   }
  of ww_aNW { __DEFAULT -
  GHC.Word.W# ww_aNW
  }
  }

M.lit1 :: GHC.Word.Word
[GlobalId]
[Str: DmdType]
M.lit1 =
  case GHC.Prim.addIntC# 2130771713 2147483647
  of wild2_aN5 { (# r_aN7, c_aN8 #) -
  case case c_aN8 of wild3_aN9 {
 __DEFAULT -
   case GHC.Prim.int2Integer# 2130771713 of wild4_aNa { (# s_aNc, 
d_aNd #) -
   case GHC.Prim.int2Integer# 2147483647 of wild5_aNe { (# s1_aNg, 
d1_aNh #) -
   case GHC.Prim.plusInteger# s_aNc d_aNd s1_aNg d1_aNh
   of wild_aO8 { (# s2_aOa, d2_aOb #) -
   GHC.Prim.integer2Word# s2_aOa d2_aOb
   }
   }
   };
 0 - GHC.Prim.int2Word# r_aN7
   }
  of ww_aNW { __DEFAULT -
  GHC.Word.W# ww_aNW
  }
  }

M.$wfhb_boxed :: GHC.Prim.Word# - GHC.Prim.Word#
[GlobalId]
[Arity 1
 Str: DmdType L]
M.$wfhb_boxed =
  \ (ww_sPh :: GHC.Prim.Word#) -
case M.lit1 of wild_aOp { GHC.Word.W# x#_aOr -
case GHC.Prim.eqWord# (GHC.Prim.and# x#_aOr ww_sPh) __word 0 of 
wild2_aOk {
  GHC.Base.False -
case M.lit of wild1_XPt { GHC.Word.W# x#1_XPx -
case GHC.Prim.eqWord# (GHC.Prim.and# x#1_XPx ww_sPh) __word 0 of 
wild21_XOP {
  GHC.Base.False - __word 3; GHC.Base.True - __word 1
}
};
  GHC.Base.True -
case M.lit of wild1_XPt { GHC.Word.W# x#1_XPx -
case GHC.Prim.eqWord# (GHC.Prim.and# x#1_XPx ww_sPh) __word 0 of 
wild21_XOP {
  GHC.Base.False - __word 2; GHC.Base.True - __word 0
}
}
}
}



So not sure where those Integer thingies are creeping in.

Here's a little test case, btw, with a QuickCheck property.

-- Don
{-# OPTIONS -fglasgow-exts #-}

module M where

import Data.Word
import Data.Bits

import GHC.Prim
import GHC.Word

import Test.QuickCheck

fhb_boxed :: Word - Word
fhb_boxed w = b1 .|. b2  where
b2 = if 0x .. w /= 0 then 0x2 else 0
b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0

fhb_ideal :: Word - Word
fhb_ideal (W# w) =
W# ((int2Word# (case word2Int# (int2Word# 0xFF00FF00# `and#` w) of 0# - 
0#; _ - 1#))
`or#`
(int2Word# (case word2Int# (int2Word# 0x# `and#` w) of 0# - 
0#; _ - 2#)))



--
-- QuickCheck test
--
prop_eq n = fhb_boxed w == fhb_ideal w
  where
w = fromIntegral (n :: Int)

main = test prop_eq

$ ./A
OK, passed 100 tests.
-}
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: hrm...

2007-01-26 Thread Lemmih


On 1/27/07, John Meacham [EMAIL PROTECTED] wrote:

so I have this simple bit of code, which should be fast but seems to be
being compiled to something very slow.

 import Data.Word
 import Data.Bits

 fhb :: Word - Word
 fhb w = b1 .|. b2  where
 b2 = if 0x .. w /= 0 then 0x2 else 0
 b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0

what it compiles to is something involving Integers, lots of coercions
and other nasty stuff when it should consist of a couple of primitive
operations.


Output from an AMD64 box:

$wfhb =
 \ (ww_sIw :: GHC.Prim.Word#) -
   case GHC.Prim.eqWord# (GHC.Prim.and# __word 4278255360 ww_sIw) __word 0
   of wild2_aHI {
 GHC.Base.False -
   case GHC.Prim.eqWord# (GHC.Prim.and# __word 4294901760 ww_sIw) __word 0
   of wild21_XHW {
 GHC.Base.False - __word 3; GHC.Base.True - __word 1
   };
 GHC.Base.True -
   case GHC.Prim.eqWord# (GHC.Prim.and# __word 4294901760 ww_sIw) __word 0
   of wild21_XHW {
 GHC.Base.False - __word 2; GHC.Base.True - __word 0
   }
   }


--
Cheers,
 Lemmih
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: hrm...

2007-01-26 Thread John Meacham

On Sat, Jan 27, 2007 at 01:48:29AM +0100, Lemmih wrote:
 On 1/27/07, John Meacham [EMAIL PROTECTED] wrote:
 so I have this simple bit of code, which should be fast but seems to be
 being compiled to something very slow.
 
  import Data.Word
  import Data.Bits
 
  fhb :: Word - Word
  fhb w = b1 .|. b2  where
  b2 = if 0x .. w /= 0 then 0x2 else 0
  b1 = if 0xFF00FF00 .. w /= 0 then 0x1 else 0
 
 what it compiles to is something involving Integers, lots of coercions
 and other nasty stuff when it should consist of a couple of primitive
 operations.
 
 Output from an AMD64 box:
 
 $wfhb =
  \ (ww_sIw :: GHC.Prim.Word#) -
case GHC.Prim.eqWord# (GHC.Prim.and# __word 4278255360 ww_sIw) __word 0
of wild2_aHI {
  GHC.Base.False -
case GHC.Prim.eqWord# (GHC.Prim.and# __word 4294901760 ww_sIw) 
__word 0
of wild21_XHW {
  GHC.Base.False - __word 3; GHC.Base.True - __word 1
};
  GHC.Base.True -
case GHC.Prim.eqWord# (GHC.Prim.and# __word 4294901760 ww_sIw) 
__word 0
of wild21_XHW {
  GHC.Base.False - __word 2; GHC.Base.True - __word 0
}
}
 

Yeah, but the 64 bit version of the algorithm also generates the bad
code on x86-64.

I think the issue is an off by one error somewhere, making ghc think that
0x is too big to fit in a Word, when it actually fits just
right.

John


-- 
John Meacham - ⑆repetae.net⑆john⑈
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

RE: [Haskell-cafe] proposal: HaBench, a Haskell Benchmark Suite

hrm...

Re: hrm...

Re: hrm...

Re: hrm...

5 matches

Site Navigation

Mail list logo

Footer information