- Haskell-Cafe - Haskell.org

RE: haskell array access
by Hal Daume 26 Jun '03

26 Jun '03

This has been hinted to before: gcc gets rid of the loop. bash-2.05b$ gcc -O3 arr.c -S -o arr.s bash-2.05b$ cat arr.s .file "arr.c" .def ___main; .scl 2; .type 32; .endef .text .align 2 .align 16 .globl _main .def _main; .scl 2; .type 32; .endef _main: pushl %ebp movl %esp, %ebp subl $72, %esp xorl %eax, %eax andl $-16, %esp call __alloca call ___main xorl %eax, %eax .align 16 L7: incl %eax cmpl $100000000, %eax jle L7 leave ret the inside of the loop is exactly: L7: incl %eax cmpl $100000000, %eax jle L7 which doesn't read the array! essentially you are being unfare to ghc by making it seq the array element, but not doing the same to GCC. even with -O0, gcc gets rid of the loop body. one solution: add in the assembly to actually read the array (i'm too lazy and busy to do this). - hal -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: haskell-cafe-admin(a)haskell.org > [mailto:haskell-cafe-admin@haskell.org] On Behalf Of Lex Stein > Sent: Thursday, June 26, 2003 3:46 PM > To: Sven Panne > Cc: haskell-cafe(a)haskell.org > Subject: Re: haskell array access > > > > Great, thanks. Those suggestions narrow the gap from GHC -O being 330x > slower than GCC -O3 to it being 20x slower. Here are the new results: > > gcc -O3 0.54s > ocamlopt 1.11s > ghc -O 10.76s > ocamlc 14.10s > > GHC is still pretty slow for native x86 instruction code. Is > there any way > to further explain the performance gap ? (new code below) > > Thanks! > Lex > > Haskell (GHC) source: > > import Array > k :: Array Int Int > k = Array.array (0,15) [(i, i+1) | i <- [0 .. 15] ] > acc :: Int -> Int > acc 0 = 0 > acc n = seq (k Array.! (n `mod` 16)) (acc (n-1)) > main = do > print (acc 100000000) > > Caml test source: > > let a = Array.make 16 0;; > let rec do1 i z = > if (i>100000000) then z else > do1 (i+1) (z + a.(i mod 16));; > do1 0 0;; > > C (gcc) test source: > > int main () { > int i, k = 0; > int a [16]; > for (i=0; i<100000000; i++) { > k += a [i % 16]; > } > return (k); > } > > > On Fri, 27 Jun 2003, Sven Panne wrote: > > > Well, part of the answer is definitely that the Haskell > program is the > > *only* one which really uses the array elements. :-) I > guess that the > > compilers for the other languages simply remove the array > access from > > the generated code (gcc definitely does, only an empty loop > remains). > > > > Another reason is that the type signatures are missing, so > Integer is > > used instead of Int, which is a bit unfair. Adding > > > > k :: Array Int Int > > acc :: Int -> Int > > > > cuts down the time by more than factor 5 on my machine. > > > > Cheers, > > S. > > > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 2

"callbacks" in Haskell
by Robert Vollmert 26 Jun '03

26 Jun '03

