🚀 go-pugleaf

S.ZIMMERT@AME.osn.de (Steffen Zimmert) benutzte seine Tastatur am
13.09.1995 um 18:24:00 Uhr, um folgenden Text unter dem Betreff
"Task-Fragen" zu erzeugen:

> Hallo liebe Leute!
> 
> Beim Programmieren stellte sich mir das Problem, daß mein  Programm  zwei  Dinge
> [...]
> anlegen.

Hört sich sinnvoll an.

> Zum Erzeugen des Task dachte ich an die Verwendung von  `CreateTask()`  aus  der
> amiga.lib,  da  dies  offensichtlich  die  komfortabelste Möglichkeit darstellt.

Das ist falsch: ein Task, darf nicht auf die dos.library zugreifen. Das
steht aber auch in der Beschreibung von 'amiga.lib/CreateTask()'. Dazu
mußt du dos.library/CreateNewProcess() benutzen.

> Unter anderem muß auch die Adresse einer Funktion angegeben werden, mit der  der
> Task  seine  Arbeit aufnimmt. Die in den Beispielen aufgeführten Funktionen sind
> alle  vom  Typ  `void  function(void)`.   Ist   es   vorgeschrieben,   daß   nur
> void-Funktionen  zum  Einsatz  kommen  dürfen  oder  ist  auch  die Übergabe von
> Parametern nach dem Motto `void function(LONG Type)` möglich?

Nein, Parameter kannst du nicht übergeben! Weder bei deiner noch bei
meiner Möglichkeit.

Einzige Möglichkeit:

dos/dostags.h und dort bei 'NP_Arguments' schauen. Habe ich selber aber
noch nicht ausprobiert.

> Eine weitere Frage hätte ich zur Koordination zwischen den beiden Tasks. Es  ist
> logisch  und auch im RKRM angeführt, daß der Haupttask erst beendet werden kann,
> wenn der Child-Task seine Arbeit  beendet  hat.  Kann  man  dafür  eine  globale
> Variable  definieren, die dann vom Child-Task je nach Zustand gesetzt wird? Oder
> kann mir jemand eine elegantere Lösung präsentieren?

Du setzte eine globale Variabel runter, die dann abgefragt wird, wenn
der Maintask sich beenden soll.

Du kannst dem Maintask eine Nachricht schicken. Programmtechnisch
genauso gut oder schlecht! B-)
> 
> Als letztes würde mich noch interessieren, wie die Verwendung  der  Bibliotheken
> zwischen  den  einzelnen Tasks geregelt ist. Laut RKRM ist es nicht möglich, die
> Library-Pointer des Haupt-Task an den Child-Task zu übergeben, richtig(Außer der
> Exec-Library)?  Heißt das für mich, jede Bibliothek nochmal durch den Child-Task
> zu öffnen, um eine darin enthaltene Funktion nutzen zu können?

Offiziell schon, aber das gehört nur zu gutem Programmierstill. Sollte
man machen, wg. Kompatibilitätsgründen!

> Was passiert eigentlich, wenn der Child-Task während der Ausführung hängen
> bleibt? Normalerweise kann man dann ja das Programm nicht beenden....

Pech gehabt! Kann man nicht viel machen!

---
So long... Fuzz (@AMB.gun.de)

S.ZIMMERT@ame.osn.de (Steffen Zimmert) vollführte eine anatomische 
Glanzleistung und hackte am 13.09.1995 um 18:24:00 Uhr 
auf seiner Tastatur folgenden Text unter dem Betreff 
"Task-Fragen" in die Leitung:

SZ> Hallo liebe Leute!
SZ> 
SZ> Beim Programmieren stellte sich mir das Problem, daß mein  Programm  zwei  Dinge
SZ> unabhängig  voneinander  und parallel zu bewerkstelligen hat. Deshalb dachte ich
SZ> mir, den anderen Programmteil als separaten Task zu  starten.  Der  Programmteil
SZ> Öffnet  das  Audiodevice,  lädt ein IFF-File, spielt es beliebig oft ab und gibt
SZ> anschließend  alle  reservierten  Ressourcen  wieder  frei.  Nebenher  hat   das
SZ> Hauptprogramm  noch  andere  Dinge  zu erledigen, also will ich einen neuen Task
SZ> anlegen.

[...]

SZ> Was passiert eigentlich, wenn der Child-Task während der Ausführung hängen
SZ> bleibt? Normalerweise kann man dann ja das Programm nicht beenden....
SZ>  
SZ>         MfG,    Steffen
SZ> 
SZ> 
SZ> -- MicroDot V1.10

Hallo, Stephan!

ich stand vor einem ähnlichem Problem. Und meine Lösung ist etwas eigenwillig,
aber sie funktioniert wunderbar:

Ich habe ein Hauptprogramm, welches ein eigens entwickeltes, zweites, und für
sich alleine lauffähiges Programm startet (über Execute), also kein vom
Hauptptorgamm angelegter Subtask.

Dieses zweite Programm spielt überlange Samples über DBuffering direkt von
einem Datenträger ab. Das (aufrufende) Hauptprogramm kann in aller Ruhe mit
seiner Arbeit fortfahren.

Ein Vorteil besteht darin, daß man dieses Abspielprogramm mit beliebigen
Parametern aufrufen kann (wie bei CLI-Start).

Die Kommunikation zwischen diesen zwei Programmen habe ich durch das Senden
von Breaksignalen an die Programports realisiert.

