for performance, what's the best variable type to use for boolean _TRUE & _FALSE ?

[SMcNeill]

"Unclothed monkey buddy," LOL!  Well who knew I had to clean up a link based on a search term. Man, there's all kindza ways to mess up around here.   Duly noted...

Like most of my code:  Works perfectly; not as intended.  

[TempodiBasic]

@madscijr
about the citation of Steve
educative program showing SPEED QB64pe rules

thread from which it arises

[dakra137]

There are three factors here.

1. Quickest Load/Store at small scale
In QB64, loading or storing a

• 64 bit long type _INTEGER64 or Double takes the fewest CPU clock cycles on most processors.
  
• 1 bit type _BIT takes the most CPU clock cycles on some processors. That is due to extra instructions to calculate, mask and maybe shift to use and the instructions to calculate, load, mask, and save to store the value.
  

2. Maximum problem size that can be handled
A large array of type _BIT may fit in memory when an array with larger elements would not.

Code: (Select All)

_Define I-N As _INTEGER64

_Define A, C-H, O-Z As DOUBLE  ' 64 bit float

_Define B As _BIT  'Choice of:  _BIT, _BYTE, INTEGER, LONG, _INTEGER64  using  1, 8, 16, 32, or 64 bits



bFalse = 0

bTrue = Not bFalse



ksize = 2000000000

ReDim bitarray(ksize)

3. Cache Hits performance advantage
When the "working set" of executable code and data fit entirely in cache, the program runs quicker.
This may not matter for I/O bound programs, but certainly does for CPU bound programs.

1. If it all fits in L1 cache, astounding.
   
2. If it all fits in L1+L2 cache, wonderful.
   
3. If it all fits in L1+L2+L3 cache, excellent.
   

In my recent application, at all problem sizes above ksize=1000000, _BIT outperformed larger sized array elements.