-         
Seite 3 von 5 ErsteErste 12345 LetzteLetzte
Ergebnis 21 bis 30 von 48

Thema: schon mal festgestellt? A. Due rechnet falsch - Mega ok!

  1. #21
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    692
    Anzeige

    Ich habe den Code mit Visual Studio gestartet, dabei erscheint das Programm in einem Windows Konsolenfenster.

    Putty ist ein Terminalprogramm, der Beaglebone hing am USB-Port des Laptops (ohne eigene Tastatur und Bildschirm).

    Ich habe also parallel zum Windowsprogramm die beiden Linuxversionen in zwei Fenstern gestartet. Und dann in allen drei Programmen jeweils die gleiche Eingabe gemacht, um zu vergleichen.

    P.S. Bin jetzt ggf. ein paar Tage offline.

    - - - Aktualisiert - - -

    Zitat Zitat von HaWe Beitrag anzeigen
    heißt das, dass sowohl Clang- als auch gpp-Compiler-Code auf dem Beaglebone liefen und beide dieselben falschen Ergebnisse auf dem Beaglebone produzierten?
    Ja, sie waren nicht zu unterscheiden.

  2. #22
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.869
    ok, ja, dann ist es klar..

    hmmm...: Jemand meinte jetzt, es könnte evtl. an little oder big endians liegen... aber wo genau und wie...

  3. #23
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    27.08.2013
    Ort
    Region Basel
    Alter
    62
    Beiträge
    2.435
    Hallo,
    Zitat Zitat von HaWe Beitrag anzeigen
    hmmm...: Jemand meinte jetzt, es könnte evtl. an little oder big endians liegen... aber wo genau und wie...
    Das ist die andere Möglichkeit.

    Probleme bekommst du immer dann, wen z.B. char und int gemischt werden. Also du auf de selben Speicherbereich mal als char und mal als int ansprichst, das wird dann nicht mehr portierbar.

    Beim besagten Macro passiert aber genau das, T ist als char definiert und dann wird da fröhlich mal als char und mal als int drin rum gestochert.

    Ich habe en Code aber nur überflogen und keine Lust da jetzt das Problem zu lösen.

    Dazu musst man zuerst einmal die CPUs vergleichen, wie das mit der Endian und dem Alignment ist.

    MfG Peter(TOO)
    Manchmal frage ich mich, wieso meine Generation Geräte ohne Simulation entwickeln konnte?

  4. #24
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    692
    Wenn ich etwas Zeit habe, was nicht in den nächsten Tagen sein wird, grabe ich mal meinen Due aus und schaue, ob es da noch Unterschiede zum Beaglebone gibt. Mit Endianess zwischen Beaglebone und PC hatte ich bisher keine Probleme, sollte gleich sein.

  5. #25
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.869
    habe den Programmierer, der das mit endians angesprochen hat, nach einem Test gefragt.
    Antwort:
    Xander Soldaat It would be easy to devise a simple test.
    Print out 0xabcdefab >> 8 on the various platforms and see if you can spot a difference in the outcome.
    Ergebnis: kein Unterschied!
    Arduino _Due: 11259375
    Arduino Mega: 11259375

    wenn mir jemand zeigt, wo genau ints mal als ints und mal als bytes angesprochen verden, könnte ich das ja versuchen per type cast
    (char)... oder (unsigned char)...
    zu korrigieren. Explizites Type cast funktioniert ja auf jeder Plattform korrekt.

  6. #26
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    692
    So, ich bins wieder.

    Die Sache hat mir keine Ruhe gelassen. Ich habe also auch noch meinen Due gesucht und jetzt mit vier Programmen getestet.

    Folgende Erkenntnisse:

    1) Die im ersten Posting genannten Züge White d2d4 und Black a7a6 akzeptiert nur die PC-Version. Bei Due und beiden Beaglebone Programmen kommt bei a7a6 ein Score 15.

    2) Wenn ich die Windows Version mit Leeren Eingaben füttere und die dort berechneten Züge in die drei ARM Programme eingebe, dann funktionieren die. Auch auf dem Due. Ich habe aber keine ganze Partie gespielt, nur ein Dutzend Züge.

    3) Alle Programme scheinen immer die selben Züge zu wählen, wenn man sie neu startet und nur leere Eingaben macht. Aber jede Version andere. Der PC beginnt immer mit d2-d4, der Due ( Arduino 1.5.8 ) immer mit f2-f3, BBB g++ mit e2-e3 und BBB Clang mit b1-c3.

    Schlussfolgerung: Hier ist "undefined behavior" im Spiel, zumindest bei den drei ARM-Versionen. Da werden irgendwo Sprachkonstrukte verwendet, die nicht wirklich erlaubt sind und wahrscheinlich auf dem PC und er 8-Bit Plattform zufällig funktionieren.

    Danach zu suchen macht sicher Arbeit, da wäre ein guter Debugger hilfreich.

  7. #27
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.869
    wenn man nur Harm Geert Mullers Email-Adresse rauskriegen könnte...
    Habs bereits probiert, aber
    H.Muller@amolf.nl
    ist leider ungültig...

  8. #28
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.869
    nicht zu glauben, was die Ursache war....

    wer mag, teste doch jetzt mal den folgenden Sketch Code auf dem Due (immer noch debug-Stadium ntl):

    Code:
    /***************************************************************************/
    /*                               micro-Max,                                */
    /* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
    /***************************************************************************/
    /* version 4.8.l Sketch (1953 characters) features:                                 */
    /* - recursive negamax search                                              */
    /* - all-capture MVV/LVA quiescence search                                 */
    /* - (internal) iterative deepening                                        */
    /* - best-move-first 'sorting'                                             */
    /* - a hash table storing score and best move                              */
    /* - futility pruning                                                      */
    /* - king safety through magnetic, frozen king in middle-game              */
    /* - R=2 null-move pruning                                                 */
    /* - keep hash and repetition-draw detection                               */
    /* - better defense against passers through gradual promotion              */
    /* - extend check evasions in inner nodes                                  */
    /* - reduction of all non-Pawn, non-capture moves except hash move (LMR)   */
    /* - full FIDE rules (expt under-promotion) and move-legality checking     */
    
    
    #define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
    // #define K(A,B) (int)(T+A+(B&8)+S*(B&7))
    
    #define HTsize (1<<8) // (1<<24)
    struct HTab {
              int  K,
                   V;
              int  X,
                   Y,
                   D;
            } HTarray[HTsize];           /* hash table, HTsize entries*/
           
           
    #define MAXNODES 60000
    
    int  K,   
         Q,
         R,
         J,
         Z;
         
    long N,
         I=80000;                         /* I=80000: "infinity score" */ ;                           
    
    int
        M=136,                           /* M=0x88   board system    */
        S=128,                           /* dummy square 0x80, highest valid square =127    */
        turn=16;             
    
    signed char  L,
         pval[]={0,2,2,7,-1,8,12,23},                      /* relative piece values    */
         vector[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
              7,-1,11,6,8,3,6},                          /* 1st dir. in vector[] per piece*/
         
         bsetup[]={6,3,5,7,4,5,3,6},                         /* initial piece setup      */
         board[129],                                        /* board: half of 16x8+dummy*/
         T[1035];                                        /* hash translation table   */
    
    signed char  psymbol[]= ".?+nkbrq?*?NKBRQ";
    
    char mfrom, mto;    // current ply from - to
    int  EPSQ,
         RemP;           // remove piece
    
    
    
    
    /* recursive minimax search, turn=moving side, n=depth*/
    
    int  Minimax(int  q, int  l, int  score, int  EPC, int  prev, int  hashkey)         
                           /* (q,l)=window, score, EnPass_sqr.*/
                           /* prev=prev.dest; J,Z=hashkeys; return score*/
    {
       int  j,
            r,
            m,
            v,
            d,
            h,
            i,
            F,
            G,
            V,
            P,
            f=J,
            g=Z,
            C,
            s;
       signed char  t,
            p,
            upiece,
            x,
            y,
            X,
            Y,
            H,
            B;
       
       struct HTab *a = HTarray + (J + turn * EPC & HTsize-1);   /* lookup pos. in hash table*/
     
       char sbuf[50];
     
     
     
       q--;                                          /* adj. window: delay bonus */
       turn^=24;                                        /* change sides             */
       d=a->D;
       m=a->V;
       X=a->X;
       Y=a->Y;                  /* resume at stored depth   */
       
       if(a->K-Z|prev|                                  /* miss: other pos. or empty*/
          !(m<=q | X&8&&m>=l | X&S))                   /*   or window incompatible */
          { d=Y=0; }                                /* start iter. from scratch */
       
       X&=~M;                                        /* start at best-move hint  */
     
       while( d++ < hashkey || d<3                   /* iterative deepening loop */
         || prev&K == I
           && ( N<60000 & d<98                        /* root: deepen upto time   */
              || (K=X, L=Y&~M, d=3)
           )
         )                                          /* time's up: go do best    */
       {
          x=B=X;                                       /* start scan at prev. best */
          h=Y&S;                                       /* request try noncastl. 1st*/
          P=d<3 ? I : Minimax(-l,1-l,-score,S,0,d-3);               /* Search null move         */
          m = (-P<l | R>35) ? ( d>2 ? -I : score ) : -P;            /* Prune or stand-pat       */
          N++;                                         /* node count (for timing)  */
          do
          {
             upiece=board[x];                                   /* scan board looking for   */
             if(upiece & turn)                                  /*  own piece (inefficient!)*/
             {
                r = p = upiece&7;                               /* p = piece type (set r>0) */
                j = vector[p+16];                                 /* first step vector f.piece*/
                while(r = p>2 & r<0 ? -r : -vector[++j] )       /* loop over directions vector[] */
                {
    labelA:                                        /* resume normal after best */
                   y=x;                            /* (x,y)=move         */
                   F=G=S;                          /* (F,G)=castl.R      */
                   
                   do
                   {                                       /* y traverses ray, or:     */
                      H=y=h?Y^h:y+r;                           /* sneak in prev. best move */
                     
                      if(y&M)break;                            /* board edge hit           */
                     
                      m= EPC-S&board[EPC]&&y-EPC<2&EPC-y<2?I:m;      /* bad castling             */
                     
                      if(p<3&y==EPC)H^=16;                           /* shift capt.sqr. H if e.p.*/
                     
                      t=board[H];
                     
                      if(t&turn|p<3&!(y-x&7)-!t)break;            /* capt. own, bad pawn mode */
                      i=37*pval[t&7]+(t&192);                     /* value of capt. piece t   */
                      m=i<0?I:m;                                  /* K capture                */
                     
                      if(m>=l&d>1) goto labelC;                     /* abort on fail high       */
               
                      v=d-1?score:i-p;                             /* MVV/LVA scoring          */
                     
                      if(d-!t>1)                               /* remaining depth          */
                      {
                         v=p<6?board[x+8]-board[y+8]:0;                  /* center positional pts.   */
                         board[G]=board[H]=board[x]=0;board[y]=upiece|32;             /* do move, set non-virgin  */
                         if(!(G&M))board[F]=turn+6,v+=50;               /* castling: put R & score  */
                         v-=p-4|R>29?0:20;                              /* penalize mid-game K move */
                         
                         if(p<3)                                        /* pawns:                   */
                         {
                            v-=9*((x-2&M||board[x-2]-upiece)+              /* structure, undefended    */
                                   (x+2&M||board[x+2]-upiece)-1            /*        squares plus bias */
                                  +(board[x^16]==turn+36))                 /* kling to non-virgin King */
                                  -(R>>2);                                 /* end-game Pawn-push bonus */
                             V=y+r+1&S?647-p:2*(upiece&y+16&32);           /* promotion or 6/7th bonus */
                             board[y]+=V;
                             i+=V;                                         /* change piece, add score  */
                         }
                         
                         v+= score+i;
                         V=m>q ? m : q;                           /* new eval and alpha       */
                         J+=K(y+0,board[y])-K(x+0,upiece)-K(H+0,t);
                         Z+=K(y+8,board[y])-K(x+8,upiece)-K(H+8,t)+G -S;  /* update hash key          */
                         C=d-1-(d>5&p>2&!t&!h);
                         C=R>29|d<3|P-I?C:d;                     /* extend 1 ply if in check */
                         do {
                            s=C>2|v>V?-Minimax(-l,-V,-v,         /* recursive eval. of reply */
                                                F,0,C):v;        /* or fail low if futile    */
                         } while( s>q & ++C<d );
                       
                         v=s;
                         if(prev&&K-I&&v+I&&x==K&y==L)              /* move pending & in root:  */
                         {
                            Q=-score-i; EPSQ=F;                            /*   exit if legal & found  */
                            a->D=99;a->V=0;                        /* lock game in hash as draw*/
                            R+=i>>7;
                            return l;                            /* captured non-P material  */
                         }
                         J=f;
                         Z=g;                                    /* restore hash key         */
                         board[G]=turn+6;
                         board[F]=board[y]=0;
                         board[x]=upiece;
                         board[H]=t;                             /* undo move,G can be dummy */
                      }
                      if(v>m)                                  /* new best, update max,best*/
                      {
                         m=v,X=x,Y=y|S&F;                      /* mark double move with S  */
                      }                       
                      if(h)
                      {
                         h=0;
                         goto labelA;                           /* redo after doing old best*/
                      }                 
                      if (
                        x+r-y|upiece&32|                             /* not 1st step,moved before*/
                        p>2 & (
                          p-4|j-7||                             /* no P & no lateral K move,*/
                          board[G=x+3^r>>1&7]-turn-6            /* no virgin R in corner G, */
                          || board[G^1] | board[G^2] )          /* no 2 empty sq. next to R */
                        )
                      {
                         t+=p<5;
                      }                                        /* fake capt. for nonsliding*/
                      else F=y;                                /* enable e.p.              */
                     
                   } while(!t);                               /* if not capt. continue ray*/
             
                }
             }  // (upiece & turn)
         
          } while((x=x+9&~M)-B);                       /* next sqr. of board, wrap */
       
    labelC:
          if (m>I-M|m<M-I) d=98;                       /* mate holds to any depth  */
          m= m+I|P==I ? m : 0;                         /* best loses K: (stale)mate*/
         
          if(a->D<99) {                                /* protect game history     */
             a->K=Z;
             a->V=m;
             a->D=d;                       /* always store in hash tab */
             a->X=X|8*(m>q)|S*(m<l);
             a->Y=Y;                       /* move, type (bound/exact),*/
          }
          /* uncomment for Kibitz */
          if(!((N-S)%987)) {       
            sprintf(sbuf, "searched: %d\n",N-S);
            Serial.print(sbuf);
          }
         
       }  // while (iterative deepening loop)                                           
     
       turn^=24;                                        /* change sides back        */
       mfrom=K; mto=L;
       return m+= m<score;                                  /* delayed-loss bonus       */
    }
    
    
    
    
    
    void chess()
    {
       int  score, i;
       char sbuf[50], sbuf2[50];
       char oboard[129];
       char oldto, oldEPSQ;
       char cstring[20];
       
       K=8;
       while(K--)
       {
          board[K]=(board[K+112]=bsetup[K]+8)+8;
          board[K+16]=18;
          board[K+96]=9;                               /* initial board setup*/
          L=8;
          while(L--)board[16*L+K+8]=(K-4)*(K-4)+(L-3.5)*(L-3.5);     /* center-pts table   */
       }                                                             /*(in unused half board[])*/
       N=1035;
       while(N-->M)T[N]=rand()>>9;
       
                                                                    /* play loop          */
       while(1)                                               
       {
         N=-1;
         
         Serial.print("\n");
         while(++N<121) {                                            /* print board */
             sprintf(sbuf," %c", N&8 && (N+=7) ? 10 : psymbol[board[N]&15]);
             Serial.print(sbuf);
         }
         
         if(turn==16) sprintf(sbuf,"\n>  WHITE: ");  else sprintf(sbuf,"\n>   BLACK:  ");
         Serial.print(sbuf);
         
         i = 0;       
         strcpy(cstring,"");
         do   {
           while (Serial.available()==0);       
           cstring[i] = Serial.read();     
           if(cstring[i]==13) {
             cstring[i]=0;
             break;
           }
           else i++;
         } while(i < 10);
         
         K=I;
         
         if(cstring[0]!=0) {                                   /* parse entered move */
           K= cstring[0]-16*cstring[1]+799;
           L= cstring[2]-16*cstring[3]+799;
         }   
         
         Serial.print("\n DEBUG cstring : "); Serial.println(cstring);
         sprintf(sbuf,"\n DEBUG K: %d  \n DEBUG L: %d \n",  K, L);
         Serial.print(sbuf);
         
         Serial.println();  Serial.println(cstring);  Serial.println();
         
         memcpy(oboard, board, sizeof(board));
         oldto=mto;
         oldEPSQ=EPSQ;
         
         score=Minimax(-I, I, Q, EPSQ, 1, 3);                              /* think or check & do*/     
         Serial.print("\nscore=");  Serial.println(score);  Serial.println();
       
        // if(ack!=15) {                     
            RemP=S;   
            if(oboard[mto])   RemP=mto;
            if(mto==oldEPSQ)  RemP=oldto;
                                           
            sprintf(sbuf,"\n\nmoved: >> %c%c", 'a'+(mfrom&7),'8'-(mfrom>>4) );
           
            if(oboard[mto]) strcat(sbuf," X ");
            else strcat(sbuf,"-");
           
            sprintf(sbuf2,"%c%c ", 'a'+(mto&7),'8'-(mto>>4&7));
            strcat(sbuf, sbuf2);
            Serial.print(sbuf);
         
            sprintf(sbuf, " (square %d to %d ) \n", mfrom, mto);
            Serial.print("\n\nDEBUG:\n");
            sprintf(sbuf2,"  EPsq: %c%c (%d)\n  RemP: %c%c (%d)",
                             'a'+(EPSQ&7), '8'-(EPSQ>>4&7), EPSQ,
                             'a'+(RemP&7), '8'-(RemP>>4&7), RemP);
            strcat(sbuf, sbuf2);
            Serial.print(sbuf);
            Serial.print("\n\n");
        //  }
        // else printf("\n\nILLEGAL!\n");
    
       }
    }
    
    
    
    
    void setup() {
       Serial.begin(9600);   
    }
    
    
    
    void loop() {   
       chess();
       
       while(1);
    }

  9. #29
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    27.08.2013
    Ort
    Region Basel
    Alter
    62
    Beiträge
    2.435
    Hallo,

    Und WAS war der Fehler?

    Ich habe keine Lust die beiden Listing zu vergleichen

    MfG Peter(TOO)
    Manchmal frage ich mich, wieso meine Generation Geräte ohne Simulation entwickeln konnte?

  10. #30
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    27.08.2013
    Ort
    Region Basel
    Alter
    62
    Beiträge
    2.435
    Hallo,

    Das wäre dann auf Compilerebene!

    ANSI stellt es frei ob char als signed oder unsigned behandelt wird. Die meisten Compiler haben einen Parameter, mit welchem dies umgeschaltet werden kann.

    Da ich schon vor 30 Jahren portablen C-Code schreiben musste, verwende ich char gar nie, sondern immer explizit unsigned char oder signed char. Selbiges natürlich gilt auch für int und long.

    Der Faulheit halber habe ich dazu Macros in einem eigenen Header, dann schreibe ich uchar und schar, bzw. uint und sint....

    Je nachdem welche CPU verwendet wird, ist char auch nicht immer 8-Bit lang.
    In den 70er Jahren, als C entstanden ist, gab es auch noch Rechner, mit z.B. 9-, 12-. 18- und 36-Bit Registerbreite.
    Heute ist so etwas hauptsächlich noch bei DSP zu finden.

    In den ersten K&R Ausgaben stand dazu noch:
    an darf nur annehmen, dass
    char <= int <= long
    ist. Man muss also damit rechnen, dass char auch 36-Bit lang sein kann.

    MfG Peter(TOO)
    Manchmal frage ich mich, wieso meine Generation Geräte ohne Simulation entwickeln konnte?

Seite 3 von 5 ErsteErste 12345 LetzteLetzte

Ähnliche Themen

  1. Arduino Mega/Due: i2c Master port multiplexen
    Von HaWe im Forum Suche bestimmtes Bauteil bzw. Empfehlung
    Antworten: 42
    Letzter Beitrag: 12.10.2014, 13:51
  2. Schon wieder: Problem mit I2C (c, mega8, mega 32)
    Von avrrobot im Forum C - Programmierung (GCC u.a.)
    Antworten: 6
    Letzter Beitrag: 19.01.2012, 20:10
  3. mega 128 hängt sich auf /oder schon tod?
    Von demlinger im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 13
    Letzter Beitrag: 09.09.2007, 20:34
  4. Rechnet der AVR falsch oder bin in ich nur zu dumm ?
    Von NumberFive im Forum C - Programmierung (GCC u.a.)
    Antworten: 9
    Letzter Beitrag: 11.02.2005, 14:35
  5. Schon mal an eine Ethernetschnittstelle gedacht?
    Von roboguy im Forum Elektronik
    Antworten: 10
    Letzter Beitrag: 27.10.2004, 22:40

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •