¿Qué hace realmente serverperfmode=1 en MacOS?

La activación del Modo de Rendimiento del Servidor aumenta esencialmente algunos parámetros del kernel/red relacionados con el número máximo de procesos y conexiones posibles/permitidas y modifica algunos ajustes de memoria/temporizador:

...
kern.maxvnodes: 66560 > 300000
kern.maxproc: 1064 > 5000
...
kern.maxfilesperproc: 10240 > 150000
kern.maxprocperuid: 709 > 3750
kern.ipc.maxsockbuf: 4194304 > 8388608
...
kern.ipc.somaxconn: 128 > 1024
...
kern.ipc.nmbclusters: 32768 > 65536
...
kern.ipc.sbmb_cnt_peak: 1120 > 1170
...
kern.ipc.njcl: 10920 > 21840
...
kern.timer.longterm.qlen: 100 > 0
kern.timer.longterm.threshold: 1000 > 0
...
net.inet.ip.maxfragpackets: 1024 > 2048
...
net.inet.tcp.tcbhashsize: 4096 > 8192
...
net.inet.tcp.fastopen_backlog: 10 > 200
...
net.inet6.ip6.maxfragpackets: 1024 > 2048
...
net.inet6.ip6.maxfrags: 2048 > 4096
#and some very special vm page-outs/compressor and and memory/cache settings

El objetivo es permitir más archivos abiertos (especialmente necesarios para los servidores web) y conexiones para servir a más clientes al mismo tiempo y descartar hilos de servidor individuales más rápidamente de la memoria / memoria virtual (si interpreto ciertas modificaciones correctamente).

En el pasado, Apple lanzó un sistema operativo diferente y ahora que el servidor se carga encima del sistema operativo de consumo, algunos ajustes básicos pueden ayudar al sistema operativo a ejecutar procesos para 25 usuarios que se conectan a un servidor en lugar de estar ajustado para una sola persona que utiliza el sistema operativo. Estos ajustes son sólo un punto de partida - cualquier persona que quiera que su servidor funcione bajo alta carga necesita personalizar y supervisar las cosas a un nivel mucho más detallado que tener el modo de rendimiento activado o desactivado.

Además, estos límites son principalmente para evitar que el software maligno haga caer un servidor agotando recursos limitados como los canales de señalización de comunicaciones entre procesos (ipc). En un sistema en el que se ejecuta un usuario, se quiere detener un proceso desbocado antes que si hay docenas de procesos ejecutándose para docenas de usuarios. El "rendimiento" puede verse como el aumento de algunos límites duros en contraposición a "servir un archivo o una página web más rápido".

Modo de rendimiento del servidor (también conocido como perfmode o serverperfmode ) cambia una serie de parámetros del kernel, reservando mucha más memoria para el kernel con el fin de proporcionar límites mucho más altos y así permitir que se ejecuten muchos más procesos, se abran archivos y se manejen conexiones de red, entre otras cosas. Todos los parámetros escalan con la cantidad de memoria instalada, dentro de unos límites, y nada cambia a menos que tenga al menos 16 GiB de memoria instalada . Los números de @klanomath corresponden a tener 16 GiB de memoria instalada.

Esta es una breve descripción de un antiguo documento de apoyo de Apple sobre el servidor 10.6:

• Por cada 8GB de memoria instalada, 2500 procesos y 150.000 vnodos están disponibles.

• El número máximo de hilos se fija en cinco veces (5x) el número de procesos máximos. (Parece que esto ya no es cierto)
• Un solo ID de usuario (uid) puede utilizar hasta el 75% del número máximo de procesos.
• Un solo proceso puede asignar hasta el 20% del valor máximo de los hilos.

Bajo el modo de rendimiento con 48 GiB de memoria, veo:

kern.maxvnodes: 900000
kern.maxproc: 15000
kern.maxprocperuid: 11250
kern.num_tasks: 15000
kern.num_taskthreads: 15000
kern.num_threads: 75000
kern.maxfiles: 900000
kern.maxfilesperproc: 450000

