Question

我有一个Go服务器，它从许多TCP客户端获取输入数据流。格式是自定义格式，结束分隔符可能出现在字节流中，因此它使用字节填充来解决此问题。

我正在寻找代码中的热点，这会引发一个巨大的热点，我确信它可以提高效率，但我现在还不确定如何提供Go功能。

代码如下，pprof显示热点是popPacketFromBuffer命令。这会在收到每个字节后查看当前缓冲区，并在其上查找endDelimiter。如果它们中有2个连续存在，那么它就在数据包本身内。

我确实看过使用ReadBytes()而不是ReadByte()，但看起来我需要指定一个分隔符，我担心这会在中途切断数据包吗？而且无论如何这会比我正在做的更有效吗？

在popPacketFromBuffer函数中，它是作为热点的for循环。

有什么想法吗？

// Read client data from channel
func (c *Client) listen() {

    reader := bufio.NewReader(c.conn)

    clientBuffer := new(bytes.Buffer)

    for {
        c.conn.SetDeadline(time.Now().Add(c.timeoutDuration))

        byte, err := reader.ReadByte()

        if err != nil {
            c.conn.Close()
            c.server.onClientConnectionClosed(c, err)
            return
        }

        wrErr := clientBuffer.WriteByte(byte)
        if wrErr != nil {
            log.Println("Write Error:", wrErr)
        }

        packet := popPacketFromBuffer(clientBuffer)
        if packet != nil {
            c.receiveMutex.Lock()
            packetSize := uint64(len(packet))
            c.bytesReceived += packetSize
            c.receiveMutex.Unlock()

            packetBuffer := bytes.NewBuffer(packet)

            b, err := uncompress(packetBuffer.Bytes())
            if err != nil {
                log.Println("Unzip Error:", err)
            } else {
                c.server.onNewMessage(c, b)
            }
        }

    }
}

func popPacketFromBuffer(buffer *bytes.Buffer) []byte {

    bufferLength := buffer.Len()

    if bufferLength >= 125000 { // 1MB in bytes is roughly this
        log.Println("Buffer is too large ", bufferLength)
        buffer.Reset()
        return nil
    }

    tempBuffer := buffer.Bytes()
    length := len(tempBuffer)

    // Return on zero length buffer submission
    if length == 0 {
        return nil
    }

    endOfPacket := -1

    // Determine the endOfPacket position by looking for an instance of our delimiter
    for i := 0; i < length-1; i++ {
        if tempBuffer[i] == endDelimiter {
            if tempBuffer[i+1] == endDelimiter {
                i++
            } else {
                // We found a single delimiter, so consider this the end of a packet
                endOfPacket = i - 2
                break
            }
        }
    }

    if endOfPacket != -1 {
        // Grab the contents of the provided packet
        extractedPacket := buffer.Bytes()

        // Extract the last byte as we were super greedy with the read operation to check for stuffing
        carryByte := extractedPacket[len(extractedPacket)-1]

        // Clear the main buffer now we have extracted a packet from it
        buffer.Reset()

        // Add the carryByte over to our new buffer
        buffer.WriteByte(carryByte)

        // Ensure packet begins with a valid startDelimiter
        if extractedPacket[0] != startDelimiter {
            log.Println("Popped a packet without a valid start delimiter")
            return nil
        }

        // Remove the start and end caps
        slice := extractedPacket[1 : len(extractedPacket)-2]

        return deStuffPacket(slice)
    }

    return nil
}

Answer 1

看起来每次从连接收到的每个字节都会调用offline_access onedrive.readonly onedrive.readwrite onedrive.appfolder。但是popPacketFromBuffer()复制空洞缓冲区并检查每个字节的每个字节的分界符。也许这是压倒性的。对我来说，你不需要循环

popPacketFromBuffer()

in for i := 0; i < length-1; i++ { if tempBuffer[i] == endDelimiter { if tempBuffer[i+1] == endDelimiter { i++ } else { // We found a single delimiter, so consider this the end of a packet endOfPacket = i - 2 break } } }也许不是循环只测试最后两个字节

popPacketFromBuffer()

就足够了。

优化网络代码

1 个答案: