¿Qué hace realmente serverperfmode=1 en macOS?

Activar el modo de rendimiento del servidor esencialmente aumenta algunos parámetros de red/kernel relacionados con la cantidad máxima de procesos y conexiones posibles/permitidos y modifica algunas configuraciones 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 servidores web) y conexiones para servir a más clientes al mismo tiempo y descartar subprocesos de servidor único más rápido 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 sobre el sistema operativo del consumidor, algunos ajustes básicos pueden ayudar al sistema operativo a ejecutar procesos para 25 usuarios que se conectan a un servidor en lugar de ajustarse para una persona que usa el sistema operativo. Estos ajustes son solo un punto de partida: cualquier persona que quiera que su servidor funcione bajo una carga alta necesita personalizar y monitorear 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 incorrecto detenga un servidor al agotar los recursos limitados, como los canales de señalización de comunicaciones entre procesos (ipc). En un sistema en el que se ejecuta un usuario, desea detener un proceso fuera de control antes que si hay docenas de procesos en ejecución para docenas de usuarios. Se puede considerar que el "rendimiento" aumenta algunos límites estrictos en lugar de "servir un archivo o una página web más rápido".

El modo de rendimiento del servidor (también conocido perfmodecomo 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, por lo tanto, permitir que se ejecuten muchos más procesos, que se abran archivos y que se establezcan conexiones de red. manejado, entre otras cosas. Todos los parámetros escalan con la cantidad de memoria instalada, dentro de los 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.

Aquí hay una breve descripción de un antiguo documento de soporte de Apple sobre Server 10.6:

• Por cada 8 GB de memoria instalada, están disponibles 2500 procesos y 150 000 vnodes.

• El número máximo de subprocesos se establece en cinco veces (5x) el número máximo de procesos. (Esto parece que ya no es cierto)
• Un único 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 subprocesos.

En 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 quiere profundizar en él, puede leer el código real. A continuación se muestra de El Capitán 10.11.6. El modo de 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 tuvo un aumento de rendimiento a partir de OS X 10.13 High Sierra si tiene al menos 12 GiB de memoria (cambios incluidos). en comentarios en el código).

La scale_seutpfunción configura el scalefactor como floor(memsize / 8 GiB)si tuviera habilitado 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, comenzando con High Sierra , memsize / 4 GiB. (El valor de task_maxal principio del fragmento de código se establece cuando se construye el kernel, y no está claro cómo lo establece Apple al distribuir 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: Tenga en cuenta que en lo anterior scale_setup, el factor de escala serverperfmodees la memoria del sistema dividida por 8 GiB, mientras que para el modo normal es la memoria del sistema dividida por 4 GiB. Por lo tanto, una computadora con 32 GiB de memoria tendrá el doble del factor de escala en el modo normal que en el modo de rendimiento, lo que hace que sea aún menos probable que desee usarla serverperfmodeen una máquina con mucha memoria.

El scalefactor se aplica en bsd_scale_setup(solo para un kernel de 64 bits) o aquí para High Sierra . Esto modifica los parámetros del kernel que se discutieron anteriormente y son visibles a través de sysctl. Tenga en cuenta que si el Modo de rendimiento del servidor no está habilitado, lo único que se escala es maxproc(532 -> 1064) y maxprocperuid(266 -> 709) hasta High Sierra, cuando maxfilesy maxfilesperproctambién se superan si tiene al menos 12 GiB de memoria. Dicho esto, los otros parámetros escalados serverperfmodese refieren principalmente al manejo de grandes cantidades de solicitudes de conexión de 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);
        }
    }

Finalmente, 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 se exec'd un proceso es digno de un capítulo completo en un libro sobre el kernel de Unix, por lo que no entraré en eso aquí. La consecuencia de alto nivel de esta configuración es que un número mayor ocupa más memoria, pero permite crear una mayor cantidad de procesos por segundo. (Aunque este código ha permanecido igual hasta el presente/Mojave, el efecto cambió con el cambio en cómo scalese calcula en High Sierra. Recuerde los detalles anteriores: en High Sierra y versiones posteriores, la escala es aproximadamente ( memory / 4 GiB) para el modo normal y ( memory / 8 GiB) para el modo de servidor. Entonces bsd_simul_execs, en realidad puede bajar cuando cambia al modo de 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);

Para El Capitan hasta el presente/Mojave, BSD_PAGEABLE_SIZE_PER_EXEC = 264 * 1024para mi Mac de 48 GiB, el kernel reservará alrededor de 67 MiB de memoria como espacio de búfer para configurar nuevos procesos que se generarán. Por un lado, es un número increíblemente alto, incluso para un servidor web. Por otro lado, 67 MiB son cacahuetes en comparación con los 48 GiB de la máquina.

Por lo tanto, 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 sale de control consumiendo recursos, pero aumenta en gran medida la capacidad del sistema para manejar muchas más tareas en segundo plano. Creo que Apple tomó la decisión correcta al no activarlo de forma predeterminada, sino que también lo hizo fácil de habilitar. Me alegro de que con High Sierra ahora estén aumentando los límites en modo normal si tienes suficiente memoria. Dejaría el modo de servidor desactivado (y lo he dejado desactivado) en todas mis computadoras hasta que me dé cuenta de que tienen problemas porque tengo muchos programas de servidor ejecutándose en él. Después de todo, no acelera el reloj del sistema, no aumenta la velocidad del disco y solo aumenta la E/S de la red si tiene cientos de conexiones. Allí'

Por otro lado, si realmente necesita ejecutar 2000 procesos, el modo servidor es su única opción hasta que llegue a High Sierra. La buena noticia es que es bastante fácil de encender, probar y, si no te gusta, volver a apagarlo.