Race-detector does not know Probe.Detach works under world stopped and
that this way it cannot break consistency of probes list attached to a
trace event - on event signalling either a probe will be run or not run
at all.

And we do not mind that e.g. while Detach was in progress a probe was
was read from traceevent list and deceded to be run and the probe
function was actually called just after Detach finished.

For this reason tell race-detector to not take into account all memory
read/write that are performed while the world is stopped.

If we do not it complains e.g. this way:

    ==================
    WARNING: DATA RACE
    Read at 0x00c42000d760 by goroutine 7:
      lab.nexedi.com/kirr/neo/go/zodb/storage._traceCacheGCFinish_run()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/xcommon/tracing/tracing.go:265 +0x81
      lab.nexedi.com/kirr/neo/go/zodb/storage.traceCacheGCFinish()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/ztrace.go:22 +0x63
      lab.nexedi.com/kirr/neo/go/zodb/storage.(*Cache).gc()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/cache.go:497 +0x62c
      lab.nexedi.com/kirr/neo/go/zodb/storage.(*Cache).gcmain()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/cache.go:478 +0x4c

    Previous write at 0x00c42000d760 by goroutine 6:
      lab.nexedi.com/kirr/neo/go/xcommon/tracing.(*Probe).Detach()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/xcommon/tracing/tracing.go:319 +0x103
      lab.nexedi.com/kirr/neo/go/xcommon/tracing.(*ProbeGroup).Done()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/xcommon/tracing/tracing.go:344 +0xa5
      lab.nexedi.com/kirr/neo/go/zodb/storage.TestCache()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/cache_test.go:576 +0x7f94
      testing.tRunner()
          /home/kirr/src/tools/go/go/src/testing/testing.go:746 +0x16c

    Goroutine 7 (running) created at:
      lab.nexedi.com/kirr/neo/go/zodb/storage.NewCache()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/cache.go:129 +0x227
      lab.nexedi.com/kirr/neo/go/zodb/storage.TestCache()
          /home/kirr/src/neo/src/lab.nexedi.com/kirr/neo/go/zodb/storage/cache_test.go:165 +0x7b1
      testing.tRunner()
          /home/kirr/src/tools/go/go/src/testing/testing.go:746 +0x16c

    Goroutine 6 (finished) created at:
      testing.(*T).Run()
          /home/kirr/src/tools/go/go/src/testing/testing.go:789 +0x568
      testing.runTests.func1()
          /home/kirr/src/tools/go/go/src/testing/testing.go:1004 +0xa7
      testing.tRunner()
          /home/kirr/src/tools/go/go/src/testing/testing.go:746 +0x16c
      testing.runTests()
          /home/kirr/src/tools/go/go/src/testing/testing.go:1002 +0x521
      testing.(*M).Run()
          /home/kirr/src/tools/go/go/src/testing/testing.go:921 +0x206
      main.main()
          lab.nexedi.com/kirr/neo/go/zodb/storage/_test/_testmain.go:44 +0x1d3
    ==================

Max < 3x (nprefetch=8) in go-go case.

improves max 2x becase probably of go scheduler.

Compared to no C-states disabled (but RX delay = 0 as before) it improves:

ping56            36μs  ->    33μs
ping1472        ~150μs  ->  ~107μs

TCP1             ~65μs  ->   ~45μs
TCP1472     ~440-515μs  ->  ~420μs    (still very bad)
TCP4096         ~370μs  ->  ~280μs    (still bad)

ZEO:            ~900μs  ->  ~670μs
NEO/pylite:    ~1050μs  ->  ~600μs    (Cpy)
NEO/pylite:     ~800μs  ->  ~505μs    (Cgo)
NEO/pysql:     ~1700μs  ->  ~900μs    (Cpy)
NEO/pysql:     ~1300μs  ->  ~790μs    (Cgo)
NEO/go:         ~730μs  ->  ~430μs    (Cpy)
NEO/go:         ~370μs  ->  ~210μs    (Cgo)
NEO/go-nosha1:  ~280μs  ->  ~190μs

Raw TCP timings are still bad.

It improves:

