- Glasgow-haskell-users

Re: Faster, GHC, and floating point.
by Andreas.Schroeder＠gillardon.de 17 Oct '03

17 Oct '03

Hi all, Ok, it isn't FTP but HTTP, but here is the link. http://haskell.sourcez.org/performance.zip Regards, Andreas Schroeder

1 0

Re: Faster, GHC, and floating point.
by Andreas.Schroeder＠gillardon.de 17 Oct '03

17 Oct '03

Hi all, using -fexcess-precision improves the runtime from about 180259 ns to 140201 ns on my environment (Intel P3, 700Mhz, 384 MB Ram, Win2k). That makes for me a speedup of 1.29. I tested the other flags, -funbox-strict-fields -fliberate-case-threshold100 but did not see an improvement. Well, pure Haskell has a runtime of 140201 ns as stated above for a test of 9000 calls (thanks to the "sum $ map f [inputlist]" pattern!). If i use the C aibd as foreign call, i get a runtime of 80115 ns That's pretty good (both ghc6.0.1 on MinGW windows env). But if i look at my Java or C++ solution, then Java takes for the same task (JVM 1.4.2_01 client vm) 30000 ns. The resolution of the currenttimemillis is pretty poor in Java. It's neither better in C++, but i guess that's because of my Arch. At home, i got a better timer resolution than that. (wich i was able to lookup through Haskell). The C++ version lies somewhere between 20000 ns and 10000 ns, close to 20000 ns. I guess it's 18000 ns. That's still the difference of 4 to 6 between C++ and Haskell. I will look at the "core source" generated by GHC to look if it is good enough. For interested souls, i will put the C++ code as well as the haskell code on an FTP server. FTP access details will come soon. Currently, i am setting up a second test. While this first study concentrates on "numbers", and does not provide much data structures, the second study i will do concentrates on complex data structures (yup, i will have a GREAT time with C++, since i "only" learned Java, Haskell, SML, MIPS assembler, ProLog, ... at the University) Thanks to all for your great help so far, Andreas Schroeder |---------+-----------------------------------------> | | JP Bernardy <jyp_7(a)yahoo.com> | | | Gesendet von: | | | glasgow-haskell-users-bounces@| | | haskell.org | | | | | | | | | 16.10.2003 12:56 | | | | |---------+-----------------------------------------> >-------------------------------------------------------------------------------------------------------------------| | | | An: glasgow-haskell-users(a)haskell.org | | Kopie: | | Thema: Faster, GHC, and floating point. | >-------------------------------------------------------------------------------------------------------------------| Hi all, > Generally, did you look at http://haskell.org/ghc/docs/latest/html/users_guide/faster.html I have to say that one advice is not perfect... "Don't use Floats: "...There's rarely a speed disadvantage -- "modern machines will use the same floating-point "unit for both. ... Assuming an i386 architecture, the way to get really faster code is 1. Use -fexcess-precision, unless you really need the exact (lesser) precision. Otherwise each intermediate result is spilled in memory. This hurts! 2. Use floats rather than doubles. You won't lose so much precision because all intermediate computations will use 80-bit precision. This saves some memory. Plus, GHC doesn't align on 64 bits, which slows down access to doubles. I've made up a simple benchmark with Andreas' code, using the pure haskell "aibd", with main: tt z = print $ sum $ map (\x -> rechneZins x 0.01 z) $ [1..10000] main = do tt 20 tt 21 ... tt 30 ghc -O2 -fglasgow-exts --make Main.hs, a.out runs in 7.82 secs. with -fexcess-precision, runs in 2.97secs; with Float instead of Double, runs in 2.72secs. This is with gcc 3.3.2, ghc 6.0.1, linux and a pentium4 arch. Just my 2 cents, JP. __________________________________ Do you Yahoo!? The New Yahoo! Shopping - with improved product search http://shopping.yahoo.com _______________________________________________ Glasgow-haskell-users mailing list Glasgow-haskell-users(a)haskell.org http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

