Variable aus Funktion in Skript auslesen

[speefak]

Moin,

declare, export sind die gebräuchlichsten Befehle um Strings durchzureichen. Dies scheint aber nur in eine Richtung zu gehen und zwar vom Parent zum Child Prozeß, sprich vom Script in die Funktion. in die andere Richtung gestaltet sich das ganze recht eigensinnig. Entweder man führt die Funktion in einer Variable aus und hat so die Funktionsausgabe in der Variablen, oder die Ausgabe der Variable in der Funktion wird in eine Datei umgeleitet, die im Script dann wieder ausgelesen wird. Letzteres dauert aber länger und erfordert mehr Operationen ( Auslesen, auf SSD schrieben , einlesen , in variable schrieben ) In Schleifen mit einigen 10000 Zeilen summiert sich da jeder Sekundenbruchteil.

Konkret geht es um folgende Funktion :

Code: Alles auswählen

create_parsed_file () {

	echo "1" > $PIDFile

	SAVEIFS=$IFS
	IFS=$(echo -en "\n\b")
	for i in $(cat $GpxFile | grep -v time) ; do										# processing all lines exerpt timestamp lines
		if [[ -n $( grep ele <<< $i) ]] ; then
			echo "$i" 														# print elevation lines 
			echo -en "\t<time>$(date +%FT%H:%M:%S.835Z -d @$Timestamp)</time>\n"	# print timestamp line
			Timestamp=$[$Timestamp + $Timestampinterval]							# raise timestamp when adding timestamp line to file		
		else
			echo "$i"															# print all lines exerpt elevation
		fi

		# calculate progressbar values  # TODO write counter to var instead of file
		ProccessingLineCounter=$[$ProccessingLineCounter + 1]						# proccessing line counter for progressbar calculation	
		sed 's/.*/'$ProccessingLineCounter'/' -i $PIDFile

#		echo $ProccessingLineCounter > $PIDFile
#		echo $ProccessingLineCounter  >&2 export counter to parent script

	done
	IFS=$SAVEIFS

	sleep 0.2
	rm $PIDFile
}

Um eine Fortschrittsanzeige zu implementieren werden zwei Werte benötigt: 1. Gesamtzeilen der Quelldatei und 2. aktuell bearbeitete Zeile
Mit den beiden Werten sind prozentualer Fortschritt und Ladebalken recht einfach umzusetzen.

Der Knackpunkt ist allerdings das Schreiben des Schleifenzählers ( $ProccessingLineCounter ) aus der im Hintergrund laufenden Funktion ( & ) in eine Datei und das Auslesen der Datei im Script selbst um die Fortschrittsanzeige zu berechnen.

Code: Alles auswählen

 sleep 0.2
 GpxFileLineCount=$(cat "$GpxFile" | grep -cv time )
 while	[[ -f $PIDFile ]]; do
	#PercentProcessing=$(cat $PIDFile)
	#Percent100=$(cat $GpxFile | grep -v time)
	#BarLength=20
	progressbar $(cat $PIDFile) $GpxFileLineCount 20 && sleep 0.1
 done
 printf " ${CHECK_MARK}\n\n" 

Ich habe testweise mal einige Befehle in der Funktion auskommentiert und geschaut was am meisten Zeit kostet. Ich dachte erst es seinen die Subshells $(cmd) innerhalb der Schleife ( if [[ -n $( grep ele <<< $i) ]] ; then ). Das sind aber keine 5% Zeitersparnis. Merklich schneller läuft das Ganze wenn die E/A Prozesse auf die SSD reduziert werden.

Ich hatte erst die Ausgabe der Funktion (create_parsed_file) direkt in ein Datei umgeleitet und die Funktion später einfach aufgerufen: create_parsed_file &

Code: Alles auswählen

funktion () {
echo foo
echo bar 
} > result.file 

Dabei wird nach jeder Zeile ein E/A Prozeß ausgelöst. Lege ich die Schleifenausführung in eine Variable und schreibe diese dann einmalig in eine Datei macht das knapp 15% Zeitersparnis aus

Code: Alles auswählen

echo "$(create_parsed_file)" > "$GpxOutputFile" & 

