F # параллелизующая проблема при вычислении идеальных чисел?

Ответ 1

@Jeffrey Sax комментарий определенно интересен, поэтому я потратил некоторое время на небольшой эксперимент. Тест Lucas-Lehmer записывается следующим образом:

let lucasLehmer p =
    let m = (PowShift p) - 1I
    let rec loop i acc =
        if i = p-2 then acc
        else loop (i+1) ((acc*acc - 2I)%m)
    (loop 0 4I) = 0I

С помощью теста Lucas-Lehmer я могу получить первые несколько совершенных чисел очень быстро:

let mersenne (i: int) =     
    if i = 2 || (isPrime (bigint i) && lucasLehmer i) then
        let p = PowShift i
        Some ((p/2I) * (p-1I))
    else None

let runPerfects n =
    seq [1..n]
        |> Seq.choose mersenne
        |> Seq.toArray

let m1 = runPerfects 2048;; // Real: 00:00:07.839, CPU: 00:00:07.878, GC gen0: 112, gen1: 2, gen2: 1

Тест Lucas-Lehmer помогает сократить время проверки простых чисел. Вместо проверки делимости 2 ^ p-1, которая принимает O(sqrt(2^p-1)), мы используем тест примитивности, который не превосходит O(p^3). С n = 2048 я могу найти первые 15 чисел Мерсенна за 7,83 секунды. 15-е число Мерсенны - это номер с i = 1279 и состоит из 770 цифр.

Я попытался распараллелить runPerfects с помощью модуля PSeq в F # Powerpack. PSeq не сохраняет порядок исходной последовательности, так что, честно говоря, я отсортировал последовательность вывода. Поскольку тест примитивности довольно сбалансирован среди индексов, результат весьма обнадеживающий:

#r "FSharp.Powerpack.Parallel.Seq.dll"    
open Microsoft.FSharp.Collections

let runPerfectsPar n =
    seq [1..n]
        |> PSeq.choose mersenne
        |> PSeq.sort (* align with sequential version *)
        |> PSeq.toArray 

let m2 = runPerfectsPar 2048;; // Real: 00:00:02.288, CPU: 00:00:07.987, GC gen0: 115, gen1: 1, gen2: 0

При том же входе параллельная версия заняла 2,28 секунды, что эквивалентно ускорению на 3,4 раза на моей четырехъядерной машине. Я считаю, что результат можно было бы улучшить, если вы используете конструкцию Parallel.For и разделите диапазон ввода разумно.

Ответ 2

Один быстрый комментарий по скорости и параллелизуемости,

Ваш isPrime - это O (sqrt (n)), и каждый succesive n имеет размер примерно 2 x, такой же большой, как и последний, поэтому для вычисления потребуется приблизительно 1,5 x, что означает, что вычисление последних чисел будет занимать гораздо больше времени

Я сделал некоторые взлома с проверкой на простоту, и некоторые вещи, которые я нашел полезными:

• Для больших N (вы тестируете числа с 20 цифрами), плотность на самом деле довольно низкая, поэтому вы будете делать много делений по составным числам. Лучшим подходом является предварительная калькуляция таблицы простых чисел (с использованием сита) до некоторого максимального предела (вероятно, определяется объемом памяти). Обратите внимание, что вы, скорее всего, найдете факторы с небольшими числами. После того, как у вас закончится нехватка памяти для вашей таблицы, вы можете протестировать остальную часть номера с помощью существующей функции с большей начальной точкой.

• Другой подход заключается в использовании нескольких потоков в проверке. Например, вы в настоящее время проверяете x,x+4,x+6... как факторы. Чувствуя себя немного умнее, вы можете сделать число, сравнимое с 1 mod 3 в 1 потоке, и числа, совпадающие с 2 mod 3 в другом потоке.

Нет. 2 является простейшим, но № 1 является более эффективным и обеспечивает потенциал для управления потоком с OutOfMemoryExceptions, который всегда может быть интересным

EDIT: Так что я реализовал обе эти идеи, он находит 2305843008139952128 почти мгновенно, нахождение 2658455991569831744654692615953842176 занимает 7 минут на моем компьютере (четырехъядерный процессор AMD 3200). Большая часть времени проведена проверка 2 ^ 61 является простой, поэтому лучший алгоритм, вероятно, будет лучше для проверки простых чисел: Код здесь

let swatch = new System.Diagnostics.Stopwatch()
swatch.Start()
let inline PowShift (exp:int32) = 1I <<< exp ;;
let limit = 10000000 //go to a limit, makes table gen slow, but should pay off
printfn "making table"
//returns an array of all the primes up to limit
let table =
    let table = Array.create limit true //use bools in the table to save on memory
    let tlimit = int (sqrt (float limit)) //max test no for table, ints should be fine
    table.[1] <- false //special case
    [2..tlimit] 
    |> List.iter (fun t -> 
        if table.[t]  then //simple optimisation
            let mutable v = t*2
            while v < limit do
                table.[v] <- false
                v <- v + t)
    let out = Array.create (50847534) 0I //wolfram alpha provides pi(1 billion) - want to minimize memory
    let mutable idx = 0
    for x in [1..(limit-1)] do
        if table.[x] then
            out.[idx] <- bigint x
            idx <- idx + 1
    out |> Array.filter (fun t -> t <> 0I) //wolfram no is for 1 billion as limit, we use a smaller number
printfn "table made"

let rec isploop testprime incr max n=
    if testprime > max then true
    else if n % testprime = 0I then false
    else isploop (testprime + incr) incr max n

let isPrime ( n : bigint) = 
    //first test the table
    let maxFactor = bigint(sqrt(float n))
    match table |> Array.tryFind (fun t -> n % t = 0I && t <= maxFactor) with
    |Some(t) -> 
        false
    |None -> //now slow test
        //I have 4 cores so
        let bases = [|limit;limit+1;limit+3;limit+4|] //uses the fact that 10^x congruent to 1 mod 3
        //for 2 cores, drop last 2 terms above and change 6I to 3I
        match bases |> Array.map (fun t -> async {return isploop (bigint t) 6I maxFactor n}) |> Async.Parallel |> Async.RunSynchronously |> Array.tryFind (fun t -> t = false) with
        |Some(t) -> false
        |None -> true


let pcount = ref 0
let perfectNumbersTwo (n : int) =  
    seq { for i in 2..n do 
           if (isPrime (bigint i)) then
                if (PowShift i) - 1I |> isPrime then
                    pcount := !pcount + 1
                    if !pcount = 9 then
                        swatch.Stop()
                        printfn "total time %f seconds, %i:%i m:s"  (swatch.Elapsed.TotalSeconds) (swatch.Elapsed.Minutes) (swatch.Elapsed.Seconds)
                    yield PowShift (i-1) * ((PowShift i)-1I)
        } 


perfectNumbersTwo 62 |> Seq.iter (printfn "PERFECT: %A") //62 gives 9th number

printfn "done"
System.Console.Read() |> ignore