1 0

RE: stg_ap_v_ret porting crash: solved?
by Simon Marlow 17 Oct '03

17 Oct '03

> but > > -------------------------------------------------------------- > ---------- > ===fptools== Recursively making `boot' in base haskell98 > network haskell-src unix ... > PWD = /scratch/users/eden/ghc-6.0.1/libraries > -------------------------------------------------------------- > ---------- > -------------------------------------------------------------- > ---------- > ==fptools== gmake boot -r; > in /scratch/users/eden/ghc-6.0.1/libraries/base > -------------------------------------------------------------- > ---------- > ../../ghc/utils/ghc-pkg/ghc-pkg-inplace --update-package > <package.conf.inplace > /usr/users/eden/scratch/ghc-6.0.1/ghc/driver/package.conf.inpl > ace: parse error in package config file > gmake[1]: *** [../../ghc/driver/stamp-pkg-conf-base] Error 1 > gmake: *** [boot] Error 1 Have you done 'make boot' in ghc/driver? Cheers, Simon

3 6

RULES for SPECIALIZ(E)ations
by Juanma Barranquero 17 Oct '03

17 Oct '03

I'm playing with rules, and I wonder if it is posible to define a rule that will trigger for a specialization of a function. (In the following examples, the functions are not necesarily useful or good-style... :) I have: count :: (Integral b) => (a -> Bool) -> [a] -> b count = count' 0 where count' n _ [] = n count' n f (x:xs) | f x = count' (n+1) f xs | otherwise = count' n f xs with b of class Integral and not an Int because it could posibly be used to count lists with more than maxInt elements (let's say, bytes in a huge file, or records in a long-lived socket connection, or whatever). Ok, if I'm not mistaken I can add: {-# SPECIALIZE count :: (a -> Bool) -> [a] -> Int #-} and have the compiler add an alternate version of count for uses such as: let c :: Int = count even [1..100] Now, to learn about RULES, I defined: {-# RULES "count/generic" forall f g xs. count f (filter g xs) = genericLength (filter (\x -> g x && f x) xs) #-} where I'm forced to use genericLength so the types of the LHS and RHS can match. Then I wondered: as I have an specialization of count which returns Int, wouldn't be possible to do: {-# RULES "count/int" forall f g xs. count f (filter g xs) = length (filter (\x -> g x && f x) xs) -#} Well, the fact is that: testc1 n = count even (filter (\x -> x `mod` 3 > 0) [1..n]) fires "count/generic" all right, but testc2 :: Int -> Int testc2 n = count even (filter (\x -> x `mod` 3 > 0) [1..n]) does not fire "count/int". I suppose I'm being bitten by User's Guide 7.8.2: "If more than one rule matches a call, GHC will choose one arbitrarily to apply." even if a bit later it says: "So a rule only matches if the types match too." Am I understanding right and it's that so? Thanks, /L/e/k/t/u

1 0

Building ghc with mingw ghc 6.0.1 and gcc 3.3.1 problem
by kyra 16 Oct '03

16 Oct '03

Hi, folks! Trying to build either 6.2 or 6.3 ghc with mingw ghc 6.0.1 and gcc 3.3.1, I get multiple "undefined reference to `__module_registered' " errors during a stage2 ghc linking. Is the gcc 3.3 behaviour the case? Regards, Kyra

1 0

Performance Tests in Haskell
by Andreas.Schroeder＠gillardon.de 16 Oct '03

16 Oct '03