Hello, I've been having a little trouble writing a module that waits for and handles IO events, e.g. by reading from a pipe. It seemed natural to use some form of callbacks here, though that may very well be the wrong approach. I'd be happy to hear of alternatives. Anyway, I got a callback-based approach to work to some extent, but am not happy with the callback's type. The abstract form of this module is as follows. I'd appreciate any input. A class that specifies what we expect of the base monad. > class (Monad m) => MonadReq m A class that specifies what we provide to the callback. > class (Monad m) => MonadProv m The module's main function. > f :: (MonadReq m) => Callback m a -> m a > f c = ... Internally, we wrap the base monad with some monad transformer, say > data InternalT m a = ... with > instance MonadTrans InternalT so that the callback can access the base monad, and > instance (MonadReq m) => MonadProv (InternalT m) so that we can actually provide MonadProv. A type for callback that works is > type Callback m a = InternalT m a What I don't like about this is that we shouldn't really need to expose what exact monad transformer we use. Also, if we added a second function that also runs the callback in a MonadProv but that uses a different transformer (for instance, needing to keep track of some extra state), we'd need a new callback type. What seems to be the right type is > type Callback m a = forall t. (MonadTrans t, MonadProv (t m)) => t m a which sort of works with '-fglasgow-exts' (what's this extension called?). However, it seems to cause all kinds of problems, e.g. pairs of this type appear to be illegal. Cheers Robert

2 2

Re: MacOS X Project Builder and Haskell
by Ashley Yakeley 26 Jun '03

26 Jun '03

At 2003-06-25 11:51, Andre Pang wrote: >Hi Ashley, I guess you've heard of the announcements of the new Apple >IDE announced at WWDC recently ("Xcode"). I'm at WWDC right now, and >I'll do my best to talk to the Apple engineers there to make sure that >all the infrastructure is in place to be able to integrate Haskell/GHC >with Xcode. Xcode does look a little bit more extensible than Project >Builder, but since it's in beta, not everything is actually >documented/integrated yet (in particular, its native build system). The (reduced) screen-shots of Xcode on the Apple site are so pretty I was worrying whether it would actually be as powerful as PB, which I'm fairly impressed with. I'm delighted to hear that Xcode will be even more extensible. >However, if you still want to use Project Builder, I have managed to >get GHC integration going. It's not pretty (put it this way: Perl is >involved ...), but it _does_ work. I'm planning to release it in ~2 >weeks, but if you can't wait, email me back and I'll give you a preview >if I have time :). All my Haskell development is cross-platform at the moment, so I must use makefiles and thus "legacy" targets anyway. Though I'm sure I'll have a look at it when you've finished with it... Actually my biggest build problem at the moment is that the version of make that comes with the system is buggy. I use the make that comes with fink, but of course not everyone has that installed. Perhaps this will be fixed in the new Darwin. -- Ashley Yakeley, Seattle WA Almost empty page: <http://semantic.org/>

1 0

MacOS X Project Builder and Haskell
by Ashley Yakeley 25 Jun '03

25 Jun '03

Does anyone else use Project Builder with Haskell? Once you fiddle around with it a bit, it seems to work OK with makefiles. But I wondered if anyone had any Haskell-specific extensions? -- Ashley Yakeley, Seattle WA

2 2

Shoot self in foot
by Shawn P. Garbett 24 Jun '03

24 Jun '03

Based on the earlier posted joke on this list, I put together the following code. Could probably use a bit of simplification, but you get the picture. import IO import GHC.IOBase -- True = nice foot, False = shot up by some lunatic type Foot = Bool -- Manage a request from the user, given request and current foot state manage :: Char -> Foot -> IO Foot manage c foot -- InterleaveIO Makes the request "lazy" | c == '1' = unsafeInterleaveIO $ do putStr "OUCH!!!! Shoot Self in Foot\n" return False -- The foot is now shot -- The doctor examines the state of the foot variable | c == '2' = do putStr "Doctor examines foot\n" if foot then putStr "I have a good foot.\n" else putStr "I have a shot-up foot.\n" return foot -- Otherwise just keep processing | otherwise = do return foot -- Main processing loop process :: Foot -> IO () process f = do c <- getChar -- Get a character putChar '\n' -- Return to keep the screen neat if c == '0' -- Is it an exit? then return () -- then leave else do f' <- manage c f -- otherwise manage request process f' -- continue to process -- Little usage message usage :: IO () usage = do putStr "0. Exit Program\n" putStr "1. Pull Trigger\n" putStr "2. Call Doctor\n" -- Main routine main :: IO () main = do usage -- Print usage process True -- Start processing with a good foot

1 0

ANNOUNCE: hmake-3.08
by Malcolm Wallace 23 Jun '03

23 Jun '03

hmake-3.08 ---------- http://www.haskell.org/hmake/ We announce a new release of hmake, the compilation manager for Haskell. This is essentially a bugfix release, to enable hmake to build cleanly with ghc versions >= 6.0. * Hmake should now build cleanly with GHC 6.0. * In hmake-interactive, if the readline library is not available, the replacement simple line editor now has a history mechanism. Regards, Malcolm

1 0

Re: Haskell-Cafe digest, Vol 1 #730 - 5 msgs
by Mark Espinoza 23 Jun '03

23 Jun '03

2 1

RE: Assembling lists start-to-end
by Hal Daume 21 Jun '03

21 Jun '03

