Echtzeitprogrammierung HILFE!!!

[el Clio]

Hallo!

Ich brauche mal eine Hilfe für Echtzeitprogrammierung, genauer für VxWorks.
Ich muss da so ein Prog schreiben und komm nicht weiter!

Vielleicht ist ja hier jemand, der mir helfen kann oder der mir ein entsprechendes Forum oder Board nennen kann, wo ich mit dem Problem besser "ankomme"!

Danke vielmals im Voraus!

MfG
el Clio

[sandra]

an was hängt´s denn???
wäre zumindest mal ein anfang...

[el Clio]

Ich muss folgendes machen:

- Message Passing Kommunikation und Synchronisation
- Client Server Programmierung
- Emulation von ?Shared Memory? Operationen

Ich hänge irgendwie schon am Ansatz... Hab keine Ahnung, wie ich das umsetzen soll!
ich setzte mal die Aufgabenstellung hier rein (hoffe, man kanns so halbwegs lesen):

Aufgabenstellung

Message Passing Kommunikation erlaubt eine Realisierung von Multi Tasking Anwendungen in einer
Shared Memory und in einer verteilten Umgebung über ein Netzwerk. Die System Aufrufe sind unterschiedlich,
die Funktionen aber vergleichbar. In dieser Übung soll eine Synchronisation nach dem Prinzip der
Mutexe mit Hilfe von Message Passing Aufrufen realisiert werden. Dabei soll eine Client Server Lösung realisiert
werden, mit den Anwender Tasks als Clients und einer Mutex Kontroll-Task als Server. Dabei sendet
jeder Client eine Message an die Mutex Server Task, die für die Steuerung zuständig ist und wartet
anschließend auf ein Ergebnis. Der Mutex Server überprüft bei jeder Anforderung, ob die Ressource belegt
ist und schickt eine entsprechende Nachricht zurück. Bei einer Freigabe wird ebenfalls eine Nachricht
zurück gesendet.
Es sollen folgende Funktionen bereitgestellt werden:

Mutex Creation

int MuCreate(
int flags, /* mutex attributes */
int *muid /* newly created mutex id */
);

This system call creates a mutex and initializes it according to the specifications supplied with the call. The
queuing policy is based on priority only.
Arguments
flags Specifies the mutex attributes.

The following options are supported:
MU_PRIO_NONE ? No priority inheritance (0)
MU_PRIO_INHERIT ? Use priority inheritance (1)

muid Points to the variable, which contains the ID of the newly created mutex on successful creation of the
mutex object.
Return Value
This call returns 0 on success or -1 on failure.

Mutex Deletion

int MuDelete (
int muid /* MUTEX identifier */
);

This system call deletes a mutex with the specified mutex ID and frees the associated kernel resources. The
mu_delete() system call can be invoked by any task, and not necessarily the task that originally created
the mutex. In the event that there are other tasks waiting to acquire that mutex, the tasks are unblocked and
an error code is returned to them.
Arguments
muid Specifies the mutex ID of the mutex to be deleted.
Return Value
This system call returns 0 on success or -1 on failure.

Mutex Reservation

int MuLock(
int muid, /* mutex identifier */
MSG_Q_ID ret_address /* local mailbox of the receiver */
);

This system call allows a task to lock a mutex specified by the muid argument. If the mutex is not locked by
another task, the mutex is put in the locked state, and the calling task becomes the owner of the mutex.
If the mutex is locked by another task then the calling task is put in the blocked state and is queued in the
wait queue associated with the mutex.
Arguments
muid Specifies the mutex ID.
If the mutex is locked, block until it is available.
ret_address Local mailbox of the task. Ret_address should be sent to the mutex control task allowing to react on
requests.
Return Value
This system call returns 0 on success, or -1 on failure.

Mutex Release

int MuUnlock(
int muid /* mutex identifier */
);

This system call allows a task to unlock a mutex specified by the muid argument. If any tasks are waiting to
lock the mutex, the ownership of the mutex is transferred to the waiting task at the head of the mutex?s wait
queue. It is unblocked, and made ready-to-run. If the requesting task is not the current owner, the resource
stay's reserved and an error is sent back.
Arguments
muid Specifies the mutex ID.
Return Value
This call returns 0 on success or -1 on failure.

Für die Synchronisation dürfen nur Message Passing System Aufrufe benutzt werden. Clients senden alle
Daten an den Server, die für die Verwaltung notwendig sind. Der Server selbst soll keine Informationen über
das Betriebssystem anfordern müssen. Damit ist sichergestellt, dass eine Portierung auf ein verteiltes System
möglich ist.

Für die Realisierung müssen folgende Komponenten bereitgestellt werden, die alle im File mutex.c zusammengefasst
werden sollen:
- Alle o.a. Funktionen, die die Kommunikation mit dem Mutex Server durchführen.
- Der Mutex Server, der in Abhängigkeit des Mutex Status reagiert und den anfordernden Clients eine
Fortführung der Ausführung gestattet oder verwehrt.

Vorbereitung

1. Legen Sie den Mutex Kontroll Block fest. (HAB ICH SCHON) Beschreiben
Sie das Mutex Protokoll durch ein Flussdiagramm.

2. Legen Sie die grundsätzliche Kommunikationsstruktur zwischen den Clients und dem Server fest:
- Wie soll die prinzipielle Synchronisation zwischen den Anwender Tasks und dem Mutex Server bei
einer Reservierung und bei einer Freigabe durchgeführt werden. Jede Anfrage an die Mutex Task soll
beantwortet werden.
- Definieren Sie alle benötigten Mailboxen. Geben Sie alle benötigten Parameter an.
- Definieren Sie alle Message Formate, die für den Datenaustausch erforderlich sind. Welche Parameter
müssen bei einer Anforderung und bei einer Rückmeldung übermittelt werden. Erweitern Sie den
Mutex Kontroll Block um die benötigten Kommunikationskomponenten.

3. Entwickeln Sie die o.a. Funktionen. Für den Test wird zunächst ein einfacher Server benötigt, der nur
Nachrichten entgegen nimmt und die Antworten sofort zurücksendet. Schreiben Sie eine einfache
Anwendung, die die o.a. Funktionen testet.

4. Ergänzen Sie die bereitgestellten Funktionen für die Warteschlangen Verwaltung. Eine Funktion realisiert
die Speicherung einer Anforderung in Abhängigkeit der Priorität und eine zweite dient zur Entnahme des
Eintrages mit der höchsten Priorität.

5. Entwickeln Sie das Programm für den Mutex Server.

Durchführung

1. Testen Sie zunächst die Kommunikation zwischen einem Client und der einfachen Server Task.
2. Testen Sie den einfachen Server mit Hilfe des bereitgestellten Programms.
3. Testen Sie den Mutex Server mit dem bereitgestellten Programm.
4. Speichern Sie die Konsolausgabe des Testlaufes jeweils mit und ohne Prioritätsvererbung.

[hicksi]

also so ganz verstehe ich dein problem nicht, die aufgaben sind doch ziemlich genau gestellt und wie man vorgehen soll steht auch noch da.
also als erstes würde ich mal zwei programme schreiben, die mittels message passing einfach ein bischen kommunizieren.
der server wäre dann ja nur ein programm, das dauernd auf nachrichten wartet un dann entsprechend reagiert.

ciao, hicksi

[*grimmsen**]

Panzerechsen?

[sandra]

glaube ich auch :p

[el Clio]

mmm... mal sehen

Vielleicht habt ihr ja recht und das ist gar nicht so schwer...