¿Qué hace serverperfmode = 1 realmente en macOS?

Aquí se describe su activación, pero no hay detalles.

Hay una descripción vaga:

El modo de rendimiento cambia los parámetros del sistema de su Mac. Estos cambios aprovechan mejor su hardware para aplicaciones de servidor exigentes.

¿Qué está cambiando realmente dentro del sistema / kernel?

La activación del modo de rendimiento del servidor aumenta esencialmente algunos parámetros del núcleo / red relacionados con el número máximo 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 hilos de servidor individuales 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 ese 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 estar sintonizados para una persona que usa el sistema operativo. Estas afinaciones son solo un punto de partida: cualquier persona que quiera que su servidor funcione bajo una gran carga debe 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 un mal software derribe un servidor agotando recursos limitados como los canales de señalización de comunicaciones entre procesos (ipc). En un sistema en el que se está ejecutando un usuario, desea detener un proceso descontrolado antes que si hay docenas de procesos ejecutándose para docenas de usuarios. Se puede ver que el "rendimiento" aumenta algunos límites duros en lugar de "servir un archivo o una página web más rápido".

El modo de rendimiento del servidor (también conocido como perfmodeo serverperfmode) cambia una serie de parámetros del núcleo, reservando mucha más memoria para el núcleo 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 los archivos y se conecten las conexiones de red manejado, entre otras cosas. Todos los parámetros se 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 el Servidor 10.6:

• Por cada 8 GB de memoria instalada, hay disponibles 2.500 procesos y 150.000 vnodos.
• El número máximo de subprocesos se establece en cinco veces (5x) el número de procesos máximos. (Esto ya no parece ser cierto)
• Un solo ID de usuario (uid) puede usar 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 es 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 tiene 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 núcleo, 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; 
    }

Entonces ese scalefactor se aplica en bsd_scale_setup(solo para un núcleo de 64 bits) o aquí para High Sierra . Esto modifica los parámetros del núcleo que se analizan anteriormente y son visibles a través de sysctl. Tenga en cuenta que si el modo de rendimiento del servidor no está activado, la única cosa que se escala es maxproc(532 -> 1064) y maxprocperuid(266 -> 709) hasta High Sierra, cuando maxfilesy maxfilesperproctambién se chocó si tiene al menos 12 GiB de memoria.

    /* 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 la cantidad de memoria del kernel reservada para ensamblar todos los datos necesarios para inicializar un proceso. Cómo es un proceso es execdigno de un capítulo completo en un libro sobre el núcleo de Unix, así que no voy a entrar aquí. La consecuencia de alto nivel de esta configuración es que un número mayor ocupa más memoria, pero permite que se cree un mayor número de procesos por segundo. (Aunque este código se ha mantenido igual durante 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 más tarde, la escala es aproximadamente ( memory / 4 GiB) para el modo normal y ( memory / 8 GiB) para el modo de servidor. Por bsd_simul_execslo tanto, 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 a través del presente / Mojave, BSD_PAGEABLE_SIZE_PER_EXEC = 264 * 1024por lo que para mi Mac GiB 48 el núcleo reservará alrededor de 67 MiB de memoria, justo como espacio de búfer para configurar nuevos procesos que se generarán. Por un lado, ese es un número muy alto, incluso para un servidor web. Por otro lado, 67 MiB son cacahuetes en comparación con los 48 GiB en la máquina.

Por lo tanto, el Modo de rendimiento del servidor ocupa más memoria y hace que sea mucho más probable que el sistema sufra si algún programa se sale de control y consume recursos, pero aumenta en gran medida la capacidad del sistema para manejar muchas más tareas en segundo plano. Creo que Apple hizo la llamada correcta al no activarla de manera predeterminada, sino que también facilitó la activación. Me alegra que con High Sierra ahora estén aumentando los límites en modo normal si tienes suficiente memoria. Dejaría el modo de servidor apagado (y lo dejé apagado) en todas mis computadoras hasta que note 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 red si tiene cientos de conexiones. Allí'

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