[GHC] #11054: GHC on Windows could not use more than 64 logical processors

[GHC]

#11054: GHC on Windows could not use more than 64 logical processors
-------------------------------------+-------------------------------------
        Reporter:  varosi            |                Owner:  Phyx-
            Type:  feature request   |               Status:  patch
        Priority:  normal            |            Milestone:
       Component:  Runtime System    |              Version:  7.10.2
      Resolution:                    |             Keywords:
Operating System:  Windows           |         Architecture:  x86_64
 Type of failure:  Runtime           |  (amd64)
  performance bug                    |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #12602            |  Differential Rev(s):  Phab:D2533
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by Phyx-):

 Thanks for testing,

 I'm not really sure yet what's going on there. It does seem to correctly
 detect the configuration

 {{{
 [*] Number of processor groups detected: 2
 [*] Number of active processors in group 0 detected: 44
 [*] Number of active processors in group 1 detected: 44
 [*] Processor group map created
 [*] Cumulative active processors for group 0: 0
 [*] Cumulative active processors for group 1: 44
 }}}

 Two capabilities failed to be set:

 {{{
 SetThreadGroupAffinity: The parameter is incorrect.
 }}}

 I'll see if I can figure out why. Though that's only 2 of 88.

 The final dump of threads is what has be confused, as it seems to indicate
 there are only 2 active threads. While the rest are all idle/blocked.

 Could you try again using my test program?:

 {{{
 import Control.Concurrent
 import Control.Monad

 main = do ids <- replicateM 88 (forkIO $ print $ length $ primesToG
 100000000000)
           spin

 spin = do threadDelay 1000
           yield
           spin

 primesToG m = 2 : sieve [3,5..m]
   where
     sieve (p:xs)
        | p*p > m   = p : xs
        | otherwise = p : sieve (xs `minus` [p*p, p*p+2*p..])

 minus (x:xs) (y:ys) = case (compare x y) of
            LT -> x : minus  xs  (y:ys)
            EQ ->     minus  xs     ys
            GT ->     minus (x:xs)  ys
 minus  xs     _     = xs
 }}}

 If it still doesn't get passed 50 I'll make a build with more verbose
 output so I can better trace the behavior.

 The program is a bit greedy so to kill it you'll have to kill the process.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11054#comment:30>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler