github.com/xtaci/gaio

The previous implementation incorrectly extracted the type pointer (first word)
from Go interfaces instead of the data pointer (second word). Since all
*net.TCPConn share the same type pointer, this caused:

1. All connections to be identified by the same pointer value
2. Only the first connection to be properly registered in the watcher
3. Finalizers not being set correctly for subsequent connections
4. GC-based cleanup to fail (only 1 connection cleaned up instead of all)

Root cause:
Go interfaces are laid out as [type_ptr, data_ptr] (two machine words).
The old code: ptr := *(*uintptr)(unsafe.Pointer(&conn))
only retrieved the type pointer, which is identical for all *net.TCPConn.

Fix:
Changed to extract the second word (data pointer) which uniquely identifies
each connection instance:

    iface := ([2]uintptr)(unsafe.Pointer(&conn))
    ptr := iface[1] // data pointer

Affected functions:

• aioCreate(): connection registration and finalizer setup
• handleGC(): garbage collection callback handling

Also includes:

• Modernize codebase for Go 1.21+ (interface{} → any, clear() builtin)
• Use sync.Pool inline initialization
• Improve mutex handling with defer patterns
• Enhanced TestGC with 200 connections (requires ≥100 successful GC)

All tests pass with race detector enabled.

• Add pre-allocated results slice to watcher struct to reuse across
  WaitIO calls, reducing GC pressure in high-throughput scenarios
• Replace reflect.ValueOf().Pointer() with unsafe pointer extraction
  in aioCreate() and handleGC() for faster pointer retrieval
• Remove reflect package import as it's no longer needed

Benchmark results (BenchmarkEcho1K):
Before: 478 B/op, 4 allocs/op
After: 0 B/op, 0 allocs/op

Memory profile shows WaitIO allocation dropped from 60.51MB to 0MB,
which is critical for C10K+ concurrent connection scenarios.

Bug fixes:

• Fix eventfd error handling: return actual syscall error instead of nil
• Fix rawRead/rawWrite return value handling on error (-1 case)
• Fix timer initialization: stop immediately after creation to avoid spurious timeout
• Fix timeout heap cleanup: properly remove entries in deliver()

Performance optimizations:

• Pre-allocate maps (descs, connIdents) with initial capacity for C10K scenarios
• Pre-allocate slices (pendingCreate, pendingProcessing, recycles, eventSet)
• Add fdDescPool to reuse fdDesc objects and reduce allocations
• Optimize handleEvents: use index-based loop and early length check
• Optimize reflect usage: remove redundant TypeOf() call in aioCreate
• Pre-allocate kqueue changes slice on BSD

Fix: whenever a request is pushed onto w.timeouts, compare it with th…

use channel to notify buffer swap to create a full memory barrier, wh…

same with previous commit

to prevent allocation of the same address for net.Conn