Reenrante Funktion

[Johannes H. (Gast)]

Hallo liebe Forenbesucher :)

ich hätte ein Problem, um das ich irgendwie nicht herum komme und da 
wollte ich euch um Rat bitten.


Also ich habe eine Funktion x, die durch mehrere Prozesse aufgerufen 
werden soll. Das Problem ist nur, dass diese Funktion x eine globale 
Variable verwendet (es gibt auch leider keine andere Möglichkeit :( ).

Meine Frage ist jetzt, ist es ok wenn ich eine Funktion schreibe die den 
Zugriff auf die Variable ermöglicht und diese dann in der Funktion x 
aufrufe, so in der Art:

int func_critical_section_read_access(void){

  pthread_mutex_lock(&mutex);

  int var_save = global_var;

  pthread_mutex_unlock(&mutex);

  return var_save;
}

oder muss ich die komplette kritische Funktion x durch Semaphoren 
schützen?

Ich hoffe ihr könnt mir da weiterhelfen.

Lg

[OliverB (Gast)]

Du meinst "reenrantes Posting", oder?

[Johannes H. (Gast)]

uppss ja genau

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

OliverB schrieb:
> Du meinst "reenrantes Posting", oder?
Erledigt.

Johannes H. schrieb:
> ich hätte ein Problem
Mich würde die Prozessorarchitektur interessieren. Und das verwendete 
Betriebssystem.

[Johannes H. (Gast)]

Also es soll auf dem Rasperry Pi laufen, als Betriebssystem verwende ich 
Jessie.

[Einer K. (Gast)]

Und dann nutzt du die Proto Threads?
OK... soll mir recht sein...


Solange ich nicht weiß, was die Funktion genau alles tut, kann ich nur 
den Rat geben, den Aufruf der gesamten Funktion zu verriegeln.

[Carl D. (jcw2)]

Arduino F. schrieb:
> Und dann nutzt du die Proto Threads?
> OK... soll mir recht sein...

p wie Posix, also Posix Threads!

Merke: es gibt mehr als AVR!

;-))

[Einer K. (Gast)]

Carl D. schrieb:
> p wie Posix, also Posix Threads!
Soll mir auch recht sein....

[Max M. (jens2001)]

> Reenrante Funktion

> "reenrantes Posting"

OMG!

[georg (Gast)]

Johannes H. schrieb:
> oder muss ich die komplette kritische Funktion x durch Semaphoren
> schützen?

Niemand weiss was deine Funktion macht. Aber grundsätzlich musst du den 
Bereich schützen, in dem die Variable gelesen, verändert und wieder 
geschrieben wird, wie immer der aussieht. Also das was man als 
Read-Modify-Write bezeichnet. Das muss im Endeffekt ein atomarer Ablauf 
sein.

Natürlich kannst du die ganze Funktion schützen, da gibt es verschiedene 
Möglichkeiten, z.B. einfach Interrupts aus und wieder ein, aber das hat 
alles Nebenwirkungen, insbesondere muss die Zeit dafür so kurz wie 
möglich sein. Daher lohnt es sich, über den Ablauf der Funktion 
nachzudenken und nicht mehr zu sperren/schützen als unbedingt notwendig.

Georg

[Einer K. (Gast)]

Erstmal halte ich es für eine dumme Idee, in einer Funktion eine globale 
Variable zu verändern.

Möglich aber dumm.

Besser wäre es, der Funktion einen Zeiger(C) oder eine Referenz(C++) auf 
die Variable zu übergeben.

Das befreit die Funktion von einer globalen Abhängigkeit.
Macht sie portabler und wiederverwendbarer.

[Linus (Gast)]

Johannes H. schrieb:
> Also ich habe eine Funktion x, die durch mehrere Prozesse aufgerufen
> werden soll. Das Problem ist nur, dass diese Funktion x eine globale
> Variable verwendet (es gibt auch leider keine andere Möglichkeit :( ).

Eine globale Variable in mehreren Prozessen ist überhaupt kein Problem. 
Sie ist halt nur global pro Prozess.

Also, wenn man keine Ahnung hat, einfach ...
erstmal informieren was man eigentlich will. Und das dann auch 
beschreiben.

Wenn man einen Apfelkuchen backen will und feststellt, dass Äpfel ein 
Problem haben, ist es schwachsinnig zu fragen, warum Birnen angeblich 
das Problem der Äpfel haben, obwohl genau das Problem nur bei Äpfeln 
auftritt. Wirst du nicht verstehen, ist mir aber auch egal.

[Peter D. (peda)]

Johannes H. schrieb:
> Das Problem ist nur, dass diese Funktion x eine globale
> Variable verwendet (es gibt auch leider keine andere Möglichkeit :( ).

Schön für Dich.
Nur können wir nicht hellsehen, welchen Einfluß diese ominöse Variable 
hat.
Global muß sie nur dann sein, wenn noch ein anderer Task darauf 
zugreifen soll.

[Stefan F. (Gast)]

Deine Funktion dem Lock ist nicht Reentrant. Sie kann zwar von mehrere 
Threads nacheinander aufgerufen werden, aber sie kann nicht durch einen 
Interrupt unterbrochen und erneut aufgerufen werden.

https://de.wikipedia.org/wiki/Eintrittsinvarianz

[Alex G. (dragongamer)]

@Johannes H.

Bist du dir ganz, ganz sicher dass du von mehrere Prozessen redest, die 
auf dieser Variablen zugreifen sollen?
Und nicht eher einfach mehrere Threads?

Und ausserdem, wie kommst du auf reentrante Funktionen?
Sowas hat man doch unter einem Nicht-Echtzeit-Betriebssystem wie Linux 
doch garnicht, oder?


Des weiteren da du schon ein OS einsetzst, gibt es bestimmte Gründe 
wieso du C nimmst?
In C++ gibt es für exakt dieses Problem, atomare Operationen.
Das vereinfacht auch den Code.

[batman (Gast)]

Äh?!

[Einer K. (Gast)]

Alex G. schrieb:
> Und ausserdem, wie kommst du auf reentrante Funktionen?
> Sowas hat man doch unter einem Nicht-Echtzeit-Betriebssystem wie Linux
> doch garnicht, oder?

Du versucht mich zu verwirren!
Für mich ist der Begriff "reentrante Funktion" eindeutig.

Ob eine Funktion Wiedereintrittsfähig ist, hat nichts mit Echtzeit oder 
Linux zu tun.

[Alex G. (dragongamer)]

Arduino F. schrieb:
> Ob eine Funktion Wiedereintrittsfähig ist, hat nichts mit Echtzeit oder
> Linux zu tun.
Ja logisch, aber die Frage ist doch, wieso will der TE eine reentrante 
Funktion, wenn die Umstände das garnicht erfordern?
Er will eigentlich nur Thread-Sicherheit.

Eventuell sollte er sich das hier mal durchlesen: 
https://www.quora.com/When-is-a-function-reentrant-How-does-that-relate-to-it-being-thread-safe