josharian ( Josh Bleecher Snyder )

cmd/compile: optimize comparisons to min/max (u)ints by checking for overflow

package p

import "math"

func f(x int64) bool {
	return x == math.MinInt64
}

On amd64, the core of this compiles to:

	0x0005 00005 (z.go:6)	MOVQ	$-9223372036854775808, CX
	0x000f 00015 (z.go:6)	CMPQ	AX, CX
	0x0012 00018 (z.go:6)	SETEQ	"".~r1+16(SP)

It would be cheaper and smaller instead to decrement CX and check the flags for underflow. A similar trick can be used for checking min and max ints and uints of all sizes. It might also be useful in the division fix-up code, where we must check for min int divisor.

cc @randall77 @dr2chase @martisch @mundaym

created time in 16 hours

issue openedgolang/go

cmd/compile: missed opportunity to coalesce reads/writes

package p

import "encoding/binary"

func f(b []byte, x *[8]byte) {
	_ = b[8]
	t := binary.LittleEndian.Uint64(x[:])
	binary.LittleEndian.PutUint64(b, t)
}

This should compile down to two MOVQs on amd64, one to load from x and one to write to b.

Instead, it compiles to a series of smaller MOVxs. The coalescing rules may need more cases added.

cc @randall77 @dr2chase @martisch

created time in 17 hours

issue openedgolang/go

cmd/compile: missed opportunity to inline runtime.memmove

package p

func f(b []byte, x *[8]byte) {
	_ = b[8]
	copy(b, x[:])
}

This should compile down to a pair of MOVQs, one to load from x and one to write to b. It doesn't; it still contains a call to runtime.memmove. From a quick glance at ssa.html, the problem is that the lowering of runtime.memmove to Move happens during generic.rules, but we haven't detected that the size of the memmove is a constant until after lowering.

To fix this, we could either improve the analysis in the generic stages or add arch-specific runtime.memmove-to-Move lowering.

cc @randall77 @dr2chase @martisch

created time in 17 hours

PR opened btcsuite/btcutil

allocate less in Encode

+7 -8

2 commit in josharian/btcutil/tree/encode-allocate-less btcsuite/btcutil/tree/master

0 comment

2 changed files

pr created time in 3 days

create barnchjosharian/btcutil

branch : encode-allocate-less

created branch time in 3 days

fork josharian/btcutil

Provides bitcoin-specific convenience functions and types

btcsuite/btcutil josharian/btcutil

fork in 3 days

pull request commenttailscale/tailscale

WIP: tstime: add an abstract Time interface, which can be real or virtual.

I'm on the fence about this. I like the idea of having a more complete mockery of time, and I see its utility. But the existing implementation makes me a bit nervous, per the comment above.

I haven't done a full review of the code yet; I will do so (if appropriate) once conversation about monotonic time and cross-tstime.Time safety has settled.

danderson

comment created time in 3 days

PullRequestReviewEvent

Pull request review commenttailscale/tailscale