Hi all, i have changed the compilation flags and the codes as you said. It seems to me that it worked, since the runtime of my test stabilized at 2002ns. Before, i got sometimes 4004ns. The bigger runtime part is now (as far as i can guess, see below why) the screen output. That brings me to two issues for performance tests in Haskell: 1. how can i do performance tests if the tests are small? In imperative languages, you cycle through 1000 times and divide the runtime by 1000. How can i do something similar in haskell? 2. How do i get haskell to do something _without_ printing anything on the screen? For now, i do something like main = do startt <- getCPUTime putStr $ (show testAIBD1) ++ ", " ++ (show testZins1) endt <- getCPUTime putStr $ "\tTook " ++ (show $ (endt - startt) `div` ((10^6) * 5)) ++ " ns\n" where testAIBD1 is a sum of 40 calculation results and also is testZins1. Another issue: with foreign C calls i have the problem to link automatically. i type something like > ghc --make Main.hs -fglasgow-exts -O2 -fliberate-case-threshold100 -funbox-strict-fields -fvia-C while having compiled the external C HAIBDUtil.c with HAIBDUtil.h to HAIBDUtil.o. As result, i get Chasing modules from: Main.hs Compiling AIBD ( AIBD.hs, ./AIBD.o ) Compiling Main ( Main.hs, ./Main.o ) Linking ... AIBD.o(.text+0x11e0):ghc1052.hc: undefined reference to `caibd' shure, "caibd" is the called C procedure from AIBD. well then, i type > ghc Main.o AIBD.o HAIBDUtil.o -o HAIBD.exe then everything is fine, and i get my executable. Now i wanted to profile, and added the options "-prof --auto-all" to the first ghc command. When trying to link, i get lot's of undefined references: > ghc Main.o AIBD.o HAIBDUtil.o -o HAIBD.exe AIBD.o(.text+0x425):ghc1364.hc: undefined reference to `CC_LIST' AIBD.o(.text+0x430):ghc1364.hc: undefined reference to `CC_LIST' AIBD.o(.text+0x439):ghc1364.hc: undefined reference to `CC_ID' AIBD.o(.text+0x444):ghc1364.hc: undefined reference to `CC_ID' (...) AIBD.o(.text+0x5fc):ghc1364.hc: undefined reference to `CCCS' AIBD.o(.text+0x605):ghc1364.hc: undefined reference to `CCCS' AIBD.o(.text+0x626):ghc1364.hc: undefined reference to `PushCostCentre' (...) Obviously (see "PushCostCentre" as last misssing reference), something for profiling is missing. What is it? Regards, Andreas Schroeder |---------+-----------------------------------------> | | Andreas.Schroeder@gillardon.de| | | Gesendet von: | | | glasgow-haskell-users-bounces@| | | haskell.org | | | | | | | | | 16.10.2003 09:37 | | | | |---------+-----------------------------------------> >-------------------------------------------------------------------------------------------------------------------| | | | An: glasgow-haskell-users(a)haskell.org | | Kopie: chak(a)cse.unsw.edu.au | | Thema: Re: GHC with MS .Net 2003 C compiler | >-------------------------------------------------------------------------------------------------------------------| Hi all, hi Manuel, thanks for the help. Yes, i read the user docs for "earlier, faster, thriftier, smaller ..." or a permutation of this, but i do not _really_ remember from my university time what strict functions are. Is by strict meant as in Formal OO that a function is trict iff its result is _|_ iff any of its arguments is _|_ ? I will try to use data Genauigkeit = Absolut {wert, intervall :: !Double} | Intervall !Double is that what you meant? I will read the strictness flag documentation. Thanks for the hints. Regards, Andreas Schroeder |---------+-----------------------------------------> | | Manuel M T Chakravarty | | | <chak(a)cse.unsw.edu.au> | | | Gesendet von: | | | glasgow-haskell-users-bounces@| | | haskell.org | | | | | | | | | 16.10.2003 07:02 | | | Bitte antworten an chak | | | | |---------+-----------------------------------------> > -------------------------------------------------------------------------------------------------------------------| | | | An: Andreas.Schroeder(a)gillardon.de | | Kopie: glasgow-haskell-users(a)haskell.org | | Thema: Re: GHC with MS .Net 2003 C compiler | > -------------------------------------------------------------------------------------------------------------------| Andreas.Schroeder(a)gillardon.de wrote, Generally, did you look at http://haskell.org/ghc/docs/latest/html/users_guide/faster.html > module AIBD(aibd, rechneZins, rechneRate, rechneKapital) where > import Foreign(unsafePerformIO) > > type Funktion = Double -> Double > > data Genauigkeit = Absolut {wert, intervall :: Double} > | Intervall Double See the paragraph under "Use strictness annotations" on the above web page on how to use strictness annotations to speed this data type up. > istOk :: Genauigkeit -> Double -> Double -> Bool > istOk (Absolut w i) x _ = abs (x-w) <= i > istOk (Intervall i) _ dx = abs dx <= i > > sekantenVerfahren :: Funktion -> Genauigkeit -> Genauigkeit -> Int -> > Double -> Double > sekantenVerfahren f gx gy tiefe start = sekantenIter f tiefe gx gy x1 x2 y1 > y2 where > x1 = start > x2 = start + start * 0.1 > y1 = f x1 > y2 = f x2 > sekantenIter _ 0 _ _ _ x2 _ _ = x2 > sekantenIter f tiefe gx gy x1 x2 y1 y2 = > let > x3 = x2 - y2 * (x2 - x1) / (y2 - y1) > y3 = f x3 > dy = y3 - y2 > dx = x3 - x2 > in > if (istOk gx x3 dx) && (istOk gy y3 dy) then x3 > else sekantenIter f (tiefe-1) gx gy x2 x3 y2 y3 Code like this may benefit from using the option "-O2" and possibly also "-fliberate-case-threshold100" http://haskell.org/ghc/docs/latest/html/users_guide/flag-reference.html#AEN… > foreign import ccall "HAIBDUtil.h caibd" caibd :: Double -> Double -> > Double -> Int -> IO Double > > aibd:: Double -> Double -> Double -> Int -> Double > aibd kapital zins rate jahre = unsafePerformIO (caibd kapital zins rate > jahre) > {- > does the same than > aibd:: Double -> Double -> Double -> Int -> Double > aibd kapital _ _ 0 = kapital > aibd kapital zins rate jahre = aibd (kapital + kapital * zins - rate) > zins rate (jahre-1) > -} Two comments with -O2 -fliberate-case-threshold100 the Haskell version may be as fast as the C version. If not, better foreign import as a pure functions foreign import ccall "HAIBDUtil.h caibd" caibd :: Double -> Double -> Double -> Int -> Double and omit the unsafePerformIO. Cheers, Manuel _______________________________________________ Glasgow-haskell-users mailing list Glasgow-haskell-users(a)haskell.org http://www.haskell.org/mailman/listinfo/glasgow-haskell-users _______________________________________________ Glasgow-haskell-users mailing list Glasgow-haskell-users(a)haskell.org http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

