Kornshell (ksh) vs Perl – Part II – Laufzeitvergleich: mehre Arbeitsschritte mit kleine Dateien

Im vorigen Artikel ging es um einen allgemeinen Vergleich von KornShell (ksh) vs Perl. Dabei wurde deutlich, je größer die Dateien desto größer der Geschwindigkeitsvorteil von Perl gegenüber Kornshell. Perl ist bei einer Dateigröße von 500 KB bzw. 1 MB klar im Vorteil.

Jetzt stellt sich die Frage, was passiert bei kleinen Dateien, wenn mehre Aktionen bzw. Operationen innerhalb eines Scripts angewendet werden. Beispiel wäre hier die EDI Vorverarbeitung, wo die Dateien eine durchschnittliche Größe von 5KB bis 16KB haben. Dort werden Daten auf Basis von Teilstrings analysiert, sortiert oder angereichert.

In diesem Test werden 8 Arbeitsschritte (Aktionen/Operationen) in den Skripten durchgeführt und zur Gegenüberstellung einfach verdoppelt.

Was sind Operationen/Aktionen?

In diesem Fall betrachten wir Operationen/Aktionen eines Scripts als einzelnen Verarbeitungsschritte z.B. String suchen; Datei lesen usw.

Schritte der Testskripte

1. Datei Zeilenweise durchlaufen
2. Zeichen rechts von einer Zeichenkette (Zeile) abschneiden
3. Zeichen links von der Zeichenkette abschneiden
4. Neue Zeichenkette in eine Datei schreiben
5. Prüfen ob ein Verzeichnis existiert
6. Datei kopieren
7. Länge der Zeichenkette in die Datei schreiben
8. Kopierte Datei löschen.

Zeitmessung

Zur Zeitmessung wird vor und nach dem Aufruf des jeweiligen Testskriptes die Zeit weggeschrieben und anschließend daraus die Laufzeit in Millisekunden berechnet. Zur Start- und Endzeitermittlung wird wie im vorigen Test nachfolgendes kleines Perlskript verwendet.

#!/usr/bin/perl

use warnings;
use strict;
use Time::HiRes qw(time);
use POSIX qw(strftime);

my $t = time;
my $s=sprintf "%06.3f", $t-int($t/60)*60;
my $date=strftime "%d.%m.%Y %H:%M:$s", localtime $t;
print $date, "\n";

#!/usr/bin/perl

use warnings;

use strict;

use Time::HiRes qw(time);

use POSIX qw(strftime);

my $t = time;

my $s=sprintf "%06.3f", $t-int($t/60)*60;

my $date=strftime "%d.%m.%Y %H:%M:$s", localtime $t;

print $date, "\n";

Test Scripts

Kornshell (ksh)

Perl

MyTest.ksh

MyTest.pl

#!/bin/ksh
myFilenName="${HOME}/myTestFile.txt"
myOutPutFile="${HOME}/myOutTestFile.txt"












