Existe t'il une méthode pour accélerer PowerShell?

Version imprimable

12/07/2018, 12h21
Komainu

Existe t'il une méthode pour accélerer PowerShell?

Bonjour,

Je viens vers vous étant à cours de solution.

Alors voilà j'ai un script qui doit traité 36 .txt, d'environ 500 000 lignes chacun sachant aussi que certaines lignes sont obsolètes. Pour cela j'ai rajouté -EA SilentlyContinue.

Mon problème est le suivant ayant beaucoup de ligne a traité je voulais savoir si il existait un moyen d’accélérer l'exécution du script pour ainsi évité d'impacter le serveur en prod' je vous mets donc mon script a disposition.

Citation:

#Rechcerche du fichier spécifique
$file2 = "C:\Users\*.txt"

#Initailisation des différentes variables permettant de savoir le nombre total de fichiers et la taille total se trouvant dans $file2
$NumberOfFilesTotal = 0
$tailleTotal = 0

#Initailisation de la variable $list permettant la lecture de chaque ligne dans le $file2
$list = Get-Content $file2
$list | foreach {
#Lecture des différentes lignes
$list = $_

#Calcul du nombre de fichiers
$NumberOfFiles = Get-ChildItem -path $list -Recurse -force -EA silentlycontinue -include *.*| Measure-Object | %{$_.Count}

#Calcul de la taille de chaque fichiers se trouvant dans $file2
$taille = ((Get-ChildItem -path $list -Recurse -force -EA silentlycontinue -include *.* | Measure-Object -Property Length -Sum -ErrorAction Stop).Sum)

#Incrémentation de tous les fichiers se trouvant dans $file2
$NumberOfFilesTotal += $NumberOfFiles

#Incrémentation de toutes les tailles se trouvant dans $file2
$tailleTotal += $taille
}
#Conversion de bytes en MégaBytes
$tailletotal = $tailleTotal /1048576

#Ecriture du résultat à l'écran
Write-Host "Il y a" $NumberOfFilesTotal "fichiers, dossiers et de sous dossiers" -ForegroundColor Yellow
Write-Host "Le fichier fait" $tailleTotal "MB" -ForegroundColor Green

#Enregistrement des différents retours de variable
#$NumberOfFilesTotal | Export-CSV -Path "C:\users\$env:USERNAME\$env:COMPUTERNAME-NombreDeFichier.csv"
#$tailleTotal | Export-CSV -Path "c:\users\$env:USERNAME\$env:COMPUTERNAME-TailleTotal.csv"
$Fichier1="Il y a" + " " + $NumberOfFilesTotal+ " " + "fichiers sur" + " " + $env:COMPUTERNAME
$Fichier1 > "C:\users\$env:USERNAME\$env:COMPUTERNAME-NombreDeFichier.csv"
$Fichier2="La taille total est de" + " " + $tailleTotal + " " + "MB sur"+ " " + $env:COMPUTERNAME
$Fichier2 > "c:\users\$env:USERNAME\$env:COMPUTERNAME-TailleTotal.csv"
12/07/2018, 13h49
ericlm128

Peux tu utiliser les balises "code=powershell" pour ton code STP ?

Que souhaites tu obtenir ? Il semblerait que se soit uniquement la taille total des fichiers et leurs nombres correspondant au motif de recherche "C:\Users\*.txt" ?
Si oui, il n'y a pas d’intérêt à lire le contenu qui est l'opération la plus consommatrice.
12/07/2018, 13h56
ericlm128

Peut être que je n'ai pas bien comprit, à quoi sert et à quoi ressemble tes 36 fichiers .txt ?

Je souhaite obtenir un fichier excel avec le nombre de fichier et la taille total.
Les fichiers txt se formule comme cela :
\\chemin\dossier\fichier.doc
\\chemin\dossier\fichier2.doc
\\chemin\dossier\fichier3.pdf
\\chemin\dossier\fichier.tif

J'ai donc besoin de lire les fichiers .txt pour savoir ou se trouve le fichier en question le nombre qu'il y en a et le taille total.

Code:

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
 
#Rechcerche du fichier spécifique
$file2 = "C:\Users\*.txt"
 
