dpc · September 9, 2015 00:40
diff --git a/tcp_bench.go b/tcp_bench.go
 package main

 import (
 	"flag"
 	"fmt"
 	"log"
 	"net"
 	"sync"
 	"sync/atomic"
 	"time"
 )

 var (
 	targetAddr  = flag.String("a", "127.0.0.1:12345", "target echo server address")
 	testMsgLen  = flag.Int("l", 26, "test message length")
 	testConnNum = flag.Int("c", 50, "test connection number")
 	testSeconds = flag.Int("t", 10, "test duration in seconds")
 )

 func main() {
 	flag.Parse()

 	var (
 		outNum uint64
 		inNum  uint64
 		stop   uint64
 	)

 	msg := make([]byte, *testMsgLen)

 	go func() {
 		time.Sleep(time.Second * time.Duration(*testSeconds))
 		atomic.StoreUint64(&stop, 1)
 	}()

 	wg := new(sync.WaitGroup)

 	for i := 0; i < *testConnNum; i++ {
 		wg.Add(1)

 		go func() {
 			if conn, err := net.DialTimeout("tcp", *targetAddr, time.Minute*99999); err == nil {
 				l := len(msg)
 				recv := make([]byte, l)

 				for {
 					for rest := l; rest > 0 ; {
 						i, err := conn.Write(msg);
 						rest -= i
 						if err != nil {
 							log.Println(err)
 							break
 						}
 					}

 					atomic.AddUint64(&outNum, 1)

 					if atomic.LoadUint64(&stop) == 1 {
 						break
 					}

 					for rest := l; rest > 0 ; {
 						i, err := conn.Read(recv)
 						rest -= i
 						if err != nil {
 							log.Println(err)
 							break
 						}
 					}

 					atomic.AddUint64(&inNum, 1)

 					if atomic.LoadUint64(&stop) == 1 {
 						break
 					}
 				}
 			} else {
 				log.Println(err)
 			}

 			wg.Done()
 		}()
 	}

 	wg.Wait()

 	fmt.Println("Benchmarking:", *targetAddr)
 	fmt.Println(*testConnNum, "clients, running", *testMsgLen, "bytes,", *testSeconds, "sec.")
 	fmt.Println()
 	fmt.Println("Speed:", outNum/uint64(*testSeconds), "request/sec,", inNum/uint64(*testSeconds), "response/sec")
 	fmt.Println("Requests:", outNum)
 	fmt.Println("Responses:", inNum)
 }
diff --git a/tcp_echo_cluster.js b/tcp_echo_cluster.js
 var net = require('net');

 var cluster = require('cluster');

 var numCPUs = require('os').cpus().length;

 if (cluster.isMaster) {
 	for (var i = 0; i < numCPUs ; i++) {
 		cluster.fork();
 	}

 	cluster.on('exit', function (worker, code, signal) {
 		console.log('worker ' + worker.process.pid + ' died');
 		cluster.fork();
 	});
 } else {
 	console.log("worker");

 	var server = net.createServer(function (socket) {
 		socket.pipe(socket);
 	});

 	server.listen(12345, '0.0.0.0', 10000);
 }
diff --git a/tcp_echo_normal.go b/tcp_echo_normal.go
 package main

 import (
 	"flag"
 	"net"
 )

 var testMsgLen = flag.Int("l", 26, "test message length")

 func main() {
 	flag.Parse()

 	if lsn, err := net.Listen("tcp", "0.0.0.0:12345"); err == nil {
 		for {
 			conn, err := lsn.Accept()

 			if err != nil {
 				break
 			}

 			sendChan := make(chan []byte, 1000)

 			go func() {
 				defer func() {
 					conn.Close()
 					close(sendChan)
 				}()

 				msg := make([]byte, *testMsgLen)

 			L:
 				for {
 					if _, err := conn.Read(msg); err == nil {
 						select {
 						case sendChan <- msg:
 						default:
 							break L
 						}
 					} else {
 						break L
 					}
 				}
 			}()

 			go func() {
 				defer conn.Close()

 				for {
 					msg, ok := <-sendChan

 					if !ok {
 						break
 					}

 					if _, err := conn.Write(msg); err != nil {
 						break
 					}
 				}
 			}()
 		}
 	}
 }
