September 2004 - Haskell-Cafe

OCaml list sees abysmal Language Shootout results
by Keith Wansbrough 08 Oct '04

08 Oct '04

I just saw this on the OCaml list (in a posting by "Rafael 'Dido' Sevilla" <dido(a)imperium.ph> in the "Observations on OCaml vs. Haskell" thread). I can't believe that a simple "wc" implementation should be 570 times slower in Haskell than OCaml - could someone investigate and fix the test? --KW 8-) http://caml.inria.fr/archives/200409/msg00485.html > > 2. Haskell strings are lists of characters > > > > It's annoying that strings aren't normally processed this way in OCaml, > > and even more annoying that (^) or (::) cannot be used in pattern > > matching over strings. I like Haskell's approach. The list > > concatenation operator is the same as the string concatenation operator > > in Haskell. > > > > This is something of an efficiency/elegance tradeoff. Making strings > act like lists means potentially boxing *every character in the string*. > In other words, it's potentially a very expensive way of doing business. > Paul Graham was mulling over this kind of tradeoff in his design of Arc, > as I recall. Another language that does this type of thing is Erlang, > and both languages seem to be significantly slower than OCaml in string > handling, at least as far as this site goes: > > http://shootout.alioth.debian.org/ > > For the word count benchmark OCaml scores 0.1850 seconds, while GHC is a > dismal last place at 105.2110 seconds! Even the bytecode ocaml is an > order of magnitude faster. The word frequency benchmark also shows this > kind of poor string handling performance for Haskell, with OCaml scoring > 0.5669 seconds, while GHC scores a truly dismal 6.4540, more than an > order of magnitude slower, and even the bytecode ocaml is faster at > 4.2644 seconds. > > All in all, it would appear that Haskell's approach has been expensive > in terms of performance, if the benchmarks are to be taken at face > value. Such are the tradeoffs language designers have to make.

18 43

Compiling GHC for AIX5.1L
by John Goerzen 01 Oct '04

01 Oct '04

Hello, Following the directions at http://www.haskell.org/ghc/docs/6.2.1/html/building/sec-porting-ghc.html#UN…... I have a Debian unstable system on i386 as the host machine and an IBM PowerPC system as the target. I have configured the files as specified in the docs. I am to the "make boot && make" phase in the ghc directory on the (Linux) host. All goes well until: ==fptools== make all -r; in /home/jgoerzen/no-backup/programs/ghc-6.2.1/ghc/rts ------------------------------------------------------------------------ ../../ghc/compiler/ghc-inplace -optc-O -optc-Wall -optc-W -optc-Wstrict-prototypes -optc-Wmissing-prototypes -optc-Wmissing-declarations -optc-Winline -optc-Waggregate-return -optc-Wbad-function-cast -optc-I../includes -optc-I. -optc-Iparallel -optc-DCOMPILING_RTS -optc-fomit-frame-pointer -H16m -O -O2 -static -c Adjustor.c -o Adjustor.o /tmp/ghc10917.s: Assembler messages: /tmp/ghc10917.s:54: Error: no such instruction: `dcbf 0,%eax' /tmp/ghc10917.s:55: Error: no such instruction: `sync' /tmp/ghc10917.s:56: Error: no such instruction: `icbi 0,%eax' /tmp/ghc10917.s:63: Error: no such instruction: `sync' /tmp/ghc10917.s:64: Error: no such instruction: `isync' make[1]: *** [Adjustor.o] Error 1 make: *** [all] Error 1 Why it's trying to use PowerPC assembler on an x86 host I don't know. (I assume that's what's going on here; but I don't really know.) What is the problem?

2 5

Re: [Haskell-cafe] OCaml list sees abysmal Language Shootout results]
by Greg Buchholz 30 Sep '04

30 Sep '04