ZEO:             ~500μs ->  ~470μs
NEO/pylite:      ~640μs ->  ~460μs      (Cpy)
NEO/pylite:      ~415μs ->  ~350μs      (Cgo)
NEO/pysql:      ~1300μs ->  ~790μs      (Cpy)
NEO/pysql:       ~850μs ->  ~650μs      (Cgo)
NEO/go:          ~350μs ->  ~275μs      (Cpy)
NEO/go:           ~78μs ->   ~78μs      (Cgo)
NEO/go-nosha1:    ~45μs ->   ~45μs

Same as on oct4 - we just add C-states profiling. In particular TCP1472 and TCP4096 are awful.
C-states are not yet disabled.

Same as oct04 - we just add C-states profiling. C-states are not yet disabled.

Compared to just C-states disabled it improves:

ping56           ~76μs  ->   ~40μs
ping1472        ~150μs  ->  ~120μs

TCP1             ~90μs  ->   ~50μs
TCP1472         ~180μs  ->  ~145μs
TCP4096      ~220-230μs ->  ~175μs

ZEO:            ~660μs  ->  ~660μs
NEO/pylite:     ~630μs  ->  ~575μs    (Cpy)
NEO/pylite:     ~505μs  ->  ~460μs    (Cgo)
NEO/pysql:      ~930μs  ->  ~880μs    (Cpy)
NEO/pysql:      ~810μs  ->  ~750μs    (Cgo)
NEO/go:         ~430μs  ->  ~380μs    (Cpy)
NEO/go:         ~215μs  ->  ~170μs    (Cgo)
NEO/go-nosha1:  ~195μs  ->  ~150μs

It improves:

ping56          ~
ping1472        ~

TCP1             ~92μs  ->  ~89μs       (c -> c)
TCP1            ~120μs  ->  ~91μs       (c -> go)
TCP1            ~120μs  ->  ~90μs       (c <- c)
TCP1            ~120μs  ->  ~90μs       (go <- c)

TCP1472         ~220-250μs  -> ~180μs
TCP4096         ~270-300μs  -> ~220-230μs

ZEO:             ~750μs ->  ~660μs
NEO/pylite:      ~850μs ->  ~630μs      (Cpy)
NEO/pylite:      ~640μs ->  ~505μs      (Cgo)
NEO/pysql:      ~1500μs ->  ~930μs      (Cpy)
NEO/pysql:      ~1350μs ->  ~810μs      (Cgo)
NEO/go:          ~600μs ->  ~430μs      (Cpy)
NEO/go:          ~320μs ->  ~215μs      (Cgo)
NEO/go-nosha1:   ~260μs ->  ~195μs

It improves a lot:

ZEO:             ~660μs ->  ~490μs
NEO/pylite:      ~750μs ->  ~470μs      (Cpy)
NEO/pylite:      ~500μs ->  ~370μs      (Cgo)
NEO/pysql:      ~1450μs ->  ~780μs      (Cpy)
NEO/pysql:      ~1000μs ->  ~670μs      (Cgo)
NEO/go:          ~450μs ->  ~280μs      (Cpy)
NEO/go:           ~90μs ->   ~80μs      (Cgo)
NEO/go-nosha1:    ~60μs ->   ~55μs

Same as on oct04 but now we add C-states profile. C-states are not yet disabled.

~ the same as on oct04 only we add C-states profiling. C-states are not yet disabled.

py timings improve a bit - ~15-20μs per python part (i.e. ~30-40μs if
both client and server is in python).

go-go timings stays ~ the same.

Timings are ~same as on sep17 but now a lot more info about system is
added + C-stats profile. C-states are not yet disabled.

Like info-local but about any remote deployment.

Numbers stays the same; we just added more diagnostic to log.

for ZEO and NEO/py the time over network is ~ the same as the time over just IPC on z6001 !
for Go network makes it visible slower.

Probably C-states play a big role above.

Seems to be similar to localhost on z6001 and is a bit _faster_ for cases where
ther is interprocesses communication.

This is explained by the fact that intel_idle tend not to go to deeper sleep
states whenever system loadavg increases.

Seems to be similar to localhost on neo1.