Beispiel: Hauptprogramm sendet CTRL-C an das Abspielprogramm, worauf dieses
          seine Arbeit einstellt und sich beendet.

Ich weiß nicht, ob du bei deinem Projekt ähnlich verfahren kannst,
ich hoffe aber, wenigstens eine kleine brauchbare Anregung geliefert
zu haben.


Bis dahin...

     -------------------------------------------------------------------
     Vierheilig@RudisBox.rb.org     AMIGA 4000/40 Cybervision, 16 MB RAM
     Vierheilig@sunshine.domino.de
     -------------------------------------------------------------------
                                     
Uebrigens: In Weinheim ist ein Sack Kartoffeln umgefallen.
Nur, falls es jemanden interessiert...

Am Fr 15.09.1995 um 12:25:39 Uhr meinte FUZZ@amb.gun.de (Erik Wasser) zum Thema "Re^1:Task-Fragen":


EW> Du setzte eine globale Variabel runter, die dann abgefragt wird, wenn
EW> der Maintask sich beenden soll.
EW>
EW> Du kannst dem Maintask eine Nachricht schicken. Programmtechnisch
EW> genauso gut oder schlecht! B-)

Die erste Methode ist WIRKLICH SCHLECHT!!!!! Das bedeutet doch, daß Du
aktiv in einer Schleife die Variable abfragen mußt. Das ist unter
Multitasking ABSOLUT zu vermeiden!

Besser ist es immer ein Signal, oder eine Message zu schicken. Das frißt
nicht soviel Rechenzeit.

Sorry, das ich so laut geworden bin, aber sowas... :-)



 #################################################
##  || //  ||\	/||  ## 			 ##
##  ||//   ||\\//||  ## Klemens Meyer		 ##
##  ||\\   || \/ ||  ## Klemens@DC.han.de	 ##
##  || \\O ||	 ||O ## 			 ##
 #################################################

Hallo!

S.ZIMMERT@ame.osn.de (Steffen Zimmert) schrieb am 13.09.1995
in <wVz3gMD356aez2@p-zimmer.ame.osn.de>:

> Hallo liebe Leute!

Hallo lieber Steffen! Da du nicht zum ersten Mal hier im Netz was
fragst, solltest du mittlerweile wissen, daß man seine Zeilenlänge auf
*deutlich* unter 80 Zeichen einstellen und Blocksatz vermeiden sollte.

> Die
> in den Beispielen aufgeführten Funktionen sind alle vom Typ `void
> function(void)`. Ist es vorgeschrieben, daß nur void-Funktionen zum
> Einsatz kommen dürfen oder ist auch die Übergabe von Parametern nach
> dem Motto `void function(LONG Type)` möglich?

CreateTask() ist das egal. Du mußt es allerdings dann sinnvollerweise
auch tatsächlich schaffen, deiner Funktion das Argument mitzugeben. Da
AddTask() (welches von CreateTask() benutzt wird) alle Register außer
dem PC (und höchstwahrscheinlich auch A7, auch wenn's im Autodoc
anders steht) löscht, geht das nur über den Stack. Bei Verwendung von
CreateTask() hast du aber keinen Zugriff auf den Stack. Daher mußt du
AddTask() nehmen, denn das läßt das ausdrücklich zu (siehe Autodoc).

[Ende des Child-Tasks signalisieren]
> Oder kann mir jemand eine elegantere Lösung präsentieren?

Dein Tochtertask könnte dem Muttertask einfach ein Signal geben (mit
Signal()). Oder wenn du bei der Gelegenheit die Parameterübergabe
zwischen beiden eleganter machen willst, kannst du es wie die Work-
bench machen und dem Tochtertask zu Beginn eine Message zuschicken
(wobei du bei reinen Tasks allerdings erstmal einen passenden Rendez-
vous-Port finden mußt), die er dann am Ende mit ReplyMsg() zurück-
schickt als "Fertig!"-Meldung.

Beide Methoden sollten mit Forbid() geschützt werden, sodaß in etwa
folgendes Ende herauskommt:

	Forbid();
	/* Signal(), ReplyMsg(), o.ä. */
	Wait(0);
}

Wait(0) kehrt nie zurück und ich ein sicherer Zustand, aus dem heraus
der Task bedenkenlos geRemTask()t werden kann.

> jede Bibliothek nochmal durch den Child-Task zu öffnen, um eine darin
> enthaltene Funktion nutzen zu können?

Ja.

> Was passiert eigentlich, wenn der Child-Task während der Ausführung
> hängen bleibt? Normalerweise kann man dann ja das Programm nicht
> beenden....

Das ist dann eben Pech. :-) Aber das Problem hast du ja auch, wenn der
Muttertask sich aufhängt. Man muß halt so programmieren, daß das nicht
passiert. Gegen einzelne Fehlerquellen (z.B. Traps) kann man sich
vielleicht schützen, aber auch nicht umfassend. (Was ist, wenn der
Task mitten in OpenWindow() abstürzt und LockIBase() aktiv ist?!)

-- __
__/// Arno Eigenwillig //   <arno@yaps.rhein.de>   \\ PGP key available
\XX/   V+49-2225-5870 // <ARNO@BIGBEN.dssd.sub.org> \\  <Arnooo @ IRC>

The i486 protection mode: It protects you from running DOS.
[Bryan Butler]