diff --git a/tcp_echo_normal.js b/tcp_echo_normal.js
 var net = require('net');

 var server = net.createServer(function (socket) {
    socket.pipe(socket);
 });

 server.listen(12345, '0.0.0.0', 100000);
diff --git a/tcp_echo_sendfile.go b/tcp_echo_sendfile.go
 package main

 import "net"

 func main() {
 	if lsn, err := net.Listen("tcp", "0.0.0.0:12345"); err == nil {
 		for {
 			conn, err := lsn.Accept()

 			if err != nil {
 				break
 			}

 			go func() {
 				conn.(*net.TCPConn).ReadFrom(conn)
 			}()
 		}
 	}
 }
diff --git a/test_result.md b/test_result.md
	package main

	import (
	"flag"
	"fmt"
	"log"
	"net"
	"sync"
	"sync/atomic"
	"time"
	)

	var (
	targetAddr = flag.String("a", "127.0.0.1:12345", "target echo server address")
	testMsgLen = flag.Int("l", 26, "test message length")
	testConnNum = flag.Int("c", 50, "test connection number")
	testSeconds = flag.Int("t", 10, "test duration in seconds")
	)

	func main() {
	flag.Parse()

	var (
	outNum uint64
	inNum uint64
	stop uint64
	)

	msg := make([]byte, *testMsgLen)

	go func() {
	time.Sleep(time.Second * time.Duration(*testSeconds))
	atomic.StoreUint64(&stop, 1)
	}()

	wg := new(sync.WaitGroup)

	for i := 0; i < *testConnNum; i++ {
	wg.Add(1)

	go func() {
	if conn, err := net.DialTimeout("tcp", targetAddr, time.Minute99999); err == nil {
	l := len(msg)
	recv := make([]byte, l)

	for {
	for rest := l; rest > 0 ; {
	i, err := conn.Write(msg);
	rest -= i
	if err != nil {
	log.Println(err)
	break
	}
	}

	atomic.AddUint64(&outNum, 1)

	if atomic.LoadUint64(&stop) == 1 {
	break
	}

	for rest := l; rest > 0 ; {
	i, err := conn.Read(recv)
	rest -= i
	if err != nil {
	log.Println(err)
	break
	}
	}

	atomic.AddUint64(&inNum, 1)

	if atomic.LoadUint64(&stop) == 1 {
	break
	}
	}
	} else {
	log.Println(err)
	}

	wg.Done()
	}()
	}

	wg.Wait()

	fmt.Println("Benchmarking:", *targetAddr)
	fmt.Println(testConnNum, "clients, running", testMsgLen, "bytes,", *testSeconds, "sec.")
	fmt.Println()
	fmt.Println("Speed:", outNum/uint64(testSeconds), "request/sec,", inNum/uint64(testSeconds), "response/sec")
	fmt.Println("Requests:", outNum)
	fmt.Println("Responses:", inNum)
	}
	var net = require('net');

	var cluster = require('cluster');

	var numCPUs = require('os').cpus().length;

	if (cluster.isMaster) {
	for (var i = 0; i < numCPUs ; i++) {
	cluster.fork();
	}

	cluster.on('exit', function (worker, code, signal) {
	console.log('worker ' + worker.process.pid + ' died');
	cluster.fork();
	});
	} else {
	console.log("worker");

	var server = net.createServer(function (socket) {
	socket.pipe(socket);
	});

	server.listen(12345, '0.0.0.0', 10000);
	}
	package main

	import "net"

	func main() {
	if lsn, err := net.Listen("tcp", "0.0.0.0:12345"); err == nil {
	for {
	conn, err := lsn.Accept()

	if err != nil {
	break
	}

	go func() {
	conn.(*net.TCPConn).ReadFrom(conn)
	}()
	}
	}
	}