2 1

Re: GHC with MS .Net 2003 C compiler
by Andreas.Schroeder＠gillardon.de 16 Oct '03

16 Oct '03

Hi all, hi Manuel, thanks for the help. Yes, i read the user docs for "earlier, faster, thriftier, smaller ..." or a permutation of this, but i do not _really_ remember from my university time what strict functions are. Is by strict meant as in Formal OO that a function is trict iff its result is _|_ iff any of its arguments is _|_ ? I will try to use data Genauigkeit = Absolut {wert, intervall :: !Double} | Intervall !Double is that what you meant? I will read the strictness flag documentation. Thanks for the hints. Regards, Andreas Schroeder |---------+-----------------------------------------> | | Manuel M T Chakravarty | | | <chak(a)cse.unsw.edu.au> | | | Gesendet von: | | | glasgow-haskell-users-bounces@| | | haskell.org | | | | | | | | | 16.10.2003 07:02 | | | Bitte antworten an chak | | | | |---------+-----------------------------------------> >-------------------------------------------------------------------------------------------------------------------| | | | An: Andreas.Schroeder(a)gillardon.de | | Kopie: glasgow-haskell-users(a)haskell.org | | Thema: Re: GHC with MS .Net 2003 C compiler | >-------------------------------------------------------------------------------------------------------------------| Andreas.Schroeder(a)gillardon.de wrote, Generally, did you look at http://haskell.org/ghc/docs/latest/html/users_guide/faster.html > module AIBD(aibd, rechneZins, rechneRate, rechneKapital) where > import Foreign(unsafePerformIO) > > type Funktion = Double -> Double > > data Genauigkeit = Absolut {wert, intervall :: Double} > | Intervall Double See the paragraph under "Use strictness annotations" on the above web page on how to use strictness annotations to speed this data type up. > istOk :: Genauigkeit -> Double -> Double -> Bool > istOk (Absolut w i) x _ = abs (x-w) <= i > istOk (Intervall i) _ dx = abs dx <= i > > sekantenVerfahren :: Funktion -> Genauigkeit -> Genauigkeit -> Int -> > Double -> Double > sekantenVerfahren f gx gy tiefe start = sekantenIter f tiefe gx gy x1 x2 y1 > y2 where > x1 = start > x2 = start + start * 0.1 > y1 = f x1 > y2 = f x2 > sekantenIter _ 0 _ _ _ x2 _ _ = x2 > sekantenIter f tiefe gx gy x1 x2 y1 y2 = > let > x3 = x2 - y2 * (x2 - x1) / (y2 - y1) > y3 = f x3 > dy = y3 - y2 > dx = x3 - x2 > in > if (istOk gx x3 dx) && (istOk gy y3 dy) then x3 > else sekantenIter f (tiefe-1) gx gy x2 x3 y2 y3 Code like this may benefit from using the option "-O2" and possibly also "-fliberate-case-threshold100" http://haskell.org/ghc/docs/latest/html/users_guide/flag-reference.html#AEN… > foreign import ccall "HAIBDUtil.h caibd" caibd :: Double -> Double -> > Double -> Int -> IO Double > > aibd:: Double -> Double -> Double -> Int -> Double > aibd kapital zins rate jahre = unsafePerformIO (caibd kapital zins rate > jahre) > {- > does the same than > aibd:: Double -> Double -> Double -> Int -> Double > aibd kapital _ _ 0 = kapital > aibd kapital zins rate jahre = aibd (kapital + kapital * zins - rate) > zins rate (jahre-1) > -} Two comments with -O2 -fliberate-case-threshold100 the Haskell version may be as fast as the C version. If not, better foreign import as a pure functions foreign import ccall "HAIBDUtil.h caibd" caibd :: Double -> Double -> Double -> Int -> Double and omit the unsafePerformIO. Cheers, Manuel _______________________________________________ Glasgow-haskell-users mailing list Glasgow-haskell-users(a)haskell.org http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

