srv bench

bench.py

import time
import struct
import socket
from server import _recvall

NUM_CLIENT = 1

socks = []
for i in range(NUM_CLIENT):
    sock = socket.socket()
    sock.connect(("127.0.0.1", 10000))
    socks.append(sock)

res_count = 0
st = time.perf_counter()
try:
    while True:
        for sock in socks:
            sock.send(b"\x07\x00\x65\x00\x00\x00\x00")
            size = struct.unpack("<H", _recvall(sock, 2))[0]
            res = _recvall(sock, size - 2)
            res_count += 1
            elapsed = time.perf_counter() - st
            if elapsed > 0.5:
                rps = res_count / elapsed
                res_count = 0
                st = time.perf_counter()
                print(str(rps))
finally:
    for sock in socks:
        sock.close()

server.go

package main

import (
	"net"
	"io"
	"encoding/binary"
	"fmt"
	"bufio"
	"runtime"
)

const (
	bufferSize = 1024
)

func main() {
	addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:10000")
	if err != nil {
		panic(err)
	}
	listener, err := net.ListenTCP("tcp", addr)
	if err != nil {
		panic(err)
	}
	defer listener.Close()
	println("[golang]start listening...")
	fmt.Printf("GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))
	for {
		conn, err := listener.AcceptTCP()
		if err != nil {
			panic(err)
		}

		go handleConn(conn)
	}
}


func handleConn(c *net.TCPConn) {
	defer c.Close()
	fmt.Printf("new sock accepted %#v\n", c)
	r := bufio.NewReaderSize(c, bufferSize)
	w := bufio.NewWriterSize(c, bufferSize)

	for {
		// read size
		var b [2]byte
		_, err := io.ReadFull(r, b[:])
		if err != nil {
			panic(err)
		}
		reqLen := binary.LittleEndian.Uint16(b[:]) - 2

		// read body
		req := make([]byte, reqLen)
		_, err = io.ReadFull(r, req)
		if err != nil {
			panic(err)
		}

		// response
		resLen := uint16(len(req) + 2)
		binary.LittleEndian.PutUint16(b[:], resLen)
		_, err = w.Write(b[:])
		if err != nil {
			panic(err)
		}
		_, err = w.Write(req[:])
		if err != nil {
			panic(err)
		}

		err = w.Flush()
		if err != nil {
			panic(err)
		}
	}
}

server.py

import struct
import socket
import socketserver


def _recvall(sock, size) -> bytes:
    received = bytearray()
    while len(received) < size:
        result = sock.recv(size - len(received))
        if result == b"":
            raise Exception("recv() failed on {}".format(sock))
        received += result
    return bytes(received)


class Handler(socketserver.BaseRequestHandler):

    def handle(self):
        sock = self.request  # type: socket.socket
        print("[python]new socket accpeted: " + str(self.client_address))
        try:
            while (True):
                size = struct.unpack("<H", _recvall(sock, 2))[0]
                req = _recvall(sock, size - 2)
                res = bytearray(req)
                res[0] += 0x01
                res_p = struct.pack("<H", len(res) + 2) + res
                sock.sendall(res_p)
        finally:
            sock.shutdown(socket.SHUT_RDWR)
            sock.close()


if __name__ == "__main__":
    server = socketserver.ThreadingTCPServer(("127.0.0.1", 10000), Handler)
    server.serve_forever()