Daniel Fischer daniel.is.fischer at web.de
Mon Jan 4 10:05:45 EST 2010

Am Montag 04 Januar 2010 02:17:06 schrieb Patrick LeBoutillier:
> Hi,
>
> This question didn't get any replies on the beginners list, I thought
> I'd try it here...

Sorry, been occupied with other things. I already took a look, but hadn't anything

>
> I've written (and improved using other solutions I've found on the
> net) a simple sudoku solver which I'm trying to profile. Here is the
> code:
>
>
> import Array

Better

import Data.Array.Unboxed

*much* faster

> import List (transpose, nub, (\\))
> import Data.List
>
> data Sudoku = Sudoku { unit :: Int, cells :: Array (Int, Int) Int,

cells :: UArray (Int,Int) Int

> holes :: [(Int, Int)] }
>
> cell :: Sudoku -> (Int, Int) -> Int
> cell s i = (cells s) ! i
>
>  readsPrec _ s = [(Sudoku unit cells holes, "")]
>    where unit = length . words . head . lines \$ s
>          cells = listArray ((1, 1), (unit, unit)) (map read . words \$ s)
>          holes = [ c | c <- indices cells, (cells ! c) == 0]
>
> instance Show Sudoku where
>  show s = unlines [unwords [show \$ cell s (x,y) | x <- [1 .. unit s]]
>
> | y <- [1 .. unit s]]
>
> genNums :: Sudoku -> (Int, Int) -> [Int]
> genNums s c@(i,j) = ([1 .. u] \\) . nub \$ used
>  where

nub isn't nice. It's quadratic in the length of the list. Use e.g.

map head . group . sort

or

Data.[Int]Set.toList . Data.[Int]Set.fromList

if the type is in Ord (and you don't need the distinct elements in the order they come
in). That gives an O(n*log n) nub with a sorted result.
And (\\) isn't particularly fast either (O(m*n), where m and n are the lengths of the
lists). If you use one of the above instead of nub, you can use the O(min m n) 'minus' for
sorted lists:

xxs@(x:xs) `minus` yys@(y:ys)
| x < y     = x : xs `minus` yys
| x == y    = xs `minus` ys
| otherwise = xxs `minus` ys
xs `minus` _ = xs

Here, you can do better:

genNums s c@(i,j) = nums
where
nums = [n | n <- [1 .. u], arr!n]
arr :: [U]Array Int Bool
arr = accumArray (\_ _ -> False) True (0,u) used

>    used = (row s u i j) ++ (col s u i j) ++ (square s sq u i j)
>    u = unit s

Not good to calculate sq here. You'll use it many times, calculate once and store it in s.

>    sq = truncate . sqrt . fromIntegral \$ u
>
> row s u i j = [cell s (i, y) | y <- [1 .. u]]
>
> col s u i j = [cell s (x, j) | x <- [1 .. u]]
>
> square s sq u i j = [cell s (x, y) | y <- [1 .. u], x <- [1 .. u], f x i, f
> y j] where f a b = div (a-1) sq == div (b-1) sq

Test for f y j before you generate x to skip early.

square s sq u i j = [cell s (ni+x,nj+y) | x <- [1 .. sq], y <- [1 .. sq]]
where
qi = (i-1) `div` sq
qj = (j-1) `div` sq
ni = qi*sq
nj = qj*sq

>
> solve :: Sudoku -> [Sudoku]
> solve s =
>  case holes s of
>    [] -> [s]
>    (h:hs) -> do
>      n <- genNums s h
>      let s' = Sudoku (unit s) ((cells s) // [(h, n)]) hs
>      solve s'
>
> main = print . head . solve . read =<< getContents
>
>
> When I compile as such:
>
> \$ ghc -O2 --make Sudoku.hs -prof -auto-all -caf-all -fforce-recomp
>
> and run it on the following puzzle:
>
> 0 2 3 4
> 3 4 1 0
> 2 1 4 0
> 0 3 2 1
>
> I get the following profiling report:
>
>        Fri Jan  1 10:34 2010 Time and Allocation Profiling Report  (Final)
>
>           Sudoku +RTS -p -RTS
>
>        total time  =        0.00 secs   (0 ticks @ 20 ms)

That means the report is basically useless. Not entirely, because the allocation figures
may already contain useful information. Run on a 9x9 puzzle (a not too hard one, but not
trivial either).

allocation then.

>        total alloc =     165,728 bytes  (excludes profiling overheads)
>
> COST CENTRE                    MODULE               %time %alloc
>
> CAF                            GHC.Handle             0.0   10.7
> square                         Main                   0.0    2.8
> solve                          Main                   0.0    1.3
> show_aVx                       Main                   0.0    3.7
> main                           Main                   0.0    9.6
> genNums                        Main                   0.0    5.0
> cell                           Main                   0.0    1.2
>
>
>
>                        individual    inherited
> COST CENTRE              MODULE
>       no.    entries  %time %alloc   %time %alloc
>
> MAIN                     MAIN
>         1           0   0.0    0.3     0.0  100.0
>  main                    Main
>       186           1   0.0    9.6     0.0   85.6
>  show_aVx               Main
>       196           2   0.0    3.7     0.0    3.7
>   cell                  Main
>       197          16   0.0    0.0     0.0    0.0
>  solve                  Main
>       188           5   0.0    1.3     0.0   11.8
>   genNums               Main
>       189           8   0.0    5.0     0.0   10.4
>    square               Main
>       194          88   0.0    2.8     0.0    3.2
>     cell                Main
>       195          16   0.0    0.4     0.0    0.4
>    col                  Main
>       192           4   0.0    0.7     0.0    1.1
>     cell                Main
>       193          16   0.0    0.4     0.0    0.4
>    row                  Main
>       190           4   0.0    0.7     0.0    1.1
>     cell                Main
>       191          16   0.0    0.4     0.0    0.4
>       187           3   0.0   60.6     0.0   60.6
>       151           1   0.0    1.2     0.0    1.2
>       144           8   0.0    2.1     0.0    2.1
>  CAF                     GHC.Handle
>       128           4   0.0   10.7     0.0   10.7
>  CAF                     GHC.Conc
>       127           1   0.0    0.0     0.0    0.0
>
> Does the column 'entries' represent the number of times the function
> was called?

Number of times it was 'entered', not quite the same as the number of times it was called.
I think (Warning: speculation ahead, I don't *know* how the profiles are generated) it's
thus:
Say you call a function returning a list. One call, first entry. It finds the beginning of
the list, the first k elements and hands them to the caller. Caller processes these, asks
"can I have more, or was that it?". Same call, second entry: f looks for more, finds the
next m elements, hands them to caller. Caller processes. Repeat until whatever happens
first, caller doesn't ask whether there's more or callee finds there's nothing more (or
hits bottom).

> If so, I don't understand how the 'square' function could
> be called 88 times when it's caller is only called 8 times. Same thing
> with 'genNums' (called 8 times, and solve called 5 times)
>
> What am I missing here?
>
> Patrick

-------------- next part --------------
An HTML attachment was scrubbed...