Add an int64 quantity implementation

Provides fast transformations of int64 scaled values with overflow to
inf.Dec as needed. Attempts to reduce allocations and expensive
operations in the critical path.

Alters the public signature of Quantity to encourage more efficient use

pkg/api/resource/suffix.go

@@ -24,8 +24,9 @@ type suffix string
 
 // suffixer can interpret and construct suffixes.
 type suffixer interface {
-	interpret(suffix) (base, exponent int, fmt Format, ok bool)
-	construct(base, exponent int, fmt Format) (s suffix, ok bool)
+	interpret(suffix) (base, exponent int32, fmt Format, ok bool)
+	construct(base, exponent int32, fmt Format) (s suffix, ok bool)
+	constructBytes(base, exponent int32, fmt Format) (s []byte, ok bool)
 }
 
 // quantitySuffixer handles suffixes for all three formats that quantity
@@ -33,12 +34,13 @@ type suffixer interface {
 var quantitySuffixer = newSuffixer()
 
 type bePair struct {
-	base, exponent int
+	base, exponent int32
 }
 
 type listSuffixer struct {
-	suffixToBE map[suffix]bePair
-	beToSuffix map[bePair]suffix
+	suffixToBE      map[suffix]bePair
+	beToSuffix      map[bePair]suffix
+	beToSuffixBytes map[bePair][]byte
 }
 
 func (ls *listSuffixer) addSuffix(s suffix, pair bePair) {
@@ -48,11 +50,15 @@ func (ls *listSuffixer) addSuffix(s suffix, pair bePair) {
 	if ls.beToSuffix == nil {
 		ls.beToSuffix = map[bePair]suffix{}
 	}
+	if ls.beToSuffixBytes == nil {
+		ls.beToSuffixBytes = map[bePair][]byte{}
+	}
 	ls.suffixToBE[s] = pair
 	ls.beToSuffix[pair] = s
+	ls.beToSuffixBytes[pair] = []byte(s)
 }
 
-func (ls *listSuffixer) lookup(s suffix) (base, exponent int, ok bool) {
+func (ls *listSuffixer) lookup(s suffix) (base, exponent int32, ok bool) {
 	pair, ok := ls.suffixToBE[s]
 	if !ok {
 		return 0, 0, false
@@ -60,19 +66,50 @@ func (ls *listSuffixer) lookup(s suffix) (base, exponent int, ok bool) {
 	return pair.base, pair.exponent, true
 }
 
-func (ls *listSuffixer) construct(base, exponent int) (s suffix, ok bool) {
+func (ls *listSuffixer) construct(base, exponent int32) (s suffix, ok bool) {
 	s, ok = ls.beToSuffix[bePair{base, exponent}]
 	return
 }
 
+func (ls *listSuffixer) constructBytes(base, exponent int32) (s []byte, ok bool) {
+	s, ok = ls.beToSuffixBytes[bePair{base, exponent}]
+	return
+}
+
 type suffixHandler struct {
 	decSuffixes listSuffixer
 	binSuffixes listSuffixer
 }
 
+type fastLookup struct {
+	*suffixHandler
+}
+
+func (l fastLookup) interpret(s suffix) (base, exponent int32, format Format, ok bool) {
+	switch s {
+	case "":
+		return 10, 0, DecimalSI, true
+	case "n":
+		return 10, -9, DecimalSI, true
+	case "u":
+		return 10, -6, DecimalSI, true
+	case "m":
+		return 10, -3, DecimalSI, true
+	case "k":
+		return 10, 3, DecimalSI, true
+	case "M":
+		return 10, 6, DecimalSI, true
+	case "G":
+		return 10, 9, DecimalSI, true
+	}
+	return l.suffixHandler.interpret(s)
+}
+
 func newSuffixer() suffixer {
 	sh := &suffixHandler{}
 
+	// IMPORTANT: if you change this section you must change fastLookup
+
 	sh.binSuffixes.addSuffix("Ki", bePair{2, 10})
 	sh.binSuffixes.addSuffix("Mi", bePair{2, 20})
 	sh.binSuffixes.addSuffix("Gi", bePair{2, 30})
@@ -94,10 +131,10 @@ func newSuffixer() suffixer {
 	sh.decSuffixes.addSuffix("P", bePair{10, 15})
 	sh.decSuffixes.addSuffix("E", bePair{10, 18})
 
-	return sh
+	return fastLookup{sh}
 }
 
-func (sh *suffixHandler) construct(base, exponent int, fmt Format) (s suffix, ok bool) {
+func (sh *suffixHandler) construct(base, exponent int32, fmt Format) (s suffix, ok bool) {
 	switch fmt {
 	case DecimalSI:
 		return sh.decSuffixes.construct(base, exponent)
@@ -115,7 +152,32 @@ func (sh *suffixHandler) construct(base, exponent int, fmt Format) (s suffix, ok
 	return "", false
 }
 
-func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int, fmt Format, ok bool) {
+func (sh *suffixHandler) constructBytes(base, exponent int32, format Format) (s []byte, ok bool) {
+	switch format {
+	case DecimalSI:
+		return sh.decSuffixes.constructBytes(base, exponent)
+	case BinarySI:
+		return sh.binSuffixes.constructBytes(base, exponent)
+	case DecimalExponent:
+		if base != 10 {
+			return nil, false
+		}
+		if exponent == 0 {
+			return nil, true
+		}
+		result := make([]byte, 8, 8)
+		result[0] = 'e'
+		number := strconv.AppendInt(result[1:1], int64(exponent), 10)
+		if &result[1] == &number[0] {
+			return result[:1+len(number)], true
+		}
+		result = append(result[:1], number...)
+		return result, true
+	}
+	return nil, false
+}
+
+func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int32, fmt Format, ok bool) {
 	// Try lookup tables first
 	if b, e, ok := sh.decSuffixes.lookup(suffix); ok {
 		return b, e, DecimalSI, true
@@ -129,7 +191,7 @@ func (sh *suffixHandler) interpret(suffix suffix) (base, exponent int, fmt Forma
 		if err != nil {
 			return 0, 0, DecimalExponent, false
 		}
-		return 10, int(parsed), DecimalExponent, true
+		return 10, int32(parsed), DecimalExponent, true
 	}
 
 	return 0, 0, DecimalExponent, false