Que fait réellement serverperfmode = 1 sur macOS?

L'activer est décrit ici mais il n'y a aucun détail.

Il y a une description vague:

Le mode Performance modifie les paramètres système de votre Mac. Ces modifications profitent mieux de votre matériel pour les applications serveur exigeantes.

Qu'est-ce qui change réellement à l'intérieur du système / noyau?

L'activation du mode de performance du serveur augmente essentiellement certains paramètres noyau / net liés au nombre maximal de processus et de connexions possibles / autorisés et modifie certains paramètres de mémoire / minuterie:

...
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

L'objectif est de permettre à des fichiers plus ouverts (particulièrement nécessaires pour les serveurs Web) et aux connexions de servir plus de clients en même temps et de supprimer les threads de serveur unique plus rapidement de la mémoire / mémoire virtuelle (si j'interprète correctement certaines modifications).

Dans le passé, Apple a publié un système d'exploitation différent et maintenant que le serveur se charge sur le système d'exploitation grand public, certains réglages de base peuvent aider le système d'exploitation à exécuter des processus pour 25 utilisateurs qui se connectent à un serveur au lieu d'être réglés pour une seule personne utilisant le système d'exploitation. Ces réglages ne sont qu'un point de départ - quiconque souhaite que son serveur fonctionne sous une charge élevée doit personnaliser et surveiller les choses à un niveau beaucoup plus détaillé que d'activer ou de désactiver le mode de performance.

En outre, ces limites visent principalement à empêcher les mauvais logiciels de faire tomber un serveur en épuisant des ressources limitées comme les canaux de signalisation de communications inter-processus (ipc). Sur un système sur lequel un utilisateur est en cours d'exécution, vous souhaitez arrêter un processus incontrôlable plus tôt que s'il y avait des dizaines de processus en cours d'exécution pour des dizaines d'utilisateurs. La «performance» peut être considérée comme soulevant certaines limites strictes au lieu de «servir un fichier ou une page Web plus rapidement».

Le mode de performance du serveur (aka perfmodeou serverperfmode) modifie un certain nombre de paramètres du noyau, réservant beaucoup plus de mémoire pour le noyau afin de fournir des limites beaucoup plus élevées et ainsi permettre à beaucoup plus de processus de s'exécuter, aux fichiers d'être ouverts et aux connexions réseau d'être entre autres. Tous les paramètres évoluent avec la quantité de mémoire installée, dans les limites, et rien ne change sauf si vous avez au moins 16 Go de mémoire installés . Les nombres de @ klanomath correspondent à 16 Go de mémoire installés.

Voici une brève description d'un ancien document de support d'Apple sur le serveur 10.6:

• Pour chaque 8 Go de mémoire installée, 2500 processus et 150 000 nœuds virtuels sont disponibles.
• Le nombre maximal de threads est défini sur cinq fois (5x) le nombre de processus maximum. (Cela ne semble plus être vrai)
• Un ID utilisateur unique (uid) peut utiliser jusqu'à 75% du nombre maximal de processus.
• Un seul processus peut allouer jusqu'à 20% de la valeur maximale des threads.

En mode performance avec 48 Gio de mémoire, je vois:

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 vous voulez vraiment y creuser, vous pouvez lire le code réel. Ci-dessous est tiré d'El Capitan 10.11.6. Le mode serveur est toujours le même (jusqu'au code le plus récent publié, qui provient d'OS X 10.14 Mojave), mais le mode normal a obtenu une augmentation des performances à partir d'OS X 10.13 High Sierra si vous avez au moins 12 Gio de mémoire (changements inclus dans les commentaires du code).

La scale_seutpfonction configure le scalefacteur comme floor(memsize / 8 GiB)si le mode de performances du serveur était activé et au moins 16 Go de mémoire installés. Sinon, il est nul sauf si vous avez au moins 3 Gio de mémoire, auquel cas il est de 2, ou, à partir de High Sierra , memsize / 4 Gio. (La valeur de task_maxau début de l'extrait de code est définie lors de la construction du noyau, et on ne sait pas comment il est défini par Apple lors de la distribution d'OS X. Il s'agit probablement de 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; 
    }

Ensuite, ce scalefacteur est appliqué dans bsd_scale_setup(uniquement pour un noyau 64 bits) ou ici pour High Sierra . Cela modifie les paramètres du noyau qui sont discutés ci-dessus et sont visibles via sysctl. Notez que si le mode de performance du serveur n'est pas activé, la seule chose qui est mise à l'échelle est maxproc(532 -> 1064) et maxprocperuid(266 -> 709) jusqu'à High Sierra, quand maxfileset maxfilesperprocsont également bumpés si vous avez au moins 12 Gio de mémoire.

    /* 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);
        }
    }

Enfin, le facteur d'échelle est également appliqué dans bsd_exec_setup. Cela configure la quantité de mémoire du noyau réservée pour assembler toutes les données nécessaires à l'initialisation d'un processus. Comment un processus est exec-il digne d'un chapitre complet dans un livre sur le noyau Unix donc je ne vais pas y entrer ici. La conséquence de haut niveau de ce paramètre est qu'un plus grand nombre occupe plus de mémoire, mais permet la création d'un plus grand nombre de processus par seconde. (Bien que ce code soit resté le même jusqu'à présent / Mojave, l'effet a changé avec le changement de mode de scalecalcul dans High Sierra. Rappelez-vous les détails ci-dessus: dans High Sierra et versions ultérieures, l'échelle est à peu près ( memory / 4 GiB) pour le mode normal et ( memory / 8 GiB) pour le mode serveur. Donc, vous bsd_simul_execspouvez réellement baisser lorsque vous passez en mode serveur.)

    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);

Pour El Capitan à travers le présent / Mojave, BSD_PAGEABLE_SIZE_PER_EXEC = 264 * 1024donc pour mon Mac de 48 Gio, le noyau réservera environ 67 Mio de mémoire juste comme un espace tampon pour la mise en place de nouveaux processus à générer. D'un côté, c'est un chiffre fou, même pour un serveur web. En revanche, 67 Mio sont des arachides par rapport aux 48 Gio sur la machine.

Le mode de performance du serveur prend donc plus de mémoire et rend le système beaucoup plus susceptible de souffrir si un programme devient incontrôlable en consommant des ressources, mais augmente considérablement la capacité du système à gérer beaucoup plus de tâches en arrière-plan. Je pense qu'Apple a fait le bon appel en ne l'activant pas par défaut mais en facilitant également l'activation. Je suis heureux qu'avec High Sierra, ils augmentent maintenant les limites en mode normal si vous avez suffisamment de mémoire. Je laisserais le mode serveur désactivé (et je l'ai laissé désactivé) sur tous mes ordinateurs jusqu'à ce que je les remarque rencontrer des problèmes parce que j'ai tellement de programmes serveur en cours d'exécution. Après tout, cela n'accélère pas l'horloge système, n'augmente pas la vitesse du disque et n'augmente les E / S réseau que si vous avez des centaines de connexions. Là'

D'un autre côté, si vous avez vraiment besoin d'exécuter 2000 processus, le mode serveur est votre seule option jusqu'à ce que vous arriviez à High Sierra. La bonne nouvelle est qu'il est assez facile de l'allumer, de l'essayer et, si vous ne l'aimez pas, de l'éteindre.