Problem dabei : Die Variable kann erst weiterverarbeitet werden wenn die Funktion/Schleife komplett durchlaufen ist. Für die Fortschrittsanzeige wird aber ein aktueller, auslesbarer Wert nach jedem Schleifendurchlauf benötigt.

Ein anderer Versuch war über zwei versch. Ausgaben ( stdout und stderr ) die Counterausgabe von der eigentlichen Ausgabe zu trennen. Das geht aber wieder nicht weil ich stderr entweder direkt im Terminal sehe oder stderr erst nach Schleifenende auslesbar ist. Gibt es eine Möglichkeit stderr direkt auszulesen WÄHREND die Funktion noch läuft ? Sowas in der Art :

Code: Alles auswählen

echo "$(create_parsed_file 2> $VARforWHILELOOP)" > "$GpxOutputFile" & 

Oder hat sonst jemand eine Vorschlag wie ich eine in einer Funktion gesetzen Variable im Skript selbst auslesen kann OHNE den Umweg über eine Datei zu gehn ?

[mludwig]

und wenn du die Variable im Skript definierst, und dann in der Funktion lediglich modifizierst? Oder geht das in deinem Fall nicht?

[heinz]

Hallo speefak,

ich verstehe es so:
Alles, was in der Funktion ausgegeben wird, wird komplett umgeleitet sodas die Funktion keinerlei Ausgaben in die Konsole macht.
Du moechtest eine Fortschrittsanzeige, die anzeigt wie weit die Funktion ist.

Wenn dem so ist und Du nicht unbedingt die Fortschrittsanzeige selbst Coden moechtest, wuerde ich Dir einen kleinen Umbau vorschlagen:
(Ungetestet)

Code: Alles auswählen

#!/bin/bash

function create_parsed_file
{
	while read
	do
# print all lines exerpt elevation
		echo "$REPLY"
		if [[ -n $( grep ele <<< "$REPLY") ]] ; then
# print timestamp line
			echo -en "\t<time>$(date +%FT%H:%M:%S.835Z -d @$Timestamp)</time>\n"
# raise timestamp when adding timestamp line to file
			let Timestamp+=$Timestampinterval
		fi
	done
}


pv "$GpxFile" | grep -ve time | create_parsed_file > "$GpxOutputFile"

Fuer die Fortschrittsanzeige wuerde in diesem Fall das Programm pv sorgen.

Gruss,
heinz

[JTH]

Ich gebe mal meinen Senf dazu Wegen des Test mit doppelten [[ ]] geh ich mal davon aus, das du Bash, nicht Posix-Shell benutzt.

(Nachtrag: Hatte anfangs überlesen, dass du das Dateischreiben schon als Flaschenhals eingegrenzt hast.)

In Schleifen mit einigen 10000 Zeilen summiert sich da jeder Sekundenbruchteil.

Du möchtest ja anscheinend die Performance optimieren. Aus meiner Erfahrung wirkt es sich bei langen Schleifen, großen Datenmengen negativ aus, wenn man für Kleinigkeiten unnötig immer wieder externe Kommandos aufruft (grep, cat, sed, …). Besser und schneller kann es oft sein, Shell-Interna zu benutzen:

Code: Alles auswählen

	for i in $(cat $GpxFile | grep -v time) ; do

 GpxFileLineCount=$(cat "$GpxFile" | grep -cv time )
 
 	#Percent100=$(cat $GpxFile | grep -v time)

cat DATEI | grep SUCHMUSTER ist eigentlich immer ein Antipattern. grep kann selbst Dateien öffnen:

Code: Alles auswählen

grep SUCHMUSTER DATEI

Außerdem erzeugt die Pipe | dort für jeden Aufruf zusätzliche Subshells.

Code: Alles auswählen

sed 's/.*/'$ProccessingLineCounter'/' -i $PIDFile

Ein sed, nur um den Inhalt einer einzeiligen Datei zu ersetzen, dürfte auch Kanonen auf Spatzen sein. An so einer Stelle dürfte doch folgendes reichen?!

Code: Alles auswählen

echo "$ProccessingLineCounter" >"$PIDFile"

Code: Alles auswählen

echo -en "\t<time>$(date +%FT%H:%M:%S.835Z -d @$Timestamp)</time>\n"

