1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
{-# LANGUAGE BangPatterns, CPP, MagicHash #-}
module Main ( main ) where
import Data.Bits
import GHC.Prim
import GHC.Word
#include "MachDeps.h"
main = putStr
(test_lzCnt ++ "\n"
++ test_lzCnt8 ++ "\n"
++ test_lzCnt16 ++ "\n"
++ test_lzCnt32 ++ "\n"
++ test_lzCnt64 ++ "\n"
++ "\n"
++ test_tzCnt ++ "\n"
++ test_tzCnt8 ++ "\n"
++ test_tzCnt16 ++ "\n"
++ test_tzCnt32 ++ "\n"
++ test_tzCnt64 ++ "\n"
++ "\n"
)
lzcnt :: Word -> Word
lzcnt (W# w#) = W# (clz# w#)
lzcnt8 :: Word -> Word
lzcnt8 (W# w#) = W# (clz8# w#)
lzcnt16 :: Word -> Word
lzcnt16 (W# w#) = W# (clz16# w#)
lzcnt32 :: Word -> Word
lzcnt32 (W# w#) = W# (clz32# w#)
lzcnt64 :: Word64 -> Word
lzcnt64 (W64# w#) =
#if SIZEOF_HSWORD == 4
W# (clz64# w#)
#else
W# (clz# w#)
#endif
lzcnt_slow :: Int -> Word -> Word
lzcnt_slow size x = fromIntegral $ min size $ length $ takeWhile (== False) $ reverse $ map (testBit x) [0 .. size - 1]
tzcnt :: Word -> Word
tzcnt (W# w#) = W# (ctz# w#)
tzcnt8 :: Word -> Word
tzcnt8 (W# w#) = W# (ctz8# w#)
tzcnt16 :: Word -> Word
tzcnt16 (W# w#) = W# (ctz16# w#)
tzcnt32 :: Word -> Word
tzcnt32 (W# w#) = W# (ctz32# w#)
tzcnt64 :: Word64 -> Word
tzcnt64 (W64# w#) =
#if SIZEOF_HSWORD == 4
W# (ctz64# w#)
#else
W# (ctz# w#)
#endif
tzcnt_slow :: Int -> Word -> Word
tzcnt_slow size x = fromIntegral $ min size $ length $ takeWhile (== False) $ map (testBit x) [0 .. size - 1]
test_lzCnt = test "lzcnt" lzcnt (lzcnt_slow (8 * SIZEOF_HSWORD))
test_lzCnt8 = test "lzcnt8" lzcnt8 (lzcnt_slow 8 . fromIntegral . (mask 8 .&.))
test_lzCnt16 = test "lzcnt16" lzcnt16 (lzcnt_slow 16 . fromIntegral . (mask 16 .&.))
test_lzCnt32 = test "lzcnt32" lzcnt32 (lzcnt_slow 32 . fromIntegral . (mask 32 .&.))
test_lzCnt64 = test "lzcnt64" lzcnt64 (lzcnt_slow 64 . fromIntegral . (mask 64 .&.))
test_tzCnt = test "tzcnt" tzcnt (tzcnt_slow (8 * SIZEOF_HSWORD))
test_tzCnt8 = test "tzcnt8" tzcnt8 (tzcnt_slow 8 . fromIntegral . (mask 8 .&.))
test_tzCnt16 = test "tzcnt16" tzcnt16 (tzcnt_slow 16 . fromIntegral . (mask 16 .&.))
test_tzCnt32 = test "tzcnt32" tzcnt32 (tzcnt_slow 32 . fromIntegral . (mask 32 .&.))
test_tzCnt64 = test "tzcnt64" tzcnt64 (tzcnt_slow 64 . fromIntegral . (mask 64 .&.))
mask n = (2 ^ n) - 1
test :: (Show a, Num a) => String -> (a -> Word) -> (a -> Word) -> String
test name fast slow = case failing of
[] -> "OK"
((_, e, a, i):xs) ->
"FAIL " ++ name ++ "\n" ++ " Input: " ++ show i ++ "\nExpected: " ++ show e ++
"\n Actual: " ++ show a
where
failing = dropWhile ( \(b,_,_,_) -> b)
. map (\ x -> (slow x == fast x, slow x, fast x, x)) $ cases
expected = map slow cases
actual = map fast cases
#if SIZEOF_HSWORD == 4
cases = [0, 1, 2, 1480294021,1626858410,2316287658,1246556957,3806579062,65945563,
1521588071,791321966,1355466914,2284998160]
#elif SIZEOF_HSWORD == 8
cases = [0, 1, 2, 11004539497957619752,5625461252166958202,1799960778872209546,
16979826074020750638,12789915432197771481,11680809699809094550,
13208678822802632247,13794454868797172383,13364728999716654549,
17516539991479925226]
#else
# error Unexpected word size
#endif
|