#Initailisation des différentes variables permettant de savoir le nombre  total de fichiers et la taille total se trouvant dans $file2
$NumberOfFilesTotal = 0
$tailleTotal = 0
 
#Initailisation de la variable $list permettant la lecture de chaque ligne dans le $file2
$list = Get-Content $file2
$list | foreach { 
#Lecture des différentes lignes
    $list = $_ 
 
    #Calcul du nombre de fichiers
    $NumberOfFiles = Get-ChildItem -path $list -Recurse -force -EA silentlycontinue -include *.*| Measure-Object | %{$_.Count}
 
    #Calcul de la taille de chaque fichiers se trouvant dans $file2
    $taille = ((Get-ChildItem -path $list -Recurse -force -EA  silentlycontinue -include *.* | Measure-Object -Property Length -Sum  -ErrorAction Stop).Sum)
 
    #Incrémentation de tous les fichiers se trouvant dans $file2
    $NumberOfFilesTotal += $NumberOfFiles 
 
    #Incrémentation de toutes les tailles se trouvant dans $file2
    $tailleTotal += $taille 
                    }
#Conversion de bytes en MégaBytes
$tailletotal = $tailleTotal /1048576
 
#Ecriture du résultat à l'écran
Write-Host "Il y a" $NumberOfFilesTotal  "fichiers, dossiers et de sous dossiers" -ForegroundColor Yellow
Write-Host "Le fichier fait" $tailleTotal "MB" -ForegroundColor Green
 
#Enregistrement des différents retours de variable 
#$NumberOfFilesTotal |  Export-CSV -Path "C:\users\$env:USERNAME\$env:COMPUTERNAME-NombreDeFichier.csv"
#$tailleTotal | Export-CSV -Path  "c:\users\$env:USERNAME\$env:COMPUTERNAME-TailleTotal.csv"
$Fichier1="Il y a" + " " + $NumberOfFilesTotal+ " " + "fichiers sur" + " " + $env:COMPUTERNAME
$Fichier1 > "C:\users\$env:USERNAME\$env:COMPUTERNAME-NombreDeFichier.csv"
$Fichier2="La taille total est de" + " " + $tailleTotal + " " + "MB sur"+ " " + $env:COMPUTERNAME
$Fichier2 > "c:\users\$env:USERNAME\$env:COMPUTERNAME-TailleTotal.csv"

12/07/2018, 14h09
ericlm128

Ok donc il faut effectivement que tu lise tes x fichiers .txt

Il semblerait que chaque ligne, de tes fichiers textes, corresponde à 1 fichiers (selon l'exemple que tu m'a transmis) maximum, ou 0 si il n'existe pas.

Tu confirmes ma supposition ?
12/07/2018, 14h15
ericlm128

Nous allons devoir tenter d'optimiser ton script, nous devons donc évaluer précisément le contexte dans lequel il se déroule

chemin et dossier sont ils toujours identiques ?
12/07/2018, 14h16
Komainu

C'est exactement ça, une ligne 1 fichier.
12/07/2018, 14h25
Komainu

Le début oui il pointe vers un serveur et après ce n'ai pas toujours le cas.

Et certains fichiers.txt ont le même chemin/ dossier parent. Ce qui normalement voudrait dire j'utilise un logiciel tiers ou via powershell pour mesurer le dossier parent, mais dans ce dossier parent j'ai peut-être 66% des fichiers (.doc,.pdf,.jpg...) qui m'intéresse.

Même si le travail demandé est conséquent dans tout les cas, quelques chose comme ceci serait surement plus efficace, a tester/benchmarker.

Il faut juste voir si Get-Content -LiteralPath digère autant d'élément, mais je n'ai pas vu de contrainte identifiée.