Neuere Bash kann Datum/Zeit mit printf selbst formatieren – ein Fork weniger:

Code: Alles auswählen

printf "\t<time>%(%FT%H:%M:%S.835Z)T</time>\n" "$Timestamp"

Ich hoffe, das tut exakt das gleiche. Aber sehr wahrscheinlich benutzt date, wie bash es laut manpage tut, strftime.

Code: Alles auswählen

		if [[ -n $( grep ele <<< $i) ]] ; then

Das könnte man auch – ohne Fork und Subshell – durch Patternmatching lösen:

Code: Alles auswählen

		if [[ "$i" == *ele* ]] ; then

Am Rande: Sowas

Code: Alles auswählen

echo "$(create_parsed_file 2> $VARforWHILELOOP)" > "$GpxOutputFile" & 

ist eher Käse. Das wäre (vereinfacht) ähnlich wie

Code: Alles auswählen

echo "$(echo foobar)" >datei

Mit extra, eigentlich ja ungewolltem Buffering durch die Commandsubstitution (glaube ich).


Zu deinem eigentlichen Problem:

Letzteres dauert aber länger und erfordert mehr Operationen ( Auslesen, auf SSD schrieben , einlesen , in variable schrieben )

Solche Kleinigkeiten werden sehr wahrscheinlich nicht direkt auf die Festplatte geschrieben, sondern landen erstmal nur im Cache. Trotzdem gibts vielleicht bessere oder auch elegantere Möglichkeiten. Einfallen würde mir, wie du schon überlegt hast, geschicktes Nutzen von stdout und stderr verbunden mit Processsubstitution oder einer Named Pipe:

Ein vereinfachtes Beispiel für ersteres:

Code: Alles auswählen

#!/bin/bash
set -eu

M=$2
N=$1

create_parsed_file()
{
	for ((i = 0; i < N; ++i)); do
		if [[ $((RANDOM % M)) == 0 ]]; then
			# Nutzdaten nach stdout:
			printf "\t<time>%(%FT%H:%M:%S.835Z)T</time>\n" -1
		fi

		# Fortschritt nach stderr:
		echo "$i" >&2
	done
}

progress()
{
	# Mach irgendwas mit dem Fortschritt, die Ausgabe könnte hier auch problemlos nach stderr:
	while read n; do
		echo "$n/$N"
	done
}

# Nutzdaten in die Datei, Fortschritt als stdin für progress:
create_parsed_file >"$GpxOutputFile" 2> >(progress)

Alternative wäre eine Named Pipe, falls die letzte Zeile noch irgendwelche Probleme für das was du vorhast macht:

Code: Alles auswählen

fifo=$(mktemp -d)/progress
mkfifo "$fifo"

progress <"$fifo" &
create_parsed_file >"$GpxOutputFile" 2>"$fifo"

rm -f "$fifo"
rmdir "${fifo%/*}"

[speefak]

Danke für die Tipps In den nächsten Tagen habe ich Zeit das umzusetzen und schauen ob es schneller läuft.

sed ist in der Tat bei sowas nicht optimal. Sed editiert einen vorhandenen Wert , echo schriebt die ganze Datei neu. Das führt bei echo dazu, dass es beim Auslesen und einer unvollständig geschrieben Datei zu Fehlern kommt. Bei Sed nicht.

sed 's/.*/'$ProccessingLineCounter'/' -i $PIDFile => Wert in Datei immer vorhanden => kein Auslesefehler
echo "$ProccessingLineCounter" >"$PIDFile" => Datei / Wert nicht immer vollständig vorhanden => Lesefehler in der Countdownschleife => Abbruch der Schleife.

Darum die Überlegung mit echo statt sed direkt in eine Variable zu schreiben. Tritt o.g. Fehler dann wieder auf bleibt mir wohl nur sed oder die Fehlerausgabe in der While Schleife abzufangen. Mit echo statt sed läuft es bedeutend schneller - bis zum ungünstigen Fall dass echo gerade die Datei schreibt und cat die nicht fertig geschriebene Datei ausliest.

In den nächsten Tagen teste ich die Tips mal, mit grep hätte ich auch drauf kommen können Beim Testen waren sed und date die Zeitfresser.