Sam Mason wrote: > > You probably want some strictness annotations in there. . . Now we're getting somewhere. When I replace the tuples with my own (strict) data structure, it gets about 7.5 times faster than the original shootout example (or about 24 times faster than the version with tuples). I get another 2x speedup when I pass '+RTS -G1' to the executable. So the version below is about 15 times faster than the original using the 3MB data file from the shootout. (Now we're only about 40x slower than ocaml). Don't forget to turn on '-funbox-strict-fields' for an additional improvement. -- Compile with... -- ghc -O2 -ddump-simpl -fvia-c -funbox-strict-fields -o wc_fold2 wc_fold2.hs -- execute as... ./wc_fold2 +RTS -G1 <input.txt import IO main = do file <- getContents putStrLn $ show (foldl wc (St 0 0 0) file) data Stuple = St !Int !Int !Int deriving Show wc (St l w c) '\n' = St (l+1) w (c+1) wc (St l w c) ' ' = St l (w+1) (c+1) wc (St l w c) x = St l w (c+1) ...It still seems like it's using a lot of memory (or at least doing a lot of garbage collecting). But it it still vastly better than before. Is there any way to reduce this more? (60,000,000 bytes divided by 3,000,000 chars = 20 bytes per char). Here's the memory usage report... 61,387,752 bytes allocated in the heap 11,837,148 bytes copied during GC 99,780 bytes maximum residency (234 sample(s)) 234 collections in generation 0 ( 0.11s) 1 Mb total memory in use INIT time 0.00s ( 0.00s elapsed) MUT time 0.15s ( 0.15s elapsed) GC time 0.11s ( 0.14s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 0.26s ( 0.29s elapsed) %GC time 42.3% (48.3% elapsed) Alloc rate 409,251,680 bytes per MUT second Productivity 57.7% of total user, 51.7% of total elapsed Greg Buchholz

1 0

RE: Simple example using Parsec (was: [Haskell-cafe] Rethinking O O idioms)
by Bayley, Alistair 30 Sep '04

30 Sep '04

Sure. Learning Parsec took me a few hours, whereas John's parsing task might be done in much less time, if it's simple enough. OTOH, there's value in being able to use Parsec, so it's a good excuse to learn. > -----Original Message----- > From: Graham Klyne [mailto:GK@ninebynine.org] > Sent: 30 September 2004 10:34 > To: Bayley, Alistair; 'John Goerzen'; haskell-cafe(a)haskell.org > Subject: Simple example using Parsec (was: [Haskell-cafe] > Rethinking OO idioms) > > At 09:01 30/09/04 +0100, Bayley, Alistair wrote: > >Ben suggested using Parsec for reading the config file. > Parsec is a fine > >library, but there is a learning curve, and you might find > it quicker to do > >the parsing yourself, if it's very simple. Your call. > > Hmmm... Parsec *can* be simple too. Here's one I did earlier: > http://www.ninebynine.org/Software/HaskellUtils/RegexParser.hs > > #g ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

Simple example using Parsec (was: [Haskell-cafe] Rethinking OO idioms)
by Graham Klyne 30 Sep '04

30 Sep '04

At 09:01 30/09/04 +0100, Bayley, Alistair wrote: >Ben suggested using Parsec for reading the config file. Parsec is a fine >library, but there is a learning curve, and you might find it quicker to do >the parsing yourself, if it's very simple. Your call. Hmmm... Parsec *can* be simple too. Here's one I did earlier: http://www.ninebynine.org/Software/HaskellUtils/RegexParser.hs #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Seeking reference(s) relating to FP performance
by Graham Klyne 30 Sep '04

30 Sep '04

