Spezieller Code oder allgemeiner Code?

Tomahawk

Nachfolgend geht es vorwiegend um hohe Laufzeiteffizienz.

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

volkard

Tomahawk schrieb:

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.

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

demotron schrieb:

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

Tomahawk

Euer sarkastischer Humor zu später Stunde impliziert, dass euch nicht solch massive Grundlagenprobleme wie mir vorliegen

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)?

drakon

Machs allgemein und profile dein Programm am Ende. Wenn du merkst, dass es an der Stelle einen Engpass gibt, dann ändere es, ansonsten lass es.

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.

Ich kann dem nur Zustimmen. Grundsätzlich gilt es so zu programmieren, dass man den Code einfach warten kann. Und ein Code der redundant ist, ist ein Monster!

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

Tomahawk

demotron schrieb:

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;

Tomahawk

// für spiegelungen kommt noch etwas bitgefummel für die symetrie hinzu.

// anstatt...

if (board[square] == E1) { }

// könnte ich zwei versionen schreiben:

if (board[square^(56*color)] == E1) { }  // color=0|1

if (board[square] == (E1^(56*color))) { }  // color=0|1

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

// das waren alle probleme mit der symterie des schachbrettes

Tomahawk

Sorry, ich bin müde und unkonzentriert, ich meinte natürlich:

// 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? !

unskilled

zu müde um das "edit"-feld zu sehen? nach 37 posts sollte man das ja doch mal mitbekommen haben?! ^^

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

5cript

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 ?

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

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

Tomahawk

Tim06TR schrieb:

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.)