Repository: go
Issue: cmd/compile: complicated bounds check elimination
Labels: Performance,NeedsFix

**1. go version go1.7beta1 windows/amd64**

**2. 
set GOARCH=amd64**
set GOBIN=
set GOEXE=.exe
set GOHOSTARCH=amd64
**set GOHOSTOS=windows**
set GOOS=windows
set GOPATH=F:\Go\
set GORACE=
set GOROOT=F:\Go
set GOTOOLDIR=F:\Go\pkg\tool\windows_amd64
set CC=gcc
set GOGCCFLAGS=-m64 -mthreads -fmessage-length=0 -fdebug-prefix-map=C:\Users\Super\AppData\Local\Temp\go-build211527254=/tmp/go-build -gno-record-gcc-switches
set CXX=g++
set CGO_ENABLED=1

**3. Runnable program:**

``` go
// PrimeSpeed project PrimeSpeed.go
package main

import (
    "fmt"
    "math"
    "time"
    //    "unsafe"
)

func mkCLUT() [65536]byte {
    var arr [65536]byte
    for i := 0; i < 65536; i++ {
        var cnt byte = 0
        for v := (uint16)(i ^ 0xFFFF); v > 0; v &= v - 1 {
            cnt++
        }
        arr[i] = cnt
    }
    return arr
}

var cnstCLUT [65536]byte = mkCLUT()

func primesTest(top uint) int {
    lmtndx := (top - 3) >> 1
    lstw := lmtndx >> 5
    lmt := lstw + 1
    topsqrtndx := (int(math.Sqrt(float64(top))) - 3) >> 1
    cmpsts := make([]uint32, lstw+1)
    //    start := uintptr(unsafe.Pointer(&cmpsts[0]))
    //    step := unsafe.Sizeof(cmpsts[0])
    for i := 0; i <= topsqrtndx; i++ {
        if cmpsts[i>>5]&(uint32(1)<<uint(i)) == 0 {
            p := (uint(i) << 1) + 3
            for j := (p*p - 3) >> 1; j <= topi; j += p {
                cmpsts[j>>5] |= 1 << (j & 31)
            }
            //            p := uintptr((uint(i) << 1) + 3)
            //            lmt := uintptr(lmtndx)
            //            for j := (p*p - 3) >> 1; j <= lmt; j += p {
            //                *(*uint)(unsafe.Pointer(start + step*(j>>5))) |= 1 << (j & 31)
            //            }
        }
    }
    msk := uint32(0xFFFFFFFE) << (lmtndx & 31)
    cmpsts[lstw] |= msk
    cnt := 1
    for i := uint(0); i <= lstw; i++ {
        v := cmpsts[i]
        cnt += int(cnstCLUT[v&0xFFFF] + cnstCLUT[0xFFFF&(v>>16)])
    }
    return cnt
}

func main() {
    n := uint(262146)

    strt := time.Now()

    sum := 0
    for i := 0; i < 1000; i++ {
        sum += primesTest(n)
    }

    end := time.Now()

    fmt.Println("Found", sum, "primes up to", n, "in", end.Sub(strt), ".")
}
```

play.golang.org link:  https://play.golang.org/p/_E5R5JAlGW

**4. When "go tool compile -S PrimeSpeed.go > PrimeSpeed.s" is run**, the inner tight composite number culling loop as quoted below:

```
    line 36     for j := (p*p - 3) >> 1; j <= topi; j += p {
    line 37         cmpsts[j>>5] |= 1 << (j & 31)
    line 38     }
```

looks like the following assembly code from PrimeSpeed.s:

```
    0x00f1 00241 (Main.go:37)   MOVQ    R8, CX
    0x00f4 00244 (Main.go:37)   SHRQ    $5, R8
    0x00f8 00248 (Main.go:37)   CMPQ    R8, DX
    0x00fb 00251 (Main.go:37)   JCC $0, 454
    0x0101 00257 (Main.go:37)   MOVL    (AX)(R8*4), R10
    0x0105 00261 (Main.go:37)   MOVQ    CX, R11
    0x0108 00264 (Main.go:37)   ANDQ    $31, CX
    0x010c 00268 (Main.go:37)   MOVL    R9, R12 **;; saves 1 to r12**
    0x010f 00271 (Main.go:37)   SHLL    CX, R9
    0x0112 00274 (Main.go:37)   ORL R10, R9
    0x0115 00277 (Main.go:37)   MOVL    R9, (AX)(R8*4)
    0x0119 00281 (Main.go:36)   LEAQ    3(R11)(DI*2), R8
    0x011e 00286 (Main.go:37)   MOVL    R12, R9 **;; restores 1 to r9 from r12**
    0x0121 00289 (Main.go:36)   CMPQ    R8, BX
    0x0124 00292 (Main.go:36)   JLS $0, 241
```

**5. I expected to see**:

