[Git][ghc/ghc][wip/foundation-improve-coverage] 5 commits: ci: use treeless fetch for perf notes

14 Dec 2025


      Cheng Shao pushed to branch wip/foundation-improve-coverage at Glasgow Haskell Compiler / GHC


Commits:
3c001377 by Cheng Shao at 2025-12-13T05:03:15-05:00
ci: use treeless fetch for perf notes

This patch improves the ci logic for fetching perf notes by using
treeless fetch
(https://github.blog/open-source/git/get-up-to-speed-with-partial-clone-and-s...),
to avoid downloading all blobs of the perf notes repo at once, and
only fetch the actually required blobs on-demand when needed. This
makes the initial `test-metrics.sh pull` operation much faster, and
also more robust, since we are seeing an increasing rate of 504 errors
in CI when fetching all perf notes at once, which is a major source of
CI flakiness at this point.

Co-authored-by: Codex <codex@openai.com>

- - - - -
123a8d77 by Peter Trommler at 2025-12-13T05:03:57-05:00
Cmm: remove restriction in MachOp folding

- - - - -
0b54b5fd by Andreas Klebinger at 2025-12-13T05:04:38-05:00
Remove explicit Typeable deriviations.

- - - - -
08b13f7b by Cheng Shao at 2025-12-13T05:05:18-05:00
ci: set gc.auto=0 during setup stage

This patch sets `gc.auto=0` during `setup` stage of CI, see added
comment for detailed explanation.

- - - - -
1a841641 by Cheng Shao at 2025-12-13T23:34:32+01:00
testsuite: improve coverage of foundation test

This patch refactors the `foundation` test a bit to improve coverage:

- Instead of using a hard-coded seed, a random seed is now taken from
  the command line, and printed upon test failure. This improves test
  coverage over many future CI runs, and shall a failure occur, the
  seed is available in the CI log for local reproduction.
- The iterations count is bumped to 10000 instead of 100, similar to
  the bump in `test-primops`. Runtime timeout is bumped 2x just to be
  safe, though it's 2m39s on my machine and well within default
  timeout 300s.
- Improve `newLCGGen` by using non-atomic loads/stores on a
  `MutableByteArray#` for storing mutable `Word64`, this test doesn't
  use parallelism in the first place
- Fixed a few compiler warnings and removed redundant pragmas and
  imports

Co-authored-by: Codex <codex@openai.com>

- - - - -


16 changed files:

- .gitlab/ci.sh
- .gitlab/test-metrics.sh
- compiler/GHC/Cmm/Opt.hs
- hadrian/src/Hadrian/Haskell/Cabal/Type.hs
- hadrian/src/Hadrian/Haskell/Hash.hs
- hadrian/src/Hadrian/Oracles/ArgsHash.hs
- hadrian/src/Hadrian/Oracles/Cabal/Type.hs
- hadrian/src/Hadrian/Oracles/DirectoryContents.hs
- hadrian/src/Hadrian/Oracles/Path.hs
- hadrian/src/Hadrian/Oracles/TextFile.hs
- hadrian/src/Hadrian/Utilities.hs
- hadrian/src/Oracles/Flavour.hs
- hadrian/src/Oracles/ModuleFiles.hs
- testsuite/tests/numeric/should_run/all.T
- testsuite/tests/numeric/should_run/foundation.hs
- testsuite/tests/numeric/should_run/foundation.stdout


Changes:

=====================================
.gitlab/ci.sh
=====================================
@@ -259,6 +259,12 @@ function setup() {
   git config user.email "ghc-ci@gitlab-haskell.org"
   git config user.name "GHC GitLab CI"
 
+  # Disable auto gc. Useless in a temporary checkout, and
+  # non-deterministic "Auto packing the repository in background for
+  # optimum performance." message could pop up that confuses the
+  # testsuite driver!
+  git config gc.auto 0
+
   info "====================================================="
   info "Toolchain versions"
   info "====================================================="


=====================================
.gitlab/test-metrics.sh
=====================================
@@ -17,12 +17,14 @@ fail() {
 
 function pull() {
   local ref="refs/notes/$REF"
-  # 2023-10-04: `git fetch` started failing, first on Darwin in CI and then on
-  # Linux locally, both using git version 2.40.1. See #24055. One workaround is
-  # to set a larger http.postBuffer, although this is definitely a workaround.
-  # The default should work just fine. The error could be in git, GitLab, or
-  # perhaps the networking tube (including all proxies etc) between the two.
-  run git -c http.postBuffer=2097152 fetch -f "$NOTES_ORIGIN" "$ref:$ref"
+
+  # Fetch performance notes from a dedicated promisor remote using a
+  # treeless filter, so that individual note blobs are fetched lazily
+  # as needed.
+  git remote add perf-notes "$NOTES_ORIGIN" || true
+  git config fetch.recurseSubmodules false
+  git config remote.perf-notes.partialclonefilter tree:0
+  run git fetch --force perf-notes "$ref:$ref"
   echo "perf notes ref $ref is $(git rev-parse $ref)"
 }
 
@@ -81,4 +83,3 @@ case $1 in
   pull) pull ;;
   *) fail "Invalid mode $1" ;;
 esac
-


=====================================
compiler/GHC/Cmm/Opt.hs
=====================================
@@ -290,9 +290,7 @@ cmmMachOpFoldM _ (MO_Sub _) [CmmLit lit, CmmLit (CmmInt i rep)]
 -- the same comparison at the larger size.
 
 cmmMachOpFoldM platform cmp [CmmMachOp conv [x], CmmLit (CmmInt i _)]
-  |     -- powerPC NCG has a TODO for I8/I16 comparisons, so don't try
-    platformArch platform `elem` [ArchX86, ArchX86_64],
-        -- if the operand is widened:
+  |     -- if the operand is widened:
     Just (rep, signed, narrow_fn) <- maybe_conversion conv,
         -- and this is a comparison operation:
     Just narrow_cmp <- maybe_comparison cmp rep signed,


=====================================
hadrian/src/Hadrian/Haskell/Cabal/Type.hs
=====================================
@@ -31,7 +31,7 @@ data PackageData = PackageData
     , description               :: String
     , packageDependencies       :: [Package]
     , genericPackageDescription :: GenericPackageDescription
-    } deriving (Eq, Generic, Show, Typeable)
+    } deriving (Eq, Generic, Show)
 
 -- | Haskell package metadata obtained after resolving package configuration
 -- flags and associated conditionals according to the current build context.
