So wie der folgende Code ist fast der ganze Algorithmus aufgebaut. Die nächsten Codesequenzen sind representativ für das, wofür fast die ganze Rechenzeit verwendet wird.

A

case PIECE_BLACK_ROOK:
      board.black_bitboard&=bitboard_clear[to];
      board.black_rook_bitboard&=bitboard_clear[to];
      board.black_rooks--;
      board.black_pieces--;
      board.key_pieces^=random_black_rook[to];
      board.key_material^=random_black_rook_material[board.black_rooks];
      board.moves[to]++;
      break;

B

case PIECE_BLACK_ROOK:
      board.bitboard[color]&=bitboard_clear[to];
      board.rook_bitboard[color]&=bitboard_clear[to];
      board.rooks[color]--;
      board.pieces[color]--;
      board.key_pieces^=random_rook[color][to];
      board.key_material^=random_rook_material[color][board.rooks[color]];
      board.moves[to]++;
      break;

A ist sehr spezieller Code und muss insgesamt zweimal implementiert werden ( color kann 0 oder 1 sein). Der Code in B ist algemeingültig und muss nur einmal implementiert werden.

Meine Frage:
Ist der Code in B hinsichtlich der Laufzeiteffizienz schlechter (also langsamer) als der Code in A? Oder sind Arrayzugriffe (zB board.rooks[color] ) bei modernen Compilern genauso schnell wie eine Variable (zB board.black_rooks )?

Und ist es sinnvoller allgemeinen Code zu schreiben, der zwar ein kleines bisschen komplizierter ist, dafür aber deutlich weniger Code implementieren zu müssen?

Sorry, dass ich Samstagabend noch so doofe Fragen stelle

Und ist es sinnvoller allgemeinen Code zu schreiben, der zwar ein kleines bisschen komplizierter ist, dafür aber deutlich weniger Code implementieren zu müssen?

Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt. Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt.

Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt. Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt.

Es wäre glaub ich lehrreicher gewesen, wenn du in deinen Satz (natürlich 2x) einen Fehler eingebaut hättest

volkard schrieb:

Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt. Klar. Damit Du nicht jede Änderung im Code zweimal machen mußt.

Es wäre glaub ich lehrreicher gewesen, wenn du in deinen Satz (natürlich 2x) einen Fehler eingebaut hättest

Hat er doch, es heißt musst und nicht mußt

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Oder kann ich diesen Aspekt vernachlässigen (tue ich gerne, wenn es unter 10% Speedverlust bleiben kann)?

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Ein Zugriff auf ein Array spürst du zeitlich nicht, es muss nur ein Offset errechnet werden und du bist bei deinen Daten.
Aber ganz versteh ich dein Problem nicht, du hast in beiden Beispielen noch dein CASE, da ist es doch wurscht ob die Struktur ein farbenindiziertes Array hat, oder die Werte direkt mit black_rook oder sonstwas angesprochen werden.

Wenn dein Programm läuft, dann gibt es Möglichkeiten die Programmteile, wo wirklich Zeit verloren geht zu finden und zu verbessern.

Tomahawk schrieb:

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Ein Zugriff auf ein Array spürst du zeitlich nicht, es muss nur ein Offset errechnet werden und du bist bei deinen Daten.
Aber ganz versteh ich dein Problem nicht, du hast in beiden Beispielen noch dein CASE, da ist es doch wurscht ob die Struktur ein farbenindiziertes Array hat, oder die Werte direkt mit black_rook oder sonstwas angesprochen werden.

Sorry, das habe ich erst nach dem Posten gemerkt. So war es gemeint:

case PIECE_ROOK:                                     // so natürlich
      board.bitboard[color]&=bitboard_clear[to]; 
      board.rook_bitboard[color]&=bitboard_clear[to]; 
      board.rooks[color]--; 
      board.pieces[color]--; 
      board.key_pieces^=random_rook[color][to]; 
      board.key_material^=random_rook_material[color][board.rooks[color]]; 
      board.moves[to]++; 
      break;

// spezieller code der redundanten fassung sieht etwa so aus:

if (square == CONST_E1) { } 

// für den code allgemeinen fassung könnte ich zwei versionen schreiben: 

if ((square^(56*color)) == CONST_E1) { }  // color=0|1 

if (square == (CONST_E1^(56*color))) { }  // color=0|1 

macht das einen Unterschied für den Compiler hinsichtlich Effizienz? !

was willst du denn jetzt noch hören?
jeder programmierer wird dir immer sagen, dass doppelter code doof ist... wie volkard das schon vorgemacht hat...

bb

Value ^ 56
ist das nicht etwas hoch ???
bei 2
-->
72057594037927936

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

Hinweis: Dein Fehler liegt in der Interpretation des ^-Operators

CONST_E1^(56*color)

Value ^ 56
ist das nicht etwas hoch ???
bei 2
-->
72057594037927936

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

square^56 ist eine vertikale Spielelung eines Feldes auf dem Schachbrett (A1->A8 usw.)