code review 5728053: go.crypto/ssh: improve marshal performance

ssh/messages.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package ssh
 
 import (
         "bytes"
+        "encoding/binary"
         "io"
         "math/big"
         "reflect"
 )
 
 // These are SSH message type numbers. They are scattered around several
 // documents but many were taken from
 // http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
 const (
         msgDisconnect     = 1
@@ skipping 284 matching lines @@
                                 out.uint8(uint8(field.Index(j).Uint()))
                         }
                 case reflect.Uint32:
                         out.uint32(uint32(field.Uint()))
                 case reflect.String:
                         s := field.String()
                         out.int(len(s))
                         out = append(out, s...)
                 case reflect.Slice:
                         switch t.Elem().Kind() {
                         case reflect.Uint8:

[remyoudompheng, 2012/03/03 09:45:18]

isn't it a []byte in most cases? it could be type-asserted and appended
directly.

[dave_cheney.net, 2012/03/03 10:51:11]

Done.

-                                length := field.Len()
                                 if v.Type().Field(i).Tag.Get("ssh") != "rest" {
-                                        out.int(length)
+                                        out.int(field.Len())
                                 }
-                                for j := 0; j < length; j++ {
-                                        out.uint8(byte(field.Index(j).Uint()))
-                                }
+                                out = append(out, field.Bytes()...)
                         case reflect.String:
                                 offset := len(out)
                                 out.uint32(0)
                                 if n := field.Len(); n > 0 {
                                         for j := 0; j < n; j++ {
                                                 f := field.Index(j)
                                                 if j != 0 {
                                                         out.uint8(',')
                                                 }
                                                 out = append(out, f.String()...)
                                         }
                                         // overwrite length value
-                                        marshalUint32(out[offset:], uint32(len(out)-offset-4))
+                                        binary.BigEndian.PutUint32(out[offset:], uint32(len(out)-offset-4))
                                 }
                         default:
                                 panic("slice of unknown type")
                         }
                 case reflect.Ptr:
                         if t == bigIntType {
                                 var n *big.Int
                                 nValue := reflect.ValueOf(&n)
                                 nValue.Elem().Set(field)
                                 needed := intLength(n)
@@ skipping 14 matching lines @@
 
         return out
 }
 
 var bigOne = big.NewInt(1)
 
 func parseString(in []byte) (out, rest []byte, ok bool) {
         if len(in) < 4 {
                 return
         }
-        length := uint32(in[0])<<24 | uint32(in[1])<<16 | uint32(in[2])<<8 | uint32(in[3])
+        length := binary.BigEndian.Uint32(in)
         if uint32(len(in)) < 4+length {
                 return
         }
         out = in[4 : 4+length]
         rest = in[4+length:]
         ok = true
         return
 }
 
 var (
@@ skipping 35 matching lines @@
                 out.Add(out, bigOne)
                 out.Neg(out)
         } else {
                 // Positive number
                 out.SetBytes(contents)
         }
         ok = true
         return
 }
 
-func parseUint32(in []byte) (out uint32, rest []byte, ok bool) {
+func parseUint32(in []byte) (uint32, []byte, bool) {
         if len(in) < 4 {
-                return
-        }
-        out = uint32(in[0])<<24 | uint32(in[1])<<16 | uint32(in[2])<<8 | uint32(in[3])
-        rest = in[4:]
-        ok = true
-        return
-}
-
-func parseUint64(in []byte) (out uint64, rest []byte, ok bool) {
+                return 0, nil, false
+        }
+        return binary.BigEndian.Uint32(in), in[4:], true
+}
+
+func parseUint64(in []byte) (uint64, []byte, bool) {
         if len(in) < 8 {
-                return
-        }
-        out = uint64(in[0])<<56 |

[remyoudompheng, 2012/03/03 09:45:18]

this is out = binary.BigEndian.Uint64(in)

[dave_cheney.net, 2012/03/03 10:51:11]

Done.

-                uint64(in[1])<<48 |
-                uint64(in[2])<<40 |
-                uint64(in[3])<<32 |
-                uint64(in[4])<<24 |
-                uint64(in[5])<<16 |
-                uint64(in[6])<<8 |
-                uint64(in[7])
-        rest = in[8:]
-        ok = true
-        return
+                return 0, nil, false
+        }
+        return binary.BigEndian.Uint64(in), in[8:], true
 }
 
 func nameListLength(namelist []string) int {
         length := 4 /* uint32 length prefix */
         for i, name := range namelist {
                 if i != 0 {
                         length++ /* comma */
                 }
                 length += len(name)
         }
@@ skipping 18 matching lines @@
                 if bitLen%8 == 0 {
                         // The number will need 0x00 padding
                         length++
                 }
                 length += (bitLen + 7) / 8
         }
 
         return length
 }
 
 func marshalUint32(to []byte, n uint32) []byte {

[remyoudompheng, 2012/03/03 09:45:18]

s = marshalUint32(s, n)
looks no different from
binary.BigEndian.PutUint32(s, n)
s = s[:4]

[dave_cheney.net, 2012/03/03 10:51:11]

Done.

-        to[0] = byte(n >> 24)
-        to[1] = byte(n >> 16)
-        to[2] = byte(n >> 8)
-        to[3] = byte(n)
+        binary.BigEndian.PutUint32(to, n)
         return to[4:]
 }
 
 func marshalUint64(to []byte, n uint64) []byte {
-        to[0] = byte(n >> 56)
-        to[1] = byte(n >> 48)
-        to[2] = byte(n >> 40)
-        to[3] = byte(n >> 32)
-        to[4] = byte(n >> 24)
-        to[5] = byte(n >> 16)
-        to[6] = byte(n >> 8)
-        to[7] = byte(n)
+        binary.BigEndian.PutUint64(to, n)
         return to[8:]
 }
 
 func marshalInt(to []byte, n *big.Int) []byte {
         lengthBytes := to
         to = to[4:]
         length := 0
 
         if n.Sign() < 0 {
                 // A negative number has to be converted to two's-complement
@@ skipping 117 matching lines @@
         case msgChannelFailure:
                 msg = new(channelRequestFailureMsg)
         default:
                 return UnexpectedMessageError{0, packet[0]}
         }
         if err := unmarshal(msg, packet, packet[0]); err != nil {
                 return err
         }
         return msg
 }