Loop unrolling optimization

[nt314p]

Hi,

I've been messing around with methods to increase shift out speed (possibly to under 10 us per byte).

One suggestion I have to increase performance is to manually unroll loops within write functions, since the number of iterations (8, 16, 24, etc.) is known at compile time.

This will increase sketch size, so perhaps options to use unrolled function versions could be provided through alternative functions (like writeMSBFIRSTU where U indicates unrolled) or a #define #ifdef for USE_UNROLLED. 🤷

-NT

[RobTillaart]

Thanks for sharing this idea.
As I am rather busy, it will take time before I will dive into it..
Did you make measurements of the gain / size ?

A define sounds good, would allow to set it from commandline too.

[nt314p]

No worries, I am busy as well and probably will only get around to testing it on hardware in a month.

Certainly though, unrolling should remove the jump instructions needed for the loop and give some performance benefit.

--

Unrelated, but I was wondering what the purpose is of the status register manipulation and noInterrupts() call?

// inner for loop of FastShiftOut::writeLSBFIRST
  for (uint8_t m = 1; m > 0; m <<= 1)
  {
    uint8_t oldSREG = SREG; // <-
    noInterrupts(); // <-
    if ((value & m) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;
    SREG = oldSREG; // <-
  }

[RobTillaart]

The noInterrupts() prevents that interrupts are run. The interrupt flag is part of the SREG (Status Register).
SREG = oldSREG resets all status flags to point before noInterrupts() is called.

Imagine that an IRQ uses the data and/or clock register in the loop.
e.g *_dataOutRegister &= outmask2; is in pseudo machine code.

1 LOAD  _dataOutRegister INTO CPUREGISTER
2 AND CPUREGISTER outmask2
3 STORE CPUREGISTER INTO _dataOutRegister 

That could corrupt the content of the dataRegister if the IRQ would happen between step 2 and 3 in the above code.

---

Note:
The nointerrupts should be out of the loop as it would make the loop more predictable with respect to the arrival time of the individual bits. Could be important, even critical, depending on the receiving end.

[RobTillaart]

Reference timing of the current 0.3.3 version:

IDE: 1.8.19
Board: UNO

FastShiftOut_test.ino
FASTSHIFTOUT_LIB_VERSION: 0.3.3

Performance - time in us
        write: 23.51
        write: 45.78
        Delta: 22.27

writeLSBFIRST: 22.51
writeLSBFIRST: 45.77
        Delta: 23.26

writeMSBFIRST: 23.02
writeMSBFIRST: 44.77
        Delta: 21.75

Standard shiftOut1: 89.85
Standard shiftOut2: 179.44
             Delta: 89.60


Test print interface
println("Hello world"): 	328.92
println(1357): 			311.68
println(3.14159265, 4): 	716.04

done ...

[RobTillaart]

Not correct test, see below

Quick test:

Moving the noInterrupts() out of the loop improves from 21.75 us => 19.11 us (~10%)

writeMSBFIRST: 23.02
writeMSBFIRST: 42.13
        Delta: 19.11

IDE: 1.8.19
Board UNO

Sketch uses 6544 bytes (20%) of program storage space. Maximum is 32256 bytes.
Global variables use 609 bytes (29%) of dynamic memory, leaving 1439 bytes for local variables. Maximum is 2048 bytes.

[RobTillaart]

Not correct test, see below

Quick test

Unrolling the loop and replacing m by constants improves from 19.11 us ==> 11.94 (~38%)

writeMSBFIRST: 23.02
writeMSBFIRST: 34.96
        Delta: 11.94

  uint8_t oldSREG = SREG;
  noInterrupts();

    if ((value & 0x80) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x40) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x20) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x10) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x08) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x04) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x02) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;

    if ((value & 0x01) == 0) *_dataOutRegister &= outmask2;
    else                  *_dataOutRegister |= outmask1;
    *_clockRegister |= cbmask1;
    *_clockRegister &= cbmask2;


  SREG = oldSREG;

IDE: 1.8.19
Board UNO

Sketch uses 6792 bytes (21%) of program storage space. Maximum is 32256 bytes.
Global variables use 609 bytes (29%) of dynamic memory, leaving 1439 bytes for local variables. Maximum is 2048 bytes.

uses 250 bytes more PROGMEM,
NOTE only patched the MSB code to do the test, so it would add twice this amount of PROGMEM.

[RobTillaart]

Not correct test, see below

Quick test

replacing &= by = and |= by = for all masking, improves from 11.94 us ==> 4.65 (~60%)
Improvement from reference 21.75 ==> 4.65 is almost 80% (factor 4.6)