WIP: tstime: add an abstract Time interface, which can be real or virtual.

 package tstime  import (-	"errors"-	"fmt"-	"strings"-	"sync"+	"context"+	"math/bits"+	"sync/atomic" 	"time" ) -// zoneOf returns the RFC3339 zone suffix (either "Z" or like-// "+08:30"), or the empty string if it's invalid or not something we-// want to cache.-func zoneOf(s string) string {-	if strings.HasSuffix(s, "Z") {-		return "Z"-	}-	if len(s) < len("2020-04-05T15:56:00+08:00") {-		// Too short, invalid? Let time.Parse fail on it.-		return ""-	}-	zone := s[len(s)-len("+08:00"):]-	if c := zone[0]; c == '+' || c == '-' {-		min := zone[len("+08:"):]-		switch min {-		case "00", "15", "30":-			return zone-		}-	}-	return ""+// Time is an interface to all things that deal with the current time,+// and the passage of time. It's meant to be used as a replacement for+// the functions of the same name in the `time` and `context`+// packages, so that different implementations of time can be swapped+// in.+type Time interface {+	// After is like time.After.+	After(time.Duration) <-chan time.Time+	// Sleep is like time.Sleep.+	Sleep(time.Duration)++	// Since is like time.Since.+	Since(time.Time) time.Duration+	// Until is like time.Until.+	Until(time.Time) time.Duration++	// Now is like time.Now.+	Now() time.Time++	// AfterFunc is like time.AfterFunc.+	AfterFunc(time.Duration, func()) *Timer+	// NewTimer is like time.NewTimer.+	NewTimer(time.Duration) *Timer+	// NewTicker is like time.NewTicker.+	NewTicker(time.Duration) *time.Ticker++	// WithTimeout is like context.WithTimeout.+	ContextWithTimeout(context.Context, time.Duration) (context.Context, context.CancelFunc)+	// WithDeadline is like context.WithDeadline.+	ContextWithDeadline(context.Context, time.Time) (context.Context, context.CancelFunc) } -// locCache maps from zone offset suffix string ("+08:00") =>-// *time.Location (from FixedLocation).-var locCache sync.Map+// Timer wraps a time.Timer and makes its Reset function integrate+// with a custom Time implementation, rather than hardcode stdlib's.+type Timer struct {+	timer  *time.Timer+	adjust func(time.Duration) time.Duration+} -func getLocation(zone, timeValue string) (*time.Location, error) {-	if zone == "Z" {-		return time.UTC, nil-	}-	if loci, ok := locCache.Load(zone); ok {-		return loci.(*time.Location), nil-	}-	// TODO(bradfitz): just parse it and call time.FixedLocation.-	// For now, just have time.Parse do it once:-	t, err := time.Parse(time.RFC3339Nano, timeValue)-	if err != nil {-		return nil, err-	}-	loc := t.Location()-	locCache.LoadOrStore(zone, loc)-	return loc, nil+func (t *Timer) Reset(d time.Duration) bool {+	return t.timer.Reset(t.adjust(d))+} +func (t *Timer) Stop() bool {+	return t.timer.Stop() } -// Parse3339 is a wrapper around time.Parse(time.RFC3339Nano, s) that caches-// timezone Locations for future parses.-func Parse3339(s string) (time.Time, error) {-	zone := zoneOf(s)-	if zone == "" {-		// Invalid or weird timezone offset. Use slow path,-		// which'll probably return an error.-		return time.Parse(time.RFC3339Nano, s)-	}-	loc, err := getLocation(zone, s)-	if err != nil {-		return time.Time{}, err-	}-	s = s[:len(s)-len(zone)] // remove zone suffix-	var year, mon, day, hr, min, sec, nsec int-	const baseLen = len("2020-04-05T15:56:00")-	if len(s) < baseLen ||-		!parseInt(s[:4], &year) ||-		s[4] != '-' ||-		!parseInt(s[5:7], &mon) ||-		s[7] != '-' ||-		!parseInt(s[8:10], &day) ||-		s[10] != 'T' ||-		!parseInt(s[11:13], &hr) ||-		s[13] != ':' ||-		!parseInt(s[14:16], &min) ||-		s[16] != ':' ||-		!parseInt(s[17:19], &sec) {-		return time.Time{}, errors.New("invalid time")+// Std is a Time implementation that uses standard library+// functions. With this implementation, time works as you'd normally+// expect.+type Std struct{}++// After is like time.After.+func (Std) After(d time.Duration) <-chan time.Time { return time.After(d) }++// After is like time.Sleep.+func (Std) Sleep(d time.Duration) { time.Sleep(d) }++// After is like time.Since.+func (Std) Since(t time.Time) time.Duration { return time.Since(t) }++// After is like time.Until.+func (Std) Until(t time.Time) time.Duration { return time.Until(t) }++// After is like time.NewTicker.+func (Std) NewTicker(d time.Duration) *time.Ticker { return time.NewTicker(d) }++// After is like time.Now.+func (Std) Now() time.Time                           { return time.Now() }+func durationIdentity(d time.Duration) time.Duration { return d }++// After is like time.AfterFunc.+func (s Std) AfterFunc(d time.Duration, f func()) *Timer {+	return &Timer{time.AfterFunc(d, f), durationIdentity}+}++// After is like time.NewTimer.+func (s Std) NewTimer(d time.Duration) *Timer { return &Timer{time.NewTimer(d), durationIdentity} }++// ContextWithTimeout is like context.WithTimeout.+func (Std) ContextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) {+	return context.WithTimeout(ctx, d)+}++// ContextWithDeadline is like context.WithDeadline.+func (Std) ContextWithDeadline(ctx context.Context, t time.Time) (context.Context, context.CancelFunc) {+	return context.WithDeadline(ctx, t)+}++// Virtual is a Time implementation that runs faster or slower than+// wall clock time, but keeps ratios the same.+type Virtual struct {+	// Second is how long a virtual second actually takes in wall+	// clock time. That is, if you virtual.Sleep(time.Second), this is+	// how long you'll actually sleep.+	Second time.Duration++	// first is the first value of time.Now seen by this virtual+	// instance. It's used as the origin point for virtual time.Time+	// values when scaling them to/from wall clock time.+	first int64 // nanoseconds since Epoch, accessed atomically.+}++func (vt *Virtual) init() {+	atomic.CompareAndSwapInt64(&vt.first, 0, time.Now().UnixNano())+}++// mulDiv implements v*mul/div using 128-bit integer math, to avoid+// overflows and losses of precision.+func mulDiv(v, mul, div time.Duration) time.Duration {+	neg := v < 0+	if neg {+		v = -v 	}-	nsStr := s[baseLen:]-	if nsStr != "" {-		if nsStr[0] != '.' {-			return time.Time{}, errors.New("invalid optional nanosecond prefix")-		}-		if !parseInt(nsStr[1:], &nsec) {-			return time.Time{}, fmt.Errorf("invalid optional nanosecond number %q", nsStr[1:])-		}-		for i := 0; i < len("999999999")-(len(nsStr)-1); i++ {-			nsec *= 10-		}++	hi, lo := bits.Mul64(uint64(v), uint64(mul))+	quo, _ := bits.Div64(hi, lo, uint64(div))++	ret := time.Duration(quo)+	if neg {+		ret = -ret 	}-	return time.Date(year, time.Month(mon), day, hr, min, sec, nsec, loc), nil+	return ret+}++// virtualToWallDuration converts a time.Duration from the virtual+// reference frame to the wall clock reference frame. This is the+// transform that takes place to convert+// virtual.Sleep(virtualDuration) into time.Sleep(realDuration), for+// example.+func (vt *Virtual) virtualToWallDuration(d time.Duration) time.Duration {+	return mulDiv(d, vt.Second, time.Second)+}++// wallToVirtualDuration converts a time.Duration from the wall clock+// reference frame to the virtual reference frame.+func (vt *Virtual) wallToVirtualDuration(d time.Duration) time.Duration {+	return mulDiv(d, time.Second, vt.Second)+}++func (vt *Virtual) virtualToWallTime(t time.Time) time.Time {+	vt.init()+	wt := time.Unix(0, atomic.LoadInt64(&vt.first)).In(t.Location())+	return wt.Add(vt.virtualToWallDuration(t.Sub(wt)))+}+func (vt *Virtual) wallToVirtualTime(t time.Time) time.Time {+	vt.init()+	ret := time.Unix(0, atomic.LoadInt64(&vt.first)).In(t.Location())+	return ret.Add(vt.wallToVirtualDuration(t.Sub(ret)))+}++// After is like time.After.+func (vt *Virtual) After(d time.Duration) <-chan time.Time {+	return time.After(vt.virtualToWallDuration(d))+}++// Sleep is like time.Sleep.+func (vt *Virtual) Sleep(d time.Duration) {+	time.Sleep(vt.virtualToWallDuration(d))+}++// Since is like time.Since.+func (vt *Virtual) Since(t time.Time) time.Duration {+	return vt.wallToVirtualDuration(time.Since(vt.virtualToWallTime(t)))

