panic: runtime error with 32 bits CPU Arquitectures

[dumacp]

Describe the bug

This code:

func (s *SliceMap) GetBucket(key string) cmap.ConcurrentMap {
	hash := murmur32.Sum32([]byte(key))
	index := int(hash) % len(s.LocalPIDs)

	return s.LocalPIDs[index]
}

in https://github.com/asynkron/protoactor-go/blob/dev/actor/process_registry.go

cuases a panic: runtime error: index out of range [-327] when the code is compiled for 32 bit architecture

To Reproduce

Run the next code in 32 bit arquitecture

package main

import (
        "time"

        "github.com/asynkron/protoactor-go/actor"
        "github.com/asynkron/protoactor-go/remote"
)

func main() {
        sys := actor.NewActorSystem()

        rconfig := remote.Configure("127.0.0.1", 8910)
        r := remote.NewRemote(sys, rconfig)
        r.Start()
        time.Sleep(30 * time.Second)
}

The instruction hash := murmur32.Sum32([]byte(key)) in the function func (s *SliceMap) GetBucket(key string) cmap.ConcurrentMap returns a uint32, the conversion int(hash) in 32 bit arquitecture could return a negative number, and a panic in s.LocalPIDs[index] when the index is negative.

panic: runtime error: index out of range [-327]

goroutine 1 [running]:
github.com/asynkron/protoactor-go/actor.(*SliceMap).GetBucket(0x149fbb0, {0x141a0f0, 0xa})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/process_registry.go:38 +0xd0
github.com/asynkron/protoactor-go/actor.(*ProcessRegistryValue).Add(0x1922000, {0x6dc6a8, 0x140e110}, {0x141a0f0, 0xa})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/process_registry.go:89 +0x30
github.com/asynkron/protoactor-go/actor.(*guardiansValue).newGuardian(0x1410040, {0x6da25c, 0xa5c8a0})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/guardian.go:39 +0x114
github.com/asynkron/protoactor-go/actor.(*guardiansValue).getGuardianPid(0x1410040, {0x6da25c, 0xa5c8a0})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/guardian.go:26 +0x8c
github.com/asynkron/protoactor-go/actor.(*RootContext).Self(0x19240f0)
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/root_context.go:81 +0x3c
github.com/asynkron/protoactor-go/actor.glob..func1(0x1480d50, {0x6122aa, 0x9}, 0x193c000, {0x6deb00, 0x19240f0})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/props.go:27 +0x28
github.com/asynkron/protoactor-go/actor.(*Props).spawn(0x193c000, 0x1480d50, {0x6122aa, 0x9}, {0x6deb00, 0x19240f0})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/props.go:144 +0x60
github.com/asynkron/protoactor-go/actor.(*RootContext).SpawnNamed(0x1924000, 0x193c000, {0x6122aa, 0x9})
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/actor/root_context.go:186 +0x134
github.com/asynkron/protoactor-go/remote.(*endpointManager).startActivator(0x1920920)
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/remote/endpoint_manager.go:128 +0xec
github.com/asynkron/protoactor-go/remote.(*endpointManager).start(0x1920920)
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/remote/endpoint_manager.go:85 +0xc4
github.com/asynkron/protoactor-go/remote.(*Remote).Start(0x1920900)
	/home/duma/go/pkg/mod/github.com/asynkron/protoactor-go@v0.0.0-20221002142108-880b460fcd1f/remote/server.go:79 +0x4f8
main.main()
	/tests/main_bugprotocator/main.go:15 +0x9c

Expected behavior
avoid conversion int32 from uint32 when the return is negative.

Additional context
The problem is in 32 bit Arquitecture because the built-in type int is a 32 bit data.

[ljluestc]

package main

import (
	"fmt"
	"log"

	"github.com/AsynkronIT/protoactor-go/actor"
	"github.com/AsynkronIT/protoactor-go/persistence"
	"github.com/goccy/go-reflect"
)

// Message represents an incoming message
type Message struct {
	Content string
}

// Response represents the actor's response
type Response struct {
	Reply string
}

// MyActor is the persistent actor
type MyActor struct {
	persistence.Mixin
	state string
}

func (a *MyActor) Receive(ctx actor.Context) {
	switch msg := ctx.Message().(type) {
	case *persistence.ReplayComplete:
		log.Println("Replay complete")
	case *Message:
		if !a.Recovering() {
			// Respond first to avoid dead letters
			ctx.Respond(&Response{Reply: fmt.Sprintf("Processed: %s", msg.Content)})
			// Persist after responding
			a.PersistReceive(msg)
			a.state = msg.Content
			if len(a.state)%10 == 0 {
				a.RequestSnapshot()
			}
		}
	case *persistence.Event:
		if eventMsg, ok := msg.Data.(*Message); ok {
			a.state = eventMsg.Content
			log.Printf("Recovered state: %s", a.state)
		}
	case *persistence.Snapshot:
		if snapshotState, ok := msg.Data.(string); ok {
			a.state = snapshotState
			log.Printf("Recovered snapshot: %s", a.state)
		}
	}
}

// Simple serializer using go-reflect
type CustomSerializer struct{}

func (s *CustomSerializer) FromBytes(data []byte, t *reflect.rtype) (interface{}, error) {
	v := reflect.New(t).Interface()
	// Simulate deserialization (in practice, use JSON or Protobuf)
	switch v := v.(type) {
	case *Message:
		v.Content = string(data)
		return v, nil
	}
	return nil, fmt.Errorf("unknown type")
}

func main() {
	system := actor.NewActorSystem()
	provider := persistence.NewInMemoryProvider()

	// Register type for serialization
	typeRegistry := map[string]*reflect.rtype{
		"Message": reflect.TypeOf(&Message{}),
	}

	props := actor.PropsFromProducer(func() actor.Actor {
		return &MyActor{state: "initial"}
	}, actor.WithReceiverMiddleware(persistence.Using(provider)))

	pid := system.Root.Spawn(props)

	// Test message
	response, err := system.Root.RequestFuture(pid, &Message{Content: "Hello"}, -1).Result()
	if err != nil {
		log.Fatalf("Failed to get response: %v", err)
	}
	if resp, ok := response.(*Response); ok {
		log.Printf("Received response: %s", resp.Reply)
	}

	// Simulate multiple messages
	for i := 0; i < 12; i++ {
		response, err = system.Root.RequestFuture(pid, &Message{Content: fmt.Sprintf("Message-%d", i)}, -1).Result()
		if err != nil {
			log.Printf("Error on message %d: %v", i, err)
		} else if resp, ok := response.(*Response); ok {
			log.Printf("Response for message %d: %s", i, resp.Reply)
		}
	}

	fmt.Scanln()
}