Google Go: Why does the http server package not serve more than 5 simultaneous requests?

I'm trying to code a small http server for later extension in Google's Go language. I am using Go on Windows (MinGw compiled version).

This is quite easy in this language since it already has the necessary package:

package main

import (
	"http"
	"io"
	"os"
	"fmt"
	"strconv"
)  


func FileTest(w http.ResponseWriter, req *http.Request) {
	w.Header().Add("Content-Type", "image/jpeg")
	w.Header().Add("Content-Disposition", "inline; filename=image.jpg")
    inName := "d:\\googlego\\somepic.jpg";
    inFile, inErr := os.OpenFile(inName, os.O_RDONLY, 0666);
    if inErr == nil {
    	inBufLen := 16;
    	inBuf := make([]byte, inBufLen);
    	
    	_, inErr := inFile.Read(inBuf);
    	for inErr == nil {
    		w.Write(inBuf)
    		_, inErr = inFile.Read(inBuf);
    	} 
    }
    inErr = inFile.Close(); 
    
}

func MainPage(w http.ResponseWriter, req *http.Request) {
	io.WriteString(w, "Hi, download here: <a href=\"/FileTest\">HERE</a>")
	
}


func main() {
	fmt.Print("Port: ")
	var hi int 
	fmt.Scanf("%d", &hi)
	http.HandleFunc("/FileTest", FileTest)
	http.HandleFunc("/", MainPage)
	
	err := http.ListenAndServe("0.0.0.0:" + strconv.Itoa(hi), nil)
 	
	if err != nil {
		fmt.Print(err) 
		fmt.Print((hi))
	}
}

This starts a server that serves a main page and a download from an image. Both work very well and I get very good results from ab (Apache benchmark) up to 6 concurrent threads:

> ab -n 10000 -c 6 http://localhost:8080/
Concurrency Level:      6
Time taken for tests:   1.678096 seconds
Complete requests:      10000

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      2
  95%      2
  98%      2
  99%      2
 100%      3 (longest request)

When the concurrency level is set higher, this happens:

>ab -n 1000 -c 7 http://localhost:8080/
Concurrency Level:      7
Time taken for tests:   10.239586 seconds
Complete requests:      1000

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      2
  75%      2
  80%      3
  90%    499
  95%    505
  98%    507
  99%    507
 100%    510 (longest request)

Note that I only made 1'000 requests this time and it still took almost 6 times as much time.

Both benchmarks don't even request the file yet.

I don't know a lot about Go yet, but it seems that the Go runtime doesn't create enough OS threads to put the goroutines on, or something like that?

EDIT: I downloaded the new r60.2 from 07.10.2011.

Now it went even worse:

>ab -c 7 -n 1000 http://localhost:8080/
Concurrency Level:      7
Time taken for tests:   12.622722 seconds
Complete requests:      1000
Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      2
  80%      2
  90%    496
  95%    503
  98%    506
  99%    506
 100%    507 (longest request)

As of today (Sep 2011) the Windows port of Go is a work-in-progress. It lags behind the other supported platforms (Linux, etc.) in some important measures including stability and performance (though it is improving every day). I would suggest that you try your test on a 64-bit Linux platform, and see how it differs, then maybe you can start deconstructing what's going wrong under Windows.

I just tried this benchmark with Go 64-bit at tip, and got the following results (on a Core 2 Duo 2GHz, Windows 7 x64):

C:\Program Files (x86)\Apache Software Foundation\Apache2.2\bin>ab -c 7 -n 1000 http://localhost:8080/
Concurrency Level:      7
Time taken for tests:   0.458 seconds
Complete requests:      1000
Percentage of the requests served within a certain time (ms)
  50%      3
  66%      3
  75%      3
  80%      3
  90%      4
  95%      5
  98%      7
  99%      8
 100%      9 (longest request)