Sie wollen Performance aus Ihren Skripten, komplexen Kommandos und Statements herausholen? Ressourcen richtig nutzen mit Parallelisierung! Verschiedene einfache Beispiele zur Parallelisierung unter Windows (Batch & Powershell), Linux Shell (parallel & Job Control) und in der Oracle Datenbank anschaulich erklärt.
Skripte und Befehle werden mit fortlaufender Zeit und Entwicklung immer komplexer und deswegen auch zeitaufwändiger. Und das obwohl die Hardware mehr als genug Ressourcen zur Verfügung stellt. Dies liegt in den meisten Fällen daran, dass man seine "Last" nicht auf die verfügbaren Ressourcen verteilt. Dafür gibt es eine simple Lösung: Parallelisierung!
In diesem Artikel wird die Parallelisierung in verschiedenen Varianten veranschaulicht und erklärt. Angefangen mit PL/SQL Prozeduren in der Oracle Datenbank bis hin zu Batch-Kommandos unter Windows.
Bei Parallelisierung oder auch die parallele Programmierung fallen Schlüsselwörter wie Multiprogramming, Multiprocessing und Multitasking.
Begrifsserklärungen:
Multiprogramming verhindert CPU Idles, indem eine auf z.B. I/O-wartende Aufgabe solange durch eine andere wartende Aufgabe ersetzt wird, bis diese fertig ist.
Multitasking suggeriert parallele Abarbeitung, indem verschiedene Aufgaben in sehr kleinen Abständen von der CPU bearbeitet werden. Wenn sich also mehrere Prozesse alle x-Millisekunden (oder Nanosekunden) bei der CPU Zeit abwechseln, entsteht eine quasi-Parallelisierung.
Multiprocessing ermöglicht das echt parallele Ausführen von mehr als einem Thread auf mind. zwei CPU Kerne.
Threads sind Teile eines Prozesses.
An einigen Stellen werden aufwändige und zeitintensive Befehle und Skripte mit einem "Sleep" bzw. "Timeout" simuliert bzw. vereinfacht, welche in realen Anwendungen für Ihre individuellen Befehle stehen.
PARALLELISIERUNG IN ORACLE
Wie so oft sind gerade die nützlichen Features in Oracle ausschließlich in der Enterprise Edition verfügbar, so auch die Parallelisierung in der Oracle Datenbank. Hier zeigen wir Ihnen eine kostenlose Alternative, die außerhalb der Oracle EE mit einem geringen Mehraufwand eine Parallelisierung zulässt. In diesen Beispielen legen wir die Kommandos nur in den Hintergrund, was lediglich einer quasi-Parallelisierung entspricht.
Folgendes Skript erlaubt uns Aufrufe im Hintergrund auszuführen (Erklärung folgt):
CREATE OR REPLACE PROCEDURE set_bg(cmd IN varchar2) IS
s VARCHAR2(32000);
job_id NUMBER;
BEGIN
job_id:=round(dbms_random.value(1,999999));
IF substr(cmd,1,5)='DBMS_' THEN -- Packageaufruf
s:='BEGIN '||rtrim(cmd,';')||'; END;';
ELSE -- DDL Aufruf
s:=q'!BEGIN EXECUTE IMMEDIATE '!'||rtrim(cmd,';')||q'!'; END;!'; --'
END IF;
DBMS_SCHEDULER.CREATE_JOB (
job_name => 'BG_JOB'||to_char(job_id),
job_type => 'PLSQL_BLOCK',
job_action => s,
start_date => systimestamp,
auto_drop => TRUE,
enabled => TRUE,
comments => 'Background Job for DDL / DBMS Package');
dbms_output.put_line('Job ID('||job_id||'): '||s);
END;
/
show errors
Oder auch als Lightweight-Job:
CREATE OR REPLACE PROCEDURE set_bg(cmd IN varchar2) IS
s VARCHAR2(32000);
job_id NUMBER;
l_start NUMBER;
BEGIN
l_start := DBMS_UTILITY.get_time;
job_id:=round(dbms_random.value(1,999999));
IF substr(cmd,1,5)='DBMS_' THEN -- Packageaufruf
s:='BEGIN '||rtrim(cmd,';')||'; END;';
ELSE -- DDL Aufruf
s:=q'!
BEGIN
--INSERT INTO logme (start_date) SELECT to_char(sysdate,'HH24:MI:SS') FROM dual;
EXECUTE IMMEDIATE '!'||rtrim(cmd,';')||q'!';
--INSERT INTO logme (end_date) SELECT to_char(sysdate,'HH24:MI:SS') FROM dual;
END;!'; --'
END IF;
DBMS_SCHEDULER.CREATE_PROGRAM (
program_name => 'BG_JOB_PRG'||to_char(job_id),
program_type => 'PLSQL_BLOCK',
program_action => s,
enabled => TRUE);
DBMS_SCHEDULER.CREATE_JOB (
job_name => 'BG_JOB'||to_char(job_id),
program_name => 'BG_JOB_PRG'||to_char(job_id),
start_date => systimestamp,
auto_drop => TRUE,
job_style => 'LIGHTWEIGHT',
enabled => TRUE);
dbms_output.put_line('Job ID('||job_id||'): '||s);
END;
/
Hier wird eine Prozedur "set_bg" angelegt, welche ein zu parallelisierendes Kommando entgegennimmt. Die Prozedur prüft zu Anfang, ob es sich um einen Package- oder DDL-Aufruf handelt. Dies wird mittels einer bedingten Prüfung (IF-Abfrage) auf bestimmte Schlüsselwörter realisiert. Der ursprünglich eingegebene Befehl wird dann der Prozedur "CREATE_JOB" aus dem Package "DBMS_SCHEDULER" übergeben und somit in den Hintergrund geschoben. Zur Übersicht geben wir uns noch die generierte Job-ID und den auszuführenden Befehl aus.
Man kann auch aus Testgründen die Start- und Endzeiten der abgesetzten Jobs in einer kleinen Tabelle festhalten und diese später einsehen. Dazu müssen die auskommentierten "INSERT INTO"-Statements wieder einkommentiert werden und zusätzlich folgende kleine Tabelle angelegt werden:
CREATE TABLE logme (
start_date varchar2(3001),
end_date varchar2(3001)
)
Die Prozedur ruft man wie folgt auf:
EXEC set_bg('CREATE TABLE big_scott1 AS SELECT e.* FROM scott.emp e, scott.emp, scott.emp, scott.emp, scott.emp, scott.emp');
EXEC set_bg('CREATE TABLE big_scott2 AS SELECT e.* FROM scott.emp e, scott.emp, scott.emp, scott.emp, scott.emp, scott.emp');
EXEC set_bg('CREATE TABLE big_scott3 AS SELECT e.* FROM scott.emp e, scott.emp, scott.emp, scott.emp, scott.emp, scott.emp');
SELECT * FROM scott.emp;
In diesem Beispiel legen wir drei neue Tabellen anhand eines Kreuzprodukts der Tabelle EMP aus dem Demo-Schema SCOTT, welche im Hintergrund angelegt werden sollen. Zur Demonstration wollen wir gleich den Inhalt der verwendeten Beispieltabelle einsehen, ohne auf die CREATE TABLE-Statements warten zu müssen:
Output:
PL/SQL-Prozedur erfolgreich abgeschlossen.
PL/SQL-Prozedur erfolgreich abgeschlossen.
PL/SQL-Prozedur erfolgreich abgeschlossen.
EMPNO ENAME JOB MGR HIREDATE SAL COMM
---------- ---------- ------- -------- -------- -------- --------
.....
Statt der CREATE TABLES können auch komplexere und länger dauernde Statements, wie sie z.B. für Monitoring-Abfragen üblich sind, genutzt werden.
Informationen zu Jobs holt man sich über folgendes Statement:
SELECT to_char(log_date,'DD.MM.YY Hh24:MI:SS') AS LOG_DATE, OWNER, JOB_NAME, RUN_DURATION, ADDITIONAL_INFO
FROM DBA_SCHEDULER_JOB_RUN_DETAILS
WHERE JOB_NAME LIKE 'BG_JOB%';
Da wir in unserer Prozedur Programs anlegen, müssen wir diese auch hinterher wieder aufräumen:
SELECT 'exec dbms_scheduler.drop_program('|| chr(39) || program_name ||chr(39) || ');' FROM dba_scheduler_programs WHERE program_name LIKE 'BG_JOB%';
Ab der Version 12c lässt sich die oben beschriebene Prozedur eleganter mit der WITH-Klausel realisieren. Damit erhält man die Möglichkeit, den zu parallelisierenden Befehl innerhalb eines SELECT-Statements auszuführen. Der Vorteil dieser Variante ist, dass man keine CREATE PROCEDURE-Rechte wie in den oberen Beispielen benötigt.
WITH
PROCEDURE p(cmd IN varchar2,job_id IN VARCHAR2 ) IS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
DBMS_SCHEDULER.CREATE_JOB (
job_name => job_id,
job_type => 'PLSQL_BLOCK',
job_action => 'BEGIN '||rtrim(cmd,';')||'; END;',
start_date => systimestamp,
auto_drop => TRUE,
enabled => TRUE);
END;
FUNCTION set_bg(cmd IN VARCHAR2) RETURN VARCHAR2 IS
v_job varchar2(32):='BG_JOB'||round(dbms_random.value(1,999999));
BEGIN
p(cmd,v_job);
RETURN 'Job mit Namen '||v_job||' gestartet' ;
END;
SELECT set_bg('CREATE TABLE emp_copy AS SELECT * FROM emp')
FROM dual
/
Hier wird, im Gegensatz zum Beispiel weiter oben, eine Funktion "set_bg" erstellt, die ein zu parallelisierenden Befehl entgegennimmt. Innerhalb der WITH-Klausel wird dann einer Prozedur nochmals der ursprünglich auszuführende Befehl übergeben, welcher letztendlich wieder mit dem Prozeduraufruf "DBMS_SCHEDULER.CREATE_JOB" in den Hintergrund gesetzt wird.
Der eigentliche Aufruf "versteckt" sich hier:
SELECT set_bg('CREATE TABLE emp_copy AS SELECT * FROM emp') FROM dual;
PARALLELISIERUNG IN DER SHELL
BEISPIEL MIT JOB CONTROL:
#!/bin/bash
for i in {0..9}; do echo $i; sleep 1; done &
for k in {0..9}; do echo $k; sleep 1; done &
wait
Bei Verwendung von Job Control unter UNIX werden mit "&"-endende Befehle als eigene Prozesse direkt in den Hintergrund gesetzt. Dadurch kann das ursprüngliche Programm (oder der User via Konsole) seinen Prozess fortsetzen ohne auf den Unterprozess warten zu müssen. Falls man der Vollständigkeit/Verfügbarkeit halber auf beendete Prozesse warten muss, kann man dies mit "wait" erreichen. Sobald alle Hintergrundprozesse abgeschlossen wurden, fährt der Hauptprozess fort.
Mit dem Befehl jobs lässt man sich alle laufende Hintergrundprozesse ausgeben. Falls Jobs angehalten wurden, sieht man diese nur mit einem Process Explorer wie top oder ps -aux.
Zeitmessung: Stapelverarbeitung
time { sleep 3; sleep 3; };
-> real 6.004s
Zeitmessung: Parallelisierung
time { sleep 3 & sleep 3 && wait; };
-> real 3.025s
BEISPIEL MIT GNU PARALLEL:
Mithilfe des Perl Programms parallel für die Shell, kann man das Parallelisieren sehr leicht vereinfachen. Parallel automatisiert die Parallelisierung, indem das Programm eine optimale Verteilung der Jobs, welche man auch manuell anpassen darf, auf CPUs übernimmt und so Idles verhindert.
parallel -j2 <<EOF
sleep 3; echo "finished"
sleep 3; echo "finished"
EOF
Anschauliches Beispiel:
Mit time zeichnen wir die Dauer des gesamten Prozesses auf. Es werden insgesamt acht Befehle ausgeführt, wobei immer zwei Jobs gleichzeitig laufen können. Mit dem Switch "-j" von parallel können wir bestimmen, wieviele Jobs maximal gleichzeitig laufen dürfen, hier zwei. Parallel bietet sehr viele Möglichkeiten zur Anpassung, welche man wie üblich mit parallel einsehen kann.
#!/bin/bash
time { parallel -j2 <<EOF
sleep 2; echo "Sleep 1 finished"
sleep 1; echo "Sleep 2 finished"
sleep 3; echo "Sleep 3 finished"
sleep 4; echo "Sleep 4 finished"
sleep 6; echo "Sleep 5 finished"
sleep 19; echo "Sleep 6 finished"
sleep 3; echo "Sleep 7 finished"
sleep 4; echo "Sleep 8 finished"
EOF
}
Output:
Sleep 2 finished
Sleep 1 finished
Sleep 3 finished
Sleep 4 finished
Sleep 5 finished
Sleep 7 finished
Sleep 8 finished
Sleep 6 finished <-
real 25.146s <-
Der am längsten dauernde Job Sleep 6 wurde als letztes beendet und der Gesamtprozess dauerte insgesamt ca. 25 Sekunden.
Tunen: z. B. den zeitintensivsten Job als erstes bearbeiten:
#!/bin/bash
time { parallel -j2 <<EOF
sleep 19; echo "Sleep 6 finished"
sleep 2; echo "Sleep 1 finished"
sleep 1; echo "Sleep 2 finished"
sleep 3; echo "Sleep 3 finished"
sleep 4; echo "Sleep 4 finished"
sleep 6; echo "Sleep 5 finished"
sleep 3; echo "Sleep 7 finished"
sleep 4; echo "Sleep 8 finished"
EOF
}
Output:
Sleep 1 finished
Sleep 2 finished
Sleep 3 finished
Sleep 4 finished
Sleep 5 finished
Sleep 6 finished <-
Sleep 7 finished
Sleep 8 finished
real 23.120s <-
Der Job Sleep 6 wurde nun vor Abschluss der letzten zwei Jobs beendet. Das bedeutet, die Jobs Sleep 1 bis Sleep 5 wurden während der Job Sleep 6 lief, bearbeitet. Wie man an diesem Beispiel sehen kann, dauert Sleep 6 genau so lange wie Sleep 1 bis Sleep 7, exakt 19 Sekunden. Dies bedeutet, Sleep 6 und Sleep 7 enden gleichzeitig und übrig bleibt der Job Sleep 8, welcher dann nur noch vier Sekunden auf die bisher vergangenen 19 Sekunden addiert.
Tunen: Oder einfach drei parallele Jobs zulassen:
#!/bin/bash
time { parallel -j3 <<EOF
sleep 19; echo "6 finished"
sleep 2; echo "Sleep 1 finished"
sleep 1; echo "Sleep 2 finished"
sleep 3; echo "Sleep 3 finished"
sleep 4; echo "Sleep 4 finished"
sleep 6; echo "Sleep 5 finished"
sleep 3; echo "Sleep 7 finished"
sleep 4; echo "Sleep 8 finished"
EOF
}
Output:
Sleep 2 finished
Sleep 1 finished
Sleep 3 finished
Sleep 4 finished
Sleep 7 finished
Sleep 5 finished
Sleep 8 finished
Sleep 6 finished
real 19.128s <-
Nachfolgend weitere Möglichkeiten und Erklärungen wie man mit parallel arbeiten kann:
Standard: Anzahl parallele Jobs = Anzahl CPU-Kerne
parallel --jobs 2 : Zwei parallel-laufende Jobs
parallel --jobs 200% : Zwei Jobs pro CPU-Kern
parallel --jobs 0 : So viele Jobs wie möglich
parallel --use-cpus-instead-of-cores : Werte anhand der CPU-Anzahl statt Anzahl CPU-Kerne berechnen
Verzögerungen für Jobs:
parallel --delay 2 : Verzögerung zwischen dem Starten der Jobs, sinnvoll bei z.B. I/O-Jobs
Log-file anlegen:
parallel --joblog /var/log/parallel
Statusausgabe:
parallel --eta : geschätzte Zeit bis parallel fertig ist
parallel --bar : Statusbar
Simple graphische Statusausgabe:
time { parallel -j3 --bar <<EOF
sleep 9; echo "6 finished"
sleep 2; echo "Sleep 1 finished"
sleep 1; echo "Sleep 2 finished"
sleep 3; echo "Sleep 3 finished"
sleep 4; echo "Sleep 4 finished"
EOF
} 2> >(zenity --progress --auto-kill --auto-close)
Ein nützliches Beispiel: Man möchte das Zippen großer oder vieler Dateien optimieren.
Üblicher Befehl:
time gzip ./*
real 0m52.802s
Mit parallel:
time parallel --jobs 0 gzip ::: *
real 0m27.428s
PARALLELISIERUNG IN POWERSHELL
POWERSHELL JOBS:
Während Prozesse abhängig von der aktuellen Session sind, kann man mit "Start-Job" unabhängige Hintergrundaufträge erstellen. Im folgenden Beispiel wird acht Sekunden gewartet und anschließend etwas ausgegeben.
Start-Job -scriptblock {Start-Sleep 8; Write-Host "...ausgeschlafen"}
Beim Absetzen dieses Beispiels kann man beobachten, dass zwar eine Rückmeldung über den Status des Jobs ausgegeben wird, nicht jedoch über das Ergebnis des Jobs. Um sich dieses anzeigen zu lassen, muss zuerst einmal auf Abschluss des Jobs gewartet werden:
While (Get-Job -State "Running") { Write-Host "." -NoNewLine; sleep 2 }
Solange der Job den Status "Running" hat, wird alle zwei Sekunden etwas ausgegeben. Sobald der Job beendet wurde, kann man sich das Ergebnis mit folgendem Befehl holen:
Get-Job | Receive-Job
Get-Job ruft die Informationen zu allen Jobs aus der aktuellen Session ab, während Receive-Job den Output der ausgeführten Jobs ausgibt. Wenn man Get-Job an Receive-Job weitergibt, erhält man also den Output aller Jobs der aktuellen Session.
Damit der bereits beendete Job nicht weiter im Cache bleibt, löscht man diesen wie folgt:
Get-Job | Remove-Job
Falls noch laufende Jobs existieren, muss man diese erst stoppen bevor man sie löscht:
Get-Job | Stop-Job
Das komplette Skript nochmal zusammengefasst:
Start-Job -scriptblock {Start-Sleep 8; Write-Host "...ausgeschlafen"}
While (Get-Job -State "Running") { Write-Host "." -NoNewLine; sleep 2 }
Get-Job | Receive-Job
Remove-Job *
Read-Host -Prompt "Press Enter to finish"
Umfangreichere Job-Implementation:
(Quelle: Opens external link in new windowhttps://stackoverflow.com/questions/4016451/can-powershell-run-commands-in-parallel)
$t = Measure-Command {
cls
"25", "30" | %{
$ScriptBlock = {
param($name)
Start-Sleep $name
Write-Host "Wait $name seconds."
}
Write-Host "Starting job $_..."
Start-Job $ScriptBlock -ArgumentList $_
}
Write-Host "Running" -NoNewLine
While (Get-Job -State "Running") { Write-Host "." -NoNewLine; sleep 2 }
Write-Host "Finish!"
Get-Job | Receive-Job
Remove-Job *
}
Write-Host "It took" $t.Seconds "seconds to complete everything."
Read-Host -Prompt "Press Enter to finish"
In diesem Beispiel definieren wir zwei Werte "25" und "30", die als Parameter dienen. Das sind die Sekunden, die das Programm später warten soll. Über jedes dieser Werte wird iteriert. Innerhalb der Schleife wird ein Block ($ScriptBlock) mit jeweils für die Parameter auszuführendem Code erstellt: Es sollen x-übergebene Sekunden gewartet werden. Der Block wird anschließend als Job mit dem jeweiligen Übergabeparameter, der sich zur Zeit während der Schleife in "$_" befindet, ausgeführt. Die While-Schleife wartet (Running...) darauf, bis beide Jobs beendet werden. Mit Get-Job holt man sich die Standardausgabe der Jobs. Zuletzt räumen wir die beendeten Jobs wieder auf und entfernen sie aus dem Cache. "Measure-Command" zeigt uns in diesem Beispiel die insgesamt benötigte Zeit für unser Demoskript.
POWERSHELL PROZESSE:
Start-Process ping -ArgumentList "www.muniqsoft-training.de"
Start-Process ping -ArgumentList "www.microsoft.com"
Es werden nacheinander zwei Ping-Anfragen abgesetzt, welche dann parallel ablaufen und mehr oder weniger gleichzeitig beendet werden. Zu dem Kommando "Start-Process" gibt es noch einige hilfreiche Switches:
-WindowStyle minimized : Jegliches Fenster für die Ausgabe unterdrücken.
-NoNewWindow : Die Ausgabe im aktuellen Fenster zeigen.
-RedirectStandardOutput C:\out.log : Die Standardausgabe in Datei schreiben.
-RedirectStandardError C:\err.log : Analog zu RedirectStandardOutput.
Als Funktion:
function set_bg() {Start-Process @args}
Und schließlich der Aufruf:
set_bg ping www.muniqsoft-training.de
set_bg ping www.google.de
PARALLELISIERUNG IN BATCH
@echo off
echo Erst nacheinander:
timeout 5
timeout 5
echo Jetzt parallel:
@start /B /REALTIME cmd /C test.bat
@start /B /REALTIME cmd /C timeout 5
echo Sollen die anderen Prozesse machen was sie wollen, ich bin Fertig!
pause
exit
Zuerst werden zwei Befehle, hier Timeouts, nacheinander abgearbeitet. Danach starten wir diese nochmal, diesmal parallel als eigene Prozesse. Man kann beobachten, dass diese dabei wie gewünscht gleichzeitig herunterzählen. Statt der Timeouts lassen sich an dieser Stelle natürlich auch andere Batch-Befehle ausführen. Eine Empfehlung wäre aber, man lagert Befehle den Aufgaben entsprechend in weitere Batch Files (hier test.bat) aus und startet diese parallel.Parameter: