performance-optimization | correct common issues in a cloud-based system

No tool will give you that kind of metric because the best configuration depends greatly on your php scripts. If you have 4 cores and each request consumes 100% of one core for 1 second, the server will handle 4 request per second in the best case regardless of your mpm and php configuration. The type of hardware you have is also important. Some CPUs perform multiple times better than others.

Since you are using php_fpm, the apache mpm configuration will have little effect on performance. You just need to make sure the server doesn't crash with too many requests and have more apache threads than php processes. Note that the RAM is not the only thing that can make a server unreachable. Trying to execute more process than the CPU can handle will increase the load and the number of context switches, decrease the CPU cache efficiency and result in even lower performance.

The ideal number of php processes depends on how your scripts use CPU and other resources. If each script uses 50% of the time with I/O operations for example, 2 processes per core may be ideal. Assuming that those I/O operations can be done in parallel without blocking each other.

You'll also need to take into account the amount of resources used by other processes such as the DB. SQL databases can easily use more resources than the php scripts themselves.

Spare Servers and Spare Threads are the number of processes/threads that can be idle waiting for work. Creating threads takes time, so it's better to have them ready when a request arrives. The downside is that those threads will consume resources such as RAM even when idle, so you'll want to keep just enough of them alive. Both apache and php_fpm will handle this automatically. The number of idle threads will be reduced and increased as needed, but remain between the minimum and maximum values set in the configuration. Note that not all apache threads will serve php files as some requests may be fetching static files, therefore you should always have more apache threads than php processes.

Start Server and Start Threads represents just the number of processes/threads created during the startup. This have almost no effect on performance since the number of threads will be immediately increased or reduced to fit the values of Spare Threads.

MaxConnectionsPerChild and max_requests are just the maximum amount of requests executed during the process/thread life. Unless you have memory leaks, you won't need to tune those values.

The server block is exemplary for NGINX.

When using express, a Node.js compression middleware must be installed.

For Example:

/dev/shm/ is just a tmpfs mount point, like /tmp.

Memory you mmap in files there is normal WB cacheable, just like MAP_ANONYMOUS. It follows the normal x86 memory-ordering rules (program order + a store buffer with store forwarding) so you don't need SFENCE or LFENCE, only blocking compile-time reordering for acq_rel ordering. Or for seq_cst, MFENCE or a locked operation, like using xchg to store.

You can use C11 functions on pointers into SHM, for types that are lock_free. (Normally any power-of-2 size up to pointer width.)

Non-lock-free objects use a hash table of locks in the address-space of the process doing the operation, so separate processes won't respect each other's locks. 16-byte objects may still use lock cmpxchg16b which is address-free and works across processes, even though GCC7 and later reports it as non-lock-free for reasons even if you compile with -mcx16.

I don't think there is a way on a mainstream Linux kernel for user-space to allocate memory of any type other than WB. (Other than the X server or direct-rendering clients mapping video RAM; I mean no way to map ordinary DRAM pages with a different PAT memory type.) See also When use write-through cache policy for pages

Any type other than WB would be a potential performance disaster for normal code that doesn't try to batch stores up into one wide SIMD store. e.g. if you had a data structure in SHM protected by a shared mutex, it would suck if the normal accesses inside the critical section were uncacheable. Especially in the uncontended case where the same thread is repeatedly taking the same lock and reading/writing the same data.

So there's very good reason why it's always WB.