Help improving this code ?!

[MahmoudUthman]

This is the code I use for make/unmake :

Code: Select all

static U64 SBackup[MaxDepth][16];
static U64 CRBackup[MaxDepth][2];
static U64 PositionKeyBackUp[MaxDepth];
static unsigned int LastMoveDPushSQBackup[MaxDepth];
static U64 HalfMoveClockBackUp[MaxDepth];
static Score PSQTScore;
static Score PSQTScoreBackUp[MaxDepth];

static int ply = 0;
static U64 BitBoards[16];
static U64 HalfMoveClock = 0ULL;
static U64 GameRecordCounter = 0ULL;
static U64 Positionkey = 0ULL;
static U64 GameRecord[512];
//Junk,Real
unsigned int DoublePushSQ[2] = { 0U,0U };
BB TypeBoard[64 + MaxDepth];
Color STM = White;

make:

Code: Select all

void MakeMove(const Move& __restrict M)
{
	HalfMoveClockBackUp[ply] = HalfMoveClock;/
	HalfMoveClock++;

	std::memcpy(SBackup[ply], BitBoards, 16 * sizeof(U64));

	PositionKeyBackUp[ply] = Positionkey;
	CRBackup[ply][0] = CastleRights[0];
	CRBackup[ply][1] = CastleRights[1];

	PSQTScoreBackUp[ply] = PSQTScore;

	Color NTM = Color(7 - STM);
	unsigned int From = M.From, To = M.To;
	BB PT = TypeBoard[From];

	PSQTScore += psq[STM ? 1 : 0][PT][To] - psq[STM ? 1 : 0][PT][From];


	LastMoveDPushSQBackup[ply] = DoublePushSQ[1];
	if (DoublePushSQ[1] != 0) Positionkey ^= GetEnpassantZobrist();

	DoublePushSQ[1] = 0UL;
	TypeBoard[64 + ply] = TypeBoard[To];
	U64 ToMask = 1ULL << To;
	U64 FromMask = ~(1ULL << From);
	BitBoards[Occupied] &= FromMask;
	BitBoards[STM + PT] &= FromMask;
	BitBoards[Occupied] |= ToMask;
	BitBoards[NTM + Enemy] &= FromMask;
	BitBoards[NTM + Enemy] |= ToMask;
	Positionkey ^= ZobristSide;
	size_t USTM = STM & 1ULL, UNTM = NTM & 1ULL;
	Positionkey ^= Zobrist[PT][USTM][From];
	Positionkey ^= GetCatsleZobrist();
	switch (M.Type)
	{
	case NORMAL:
		if (BB CapturedPiece = TypeBoard[64 + ply])
		{
			HalfMoveClock = 0ULL;
			Positionkey ^= Zobrist[CapturedPiece][UNTM][To];
			PSQTScore -= psq[NTM & 1][CapturedPiece][To];
		}
		//HalfMoveClock = HalfMoveClock&(0ULL - (PT != Pawn));
		if (PT == Pawn) HalfMoveClock = 0ULL;
		Positionkey ^= Zobrist[PT][USTM][To];//Add To
		BitBoards[STM + PT] |= ToMask;
		DoublePushSQ[((From^To) == 16U)&(PT == Pawn)] = To;
		if (!PT) CastleRights[STM & 1U] = 0ULL;
		BitBoards[STM + Enemy] &= ~ToMask;
		BitBoards[NTM + TypeBoard[64 + ply]] &= ~ToMask;
		BitBoards[NTM + Enemy] &= ~BitBoards[STM + King];
		CastleRights[0] &= BitBoards[Black + Rook];
		CastleRights[1] &= BitBoards[White + Rook];
		break;
	case PROMOTION:
		HalfMoveClock = 0ULL;
		if (BB CapturedPiece = TypeBoard[64 + ply])
		{
			Positionkey ^= Zobrist[CapturedPiece][UNTM][To];
			PSQTScore -= psq[NTM & 1][CapturedPiece][To];
		}
		PT = BB(M.PromoType + 2);
		Positionkey ^= Zobrist[PT][USTM][To];
		BitBoards[STM + PT] |= ToMask;
		BitBoards[STM + Enemy] &= ~ToMask;
		BitBoards[NTM + TypeBoard[64 + ply]] &= ~ToMask;
		CastleRights[0] &= BitBoards[Black + Rook];
		CastleRights[1] &= BitBoards[White + Rook];
		PSQTScore += psq[STM & 1][PT][To] - psq[STM & 1][Pawn][To];
		break;
	case ENPASSANT:
		HalfMoveClock = 0ULL;
		{
			const auto dpSq = LastMoveDPushSQBackup[ply];
			Positionkey ^= Zobrist[PT][UNTM][dpSq];
			Positionkey ^= Zobrist[PT][USTM][To];
			BitBoards[Occupied] &= ~(1ULL << dpSq);
			PSQTScore -= psq[NTM & 1][Pawn][dpSq];
			BitBoards[NTM + PT] &= BitBoards[Occupied];
			BitBoards[STM + Enemy] &= BitBoards[Occupied];
			BitBoards[STM + PT] |= ToMask;
			TypeBoard[dpSq] = Null;
		}
		break;
	case CASTLING:
		Positionkey ^= Zobrist[King][USTM][(NTM * 8) + 4];
		Positionkey ^= Zobrist[Rook][USTM][To];
		BitBoards[Occupied] &= ~BitBoards[STM + King];
		{
			unsigned int KingTo = (From + To + 1) >> 1;
			Positionkey ^= Zobrist[King][USTM][KingTo];
			BitBoards[STM + King] = 1ULL << KingTo;
			PSQTScore += psq[STM & 1][King][KingTo] - psq[STM & 1][King][(NTM * 8) + 4];
		}
		BitBoards[STM + PT] |= ToMask;
		BitBoards[Occupied] |= BitBoards[STM + King];
		CastleRights[STM & 1U] = 0ULL;
		break;
	default:
		break;
	}
	Positionkey ^= GetCatsleZobrist();
	if (DoublePushSQ[1] != 0) Positionkey ^= GetEnpassantZobrist();
	GameRecord[++GameRecordCounter] = Positionkey;
	ply++;
	BitBoards[Empty] = ~BitBoards[Occupied];
	STM = NTM;
	TypeBoard[From] = Null;
	TypeBoard[To] = PT;
}

