I can only run 400 concurrent requests on my machine(4c 8g). Is this normal?

[lixiangzzz2017]

as title.
the cpu utilization will raised up to 95%
the code are as below.
sleep 20ms to simulate real phone

package main

import (
	"fmt"
	"io"
	"net/http"
	_ "net/http/pprof"
	"os"
	"postsuperman/codec/g729"
	"strconv"
	"sync"
	"time"
)

/*
#include <stdio.h>
int sum(int a, int b) {
    return a + b;
}
*/
import "C"

func main() {
	go func() {
		err := http.ListenAndServe("0.0.0.0:6065", nil)
		if err != nil {
			fmt.Println(err)
		}
	}()

	dirName := os.Args[1]
	list, err := os.ReadDir(dirName)
	if err != nil {
		panic(err)
	}

	concurrency, err := strconv.Atoi(os.Args[2])
	fmt.Println(concurrency)
	if err != nil {
		panic(err)
	}

	m := map[string][][]byte{}
	for _, entry := range list {
		fullName := dirName + "/" + entry.Name()
		inputWAV, err := os.Open(fullName)
		if err != nil {
			panic(err)
		}

		wavHeader := make([]byte, 44)
		if _, err = inputWAV.Read(wavHeader); err != nil {
			panic(err)
		}

		arr := [][]byte{}
		for {
			buf := make([]byte, 160)
			if n, err := inputWAV.Read(buf); err == io.EOF {
				break
			} else if err != nil {
				break
			} else if n != 160 {
				// ignore last frame if frame size is invalid
				break
			}
			arr = append(arr, append([]byte{}, buf...))
		}
		m[entry.Name()] = arr
	}
	concurrentCh := make(chan struct{}, concurrency)
	for {
		wg := &sync.WaitGroup{}
		for i := 0; i < 500; i++ {
			for _, v := range m {
				wg.Add(1)
				go func(wg *sync.WaitGroup, v [][]byte) {
					concurrentCh <- struct{}{}
					defer func() {
						<-concurrentCh
					}()
					defer wg.Done()

					enc := g729.NewEncoder(false)
					defer enc.Close()
					dec := g729.NewDecoder()
					defer dec.Close()
					for _, value := range v {
						// for range v {
						time.Sleep(20 * time.Millisecond)
						// C.sum(C.int(2), C.int(3))
						if encodedByte, err := enc.Encode(value); err != nil {
							return
						} else {
							if _, err := dec.Decode(encodedByte); err != nil {
								return
							}
						}
					}
				}(wg, v)
			}
		}
		wg.Wait()
	}
}

[Image]

[jeannotlapin]

Hi,
on a relatively old CPU (intel core i5-6600T), a single core can encrypt/decrypt around 250 streams (doing really only that). 400 streams/core seems to be realistic for some more modern CPU core.

A common performance issue with this lib is to build it without the optimization flag (-O2),. When not present it will increase the request on CPU by a factor 3. If your test runs only on the CPU and does not use the GPU (which seems likely) it leaves you with 4 cores running it. 100 streams/core without the -O2 on the build line is more or less expected.

[lixiangzzz2017]

Thank you. At which step should I add the flag (O2) during the build? I built it according to the instructions on the homepage.

[jeannotlapin]

To enable -O2 option on the compiler command line you must add

-DCMAKE_BUILD_TYPE=RelWithDebInfo

to the cmake configuration command

[lixiangzzz2017]

I've already tried to build with -O2 option, the machine can run 1200 streams now, nearly about 3 times before.Really appreciate. Why dont you guys add it into the instructions on homepage