4. Bitweises Und + Vergleich in Assembler

Bitweises Und + Vergleich in Assembler

  • N

    Kommt wohl auf die Optimierung und verwendete Befehlssätze an, was der Compiler aus 64Bit-Ints macht. Ich traue denen da grundsaetzlich vieles (vor allem Unfug) zu. 😉
    Aber wenn du fuer i386 compilierst, kommt auch nur 32Bit i386 raus (dh. 1 64Bit aufgeteilt auf 2x32 ... sollte zumindest), unabhaengig von Windows, 64Bit, Intel oder worauf auch immer das nachher laeuft.

    0
  • ?

    Hm, ich hab noch ne andere Optimierungsmöglichkeit für diese Funktion. Die Funktion ist ja aus 7 switch-Anweisungen aufgebaut, die alle so wie die folgende aussehen (wobei diese die wenigsten If-Abfragen beinhaltet):

    switch(Height[0])
	{
		case 0:
			if((Feld1 & 0x408000000i64) == 0x408000000i64 && Height[3]<3) return 0;
			if((Feld1 & 0x8100000i64) == 0x8100000i64 && Height[1]<1) return 0;
			if((Feld1 & 0x400100000i64) == 0x400100000i64 && Height[2]<2) return 0;
			break;
		case 1:
			if((Feld1 & 0x410000000i64) == 0x410000000i64 && Height[3]<1) return 0;
			if((Feld1 & 0x10400000i64) == 0x10400000i64 && Height[1]<1) return 0;
			if((Feld1 & 0x400400000i64) == 0x400400000i64 && Height[2]<1) return 0;
			if((Feld1 & 0x204000000i64) == 0x204000000i64 && Height[3]<4) return 0;
			if((Feld1 & 0x4080000i64) == 0x4080000i64 && Height[1]<2) return 0;
			if((Feld1 & 0x200080000i64) == 0x200080000i64 && Height[2]<3) return 0;
			break;
		case 2:
			if((Feld1 & 0x208000000i64) == 0x208000000i64 && Height[3]<2) return 0;
			if((Feld1 & 0x8200000i64) == 0x8200000i64 && Height[1]<2) return 0;
			if((Feld1 & 0x200200000i64) == 0x200200000i64 && Height[2]<2) return 0;
			if((Feld1 & 0x102000000i64) == 0x102000000i64 && Height[3]<5) return 0;
			if((Feld1 & 0x2040000i64) == 0x2040000i64 && Height[1]<3) return 0;
			if((Feld1 & 0x100040000i64) == 0x100040000i64 && Height[2]<4) return 0;
			break;
		case 3:
			if((Feld1 & 0x104000000i64) == 0x104000000i64 && Height[3]<3) return 0;
			if((Feld1 & 0x4100000i64) == 0x4100000i64 && Height[1]<3) return 0;
			if((Feld1 & 0x100100000i64) == 0x100100000i64 && Height[2]<3) return 0;
			if((Feld1 & 0x10800000i64) == 0x10800000i64 && Height[1]<2) return 0;
			if((Feld1 & 0x200800000i64) == 0x200800000i64 && Height[2]<1) return 0;
			break;
		case 4:
			if((Feld1 & 0x82000000i64) == 0x82000000i64 && Height[3]<4) return 0;
			if((Feld1 & 0x2080000i64) == 0x2080000i64 && Height[1]<4) return 0;
			if((Feld1 & 0x80080000i64) == 0x80080000i64 && Height[2]<4) return 0;
			if((Feld1 & 0x108000000i64) == 0x108000000i64 && Height[3]<1) return 0;
			if((Feld1 & 0x8400000i64) == 0x8400000i64 && Height[1]<3) return 0;
			if((Feld1 & 0x100400000i64) == 0x100400000i64 && Height[2]<2) return 0;
			break;
		case 5:
			if((Feld1 & 0x41000000i64) == 0x41000000i64 && Height[3]<5) return 0;
			if((Feld1 & 0x1040000i64) == 0x1040000i64 && Height[1]<5) return 0;
			if((Feld1 & 0x40040000i64) == 0x40040000i64 && Height[2]<5) return 0;
			if((Feld1 & 0x84000000i64) == 0x84000000i64 && Height[3]<2) return 0;
			if((Feld1 & 0x4200000i64) == 0x4200000i64 && Height[1]<4) return 0;
			if((Feld1 & 0x80200000i64) == 0x80200000i64 && Height[2]<3) return 0;
			break;
		default:
			break;
	}

    Beim durcharbeiten des Spiel-Baumes wird die Funktion in jedem Knoten aufgerufen, die dann diese 7 switch-Anweisungen durcharbeitet. Je tiefer man im Spielbaum gelangt, desto weniger dieser If-Abfragen werden benötigt, weil man schon weiß, dass diese nicht erfüllt werden können. Da in den tieferen Bereichen des Spielbaums ja die meisten Knoten abgearbeitet werden und in diesen Bereichen die meisten If-Abfragen eingespart werden könnten, sehe ich dort Potential um noch Zeit rauszuholen. Die Frage ist nur wie??? Man kann dem Programm ja nicht so einfach ohne viel Aufwand sagen, dass er im nächst tieferen Knoten diese if-Abfragen einfach überspringen soll, weil die sowieso nicht erfüllt werden.

    Ihr scheint ja euer Fach zu verstehen, vllt. habt ihr ja ne Idee???
    Hoffentlich konnte ich klar machen, worum es geht...

    0
  • R

    pruefst du etwa in jedem durchgang alle felder durch? oder hab ich das missverstanden?

    an sich musst du nur pro feld in das du was reinsetzt einmal pruefen ob daraus jetzt ein 4er entsteht.

    wenn du das spielfeld nicht 7*6, sondern 13*12 machst, kannst du dir jegliche sonderbehandlungen ersparen und normal testen, wobei ich, wie Nobuo T auch schon sagte, eher arrays statt bitmasken nutzen wuerde, ist um einige schneller afaik.

    0
  • ?

    Die Funktion prüft ja nicht ob man einen Vierer bekommt, sondern ob man eine Drohung erstellen kann und gibt dann die entsprechende Spalte zurück, daher muss ich alle 7 Spalten prüfen. Aber die Funktion für die Vierer ist dieser sehr ähnlich, nur nen bisschen einfacher. Alles was sich auf diese Funktion anwenden kann, müsste ich normalerweise auch auf die Vierer-Funktion anwenden können. Diese Drohungen-Suchen-Funktion ist für die Zugsortierung sehr wichtig und wird daher in jedem Knoten bis zur Tiefe 22 aufgerufen, für größere Tiefen ist Sie uninteressant, weil dort in der Regel nicht mehr so viele Drohungen erstellt werden können...

    Hab ich das richtig verstanden, dass ich das Spielfeld durch ein Array darstellen soll oder meintest du was anderes???

    0
Anmelden zum Antworten