Re: sub-optimal code for packed boolean arrays -- bug or inherent limitation

[Adam Beneschan <adam@irvine.com>]

On Jul 2, 12:34 pm, Alinabi <alexander.the.aver...@gmail.com> wrote:


>     procedure Flip(B : in out Bitboard_T; I : in Index_T) is
>     begin
>         B(i) := not B(i);
>     end;

Just as an experiment, I wonder what the following does.  I realize
that this code isn't useful.

   procedure Sideways_Flip(B : in out Bitboard_T; I, J : in Index_T)
is
   begin
       B(i) := not B(j);
   end;

If the assembly code looks substantially the same as your example,
that's an indication that your compiler isn't recognizing that the
B(i) on the left and right sides of the assignment are the same.  (It
makes perfect sense to me that the compiler might be able to recognize
a simple variable that's the same on both sides, but not an indexed
variable.)  I don't know that this helps solve the problem, except to
indicate that most likely any other "solution" that has B(i) on both
sides of := isn't going to be any better.

Hmmm... it just occurred to me that if the compiler can figure out to
optimize simple names on both sides of := but not indexed variables,
maybe this will work:

   procedure Flip(B : in out Bitboard_T; I : Index_T) is
      The_Bit : Boolean renames B(I);
   begin
      The_Bit := not The_Bit;
   end;

It's worth a try.  Sometimes doing stuff like this is enough to
confuse a compiler into doing the right thing.

If nothing else works, here's a possible workaround, but be warned
that I haven't tried this:

   procedure Flip(B : in out Bitboard_T; I : in Index_T) is
      type Int_64 is mod 2**64;
      B_Overlay : Int_64;
      for B_Overlay'Address use B'Address;
   begin
      B_Overlay := B_Overlay xor 2**Integer(I);  --or
      B_Overlay := B_Overlay xor 2**Integer(63-I);
   end;

I don't know which of the xor's will work, or if either of them work;
it depends on how the elements of Bitboard_T are ordered.  The above
code is evil, and it's the kind of thing I'd do only out of
desperation---but at least the obfuscation in your program will be
limited to one place.

                   -- Adam