sorry, forgot to send this to the list: Another way to do it is to use accumulating lists. As a simple example, let's consider: > myf p l = reverse (filter p l) (myf Char.isUpper "Hello Cruel World" ==> "WCH") that is, it returns elements of a list which match the predicate in reverse order. we could write this very slowly using explicit recursion as: > myf2 p [] = [] > myf2 p (x:xs) > | p x = myf2 p xs ++ [x] > | otherwise = myf2 p xs but traversing the recusive list is very slow. we might induce tail recursion in something like: > myf3 p l = myf3' l [] > where > myf3' [] acc = acc > myf3' (x:xs) acc = myf3' xs (x:acc) Now, the accumulator 'acc' holds the value we're going to return at the end. So this is pretty much what you want. Now, suppose we're just doing filter without the reversing, but we still want it to be tail recursive. We might think we have to write: > myf4 p l = reverse (myf3' l []) (where myf3' is as before) this is not so. We can have fun with function composition. What we do is change the accumulator from a list to a function from a list to a list. > myf4 p l = myf4' l id > where > myf4' [] acc = acc [] > myf4' (x:xs) acc > | p x = myf4' xs (\l -> acc (x:l)) > | otherwise = myf4' xs acc here, we start out the accumulator as the identity function. to add an element to it, we make a function which takes the old list, adds 'x' to the front and then applies the accumulator. in the base case, we simply apply the empty list to the accumulator function. the second-to-last line can be rewritten a bit more conveniently as: > | p x = myf4' xs (acc . (x:)) the neat thing about this is that you can easily change the way the list goes. as it is, we have filter, but if we flip the order for (.), as in: > | p x = myf4' xs ((x:) . acc) then we get (reverse . filter). HTH - Hal -- Hal Daume III | hdaume(a)isi.edu "Arrest this man, he talks in maths." | www.isi.edu/~hdaume > -----Original Message----- > From: haskell-cafe-admin(a)haskell.org > [mailto:haskell-cafe-admin@haskell.org] On Behalf Of Mark Carroll > Sent: Saturday, June 21, 2003 5:39 AM > To: haskell-cafe(a)haskell.org > Subject: Assembling lists start-to-end > > > I am assembling a list from start to end. I can add elements > to the end > with "previous ++ [current]" or I can add them with "current > : previous" > and reverse it when I'm done. Or, maybe I should use some other data > structure. (I don't know the length in advance.) Any thoughts? > > -- Mark > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

IO system
by naudts guido 21 Jun '03

21 Jun '03

Hallo, Take following function: f::Array Int Char -> (Array Int Char, Char) f array = (array1, c) where c = array!1 array1 = array//[(2,'b')] and also following function: f::Direct_access_file -> (Direct_access_file, Char) f daf = (daf1, c) where c = getnext daf daf1 = set 2 'b' with a hypothetical format for the direct access file. Now I can certainly implement the first function in Haskell but not the second. Now the only difference between the two functions is the location of the data: in the first the data of the array are in RAM, in the second the data of the direct access file are on disk. There is no other difference. As far as referential integrity is concerened I don't see any difference too. So why can I implement the first function and not the second (well I can use direct access files but I have to change the type of my function.The problem is: I do not see why the location of data should have an influence here. Greetings, __________________________________ Do you Yahoo!? SBC Yahoo! DSL - Now only $29.95 per month! http://sbc.yahoo.com

3 2

Using an accumulator, "iterating"...
by Brett Kelly 21 Jun '03

21 Jun '03

Hello all, I'm trying to write a function that takes a list and a element (same type) and returns the index of the first instance of the element in the list. like: getindex "brett" 'e' would return 2, etc. i'm trying to accomplish this using an accumulator, here's what i've got: pyindex :: Eq a => a -> [a] -> Maybe Int pyindex c l = pyindex' 0 chr (x:xs) where pyindex' count chr (x:xs) = do if x == chr then return count else pyindex' (count + 1) chr xs now, i know i've got a syntax problem, because i'm pretty sure my logic is correct (or at least MOSTLY correct). can anybody see what's wrong with my stuff? thanks! -- Brett Kelly bkelly(a)sourcereview.net This message has been digitally autographed using GnuPG. Vim - this ain't your daddy's text editor http://www.vim.org

5 6