Hallo,

ich brauche Hilfe beim Erstellen eines Thread im Xilkernel. Es sollen 
zwei Programme parallel ablaufen.

Der Code unten zeigt, wie ich's gemacht habe. Aber an die untere Stelle 
"HIER KOMME ICH NICHT AN" kommt der Code leider nie. Er bleibt im Thread 
hängen.

Habe ich einen Denkfehler, oder ist der Thread-Aufbau falsch?

Wäre super, wenn mir jmd helfen könnte.

void muster_thread(){
    xil_printf("Thread-TEST");
    while(1);
 }


int main() {
  /*
   * Thread Crap
   */
   pthread_t worker;
   pthread_attr_t attr;

   pthread_attr_init (&attr);

  /* This is how we can join with a thread and reclaim its return value */
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

   int ret = pthread_create (&worker, &attr, (void*)muster_thread,
                              NULL);

   if (ret != 0) {
     xil_printf ("ERROR (%d) launching worker thread\r\n", ret);
     return -1;
   }

   if (ret) {
    xil_printf("Master Thread Terminating.\r\n");
    return -1;
   }

    xil_printf("soweit sogut");
    ret = pthread_join(worker, NULL);
   
  /*
   * END Thread Crap
   */

   while(1){
     xil_printf("HIER KOMME ICH NICHT AN");

was bedeutet noch mal "pthread_join" und was "while(1)"?

warten auf etwas was nie passiert und siehe da es passiert nix :-)

versuchs mal mit:

blah = pthread_join(ret, NULL);

noch ein (Gedankenanregungs-)Versuch:

"The pthread_join() function suspends execution of the
calling thread until the target thread terminates, unless the
target thread has already terminated."

d.h. eine Task die "while(1);" macht, beendet sich nicht
und auf ihr Ende zu warten kann dauern

LatticeFan schrieb:
> blah = pthread_join(ret, NULL);

von welchen Typ ist nochmal ret?
laut Doku muß es von Typ "pthread_t" sein.
Selbst wenn der eigentlich "int" sein sollte,
dann hat ret den Wert 0 und pthread_join wird mit ESRCH
oder "thread ungültig" zurück kommen.
Löst zwar olpo's Problem, aber bringt ihn nicht weiter!

pthread schrieb:
> "The pthread_join() function suspends execution of the
> calling thread until the target thread terminates, unless the
> target thread has already terminated."
>
> d.h. eine Task die "while(1);" macht, beendet sich nicht
> und auf ihr Ende zu warten kann dauern

Hmm, hier scheint der Hund begraben zu sein.

Aber, so ganz verstehen tu ich das noch nicht.

Wenn ich pthread_join() aufrufe, dann wartet er bis der gestartete 
Thread, hier "worker",  beendet ist???
Das macht doch gar keinen Sinn. Das ist dann ja kein Thread, sondern ein 
einfacher Funktionsaufruf.

Vielleicht ist mein Englisch auch nicht so toll...

wenn ich pthread_join() rausnehme, startet leider der muster_thread() 
nicht. Warum das?

hier nochmal der Code wie ich es jetzt probiere.
Ich setze die höchste Priorität.
Aber "PThread-TEST" wird nicht ausgegeben.

/**
 * Thread
 */ 
void test_Thread(){

  xil_printf("PThread-TEST\n\r");

  while(1);

}


int main() // CI
{
   pthread_t worker;
   pthread_attr_t attr;

   pthread_attr_init (&attr);

   attr.schedparam.sched_priority = 0;


   int ret = pthread_create (&worker, &attr, (void*)getPsiByte, NULL);
   
   if (ret != 0) {
      xil_printf ("Xilkernel Demo: ERROR (%d) launching worker thread\r\n", ret);
      return -1;
    }

Geht ja auch nicht. Es wird getPsiByte gestartet und nicht test_Thread.

Oder sehe ich das falsch?

hmm ja, das ist für's Forum übersichtlicher gemacht und in test_Thread 
umbenannt. Im eigentlichen C-Code stimmt beides überein.

probier mal:

yield();

damit sollte der ThreadScheduler aktiv werden.
Kann sein, daß der "High Prio" Thread zwar existiert,
aber eben (noch) nicht läuft.