```
    0x00f1 00241 (Main.go:37)   MOVQ    R8, CX
    0x00f4 00244 (Main.go:37)   SHRQ    $5, R8
    0x00f8 00248 (Main.go:37)   CMPQ    R8, DX ;; array bounds check, only if no -B option
    0x00fb 00251 (Main.go:37)   JCC $0, 454 ;; panic if out of bounds
    0x0101 00257 (Main.go:37)   MOVL    (AX)(R8*4), R10
    0x0105 00261 (Main.go:37)   MOVQ    CX, R11
    0x0108 00264 (Main.go:37)   ANDQ    $31, CX
                            (Main.go:37)    MOVL    $1,R9 **;; IMMEDIATE LOAD OF 1 to R9**
                            (Main.go:37)    SHLL    CX, R9
                            (Main.go:37)    ORL R10, R9
                            (Main.go:37)    MOVL    R9, (AX)(R8*4)
                            (Main.go:36)    LEAQ    3(R11)(DI*2), R8
                            (Main.go:36)    CMPQ    R8, BX
                            (Main.go:36)    JLS $0, 241
```

Even better, without recalculating p = 2 \* i + 3 thus j += j + 2 \* i + 3 inside the inner loop:
Includes changing order of instructions for processors without OOE:

```
    0x00f1 00241 (Main.go:37)   MOVQ    R8, R11
    0x0105 00261 (Main.go:37)   MOVQ    R8, CX
    0x00f4 00244 (Main.go:37)   SHRQ    $5, R11
    0x0108 00264 (Main.go:37)   ANDQ    $31, CX
    0x00f8 00248 (Main.go:37)   CMPQ    R11, DX ;; array bounds check, only if no -B option
    0x00fb 00251 (Main.go:37)   JCC $0, 454 ;; panic if out of bounds
    0x0101 00257 (Main.go:37)   MOVL    (AX)(R11*4), R10
    0x010c 00268 (Main.go:37)   MOVL    $1,R9 **;; IMMEDIATE LOAD OF 1 to R9**
    0x010f 00271 (Main.go:37)   SHLL    CX, R9
    0x0112 00274 (Main.go:37)   ORL R10, R9
    0x0119 00281 (Main.go:36)   ADDL    R12, R8 **;; ADD PRE-CALCULATED 'p' in R12 to 'j'**
    0x0115 00277 (Main.go:37)   MOVL    R9, (AX)(R11*4)
    0x0121 00289 (Main.go:36)   CMPQ    R8, BX
    0x0124 00292 (Main.go:36)   JLS $0, 241
```

The following is the same loop without bounds checks generated for C/C++ with the Visual Studio compiler (intel assembler format):

```
    $Loop:
        mov edx, esi
        mov ecx, esi
        shr edx, 5
        and ecx, 31                 ; 0000001fH
        mov eax, 1
        add esi, edi                    ; add 'p' in edi to 'j'
        shl eax, cl
        or  DWORD PTR [ebx+edx*4], eax
        cmp esi, ebp                    ; ebp contains 'topi'
        jbe SHORT $Loop
```

Note that the above uses a total of seven registers for this inner loop, so the same code is generated for x86 and x64 compilations.  Unfortunately, it takes another register to hold the upper array bound for a range check and the x86 architecture can only have seven available; however, it is possible to slightly change the code as follows:

```
    line 36            bnds := lstw + 1
    line 37            k := (p*p - 3) >> 1
    line 38            for j, w := j, j >> 5; w <= bnds; w = r >> 5 {
    line 39                cmpsts[w] |= 1 << (j & 31)
    line 40                j += p
    line 41            }
```

which for Visual Studio C/C++ generates the following same number of instructions in the loop:

```
    $Loop:
        mov ecx, edx
        mov eax, 1
        and ecx, 31                 ; 0000001fH
        add edx, edi                    ; add 'p' in edi to 'j'
        shl eax, cl
        or  DWORD PTR [ebx+esi*4], eax
    **$Start:**
        mov esi, edx
        shr esi, 5
        cmp esi, ebp                    **; ebp contains the array length, bnds**
        jb  SHORT $Loop             **; this is the same as doing an array bounds check**
```

and it can be seen that the array bounds check is now done at the same time as the loop completion check; it should be a simple matter to clue the compiler that 'bnds' contains the array length, perhaps by assigning it inside the loop as len(cmpsts) as is done for C# x86 code so that it recognizes that the bounds check is already done.  The start point of the loop could be the line after the "or" line at the **$Start**: label or an external check could be implemented to ensure that the bounds check is done for the first loop before the array is accessed as is done for the Visual Studio C/C++ compiler.

As demonstrated above, the golang code runs slower than C/C++ code by almost a factor of two on some x86 processors and more than that factor for x86 processors.  It also runs slightly slower than C#/Java for both architectures.