2 1

reexport warnings
by Serge D. Mechveliani 16 Oct '03

16 Oct '03

Dear GHC and Haskell experts, I need advice on the following question. My application program (called DoCon), being ported recently to ghc-6.0.1, needs to provide the user (program) with the following visibility scope of items: all the proper DoCon export + most of Haskell standard library + FiniteMap, and maybe some others (please, help FiniteMap, Set to become standard!). What is the best way to organize this? I arrange this by reexporting a large part of Haskell library from certain particular DoCon module DExport. This is put so because most mathematician users are lazy to search among proper Haskell libraries: they had already imported DoCon+(Haskell library) from DoCon, and do not want to search any more among List, Ratio, etc. -------------------------------------------------------------- module DExport -- All the export of DoCon + part of GHC exploited by DoCon. -- -- Set the line import DExport -- -- if you are lazy to find more precisely which modules your -- program needs. (module DPrelude, module Categs, ... -- DoCon proper export ... module Data.FiniteMap, module Prelude, module List, module Ratio, module Random ) where import Data.FiniteMap import List hiding (minimum, maximum, sort, sortBy) import Prelude hiding (minimum, maximum, ) import Ratio import Random import DPrelude -- DoCon proper import ... ------------------------------------------------- Is this a reasonable way to arrange the thing? Now, the ghc-6.0.1 compiler reports Compiling DExport ... Warning: `++' is exported by `module Prelude' and `module List' .. Warning: `foldr' is exported by `module Prelude' and `module List' .. Warning: `concat' is exported by `module Prelude' and `module List' ... I think that these overlaps are harmless, and the compiler will still set the intended definitions for (++), foldr, etc., without any danger. Aslo proper DoCon export fron DExport has many similar overlaps. I think that it is often useful to be able to import an item from different modules. Is this reasonable? Generally, I accept these overlap warnings as useful ones. But at the installation, such strange numerous warnings on DExport will frighten the user. Therefore, Makefile has, probably, to compile the last module DExport with this kind of messages switched off. Right? Thank you in advance for your advice. Answer, please, to mechvel(a)botik.ru ----------------- Serge Mechveliani mechvel(a)botik.ru