A noter :
1 modification de Get-Content par un Get-ChildItem combiné avec un [System.IO.File]::ReadLines plus efficace
1 seul appel à Get-ChildItem avec la listes des fichiers à trouver. Plus de Recurse
1 seul Measure-Object suffit
Plus d'incrémentation de variable.
Code plus simple et lisible (selon moi)
J'ai utilisé les foreach pour plus de lisibilité
Code:

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 #Recherche du fichier spécifique $file2 = "C:\Users\*.txt" #Initialisation des différentes variables permettant de savoir le nombre total de fichiers et la taille total se trouvant dans $file2 $NumberOfFilesTotal = 0 $tailleTotal = 0 $paths = @() foreach($file in Get-ChildItem -path $file2 -force -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName) { foreach($line in [System.IO.File]::ReadLines($file, [System.Text.Encoding]::Default)) { $paths += $line } } $paths = $paths | Select-Object -Unique $ret = Get-ChildItem -LiteralPath $paths -File -Force -ErrorAction SilentlyContinue | Measure-Object -Sum Length $NumberOfFilesTotal = $ret.Count $tailleTotal = $ret.Sum #Conversion de bytes en MégaBytes $tailletotal = $tailleTotal / 1048576 #Ecriture du résultat à l'écran Write-Host "Il y a" $NumberOfFilesTotal "fichiers" -ForegroundColor Yellow Write-Host "Les fichiers font" $tailleTotal "MB" -ForegroundColor Green
Edit : ajout de $paths = $paths | Select-Object -Unique pour optimiser les redondances

12/07/2018, 15h42
Komainu

J'ai donc benchmarker votre script et le mien voici donc les scores.
Score pour traité 8570 fichiers votre script : 2:37,07
La même chose mais avec mon script : 3:51,04

Merci beaucoup pour ce script, il marche du feu de dieu :)
12/07/2018, 15h50
ericlm128

Cool si tu as pu gagner un peu de temps de traitement.

Et bien le goulot d'étranglement est la vérification de présence du fichier sur les différents partages.

Ceci est du au temps d'accès disque latence réseau ...
Ceci devient difficilement optimisable au vu du nombre conséquent de fichier à vérifier.

Il y a une dernière optimisation possible mais qui peux avoir un effet pervers, il s'agit du parallélisme.
On pourrait demande à la commande de faire plusieurs vérification en simultané, mais si l'ensemble des fichiers sont sur le même partage ceci pourrait allonger fortement (du as une congestion) le temps d'exécution au lieu de le diminuer.
Un peu comme quand tu lance 20 copie en même temps de différents fichiers provenant de la même cible vers la même destination
12/07/2018, 15h51
ericlm128

Après pour en avoir le cœur net tu peux benchmarker quelle partie du script consomme le plus de temps
https://www.pluralsight.com/blog/tut...-scripts-speed

Mais je pense que la ligne suivante consomme 99,9% du temps (j'ai enlevé volontairement Measure-Object car je ne pense pas qu'il soit le responsable)
$ret = Get-ChildItem -LiteralPath $paths -File -Force -ErrorAction SilentlyContinue
12/07/2018, 15h59
Komainu

Une minutes c'est énorme comme gain de temps surtout sur des traitements comme cela.
Dans tous les cas l'opération que je mène est longue et ch*ante.
Cela risque de faire planté les serveurs sur lequel j'exécute la commande mais j'y avais pensé aussi déjà que le script prend entre 1Go et 2Go de RAM lors de son exécution sur un serveur Windows 4Go me reste pas bcp de marge de manœuvre.

Il y a avait aussi la solution de renommage :
Première étape je renomme mes fichiers existant .old
Deuxième étape je lit que les fichiers .old
Troisième étape je l'ai renomme avec leur nom d'origine.

Mais certains fichiers sont encore utilisés donc j'ai été un peu coincé.

Mais en tout cas merci encore. :)

Peux tu juste benchmarker ceci ?

Je tente de descendre au niveau du FrameWork pour voir.

Code:

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
#Recherche du fichier spécifique
$file2 = "C:\Users\*.txt"
 
#Initialisation des différentes variables permettant de savoir le nombre total de fichiers et la taille total se trouvant dans $file2
$NumberOfFilesTotal = 0
$tailleTotal = 0
 
$paths = @()
foreach($file in Get-ChildItem -path $file2 -force -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName)
{
    foreach($line in [System.IO.File]::ReadLines($file, [System.Text.Encoding]::Default))
    {
           $paths += $line
    }
}
$paths = $paths | Select-Object -Unique
 
 
$result = @()
foreach($item in $paths)
{
    if([System.IO.File]::Exists($item))
    {
        $result += [System.IO.FileInfo]$item
    }
}
 