# 1. loop file content line by line
cat $myFilenName| while read myLine; do


  # 2. cut string from right
  myLinePart=${myLine%%,commando*}

  # 3. cut string from left
  myString=${myLinePart##*.}

  # 4. write new string content to a file
  print "SELECT * FROM myTable 
         WHERE id = \"${myString}\"" >> ${myOutPutFile}

  # 5. Check if an directory exits
  myDir="${HOME}/${myString}"
  if [ ! -d $myDir ]
  then
    echo "Not exist: ${myDir}"
  fi

  # 6. copy a file
  cp ${myOutPutFile} ${myOutPutFile}.tmp

  # 7. print length to output file
  echo "Length:${#myString}" >> ${myOutPutFile}

  # 8. remove file
  rm -f ${myOutPutFile}.tmp

done

#!/bin/ksh

myFilenName="${HOME}/myTestFile.txt"

myOutPutFile="${HOME}/myOutTestFile.txt"

# 1. loop file content line by line

cat $myFilenName| while read myLine; do

# 2. cut string from right

myLinePart=${myLine%%,commando*}

# 3. cut string from left

myString=${myLinePart##*.}

# 4. write new string content to a file

print "SELECT * FROM myTable

WHERE id = \"${myString}\"" >> ${myOutPutFile}

# 5. Check if an directory exits

myDir="${HOME}/${myString}"

if [ ! -d $myDir ]

then

echo "Not exist: ${myDir}"

# 6. copy a file

cp ${myOutPutFile} ${myOutPutFile}.tmp

# 7. print length to output file

echo "Length:${#myString}" >> ${myOutPutFile}

# 8. remove file

rm -f ${myOutPutFile}.tmp

done

#!/usr/bin/perl
use strict;
use warnings;
use File::Copy qw(copy);

# to 1. => open file for reading
my $myFileName = $ENV{"HOME"} . '/myTestFile.txt';
open(my $fh, $myFileName)
  or die "Could not open file '$myFileName' $!";

# to 4. & 7.  => open file for writing
my $myOutPutFile = $ENV{"HOME"} . '/myOutTestFile.txt';
open(my $fh_out, '>', $myOutPutFile) 
  or die "Could not open file '$myOutPutFile' $!";

#  1. loop file content line by line
while (my $row = <$fh>) {
  chomp $row;

  # 3. cut string from left
  $row =~ s/.*\.//;

  # 2. cut string from right
  $row =~ s/,commando.*//;

  # 4. write new string content to a file
  print $fh_out "SELECT * FROM myTable 
         WHERE id = \"$row\"\n";

  # 5. Check if an directory exits
  my $myDir=$ENV{"HOME"} ."/".$row;
  unless ( -d $myDir) {
        print "Not exist:".$myDir."\n";
  }

  my $myOutTmpFile =  $myOutPutFile . "tmp";
  # 6. copy a file
  copy $myOutPutFile, $myOutTmpFile;

  # 7. print length to output file
  print $fh_out "Length:".length($myDir)."\n";

  # 8. remove file
  unlink $myOutTmpFile;
}
close $fh_out;

#!/usr/bin/perl

use strict;

use warnings;

use File::Copy qw(copy);

# to 1. => open file for reading

my $myFileName = $ENV{"HOME"} . '/myTestFile.txt';

open(my $fh, $myFileName)

or die "Could not open file '$myFileName' $!";

# to 4. & 7. => open file for writing

my $myOutPutFile = $ENV{"HOME"} . '/myOutTestFile.txt';

open(my $fh_out, '>', $myOutPutFile)

or die "Could not open file '$myOutPutFile' $!";

# 1. loop file content line by line

while (my $row = <$fh>) {

chomp $row;

# 3. cut string from left

$row =~ s/.*\.//;

# 2. cut string from right

$row =~ s/,commando.*//;

# 4. write new string content to a file

print $fh_out "SELECT * FROM myTable

WHERE id = \"$row\"\n";

# 5. Check if an directory exits

my $myDir=$ENV{"HOME"} ."/".$row;

unless ( -d $myDir) {

print "Not exist:".$myDir."\n";

}

my $myOutTmpFile = $myOutPutFile . "tmp";

# 6. copy a file

copy $myOutPutFile, $myOutTmpFile;

# 7. print length to output file

print $fh_out "Length:".length($myDir)."\n";

# 8. remove file

unlink $myOutTmpFile;

}

close $fh_out;

Ergebnisse Laufzeit

Inhalt [Lines]	Size [Kb]	Laufzeit Kornshell [8 Steps]	Laufzeit Perl [8 Steps]	Laufzeit Kornshell [16 Steps]	Laufzeit Perl [16 Steps]	Faktor Perl faster Ksh!? [8 Steps]	Faktor Perl faster Ksh? [16 Steps]
3	0,122 Kb	82 ms	83 ms	102 ms	158 ms	1,01x	1,55x
15	0,610 Kb	117 ms	192 ms	124 ms	367 ms	1,64x	2,97x
30	1,221 Kb	225 ms	347 ms	129 ms	606 ms	1,54x	4,70x
60	2,441 Kb	189 ms	634 ms	236 ms	1302 ms	3,35x	5,51x
90	3,662 Kb	326 ms	857 ms	256 ms	1845 ms	2,63x	7,20x
120	4,883 Kb	275 ms	1006 ms	335 ms	2652 ms	3,66x	7,91x
150	6,104 Kb	336 ms	1217 ms	377 ms	3221 ms	3,62x	8,55x
300	12,207 Kb	648 ms	2621 ms	771 ms	6420 ms	4,05x	8,33x

Vergleich KSH vs Perl Laufzeit [8 Steps]

Vergleich KSH vs Perl Laufzeit [16 Steps]

Vergleich KSH vs Perl Laufzeitfaktor

Wie viel langsamer ist Kornshell gegenüber Perl, wenn die Arbeitsschritte (Operation/Aktion) sich erhöhen?

Fazit

In dem Test wird ersichtlich, dass mit der steigenden Anzahl von Arbeitsschritten (Aktionen/Operationen) das Kornshell (ksh) Skript sich gegenüber Perl verlangsamt. Im Bereich der Dateigröße von 0,5 KB bis >12 KB sieht man klar das sich der Geschwindigkeitsvorteil von Perl verdoppelt, wenn sich die Anzahl der Aktionen/Operationen im Skript ebenfalls verdoppelt. Kornshell ist eindeutig ein gutes Werkzeug für kleine und schnell Aufgaben zur Analyse im administrativen/operativen Bereich z.B. bei kleinen bis mittel große Dateien. Bei allen vollautomatischen Analysen oder wiederkehrenden automatisierte Scripts mit mehreren Operationen/Aktionen sowie großen Dateien sollte auf Perl Scripting gesetzt werden um die jeweiligen System Ressourcen zu schonen bzw. sparen.

(Visited 45 times, 1 visits today)

Post Views: 1.373

Christian Hoenick

my personal memory-base