@@ -75,7 +75,7 @@ data ContextData = ContextData
     , contextLibdir    :: FilePath
     -- The location where dynamic libraries go
     , contextDynLibdir :: FilePath
-    } deriving (Eq, Generic, Show, Typeable)
+    } deriving (Eq, Generic, Show)
 
 instance Binary   PackageData
 instance Hashable PackageData where hashWithSalt salt = hashWithSalt salt . show


=====================================
hadrian/src/Hadrian/Haskell/Hash.hs
=====================================
@@ -108,7 +108,7 @@ data PackageHashConfigInputs = PackageHashConfigInputs {
   deriving Show
 
 newtype PkgHashKey = PkgHashKey (Stage, Package)
-  deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+  deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult PkgHashKey = String
 
 pkgHash :: Stage -> Package -> Action String


=====================================
hadrian/src/Hadrian/Oracles/ArgsHash.hs
=====================================
@@ -38,7 +38,7 @@ trackArgsHash t = do
     void (askOracle $ ArgsHash hashedTarget :: Action Int)
 
 newtype ArgsHash c b = ArgsHash (Target c b)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult (ArgsHash c b) = Int
 
 -- | This oracle stores per-target argument list hashes in the Shake database,


=====================================
hadrian/src/Hadrian/Oracles/Cabal/Type.hs
=====================================
@@ -26,13 +26,13 @@ import Stage
 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.readPackageData'
 -- to cache reading and parsing of 'Hadrian.Haskell.Cabal.Type.PackageData'.
 newtype PackageDataKey = PackageDataKey Package
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult PackageDataKey = PackageData
 
 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.readContextData'
 -- to cache reading and parsing of 'Hadrian.Haskell.Cabal.Type.ContextData'.
 newtype ContextDataKey = ContextDataKey Context
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult ContextDataKey = ContextData
 
 -- TODO: Should @PackageConfiguration@ be simply @()@? Presumably the pair
@@ -40,7 +40,7 @@ type instance RuleResult ContextDataKey = ContextData
 -- | The result of Cabal package configuration produced by the oracle
 -- 'Hadrian.Oracles.Cabal.configurePackageGHC'.
 newtype PackageConfiguration = PackageConfiguration (C.Compiler, C.Platform)
-    deriving (Binary, Eq, Show, Typeable)
+    deriving (Binary, Eq, Show)
 
 instance NFData PackageConfiguration where
     rnf (PackageConfiguration (c, p)) =
@@ -58,5 +58,5 @@ instance Hashable PackageConfiguration where
 -- | This type of oracle key is used by 'Hadrian.Oracles.Cabal.configurePackageGHC'
 -- to cache configuration of a Cabal package.
 newtype PackageConfigurationKey = PackageConfigurationKey (Package, Stage)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult PackageConfigurationKey = PackageConfiguration


=====================================
hadrian/src/Hadrian/Oracles/DirectoryContents.hs
=====================================
@@ -15,7 +15,7 @@ import Hadrian.Utilities
 import qualified System.Directory.Extra as IO
 
 data Match = Test FilePattern | Not Match | And [Match] | Or [Match]
-    deriving (Generic, Eq, Show, Typeable)
+    deriving (Generic, Eq, Show)
 
 instance Binary   Match
 instance Hashable Match
@@ -54,7 +54,7 @@ copyDirectoryContentsUntracked expr source target = do
     mapM_ cp =<< directoryContents expr source
 
 newtype DirectoryContents = DirectoryContents (Match, FilePath)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult DirectoryContents = [FilePath]
 
 -- | This oracle answers 'directoryContents' queries and tracks the results.


=====================================
hadrian/src/Hadrian/Oracles/Path.hs
=====================================
@@ -34,11 +34,11 @@ fixAbsolutePathOnWindows path =
         return path
 
 newtype LookupInPath = LookupInPath String
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult LookupInPath = String
 
 newtype WindowsPath = WindowsPath FilePath
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult WindowsPath = String
 
 -- | Oracles for looking up paths. These are slow and require caching.


=====================================
hadrian/src/Hadrian/Oracles/TextFile.hs
=====================================
@@ -118,15 +118,15 @@ queryTargetTarget :: (Toolchain.Target -> a) -> Action a
 queryTargetTarget f = f <$> getTargetTarget
 
 newtype KeyValue = KeyValue (FilePath, String)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult KeyValue = Maybe String
 
 newtype KeyValues = KeyValues (FilePath, String)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult KeyValues = Maybe [String]
 
 newtype TargetFile = TargetFile FilePath
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult TargetFile = Toolchain.Target
 
 -- | These oracle rules are used to cache and track answers to the following


=====================================
hadrian/src/Hadrian/Utilities.hs
=====================================
@@ -298,7 +298,7 @@ userSettingRules defaultValue = do
     extra <- shakeExtra <$> getShakeOptionsRules
     return $ lookupExtra defaultValue extra
 
-newtype BuildRoot = BuildRoot FilePath deriving (Typeable, Eq, Show)
+newtype BuildRoot = BuildRoot FilePath deriving (Eq, Show)
 
 -- | All build results are put into the 'buildRoot' directory.
 buildRoot :: Action FilePath
@@ -484,7 +484,6 @@ putColoured code msg = do
         else putInfo msg
 
 newtype BuildProgressColour = BuildProgressColour String
-    deriving Typeable
 
 -- | By default, Hadrian tries to figure out if the current terminal
 --   supports colors using this function. The default can be overridden
@@ -511,7 +510,6 @@ putBuild msg = do
     putColoured code msg
 
 newtype SuccessColour = SuccessColour String
-    deriving Typeable
 
 -- | Generate an encoded colour for successful output from names
 mkSuccessColour :: Colour -> SuccessColour
@@ -528,7 +526,6 @@ putSuccess msg = do
     putColoured code msg
 
 newtype FailureColour = FailureColour String
-    deriving Typeable
 
 -- | Generate an encoded colour for failure output messages
 mkFailureColour :: Colour -> FailureColour
@@ -544,7 +541,7 @@ putFailure msg = do
   FailureColour code <- userSetting red
   putColoured code msg
 
-data ProgressInfo = None | Brief | Normal | Unicorn deriving (Eq, Show, Typeable)
+data ProgressInfo = None | Brief | Normal | Unicorn deriving (Eq, Show)
 
 -- | Version of 'putBuild' controlled by @--progress-info@ command line argument.
 putProgressInfo :: String -> Action ()


=====================================
hadrian/src/Oracles/Flavour.hs
=====================================
@@ -14,11 +14,11 @@ import Flavour
 import Settings (flavour)
 
 newtype DynGhcPrograms =
-  DynGhcPrograms () deriving (Show, Typeable, Eq, Hashable, Binary, NFData)
+  DynGhcPrograms () deriving (Show, Eq, Hashable, Binary, NFData)
 type instance RuleResult DynGhcPrograms = Bool
 
 newtype GhcProfiled =
-  GhcProfiled Stage deriving (Show, Typeable, Eq, Hashable, Binary, NFData)
+  GhcProfiled Stage deriving (Show, Eq, Hashable, Binary, NFData)
 type instance RuleResult GhcProfiled = Bool
 
 oracles :: Rules ()


=====================================
hadrian/src/Oracles/ModuleFiles.hs
=====================================
@@ -16,11 +16,11 @@ import Expression
 type ModuleName = String
 
 newtype ModuleFiles = ModuleFiles (Stage, Package)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult ModuleFiles = [Maybe FilePath]
 
 newtype Generator = Generator (Stage, Package, FilePath)
-    deriving (Binary, Eq, Hashable, NFData, Show, Typeable)
+    deriving (Binary, Eq, Hashable, NFData, Show)
 type instance RuleResult Generator = Maybe FilePath
 
 -- | We scan for the following Haskell source extensions when looking for module


=====================================
testsuite/tests/numeric/should_run/all.T
=====================================
@@ -3,6 +3,8 @@
 #	extra run flags
 #	expected process return value, if not zero
 
+import random
+
 test('arith001', normal, compile_and_run, [''])
 test('arith002', normal, compile_and_run, [''])
 test('arith003', normal, compile_and_run, [''])
@@ -82,7 +84,7 @@ test('IntegerToFloat', normal, compile_and_run, [''])
 test('T20291', normal, compile_and_run, [''])
 test('T22282', normal, compile_and_run, [''])
 test('T22671', js_fragile(24259), compile_and_run, [''])
-test('foundation', [when(js_arch(), run_timeout_multiplier(2)), js_fragile(24259), extra_ways(['optasm','ghci','ghci-opt'])], compile_and_run, ['-package transformers -fno-break-points'])
+test('foundation', [run_timeout_multiplier(2), js_fragile(24259), extra_ways(['optasm','ghci','ghci-opt']), extra_run_opts(str(random.getrandbits(64)))], compile_and_run, ['-fno-break-points'])
 test('T24066', normal, compile_and_run, [''])
 test('div01', normal, compile_and_run, [''])
 test('T24245', normal, compile_and_run, [''])


=====================================
testsuite/tests/numeric/should_run/foundation.hs
=====================================
@@ -10,9 +10,7 @@
   compare the result of the primop wrappers with the results of interpretation.
 -}
 