kern.ipc.maxsockbuf:8388608
kern.ipc.somaxconn: 2048
kern.ipc.nmbclusters: 131072
kern.ipc.sbmb_cnt_peak: # This parameter is not in my kernel
kern.ipc.njcl: 43688
...
kern.timer.longterm.qlen: 0 # same
kern.timer.longterm.threshold: 0 # same
...
net.inet.ip.maxfragpackets: 4096
...
net.inet.tcp.tcbhashsize: 32768
net.inet.tcp.fastopen_backlog: 600
...
net.inet6.ip6.maxfragpackets: 4096
net.inet6.ip6.maxfrags: 8192

Si realmente quieres profundizar en ello, puedes leer el código real. A continuación es de El Capitan 10.11.6. El modo servidor sigue siendo el mismo (hasta el código publicado más recientemente, que es de OS X 10.14 Mojave), pero el modo normal obtuvo una mejora de rendimiento a partir de OS X 10.13 High Sierra si tienes al menos 12 GiB de memoria (cambios incluidos en los comentarios del código).

El scale_seutp establece la función scale como floor(memsize / 8 GiB) si tiene activado el modo de rendimiento del servidor y al menos 16 GiB de memoria instalada. De lo contrario, es cero a menos que tenga al menos 3 GiB de memoria, en cuyo caso es 2, o, a partir de High Sierra , memsize / 4 GiB. (El valor de task_max al principio del fragmento de código se establece cuando se construye el kernel, y no está claro cómo lo establece Apple cuando distribuye OS X. Probablemente sea 1024).

    typeof(task_max) task_max_base = task_max;

    /* Raise limits for servers with >= 16G */
    if ((serverperfmode != 0) && ((uint64_t)sane_size >= (uint64_t)(16 * 1024 * 1024 *1024ULL))) {
        scale = (int)((uint64_t)sane_size / (uint64_t)(8 * 1024 * 1024 *1024ULL));
        /* limit to 128 G */
        if (scale > 16)
            scale = 16;
        task_max_base = 2500;
    } else if ((uint64_t)sane_size >= (uint64_t)(3 * 1024 * 1024 *1024ULL))
        scale = 2;
    /* Starting with OS X 10.13 High Sierra, if more than 8 GiB of memory,
     * scale = sane_size / 4 GiB with max of 16 (64 GiB or more)
     */

    task_max = MAX(task_max, task_max_base * scale);

    if (scale != 0) {
        task_threadmax = task_max;
        thread_max = task_max * 5; 
    }

Nota al margen: Obsérvese que en lo anterior scale_setup es que el factor de escala para serverperfmode es la memoria del sistema dividida por 8 GiB, mientras que para el modo normal es la memoria del sistema dividida por 4 GiB. Así que un ordenador con 32 GiB de memoria tendrá el doble de factor de escala en modo normal que en modo de rendimiento, lo que hace aún menos probable que quiera usar serverperfmode en una máquina con mucha memoria.

El scale se aplica el factor bsd_scale_setup (sólo para un núcleo de 64 bits) o aquí para High Sierra . Esto modifica los parámetros del kernel que se han comentado anteriormente y que son visibles a través de sysctl . Tenga en cuenta que si el Modo de Rendimiento del Servidor no está activado, el sólo lo que se escala es maxproc (532 -> 1064) y maxprocperuid (266 -> 709) hasta High Sierra, cuando maxfiles y maxfilesperproc también se incrementan si tienes al menos 12 GiB de memoria. Dicho esto, los otros parámetros escalados en serverperfmode son principalmente para manejar un gran número de solicitudes de conexión a la red, algo que es poco probable que necesite a menos que esté ejecutando un servidor web real con una carga muy alta.

    /* The initial value of maxproc here is 532 */
    if ((scale > 0) && (serverperfmode == 0)) {
        maxproc *= scale;
        maxprocperuid = (maxproc * 2) / 3;
        /* Starting with OS X 10.13 High Sierra, this clause is added
        if (scale > 2) {
            maxfiles *= scale;
            maxfilesperproc = maxfiles/2;
        }
        *** end of High Sierra addition */
    }
    /* Apply server scaling rules */
    if ((scale >  0) && (serverperfmode !=0)) {
        maxproc = 2500 * scale;
        hard_maxproc = maxproc;
        /* no fp usage */
        maxprocperuid = (maxproc*3)/4;
        maxfiles = (150000 * scale);
        maxfilesperproc = maxfiles/2;
        desiredvnodes = maxfiles;
        vnodes_sized = 1;
        tcp_tfo_backlog = 100 * scale;
        if (scale > 4) {
            /* clip somaxconn at 32G level */
            somaxconn = 2048;
            /*
             * For scale > 4 (> 32G), clip
             * tcp_tcbhashsize to 32K
             */
            tcp_tcbhashsize = 32 *1024;

            if (scale > 7) {
                /* clip at 64G level */
                max_cached_sock_count = 165000;
            } else {
                max_cached_sock_count = 60000 + ((scale-1) * 15000);
            }
        } else {
            somaxconn = 512*scale;
            tcp_tcbhashsize = 4*1024*scale;
            max_cached_sock_count = 60000 + ((scale-1) * 15000);
        }
    }

