Node.js echo server

[GavinRay97]

I wrote this for you, I had forgot you asked about it.
Here is one which takes the same flags as yours, I did not implement streaming because I do not understand much about streaming.

// flags.ts
export const flags = {
    SHOW_STATISTICS_INTERVAL: Number(process.env.SHOW_STATISTICS_INTERVAL || 1),
    CLIENT_MODE: "ping-pong",
    CLIENT_CONNECTION_NUM: Number(process.env.CLIENT_CONNECTION_NUM || 100),
    IP: process.env.IP || "127.0.0.1",
    PORT: Number(process.env.PORT || 9527),
    BUF_SIZE: Number(process.env.BUF_SIZE || 512),
    VCPU_NUM: Number(process.env.VCPU_NUM || 1), // TODO: Node is single-threaded, so this is not useful
}

You can run it with yarn dev:server and yarn dev:client after doing yarn install for dependencies 👍

• FILE: photon-node-echo-server.zip

Code_-_Insiders_yeqjIOQJUA.mp4

[beef9999]

It's QPS is 192K, throughput is 750Mb/s. I'd like to update it into my data sheet.

I'm not an expert here, please correct me if I'm wrong. So typescript is the project name and nodejs is the language? And what is its concurrency modle ? Coroutine ? Async callback ?

[GavinRay97]

Sure, Node.js is a runtime which uses Chrome V8 engine to allow JavaScript to execute on server.
It provides API's for interacting with network/filesystem etc.

TypeScript is a type-system for JavaScript -- it gets removed at runtime, and compiled into JavaScript.

TypeScript code (with types) --> transpile --> JavaScript code --> Node.js runs JS code --> executes on V8 C++ engine

• https://github.com/nodejs/node
  • Node.js is an open-source, cross-platform JavaScript runtime environment.
• https://v8.dev/
  • V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++. It is used in Chrome and in Node.js,
• https://github.com/microsoft/TypeScript
  • TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

I mostly use TypeScript as it makes the code easier to read/maintain,
It has no performance impact and disappears after compiling👍

---

And what is its concurrency modle ? Coroutine ? Async callback ?

It is async callback, the low-level net package in Node.js has event-listeners which fire callback functions when operations happen like data received, socket opened, connection acquired etc.

The server code is tiny, it just echos back out what it received:

function server() {
    const server = net.createServer()
    server.on("connection", (socket) => {
        socket.on("data", (data) => {
            console.count("server received ops")
            socket.write(data)
        })
    })
    server.listen(flags.PORT, flags.IP, () => {
        console.log(`server listening on ${flags.IP}:${flags.PORT}`)
    })
}

And then the callbacks are registered when the ClientSocket class is created here:
(I made some notes in comments below, for instance right now a static buffer is allocated, I'm not sure if this is supposed to be re-allocated every time)

class ClientSocket {
    // Should this be re-allocated every operation?
    // If so, this needs to be removed, see <---- down below
    private static buf: Buffer = Buffer.alloc(flags.BUF_SIZE)

    constructor() {
        this.socket = new net.Socket()
        this.sentOpsTotal = 0
        this.receivedOpsTotal = 0
        this.sentBytesTotal = 0
        this.receivedBytesTotal = 0
        this.lastOpStartTime = performance.timeOrigin
    }

	// Handlers for what should happen when data is received are registered as callbacks here
    async connect() {
        return new Promise((resolve, reject) => {
            this.socket.connect(flags.PORT, flags.IP, () => {
                resolve(this)
            })
            this.socket.on("data", (data) => {
                this.receivedOpsTotal++
                this.receivedBytesTotal += data.length
                // this.socket.write(Buffer.alloc(flags.BUF_SIZE))   <------
                this.socket.write(ClientSocket.buf)
                this.sentOpsTotal++
                this.sentBytesTotal += data.length
                this.lastOpStartTime = performance.now()
            })
            this.socket.on("error", (err) => {
                reject(err)
            })
        })
    }
}

[beef9999]

I was using my own client to test against your server, in order to reduce variables.

[GavinRay97]

Oh LOL, that makes a more sense doesn't it?

You may want to try commenting out this line
console.count("server received ops")

And see if it makes any difference btw

[beef9999]

Closed for #97