Unmake:

Code: Select all

void UnMakeMove(const Move& __restrict M)
{
	std::memcpy(BitBoards, SBackup[--ply], 16 * sizeof(U64));
	GameRecordCounter--;
	HalfMoveClock = HalfMoveClockBackUp[ply];

	Positionkey = PositionKeyBackUp[ply];
	CastleRights[0] = CRBackup[ply][0];
	CastleRights[1] = CRBackup[ply][1];

	PSQTScore = PSQTScoreBackUp[ply];

	DoublePushSQ[1] = LastMoveDPushSQBackup[ply];
	STM = Color(7 - STM);
	unsigned int From = M.From, To = M.To;
	TypeBoard[From] = TypeBoard[To];
	if (M.Type == ENPASSANT) TypeBoard[DoublePushSQ[1]] = Pawn;
	else if (M.Type == PROMOTION)TypeBoard[From] = Pawn;
	TypeBoard[To] = TypeBoard[64 + ply];
}

I wrote it a couple of years ago when I was just starting to program so it isn't in top shape , I Know that premature optimization isn't a good thing and that the speed gain from optimizing this won't affect the engine's elo much if at all , but the problem I'm facing is that when I wrapped my code inside a "position" class those parts slowed down considerably "~10%:20%", C++ isn't my "native" language and I understand that abstraction comes with a cost -"but not a huge one"- but I believe that the cause is something I'm doing wrong here , the reset of the functions don't suffer from the same performance degradation , even the move generator is the same speed .

[Henk]

10-20% is nothing. You are just wasting your time. (Like I do all day)

[Sven]

Don't know whether it is related to your problem but a line like this:

Code: Select all

BitBoards[NTM + TypeBoard[64 + ply]] &= ~ToMask;

looks *very* suspicious, since TypeBoard is an array of bitboards ...

Do you swear that there will "never ever" be an array bounds overflow?

Edit: ok, I see that I misinterpreted the meaning of "BB", in fact it seems to be a piece type, not a bitboard, despite the name ... But nevertheless, I get the feeling that the whole "TypeBoard" stuff is unintuitive (array index "64 + ply"?). And I would not be surprised if your actual problem were related to some unintuitive code.

[Sven]

Which variables are now members of your class "Position"? Those listed above as "static" (so they are now no longer static)?