writeMSBFIRST: 23.02
writeMSBFIRST: 27.67
        Delta: 4.65

  uint8_t oldSREG = SREG;
  noInterrupts();
  
  uint8_t cbmask1  = *_clockRegister | _clockBit;
  uint8_t cbmask2  = *_clockRegister & ~_clockBit;
  uint8_t outmask1 = *_dataOutRegister | _dataOutBit;
  uint8_t outmask2 = *_dataOutRegister & ~_dataOutBit;

    if ((value & 0x80) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x40) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x20) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x10) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x08) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x04) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x02) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;

    if ((value & 0x01) == 0) *_dataOutRegister = outmask2;
    else                  *_dataOutRegister = outmask1;
    *_clockRegister = cbmask1;
    *_clockRegister = cbmask2;


  SREG = oldSREG;

IDE: 1.8.19
Board UNO

Sketch uses 6708 bytes (20%) of program storage space. Maximum is 32256 bytes.
Global variables use 609 bytes (29%) of dynamic memory, leaving 1439 bytes for local variables. Maximum is 2048 bytes.

roughly 150 bytes more PROGMEM
NOTE only patched the MSB code to do the test, so it would add twice this amount of PROGMEM.

[RobTillaart]

@nt314p

Warning: tests above need to be verified, they are just quick tests and may have bugs.

Test program was incorrect, code part looks OK

---

OK, trading RAM for speed makes a call roughly 4.5 times faster which is more than expected.
4.65 us means the average bit is send in 4.65 / 8 in 0.6 us (is about 1.6 megabit/second)

Note that the duration of a pulse on the clock or data line is even less.
Needs to be checked with hardware (scope) to verify if the pulses are still "square" enough.

This code needs some serious warning in the documentation.

to be continued

[RobTillaart]

Quick test of the print interface improvement (which has far more overhead)

Test print interface
println("Hello world"): 	218.64
println(1357): 			260.68
println(3.14159265, 4): 	648.12

where the 0.3.3 scored

Test print interface
println("Hello world"): 	328.92
println(1357): 			311.68
println(3.14159265, 4): 	716.04

roughly about 9 us gained per character send?

As said before, code need to be verified.
Furthermore gain for LSB and MSB might differ a bit.

Todo test gain for write16, write24 and write32 ==> add to example

[RobTillaart]

Quick test for write16/24/32

Reference 0.3.3

      write16: 45.84
      write16: 91.42
        Delta: 45.58

      write24: 68.09
      write24: 135.93
        Delta: 67.84

      write32: 90.35
      write32: 180.45
        Delta: 90.10

optimized

      write16: 28.74
      write16: 57.22
        Delta: 28.48

      write24: 42.44
      write24: 84.63
        Delta: 42.19

      write32: 56.15
      write32: 112.04
        Delta: 55.90

Still a ~37% improvement.
Writing e.g. a dedicated write32() without function call overhead would be even be faster (would use quite some RAM)

To be contiued.

[RobTillaart]

@nt314p
Ooops!, Found bugs in the test program, so the above results are not correct and will be less significant.
Need to rerun tests.

Size indication and code snippets seems OK.

[RobTillaart]

New reference 0.3.3

FastShiftOut_test.ino
FASTSHIFTOUT_LIB_VERSION: 0.3.3

Performance - time in us
        write: 23.51
        write: 45.78
        Delta: 22.27

writeLSBFIRST: 22.51
writeLSBFIRST: 44.76
        Delta: 22.25

writeMSBFIRST: 22.51
writeMSBFIRST: 44.77
        Delta: 22.26

Standard shiftOut1: 89.85
Standard shiftOut2: 179.44
             Delta: 89.59

      write16: 45.65
      write16: 91.04
        Delta: 45.39

      write24: 67.90
      write24: 135.56
        Delta: 67.66

      write32: 90.16
      write32: 180.07
        Delta: 89.91

Test print interface
println("Hello world"): 	328.92
println(1357): 			311.60
println(3.14159265, 4): 	716.04

[RobTillaart]

New optimized writeMSBFIRST:

FSO object configured as MSBFIRST

Performance - time in us
        write: 15.02
        write: 28.80
        Delta: 13.78

writeLSBFIRST: 22.51
writeLSBFIRST: 44.77
        Delta: 22.26

writeMSBFIRST: 13.96
writeMSBFIRST: 27.67
        Delta: 13.70

Standard shiftOut1: 89.85
Standard shiftOut2: 179.44
             Delta: 89.59

      write16: 28.74
      write16: 57.21
        Delta: 28.48

      write24: 42.44
      write24: 84.62
        Delta: 42.18

      write32: 56.15
      write32: 112.04
        Delta: 55.89


Test print interface
println("Hello world"): 	218.56
println(1357): 			260.72
println(3.14159265, 4): 	648.16

Gain writeMSBFIRST is from 22.26 us ==> 13.70 us (~38%) Still interesting.