virtualToWallTime breaks monotonic time support (see https://go.googlesource.com/proposal/+/master/design/12914-monotonic.md), so this version of time.Since will behave differently in the fact of machine time changes. Maybe that's ok if it's intended for tests, but it could cause mysterious test flakes.

I haven't worked it all the way through, but I believe that you could work around this with even more wrapping. You could rename your Time interface to just T, and then instead of having this package accept/return time.Times, you could have them accept/return type Time interfaces. Clock times are unchanged (modulo being wrapped), but Virtual methods return virtual times, which are a struct containing the virtual time and the clock. You'd need to modify yourTinterface methods to deal intstime.Timeinstead oftime.Time`, and your Std implementation accordingly.

Then the implementation of this function looks like:

if u, ok := t.(*virtualTime); !ok {
  panic("cannot mix and match different tstime.T")
}
return vt.wallToVirtualDuration(time.Since(u.Clock))

The panic in this function is another sign that the existing implementation is a little bit dangerous: Mixing time.Times between different tstime.Times will cause silent weird results, not failures.

danderson

comment created time in 3 days

issue commenttailscale/tailscale

Multiple "tailscale up" can deadlock tailscaled

Manual inspection of the stack trace was not enlightening. Given all that, I'm adjusting to L1. We can reprioritize if it ever happens again.

bradfitz