I've taken it as an article of faith that performance of FP language implementations has been improving quite steadily over the past few years. I'd like to assert this, but I can't find any clear evidence to support such an assertion. I note that the "about Haskell" page makes a similar assertion, but it doesn't offer any hint of supporting evidence: [[ Aren't functional programs very slow? They used to be, but the compilers have now caught up. Haskell programs run fast enough for all but the most performance-demanding applications. ]] -- http://www.haskell.org/aboutHaskell.html I'm looking for a reference -- informal will be enough -- that can give an perspective of progress in functional language implementation performance. I'm not looking for a single benchmark that shows a case of blindingly-fast functional code, but a pointer to trends of improving performance. It would also serve my purpose to have indications based on languages other than Haskell (e.g. ML and friends). Any ideas, please? #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

4 3

RE: [Haskell-cafe] Rethinking OO idioms
by Bayley, Alistair 30 Sep '04

30 Sep '04

There are three pieces to this story: - read a config file into some structure - query/modify elements of that structure - write structure out to a file Create a data structure (analogous to a class with no methods) and functions to query/manipulate that structure. Nested FiniteMaps might be a good, simple, first attempt. Unlike the functions to read and write the file (which must be in the IO monad), the functions to query and manipulate the structure can (and probably should) be non-monadic. Ben suggested using Parsec for reading the config file. Parsec is a fine library, but there is a learning curve, and you might find it quicker to do the parsing yourself, if it's very simple. Your call. > ... Haskell has no mutable variables. A call like > config.setOption("main", "initpath", "/usr") in Python -- which alters > the state of the config object and returns nothing -- would be > impossible in Haskell (unless perhaps the FiniteMaps are mutable > somehow?) When you "modify" a structure, you return a new copy of it, where the bit that you wanted to change is replaced by the new value. For example, this is what happens when you call addToFM/delFromFM for FiniteMaps. This isn't necessarily as expensive as it sounds, as there's a lot of data sharing going on in Haskell programs, due to the fact that everything /is/ immutable. If it does turn out to be too expensive, then you could look at using a state monad. But assuming you need one immediately looks like premature optimisation to me. Alistair. ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

Rethinking OO idioms
by John Goerzen 30 Sep '04

30 Sep '04

I've worked with languages with object-oriented features for awhile now. Python and OCaml, the two with which I work the most, both have OO. One of my first projects in Haskell would be to write a Haskell version of Python's ConfigParser[1] class. I wrote[2],[3] a version of this for OCaml that works very well. In a nutshell, ConfigParser is a utility for working with sectioned configuration files in a style similar to the familiar .ini files from Windows. It has methods to read a configuration file, get/set the items that are being configured, and write a new file back out. This, then, is a fairly typical metaphor for OO programs: an instance of a class has some state that can be accessed or modified, and possibly stored and retrieved. So I am thinking about a ConfigParser for Haskell. The first thing that occured to me is that Haskell has no OO features, so I'm not sure what is the best way to handle the "class" and its various methods. The next thing that occured to me is that, unlike OCaml and Python classes, Haskell has no mutable variables. A call like config.setOption("main", "initpath", "/usr") in Python -- which alters the state of the config object and returns nothing -- would be impossible in Haskell (unless perhaps the FiniteMaps are mutable somehow?) I guess I'm having trouble translating this common OO language paradigm into the Haskell world. Thanks for any insight. -- John BTW, if I get a working ConfigParser for Haskell, I will publish it under the GPL like all the rest of my code. [1] http://www.python.org/doc/current/lib/RawConfigParser-objects.html [2] http://gopher.quux.org:70/devel/missinglib/html/ConfigParser.html [3] http://gopher.quux.org:70/devel/missinglib/html/ConfigParser.rawConfigParse…

8 9

Re: OCaml list sees abysmal Language Shootout results
by Aaron Denney 29 Sep '04

29 Sep '04

On 2004-09-29, Tomasz Zielonka <t.zielonka(a)students.mimuw.edu.pl> wrote: > I remember SPJ's motto: ,,Avoid success at all cost''. Is this motto > still valid? Maybe. The existing user-base is being used as an argument for not "doing the right thing" with regards to binary-IO, strings, localization and text IO. -- Aaron Denney -><-

1 0

Question about function on data type
by Peter Robinson 29 Sep '04

29 Sep '04

Hello! My question concerns a general term datatype: data Term = Not Term | Term :&&: Term | Term :||: Term | Literal Char Is it somehow possible to write a generic function that applies the associativity rules on a "Term" (by using pattern matching) and works with both data constructors or is it necessary to write one for :&&: and :||: ? Something like: assoc :: Term -> Term assoc ((t1 `op` t2) `op` t3) = .... -- this doesn't work Regards, Peter

2 1