ACA data analyser

dataAnalyser.hs

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE BangPatterns #-}

-- Needs bytestring-lexing installed to work!
import qualified Data.ByteString.Char8 as B
import qualified Data.ByteString.Lex.Double as B
import qualified Data.ByteString.Lex.Integral as B
import Data.Maybe
import Data.List

ruuRange, allRange :: [Int]
ruuRange = [2,4,8,16,32,64,128,256]
allRange = [2,4,8,16,32,64]

functions = [ruu_size, issue_width, lsq_size, commit_width, decode_width]

data VAResult = VAResult { energy :: Double
                         , ruu_size :: Int
                         , issue_width :: Int
                         , lsq_size :: Int
                         , commit_width :: Int
                         , decode_width :: Int }
              deriving (Eq)

instance Show VAResult where
  show x = unwords $
           [ show (energy x)
           , show (ruu_size x)
           , show (issue_width x)
           , show (lsq_size x)
           , show (commit_width x)
           , show (decode_width x) ]

instance Ord VAResult where
  x `compare` y = (energy x) `compare` (energy y)

main :: IO ()
main = do
  p_data <- initData
  let sorted = sort p_data
  mapM_ (putStrLn . show) sorted

initData :: IO [VAResult]
initData = do
  params <- B.readFile "params"
  vadata <- B.readFile "output"
  return $ zipWith makeVAR (B.lines params) (B.lines vadata)

initDataC :: IO [VAResult]
initDataC = do
  params <- B.readFile "params2"
  vadata <- B.readFile "output_vab"
  return $ zipWith makeVARC (B.lines params) (B.lines vadata)

getAvg :: (VAResult -> Int) -> Int -> [VAResult] -> (Double, Double)
getAvg func val list =
  (avg, stdDev)
  where
    stdDev =  sqrt $ (1 / len) * (sum $ map (\x -> (x - avg) ^ 2) es)
    (sumL, len) =  foldl' (\(!s, !n) x -> (s + x, n + 1)) (0,0) es
    avg = sumL / len
    es = map energy filtered
    filtered = filter (\x -> func x == val) list

stdDeviation list =
  sqrt $ (1 / len) * (sum $ map (\x -> (x - avg) ^ 2) list)
  where
    (sumL, len) = foldl' (\(!s, !n) x -> (s + x, n + 1)) (0,0) list
    avg = sumL / len

average = uncurry (/) . foldl' (\(!s, !n) x -> (s + x, n + 1)) (0,0) 

splitData :: B.ByteString -> [B.ByteString]
splitData s = B.split ' ' s

makeVARC :: B.ByteString -> B.ByteString -> VAResult
makeVARC param output =
  VAResult { energy       = energy_
           , ruu_size     = ruu_size_
           , issue_width  = issue_width_
           , lsq_size     = lsq_size_
           , commit_width = commit_width_ 
           , decode_width = decode_width_ }
  where
    ps = splitData param
    os = splitData output
    energy_       = justReadD $ os !! 24
    ruu_size_     = justReadI $ ps !! 0
    issue_width_  = justReadI $ ps !! 1
    lsq_size_     = justReadI $ ps !! 2
    commit_width_ = justReadI $ ps !! 3
    decode_width_ = justReadI $ ps !! 4

makeVAR :: B.ByteString -> B.ByteString -> VAResult
makeVAR param output =
  VAResult { energy       = energy_
           , ruu_size     = ruu_size_
           , issue_width  = issue_width_
           , lsq_size     = lsq_size_
           , commit_width = commit_width_ 
           , decode_width = decode_width_ }
  where
    ps = splitData param
    os = splitData output
    energy_       = justReadD $ os !! 4
    ruu_size_     = justReadI $ ps !! 0
    issue_width_  = justReadI $ ps !! 1
    lsq_size_     = justReadI $ ps !! 2
    commit_width_ = justReadI $ ps !! 3
    decode_width_ = justReadI $ ps !! 4
  
justReadD = fst . fromJust . B.readDouble
justReadI = fst . fromJust . B.readDecimal

np :: (Show a) => [a] -> IO ()
np = mapM_ print

multiFilter fs =
  filter (\x -> and (zipWith ($) fs (repeat x)))

gf f comp val = (\x -> f x `comp` val)

{-
Example use: multiFilter [ruuEq 2, issEq 2, comEq 8] myData
=> Returns all entries that match ALL these conditions
-}

ruuEq = gf ruu_size (==)
issEq = gf issue_width (==)
lsqEq = gf lsq_size (==)
comEq = gf commit_width (==)
decEq = gf decode_width (==)