Pourquoi les impressions sur la console sont-elles mélangées lors des calculs parallèles?

Question

Lors de l'exécution de code exécutant des calculs parallèles, la sortie devient tronquée: différents messages sont mélangés. Voici un exemple:

Iteration 1 
Iteration 
Iteration 23 of 19 - Calculating P&L for test window ending at 10/28/1968 12:00:00 AM 

of 
Iteration 4 
Iteration of 
Iteration 5 
Iteration 
Iteration 19 - Calculating P&L for test window ending at of 19 - Calculating P&L for test window ending at 5/29/1974 12:00:00 AM 
6 of 878/18/1971 12:00:00 AM19 - Calculating P&L for test window ending at 3/4/1977 12:00:00 AM 


of 19 of 
of 19 - Calculating P&L for test window ending at 6/25/1985 12:00:00 AM 

Lors de l'exécution du même programme séquentiellement la sortie de la console sort agréable, sans garbling.

impression à la console se fait par cette fonction:

let windowTrainTest (comm: Communication) critFoo count (model: IModel) (assets: Assets) (paramList: Parameters list) = 
    // Deleted some code here 
    if comm = Verbose then 
     let msg1 = sprintf "\nwindowTrainTestPandL: First date: %A, Last date: %A\nBest Criterion: %.2f\n" fDate lDate bestCriterion 
     let msg2 = sprintf "Best Parameters: %A\n" bestParameters 
     printfn "%s" <| msg1 + msg2 

    (pandl, wgts), bestParameters, (["Criterion", bestCriterion]   |> Map.ofList, 
            ["FirstDate", fDate; "LastDate", lDate] |> Map.ofList) 

parallélisation est fait par cette partie du programme:

let pSeqMapi f (xs: seq<'T>) = xs |> PSeq.mapi f 

let trainTest n i (trainSize, fullSize) = 
     let takenAssets = assets |> Assets.take (min fullSize len) 
     lastDate takenAssets 
     |> printfn "\nIteration %d of %d - Calculating P&L for test window ending at %A\n" (i + 1) n 
     paramList 
     |> windowTrainTest comm' critFoo trainSize model takenAssets 

    let mapTrainTest (initSizes: (int * int) list) = 
     let f = trainTest initSizes.Length 
     match calcType with 
     | PSeq -> initSizes |> pSeqMapi f |> List.ofSeq 
     | _ -> initSizes |> Seq.mapi f |> List.ofSeq 

Y at-il un moyen d'éviter ce genre de comportement, pour exemple en rinçant le message à la console?

Answer 1

Je pense que j'ai trouvé la solution, et elle ne nécessite pas de verrous. Je l'ai remplacé les lignes

lastDate takenAssets 
|> printfn "\nIteration %d of %d - Calculating P&L for test window ending at %A\n" (i + 1) n 

avec

let msg = sprintf "\nIteration %d of %d - Calculating P&L for test window ending at %A\n" (i + 1) n (lastDate takenAssets) 
printfn "%s" msg 

Je laisse à ceux qui sont plus compétents pour offrir une explication.

Answer 2

Les calculs parallèles s'exécutent sur différents threads, et si un thread est interrompu au milieu d'un printfn et qu'un second thread exécute un printfn avant que le premier thread ne soit à nouveau exécuté, alors leurs sorties seront entrelacées.

La façon la plus simple de résoudre ce problème est de créer une nouvelle fonction qui utilisera le mot-clé lock autour printfn invocations:

let lockObj = new obj() 
let lockedPrintfn msg = lock lockObj (fun _ -> printfn msg) 

Remplacez ensuite tous vos printfn appels avec lockedPrintfn et vous devriez obtenir la sortie sérialisé vous J'attends. Votre performance souffrira un peu car vos threads passeront parfois du temps à attendre le verrouillage printfn, mais tant que vos calculs durent beaucoup plus longtemps que le temps passé à imprimer, vous ne devriez pas remarquer les performances légèrement plus lentes.