Update ssr benchmark

Author: zaaack

Samples/SSRSample/benchmark/dotnet.fs

@@ -15,7 +15,7 @@ let initState: Model = {
 }
 
 let coreCount = Environment.ProcessorCount
-let workerTimes = 5000
+let workerTimes = 20_000
 let totalTimes = workerTimes * coreCount
 let mutable totalms = 0L
 
@@ -36,7 +36,7 @@ let render times () =
   int watch.ElapsedMilliseconds
 
 let singleTest () =
-  let times = workerTimes * 2
+  let times = totalTimes
   let time = render times ()
   printfn "[Single thread] %dms    %.3freq/s" time ((float times) / (float time) * 1000.)
 

Samples/SSRSample/benchmark/node.js

@@ -14,7 +14,7 @@ const initState = {
 
 const noop = () => {}
 const mb = bytes => (bytes / 1024 / 1024).toFixed(3)
-const workerTimes = 5000
+const workerTimes = 20000
 const totalTimes = workerTimes * coreCount
 
 function render(len = workerTimes) {
@@ -26,7 +26,7 @@ function render(len = workerTimes) {
 }
 
 function singleTest() {
-  const times = workerTimes * 2
+  const times = totalTimes
   const time = render(times)
   console.log(`[Single process] ${time}ms    ${(times / time * 1000).toFixed(3)}req/s`)
 }

Samples/SSRSample/build.fsx

@@ -100,7 +100,9 @@ Target "Run" (fun () ->
   ==> "Run"
 
 
-"BuildBench"
+"InstallClient"
+  ==> "RestoreServer"
+  ==>"BuildBench"
   ==> "Bench"
 
 RunTargetOrDefault "Build"

docs/server-side-rendering.md

@@ -32,7 +32,7 @@ There are lots of articles about comparing dotnet core and nodejs, I will only m
 * F# is a compiled language, which means it's generally considered faster then a dynamic language, like js.
 * Nodejs's single thread, event-driven, non-blocking I/O model works well in most web sites, but it is not good at CPU intensive tasks, including html rendering. Usually we need to run multi nodejs instances to take the advantage of multi-core systems. DotNet support non-blocking I/O (and `async/await` sugar), too. But the awesome part is that it also has pretty good support for multi-thread programming.
 
-In a simple test in my local macbook, rendering on dotnet core is about ~3x faster then nodejs (with ReactDOMServer.renderToString + NODE_ENV=production). You can find more detail in the bottom of this page.
+In a simple test in my local macbook, rendering on dotnet core is about ~1.5x faster then nodejs (with ReactDOMServer.renderToString + NODE_ENV=production) in a single thread. You can find more detail in the bottom of this page.
 
 In a word, with this approach, you can not only get a better performance then nodejs, but also don't need the complexity of running and maintaining nodejs instances on your server!
 
@@ -268,35 +268,51 @@ cd ./Samples/SSRSample
 
 ```
 
-Here is the benchmark result in my laptop (MacBook Pro with 2.7 GHz Intel Core i5, 16 GB 1867 MHz DD~R3), rendering on dotnet core is about ~4x faster then on nodejs in a single thread. To take the advantage of multi-core systems, we also tested with multi-thread on dotnet core and cluster mode in nodejs, the dotnet core version is still about ~3x faster then nodejs version, with less memory footprint!
+Here is the benchmark result in my linux laptop (Intel Core i7-3630QM, 8 core), rendering on dotnet core is about ~1.5x faster then on nodejs in a single thread. To take the advantage of multi-core systems, we also tested with multi-thread on dotnet core and cluster mode in nodejs, the dotnet core version is still faster then nodejs version, but not much. I guess it's because multi-process takes more advantages from multi cores then multi-threaded. What's more, multi-threaded dotnet has less memory footprint.
 
 ```sh
 
 dotnet ./bin/Release/netcoreapp2.0/dotnet.dll
 Thread 1 started
-Thread 1 render 10000 times used 2414ms
-[Single thread] 2414ms    4142.502req/s
+Thread 1 render 160000 times used 25146ms
+[Single thread] 25146ms    6362.841req/s
 Thread 1 started
-Thread 4 started
 Thread 3 started
+Thread 4 started
 Thread 5 started
-Thread 3 render 5000 times used 3399ms
-Thread 5 render 5000 times used 3401ms
-Thread 1 render 5000 times used 3402ms
-Thread 4 render 5000 times used 3405ms
-[4 tasks] Total: 3401ms    Memory footprint: 32.184MB   Requests/sec: 5880.623
+Thread 7 started
+Thread 8 started
+Thread 9 started
+Thread 6 started
+Thread 3 render 20000 times used 10370ms
+Thread 9 render 20000 times used 10409ms
+Thread 6 render 20000 times used 10421ms
+Thread 4 render 20000 times used 10434ms
+Thread 7 render 20000 times used 10445ms
+Thread 1 render 20000 times used 10458ms
+Thread 5 render 20000 times used 10483ms
+Thread 8 render 20000 times used 10497ms
+[8 tasks] Total: 10439ms    Memory footprint: 43.266MB   Requests/sec: 15327.139
 
 /usr/local/bin/node ./node.js
-Master 78856 is running
-[Single process] 9511ms    1051.414req/s
-Worker 78863: started
-Worker 78861: started
-Worker 78860: started
-Worker 78862: started
-Worker 78863: render 5000 times used 10390ms
-Worker 78861: render 5000 times used 10459ms
-Worker 78862: render 5000 times used 10528ms
-Worker 78860: render 5000 times used 10567ms
-[4 workers] Total: 10486ms    Memory footprint: 104.033MB    Requests/sec: 1907.305
+Master 3266 is running
+[Single process] 33702ms    4747.493req/s
+Worker 3275: started
+Worker 3281: started
+Worker 3303: started
+Worker 3289: started
+Worker 3304: started
+Worker 3296: started
+Worker 3320: started
+Worker 3317: started
+Worker 3281: render 20000 times used 10247ms
+Worker 3289: render 20000 times used 10709ms
+Worker 3275: render 20000 times used 11048ms
+Worker 3303: render 20000 times used 11119ms
+Worker 3296: render 20000 times used 11188ms
+Worker 3320: render 20000 times used 11359ms
+Worker 3304: render 20000 times used 11370ms
+Worker 3317: render 20000 times used 11574ms
+[8 workers] Total: 11076.75ms    Memory footprint: 200.066MB    Requests/sec: 14444.670
 
 ```