#$ret = Get-ChildItem -LiteralPath $paths -File -Force -ErrorAction SilentlyContinue | Measure-Object -Sum Length
$ret = $result | Measure-Object -Sum Length
 
$NumberOfFilesTotal = $ret.Count
$tailleTotal = $ret.Sum
 
#Conversion de bytes en MégaBytes
$tailletotal = $tailleTotal / 1048576
 
#Ecriture du résultat à l'écran
Write-Host "Il y a" $NumberOfFilesTotal  "fichiers" -ForegroundColor Yellow
Write-Host "Les fichiers font" $tailleTotal "MB" -ForegroundColor Green
 
exit

12/07/2018, 16h11
Komainu

1:26.33 !!!!
Tu viens de me faire gagner deux minutes!
Donc pour le gain du temps il faut travailler plus "prêt" du framework.

Merci encore :D!!!
12/07/2018, 16h12
ericlm128

Super ! Comme quoi la cmdlet Get-ChildItem pourrait être plus optimisée (je m'en doutais) :D
12/07/2018, 16h13
ericlm128

En théorie, avec un code correctement structuré, plus tu as besoin de puissance (optimisation) plus tu doit travailler dans les couches basses.
12/07/2018, 16h39
Komainu

Effectivement :lol:
Bah merci encore pour ses conseils, je gagne un temps précieux.
12/07/2018, 18h00
Laurent Dardenne
Salut,
ceci est à éviter :
Code:

1 2 3 $path=@() $paths += $line
utilise une collection de type arraylist :
Code:

1 2 3 $Paths=[System.Collections.Arraylist]::New() $paths.Add($Line) > $null
Citation:

Envoyé par Komainu

1:26.33 !!!!
Donc pour le gain du temps il faut travailler plus "prêt" du framework.

Voir utiliser les API win32 :aie:
13/07/2018, 12h44
Komainu

Salut,
Laurent Dardenne
Merci pour ce petit morceau de script, tu viens de me faire gagner 17 secondes. Je vais bientôt passé sous la barre de la minute a cette allure. :)
13/07/2018, 13h20
ericlm128

Si tu veux avoir une chance d'y arriver, il faut maintenant déterminer le code consommateur de ta ressource précieuse :)
13/07/2018, 13h24
ericlm128

A l'époque j'avais optimisé une script vbs, réalisé par un sous-traitant, que nous poussions régulièrement sur 16 000 postes.
La version 35 de leur script mettait 45 minutes à fond (CPU). Après optimisation il est descendu sous la seconde.

Quand je pense à toute cette énergie électrique dépensé pour rien et l'impact utilisateur, ça me dégoute :oops:
13/07/2018, 13h51
Komainu

Je lui ai encore fais gagner 10 secondes, mais les serveurs ont du mal a tenir la charge aussi.

Vache tu as bien optimisé la chose, je maitrise pas assez PowerShell pour l'optimisé plus mais je continue a creusé. :D

Je suis bien d'accord avec toi la dessus.

J'ai retrouvé dans mes archives une fonction que j'avais créé pour faire du parallélisme.
Je l'ai implémenté mais non testé en ajoutant les remarques de Laurent Dardenne corrigée (car $Paths=[System.Collections.Arraylist]::New() me sort une exception sur New)

Tu peux faire varier le paramètre -MaxThreads et vérifier l'impact.

J'espère que tout est en ordre :D