[Henk]

They always told me that object oriented programming is not for free. Calling a virtual method is like dereferencing a pointer to a function. So if you want to code more efficiently use C instead of C++. No nonsense with virtual tables.

[AlvaroBegue]

They always told me that object oriented programming is not for free. Calling a virtual method is like dereferencing a pointer to a function. So if you want to code more efficiently use C instead of C++. No nonsense with virtual tables.

This doesn't make any sense. Why is the cost of calling virtual functions an argument for using a different language? If you don't want to pay the cost of calling virtual functions, don't use virtual functions.

[Sven]

They always told me that object oriented programming is not for free. Calling a virtual method is like dereferencing a pointer to a function. So if you want to code more efficiently use C instead of C++. No nonsense with virtual tables.

Henk, please ... how can we prevent you from writing nonsense in a serious thread where someone is looking for help?

[Henk]

They always told me that object oriented programming is not for free. Calling a virtual method is like dereferencing a pointer to a function. So if you want to code more efficiently use C instead of C++. No nonsense with virtual tables.

This doesn't make any sense. Why is the cost of calling virtual functions an argument for using a different language? If you don't want to pay the cost of calling virtual functions, don't use virtual functions.

Then it is more object based programming. Yes that's possible too.

I don't know if it isn't always using virtual tables whether there are virtual methods defined or not. I would be surprised if inheritance is for free.

[AlvaroBegue]

I don't know if it isn't always using virtual tables whether there are virtual methods defined or not. Don't even know how inheritance is implemented. I think you need at least an extra pointer from an object to it's parent.

It's OK to be ignorant about something. But then you shouldn't go around giving advice about it.

No, C++ doesn't use vtables if there aren't virtual methods. Inheritance is implemented in several different ways, which you can look up on the web. You generally don't need a pointer to the parent, unless you are using virtual inheritance.

Personal opinion: If you want to live a happy life, don't use virtual inheritance, multiple inheritance or non-public inheritance. Use simple, non-virtual, public inheritance, and only to get polymorphic behavior, and only when inheritance expresses an "IS-A" relationship.

By the way, I have never used virtual functions or inheritance in a chess engine.

[MahmoudUthman]

Don't know whether it is related to your problem but a line like this:

Code: Select all

BitBoards[NTM + TypeBoard[64 + ply]] &= ~ToMask;

looks *very* suspicious, since TypeBoard is an array of bitboards ...

Do you swear that there will "never ever" be an array bounds overflow?

Edit: ok, I see that I misinterpreted the meaning of "BB", in fact it seems to be a piece type, not a bitboard, despite the name ... But nevertheless, I get the feeling that the whole "TypeBoard" stuff is unintuitive (array index "64 + ply"?). And I would not be surprised if your actual problem were related to some unintuitive code.

yes the naming is messed up .

Code: Select all

enum BB :unsigned int { Null = 0, King = 0, Pawn, Knight, Bishop, Rook, Queen, Enemy, Occupied = 14, Empty = 15 };
enum Color { Black, White = 7 };

Which variables are now members of your class "Position"? Those listed above as "static" (so they are now no longer static)?

yes :

Code: Select all

U64 GameRecord[512];
	U64 SBackup[MaxDepth][16];
	U64 CRBackup[MaxDepth][2];
	//use the Game record instead
	U64 PositionKeyBackUp[MaxDepth];
	U64 HalfMoveClockBackUp[MaxDepth];

	U64 BitBoards[16];
	U64 HalfMoveClock = 0ULL;
	U64 GameRecordCounter = 0ULL;
	U64 Positionkey = 0ULL;
	U64 CastleRights[2];

	unsigned int LastMoveDPushSQBackup[MaxDepth];
	Score PSQTScoreBackUp[MaxDepth];

	unsigned int DoublePushSQ[2] = { 0U,0U };
	Score PSQTScore;


	int ply = 0;
	BB TypeBoard[64 + MaxDepth];
	Color STM = White;

10-20% is nothing. You are just wasting your time. (Like I do all day)

they are something , and as I've already pointed in the post this is not my main concern.

They always told me that object oriented programming is not for free. Calling a virtual method is like dereferencing a pointer to a function. So if you want to code more efficiently use C instead of C++. No nonsense with virtual tables.

to achieve the same functionality they provide you'll have to pay a similar price regardless of the language you are using.