I have written the following program using Parallel Haskell to find the divisors of 1 billion.

           import Control.Parallel

           parfindDivisors :: Integer->[Integer]
           parfindDivisors n = f1 `par` (f2 `par` (f1 ++ f2))
                        where f1=filter g [1..(quot n 4)]
                              f2=filter g [(quot n 4)+1..(quot n 2)]
                              g z = n `rem` z == 0
           main = print (parfindDivisors 1000000000)

I've compiled the program with ghc -rtsopts -threaded findDivisors.hs and I run it with: findDivisors.exe +RTS -s -N2 -RTS

I have found a 50% speedup compared to the simple version which is this:

                          findDivisors :: Integer->[Integer]
                          findDivisors n = filter g [1..(quot n 2)]
                                where  g z = n `rem` z == 0

My processor is a dual core 2 duo from Intel. I was wondering if there can be any improvement in above code. Because in the statistics that program prints says: Parallel GC work balance: 1.01 (16940708 / 16772868, ideal 2) and SPARKS: 2 (1 converted, 0 overflowed, 0 dud, 0 GC'd, 1 fizzled) What are these converted , overflowed , dud, GC'd, fizzled and how can help to improve the time.