Apple M1 sum64 throw panic: runtime error: slice bounds out of range error

[maxid]

panic: runtime error: slice bounds out of range [::41] with capacity 9

goroutine 1 [running]: github.com/cespare/xxhash/v2.Sum64({0x14014c9ecc0, 0x29, 0x9}) .../vendor/github.com/cespare/xxhash/v2/xxhash_other.go:22 +0x6c4

[cespare]

Can you please show runnable code that demonstrates the problem? Thanks.

[maxid]

Can you please show runnable code that demonstrates the problem? Thanks.

package main

import (
    "context"
    "fmt"
    "time"
    "unsafe"

    "github.com/buraksezer/olric"
    "github.com/buraksezer/olric/config"
    "github.com/cespare/xxhash/v2"
)

type xxhasher struct {
}

func (xh xxhasher) Sum64(key []byte) uint64 {
    fmt.Println(fmt.Sprintf("key %s, length: %d", string(key), len(key)))
    return xxhash.Sum64(key) // replace to xxhash.Sum64([]byte(string(key))) can fixed this problem
}

var _dm olric.DMap

func main() {
    // in this case key length >= 32 always test pass
    tmp := "test-cluster-dmap" + "lock.xxx-xxxxx-xxxx-xxx"
    fmt.Println(fmt.Sprintf("key length: %d", len(tmp)))
    fmt.Println(xxhash.Sum64(*(*[]byte)(unsafe.Pointer(&tmp))))

    // but this case some time test failure
    initOlric()
    testDLock("xxx-xxxxx")          // key length < 32, test pass
    testDLock("xxx-xxxxx-xxxx-xxx") // key length >= 32, test failure
}

func initOlric() {
    ctx, cancel := context.WithCancel(context.Background())
    var db *olric.Olric
    c := config.New("local")
    c.Hasher = xxhasher{}
    c.Started = func() {
        defer cancel()
        fmt.Println("olric cluster is ready to accept connections")
    }

    db, err := olric.New(c)
    if err != nil {
        fmt.Println(fmt.Sprintf("Failed to create olric cluster instance: %v", err))
    }
    go func() {
        err = db.Start()
        if err != nil {
            fmt.Println(fmt.Sprintf("olric cluster Start returned an error: %v", err))
        }
    }()

    <-ctx.Done()

    if db != nil {
        embeddedClient := db.NewEmbeddedClient()
        if dm, err := embeddedClient.NewDMap(fmt.Sprintf("%s-cluster-dmap", "test")); err == nil {
            _dm = dm
        }
    }
}

func testDLock(key string) {
    if _dm != nil {
        ctx := context.Background()
        if lock, err := _dm.Lock(ctx, fmt.Sprintf("lock.%s", key), time.Second*5); err == nil {
            _ = lock.Unlock(ctx) // <--- failure
        }
    }
}

2024/03/19 10:26:10 [INFO] Routing table has been pushed by 127.0.0.1:3320 => operations.go:86
2024/03/19 10:26:10 [INFO] The cluster coordinator has been bootstrapped => discovery.go:42
2024/03/19 10:26:10 [INFO] Memberlist bindAddr: 127.0.0.1, bindPort: 3322 => routingtable.go:413
2024/03/19 10:26:10 [INFO] Cluster coordinator: 127.0.0.1:3320 => routingtable.go:414
2024/03/19 10:26:10 [INFO] Node name in the cluster: 127.0.0.1:3320 => olric.go:380
2024/03/19 10:26:10 [INFO] Olric bindAddr: 127.0.0.1, bindPort: 3320 => olric.go:386
2024/03/19 10:26:10 [INFO] Replication count is 1 => olric.go:388
olric cluster is ready to accept connections
key test-cluster-dmaplock.xxx-xxxxx, length: 31
key test-cluster-dmaplock.xxx-xxxxx, length: 31
key test-cluster-dmaplock.xxx-xxxxx, length: 31
key test-cluster-dmaplock.xxx-xxxxx, length: 31
key test-cluster-dmaplock.xxx-xxxxx, length: 31
key test-cluster-dmaplock.xxx-xxxxx-xxxx-xxx, length: 40
panic: runtime error: slice bounds out of range [::40] with capacity 0

goroutine 1 [running]:
github.com/cespare/xxhash/v2.Sum64({0x140000ce2d0, 0x28, 0x0})
        .../vendor/github.com/cespare/xxhash/v2/xxhash_other.go:22 +0x6c4
main.xxhasher.Sum64({}, {0x140000ce2d0, 0x28, 0x0})
        .../main.go:19 +0x1b8
github.com/buraksezer/olric/internal/cluster/partitions.HKey({0x140004ea000, 0x11}, {0x140004ea030, 0x17})
        .../vendor/github.com/buraksezer/olric/internal/cluster/partitions/hkey.go:37 +0x8c
github.com/buraksezer/olric/internal/dmap.(*DMap).put(0x140004ec000, 0x140004f0100)
        .../vendor/github.com/buraksezer/olric/internal/dmap/put.go:363 +0x68
github.com/buraksezer/olric/internal/dmap.(*DMap).tryLock(0x140004ec000, 0x140004f0100, 0x12a05f200)
        .../vendor/github.com/buraksezer/olric/internal/dmap/lock.go:94 +0x3c
github.com/buraksezer/olric/internal/dmap.(*DMap).Lock(0x140004ec000, {0x104ff5b10, 0x10544ce20}, {0x140004ea030, 0x17}, 0x0, 0x12a05f200)
        .../vendor/github.com/buraksezer/olric/internal/dmap/lock.go:157 +0x264
github.com/buraksezer/olric.(*EmbeddedDMap).Lock(0x14000126000, {0x104ff5b10, 0x10544ce20}, {0x140004ea030, 0x17}, 0x12a05f200)
        .../vendor/github.com/buraksezer/olric/embedded_client.go:167 +0x78
main.testDLock({0x104e27713, 0x12})
        .../main.go:70 +0x11c
main.main()
        .../main.go:33 +0x210
Exiting.

Debugger finished with the exit code 0

[cespare]

Can you make a simpler reproducer without the other packages? I suspect there is a bug in your code. At a glance, my best guess is that you have a data race on the slice you're passing to Sum64 (you can run with -race to check). But I'd want a simpler repro case before I do more debugging.

[maxid]

Can you make a simpler reproducer without the other packages? I suspect there is a bug in your code. At a glance, my best guess is that you have a data race on the slice you're passing to Sum64 (you can run with -race to check). But I'd want a simpler repro case before I do more debugging.

You are right！Thanks!

// xxhash.go:211 maybe binary.LittleEndian.Uint64(b) have a data race ?
func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) }