Code:

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
108
109
110
111
function ForEach-Parallel {
    param(
        [Parameter(Mandatory=$true,position=0)]
        [System.Management.Automation.ScriptBlock] $ScriptBlock,
        [Parameter(Mandatory=$true,ValueFromPipeline=$true)]
        [PSObject]$InputObject,
        [Parameter(Mandatory=$false)]
        [int]$MaxThreads=5
    )
    BEGIN {
        $iss = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
        $pool = [Runspacefactory]::CreateRunspacePool(1, $maxthreads, $iss, $host)
        $pool.open()
        $threads = @()
        $ScriptBlock = $ExecutionContext.InvokeCommand.NewScriptBlock("param(`$_)`r`n" + $Scriptblock.ToString())
        $countjob = 0
        $Results = @()
        #"Initialisation" | Out-Host
    }
    PROCESS {
        $powershell = [powershell]::Create().AddScript($scriptblock).AddArgument($InputObject)
        $powershell.runspacepool = $pool
        $threads += @{
            instance = $powershell
            handle = $null
            #handle = $powershell.begininvoke()
        }
        $countjob++
    }
    END {
 
 
        foreach ($thread in $threads)
        {
            $thread.handle = $thread.instance.begininvoke()
        }
 
        #"Début traitement" | Out-Host
 
        $finishthread= 0
        $notdone = $true
        while ($true) {
           $notdone = $false
           for ($i=0; $i -lt $threads.count; $i++) {
                $thread = $threads[$i]
                if ($thread) {
                    if ($thread.handle.iscompleted) {
                        $Result = $thread.instance.EndInvoke($thread.handle)
                        $Results += $Result
                        # $Result | Export-Csv -Path c:\Mutextest.csv -NoTypeInformation -Force -Append
                        $thread.instance.dispose()
                        $threads[$i] = $null
                        $finishthread++
                    }
                    else {
                        $notdone = $true
                    }
                }
            }
            #"$finishthread / $countjob" | Out-Host
            if (!$notdone)
            {break}
 
            Start-Sleep -Milliseconds 50
            continue
 
        }
        Return $Results
    }
}
 
 
#Recherche du fichier spécifique
$file2 = "C:\Users\*.txt"
 
#Initialisation des différentes variables permettant de savoir le nombre total de fichiers et la taille total se trouvant dans $file2
$NumberOfFilesTotal = 0
$tailleTotal = 0
 
 
$Paths = New-Object System.Collections.ArrayList($null)
foreach($file in Get-ChildItem -path $file2 -force -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName)
{
    foreach($line in [System.IO.File]::ReadLines($file, [System.Text.Encoding]::Default))
    {
           $paths.Add($Line) > $null
    }
}
$paths = $paths | Select-Object -Unique
 
$result = New-Object System.Collections.ArrayList($null)
$result = $paths | ForEach-Parallel -MaxThreads 50 {
    if([System.IO.File]::Exists($_))
    {
        return [System.IO.FileInfo]$_
    }
}
 
$ret = $result | Measure-Object -Sum Length
 
$NumberOfFilesTotal = $ret.Count
$tailleTotal = $ret.Sum
 
#Conversion de bytes en MégaBytes
$tailletotal = $tailleTotal / 1048576
 
#Ecriture du résultat à l'écran
Write-Host "Il y a" $NumberOfFilesTotal  "fichiers" -ForegroundColor Yellow
Write-Host "Les fichiers font" $tailleTotal "MB" -ForegroundColor Green
 
exit

Un test a faire, en lieu et place de Select -Unique
Code:

1 2 3 4 5 [string[]]$S=get-process |select -ExpandProperty name [string[]]$S +=get-process |select -ExpandProperty name $list=[System.Collections.Generic.HashSet[String]]::new($S,[StringComparer]::InvariantCultureIgnoreCase) $list
L'avantage est que le type hashset n'autorise pas de doublons dans la collection.
Mais il faut typer la collection à insérer car le parseur PS en a besoin. On doit aussi préciser un 'comparateur' pour que la recherche d'unicité (interne) soit insensible à la casse de la chaîne.
On peut aussi directement utiliser la collection de type HashSet directement via la méthode Add($line) -> $paths += $line

A voir si cela améliore un peu.

13/07/2018, 18h52
Laurent Dardenne

J'étais en train d'écrire mon message...

Citation:

Envoyé par ericlm128

(car $Paths=[System.Collections.Arraylist]::New() me sort une exception sur New)

Peut être la version de Powershell, j'utilise la v5.1

Oui peut être, chez moi :

Code:

1
2
3
4
5
6
7
8
9
Name                           Value
----                           -----
PSVersion                      3.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.42000
BuildVersion                   6.2.9200.16398
PSCompatibleVersions           {1.0, 2.0, 3.0}
PSRemotingProtocolVersion      2.2

14/07/2018, 09h57
Laurent Dardenne

la méthode statique new est disponible à partir de la v5, elle est ajoutée par le runtime Powershell.
En lieu et place utilise le cmdlet new-object