-{-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeAbstractions #-}
 {-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE DerivingStrategies #-}
@@ -25,28 +23,23 @@ module Main
     ( main
     ) where
 
+import Data.Array.Byte
 import Data.Bits (Bits((.&.), bit), FiniteBits, finiteBitSize)
 import Data.Word
 import Data.Int
 import GHC.Natural
 import Data.Typeable
-import Data.Proxy
 import GHC.Int
 import GHC.Word
-import GHC.Word
 import Data.Function
 import GHC.Prim
 import Control.Monad.Reader
-import System.IO
-import Foreign.Marshal.Alloc
-import Foreign.Storable
-import Foreign.Ptr
 import Data.List (intercalate)
-import Data.IORef
+import System.Environment (getArgs)
+import Text.Read (readMaybe)
 import Unsafe.Coerce
 import GHC.Types
 import Data.Char
-import Data.Semigroup
 import System.Exit
 
 import qualified GHC.Internal.PrimopWrappers as Wrapper
@@ -194,11 +187,16 @@ newtype LCGGen = LCGGen { randomWord64 :: IO Word64 }
 data LCGParams = LCGParams { seed :: Word64, a :: Word64, c :: Word64, m :: Word64 }
 
 newLCGGen :: LCGParams -> IO LCGGen
-newLCGGen LCGParams{..}  = do
-  var <- newIORef (fromIntegral seed)
-  return $ LCGGen $ do
-    atomicModifyIORef' var (\old_v -> let new_val = (old_v * a + c) `mod` m in (new_val, new_val))
-
+newLCGGen LCGParams {seed = W64# seed#, ..} = do
+  MutableByteArray mba# <- IO $ \s0 -> case newByteArray# 8# s0 of
+    (# s1, mba# #) -> case writeWord64Array# mba# 0# seed# s1 of
+      s2 -> (# s2, MutableByteArray mba# #)
+  pure $ LCGGen $ IO $ \s0 -> case readWord64Array# mba# 0# s0 of
+    (# s1, old_val# #) ->
+      let old_val = W64# old_val#
+          !new_val@(W64# new_val#) = (old_val * a + c) `mod` m
+       in case writeWord64Array# mba# 0# new_val# s1 of
+            s2 -> (# s2, new_val #)
 
 runPropertyCheck (PropertyBinaryOp res desc s1 s2) =
   if res then return Success
@@ -211,7 +209,7 @@ runPropertyCheck (PropertyAnd a1 a2) = (<>) <$> runPropertyCheck a1 <*> runPrope
 
 runProperty :: Property -> ReaderT RunS IO Result
 runProperty (Prop p) = do
-  let iterations = 100
+  let iterations = 10000 :: Int
   loop iterations iterations
   where
     loop iterations 0 = do
@@ -257,14 +255,15 @@ runTestInternal (Property name p) = do
   nest label $ runProperty (property p)
 
 
-runTests :: Test -> IO ()
-runTests t = do
+runTests :: Word64 -> Test -> IO ()
+runTests seed t = do
   -- These params are the same ones as glibc uses.
-  h <- newLCGGen (LCGParams { seed = 1238123213, m = 2^31, a = 1103515245, c = 12345 })
+  h <- newLCGGen (LCGParams { seed, m = 2 ^ (31 :: Int), a = 1103515245, c = 12345 })
   res <- runReaderT  (runTestInternal t) (RunS 0 h [])
   case res of
     Success -> return ()
     Failure tests -> do
+      putStrLn $ "Seed: " ++ show seed
       putStrLn $ "These tests failed:  \n" ++ intercalate "  \n" (map (showStack 0 . reverse) tests)
       exitFailure
 
@@ -455,7 +454,19 @@ instance TestPrimop LowerBitsAreDefined where
 twoNonZero :: (a -> a -> b) -> a -> NonZero a -> b
 twoNonZero f x (NonZero y) = f x y
 
-main = runTests (Group "ALL" [testNumberRefs, testPrimops])
+getSeedFromArgs :: IO Word64
+getSeedFromArgs = do
+  args <- getArgs
+  case args of
+    [arg] -> case readMaybe arg of
+      Just seed -> pure seed
+      Nothing -> die $ "Invalid seed (expected Word64): " ++ show arg
+    _ -> die "Usage: foundation <seed>"
+
+main :: IO ()
+main = do
+  seed <- getSeedFromArgs
+  runTests seed (Group "ALL" [testNumberRefs, testPrimops])
 
 -- Test an interpreted primop vs a compiled primop
 testPrimops = Group "primop"


=====================================
testsuite/tests/numeric/should_run/foundation.stdout
=====================================
@@ -3,1048 +3,1048 @@ Group ALL
     Group Int
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Int8
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Int16
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Int32
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Int64
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Integer
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Word
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Word8
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Word16
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Word32
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
     Group Word64
       Group Integral
         Running FromIntegral(Integer(a)) == a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Property
         Running Eq
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Show
-          Passed 100 iterations
+          Passed 10000 iterations
         Running Ord
-          Passed 100 iterations
+          Passed 10000 iterations
         Running <
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Additive
         Running a + azero == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running azero + a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a + b == b + a
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Multiplicative
         Running a * 1 == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running 1 * a == a
-          Passed 100 iterations
+          Passed 10000 iterations
         Running multiplication commutative
-          Passed 100 iterations
+          Passed 10000 iterations
         Running a * b == Integer(a) * Integer(b)
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Divisible
         Running (x `div` y) * y + (x `mod` y) == x
-          Passed 100 iterations
+          Passed 10000 iterations
       Group Precedence
         Running + and - (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and - (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running + and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running - and * (2)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (1)
-          Passed 100 iterations
+          Passed 10000 iterations
         Running * and ^ (2)
-          Passed 100 iterations
+          Passed 10000 iterations
   Group primop
     Running gtChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leChar#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int8ToInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running intToInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running negateInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRAInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int8ToWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word8ToWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running wordToWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running andWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running orWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xorWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running notWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word8ToInt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neWord8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int16ToInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running intToInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running negateInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRAInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int16ToWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word16ToWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running wordToWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running andWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running orWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xorWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running notWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word16ToInt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neWord16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int32ToInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running intToInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running negateInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRAInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int32ToWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word32ToWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running wordToWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running andWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running orWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xorWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running notWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftLWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRLWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word32ToInt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neWord32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int64ToInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running intToInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running negateInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftL64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftRA64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftRL64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int64ToWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word64ToWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running wordToWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running and64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running or64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xor64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running not64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftL64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRL64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word64ToInt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neWord64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running +#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running -#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running *#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesInt2#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running mulIntMayOflo#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running andI#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running orI#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xorI#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running notI#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running negateInt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running addIntC#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subIntC#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running >#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running >=#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ==#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running /=#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running <#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running <=#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running chr#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running int2Word#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftL#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftRA#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedIShiftRL#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running addWordC#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running subWordC#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running plusWord2#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running minusWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running timesWord2#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running remWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running quotRemWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running and#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running or#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running xor#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running not#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftL#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running uncheckedShiftRL#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running word2Int#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running gtWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running geWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running eqWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running neWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ltWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running leWord#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running popCnt8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running popCnt16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running popCnt32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running popCnt64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running popCnt#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pdep8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pdep16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pdep32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pdep64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pdep#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pext8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pext16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pext32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pext64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running pext#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running clz8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running clz16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running clz32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running clz64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running clz#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ctz8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ctz16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ctz32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ctz64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running ctz#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running byteSwap16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running byteSwap32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running byteSwap64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running byteSwap#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running bitReverse8#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running bitReverse16#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running bitReverse32#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running bitReverse64#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running bitReverse#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow8Int#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow16Int#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow32Int#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow8Word#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow16Word#
-      Passed 100 iterations
+      Passed 10000 iterations
     Running narrow32Word#
-      Passed 100 iterations
+      Passed 10000 iterations



View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/0ed6a6375079f1c92a5ba5dfe5b6a68...

-- 
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/0ed6a6375079f1c92a5ba5dfe5b6a68...
You're receiving this email because of your account on gitlab.haskell.org.

    

[Git][ghc/ghc][wip/foundation-improve-coverage] 5 commits: ci: use treeless fetch for perf notes

Cheng Shao (＠TerrorJack)