Por último, el factor de escala también se aplica en bsd_exec_setup . Esto configura cuánta memoria del kernel se reserva para ensamblar todos los datos necesarios para inicializar un proceso. Cómo un proceso es exec 'd es digno de un capítulo completo en un libro sobre el kernel de Unix, así que no entraré en él aquí. La consecuencia de alto nivel de esta configuración es que un número mayor ocupa más memoria, pero permite crear un mayor número de procesos por segundo. (Aunque este código ha permanecido igual hasta el presente/Mojave, el efecto cambió con el cambio en cómo scale se calcula en High Sierra. Recordemos los detalles anteriores: en High Sierra y posteriores, la escala es aproximadamente ( memory / 4 GiB ) para el modo normal y ( memory / 8 GiB ) para el modo servidor. Así que bsd_simul_execs puede bajar cuando se cambia al modo servidor).

    switch (scale) {
        case 0:
        case 1:
            bsd_simul_execs = BSD_SIMUL_EXECS;
            break;
        case 2:
        case 3:
            bsd_simul_execs = 65;
            break;
        case 4:
        case 5:
            bsd_simul_execs = 129;
            break;
        case 6:
        case 7:
            bsd_simul_execs = 257;
            break;
        default:
            bsd_simul_execs = 513;
            break;

    }
    bsd_pageable_map_size = (bsd_simul_execs * BSD_PAGEABLE_SIZE_PER_EXEC);

Desde El Capitán hasta el presente/Mojave, BSD_PAGEABLE_SIZE_PER_EXEC = 264 * 1024 Por lo tanto, para mi Mac de 48 GiB, el kernel reservará unos 67 MiB de memoria sólo como espacio de búfer para configurar los nuevos procesos que se generen. Por un lado, es un número muy alto, incluso para un servidor web. Por otro lado, 67 MiB es una miseria comparado con los 48 GiB de la máquina.

Así que el Modo de Rendimiento del Servidor ocupa más memoria, y hace que el sistema sea mucho más propenso a sufrir si algún programa se descontrola consumiendo recursos, pero aumenta enormemente la capacidad del sistema para manejar muchas más tareas en segundo plano. Creo que Apple ha acertado al no activarlo por defecto, pero también al facilitar su activación. Me alegra que con High Sierra ahora suban los límites en modo normal si tienes suficiente memoria. Yo dejaría el modo servidor desactivado (y lo he dejado desactivado) en todos mis ordenadores hasta que note que tienen problemas porque tengo muchos programas de servidor funcionando en él. Después de todo, no acelera el reloj del sistema, no aumenta la velocidad del disco, y sólo aumenta la E/S de la red si tienes cientos de conexiones. Hay una buena posibilidad de que tu firewall/router tenga problemas para mantener el ritmo si llegas al punto en que el modo servidor tiene un impacto real en el rendimiento de tu red.

Por otro lado, si realmente tienes la necesidad de ejecutar 2000 procesos, el modo servidor es tu única opción hasta que llegues a High Sierra. La buena noticia es que es bastante fácil de encender, probar, y si no te gusta, volver a apagar.