1 0

Re: overlapping instances
by Arie Peterson 15 Oct '03

15 Oct '03

>What would have GHC do for the "convert :: String -> String" case? >(You'd like "convert = id" here but it's not clear to me what the >general rule should be.) > > mike The general rule should be that convert :: a -> a = id, no matter what other instances are available. Is there any way to tell GHC so? It would be nice to be able to define 'precedences'. Arie

1 0

overlapping instances
by Arie Peterson 15 Oct '03

15 Oct '03

Hi all, In an attempt to design a elegant way to serialise things to any serialised form, I came up with the following exotic solution: ### {-# OPTIONS -fallow-undecidable-instances -fallow-overlapping-instances #-} module Convertable where class Convertable a b where convert :: a -> b instance Convertable a a where convert = id instance (Convertable a b,Convertable b c) => Convertable a c where convert = (convert :: b -> c) . (convert :: a -> b) class (Convertable a b,Convertable b a) => Equivalent a b ### Happily surprised to see GHC swallow this, I continued by adding ### {-# OPTIONS -fallow-undecidable-instances -fallow-overlapping-instances #-} module Serialise where import Convertable import Data.PackedString (PackedString,packString,unpackPS) instance Convertable String PackedString where convert = packString instance Convertable PackedString String where convert = unpackPS instance (Show a) => Convertable a String where convert = show instance (Read a) => Convertable String a where convert = read ### But now GHC complains about overlapping instances: "Overlapping instance declarations: Serialise.hs:16: Convertable String a Convertable.hs:7: Convertable a a" Why can't GHC decide that the "Convertable String a" instance is more specific? Apparently, there is no problem with the combination of "Convertable a a" and "Convertable a String": if I leave out "read", all is well. What is the difference with the above? In the manual one can find: "GHC is also conservative about committing to an overlapping instance. For example: class C a where { op :: a -> a } instance C [Int] where ... instance C a => C [a] where ... f :: C b => [b] -> [b] f x = op x From the RHS of f we get the constraint C [b]. But GHC does not commit to the second instance declaration, because in a paricular call of f, b might be instantiate to Int, so the first instance declaration would be appropriate. So GHC rejects the program. If you add -fallow-incoherent-instances GHC will instead silently pick the second instance, without complaining about the problem of subsequent instantiations." I do not understand why GHC can't choose between C [Int] (whenever f is parametrised with Int) or C [a] (whenever f is parametrised with anything else). (While checking the type of f, it is clear that the constraint C [b] is always met.) (Adding -fallow-incoherent-instances did not change anything.) Thanks a lot for putting up with my English and my dubious type constructions :-). Regards, Arie Peterson BTW: I would like to use this opportunity to express my content: I think haskell is a wonderful language (never, ever anymore javascript :s) and GHC is a, uhm, glorious compiler :-).

1 0