Computer Chess Club Archives


Search

Terms

Messages

Subject: Re: Ed's "indirect addressing"

Author: Matt Taylor

Date: 16:50:21 01/30/03

Go up one level in this thread


On January 29, 2003 at 23:29:36, Russell Reagan wrote:

>http://members.home.nl/matador/chess840.htm#INTRO
>
>From Ed's page...
>
>switch (piece_type) { case  0 : goto empty;
>                      case  1 : goto white_pawn;    // evaluate white pawn
>                      case  2 : goto white_knight;  // evaluate white knight
>                      case  3 : goto white_bishop;
>                      case  4 : goto white_rook;
>                      case  5 : goto white_queen;
>                      case  6 : goto white_king;
>                      case  7 : goto black_pawn;    // evaluate black pawn
>                      case  8 : goto black_knight;
>                      case  9 : goto black_bishop;
>                      case 10 : goto black_rook;
>                      case 11 : goto black_queen;
>                      case 12 : goto black_king; }
>
>
>On one portion of Ed's discussion of Rebel (see above), he talks about using
>"indirect addressing". I get the impression from Ed's words that this method is
>supposed to fast. I understand his discussion to mean that if you create a
>switch statement like he does, you create a jump table and avoid a bunch of
>conditionals.
>
>However, in past discussions, I recall hearing that using a function pointer is
>going to be at least as slow as conditional, so I asked someone, and was told
>that Ed's example should be no different than using a function pointer or
>virtual functions.
>
>Ed talks about this method as if it is a good thing to use. So what is the
>advantage of it? Either someone is mistaken, or Ed and the guy I talked to are
>talking about different things.

Most assembly programmers are used to using tricks like jump tables, and they
were extremely efficient on older processors because there was no branch
prediction. They are still extremely efficient when there are a lot of cases.
When computation is cheap, it is best to compute everything and then select the
correct result.

Sorting the order in which the pieces are processed helps in using function
pointers here. The jump table will incur minimal penalties if individual cases
are repeated so as to minimize the number of mispredicts.

Ed could improve the code by making color a parameter, too. This would minimize
the number of cases, and the transition from black pawn to white pawn may then
incur no penalty.

-Matt



This page took 0 seconds to execute

Last modified: Thu, 15 Apr 21 08:11:13 -0700

Current Computer Chess Club Forums at Talkchess. This site by Sean Mintz.