Configurer Source Dedicated Server en Real-Time

A lire avant de poursuivre : Structure & agencement.

Prérequis : Compiler un noyau Linux 1000Hz & Real-Time pour Debian ou Ubuntu ou pour Red-Hat ou CentOS

Nous allons utiliser des fichiers faisant grimper le cpu à 100%. C'est à vous de voir si votre ordinateur chauffe trop et de l'entretenir le cas échéant. Je ne suis pas responsable des dégâts qui éventuellement pourraient apparaître, c'est à vous de savoir ce que vous faites !

Pour des performances maximales, le système d'exploitation a besoin de savoir quel processus est en temps réel. Par défaut, les processus ne sont pas considérés en temps réel.

Nous devons avoir un système d'exploitation temps réel, voici les liens des tutoriaux pour installer un noyau Real-Time :

Compiler un noyau Linux 1000Hz & Real-Time pour Debian ou Ubuntu
Compiler un noyau Linux 1000Hz & Real-Time pour Red-Hat ou CentOS

Le fichier de configuration qui nous intéresse ici s'appelle « server.cfg ». Il se charge au lancement du serveur (fichier comportant les variables de jeu, exécuté à chaque changement de maps).

nous allons éditer le fichier « server.cfg » (../cstrike/cfg/server.cfg).

nano ~/hlds/srcds/css/cstrike/cfg/server.cfg

Modifions les variables comme ceci :

fps_max 0
sv_maxupdaterate 101
sv_minupdaterate 100
sv_maxcmdrate 101
sv_mincmdrate 100
sv_maxrate 0
sv_minrate 35000

Il faut mettre à la ligne de lancement du serveur de jeu le tickrate à « 100 » (-tickrate 100).

Nous allons modifier le comportement des priorités. Nous allons faire passer notre serveur de jeux en real time, et tous les autres processus seront en priorité moindre.

Pour se faire, nous allons utiliser le script de fragaholics. Nous allons placer ce script dans le répertoire « /root » et nous l'appellerons « realtime.sh », rendons le exécutable en lui donnant les droits « 0744 ».

nano /root/realtime.sh
chmod 0744 /root/realtime.sh

PIDS=`ps ax | grep sirq-hrtimer | grep -v grep | sed -e "s/^ *//" -e "s/ .*$//"`
for p in $PIDS; do
chrt -f -p 99 $p
done

PIDS=`ps ax | grep sirq-timer | grep -v grep | sed -e "s/^ *//" -e "s/ .*$//"`
for p in $PIDS; do
chrt -f -p 51 $p
done

PIDS=`pidof srcds_run`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof srcds_linux`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof srcds_i686`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof srcds_i486`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof srcds_amd`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof hlds_i686`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof hlds_i486`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof hlds_amd`
for p in $PIDS; do
chrt -f -p 98 $p
done

PIDS=`pidof SCREEN`
for p in $PIDS; do
nice -n 19 chrt -f -p 10 $p
done

nice -n 19 renice 19 -u root
nice -n 19 renice 19 -u bind
nice -n 19 renice 19 -u www-data

Les 3 dernières lignes de code de ce scripts correspondent à des utilisateurs à qui nous allons donner un niveau de priorité encore moindre avec la commande « nice ». A vous de les trouver en faisant par exemple un htop et de les répercuter dans ce script. Je vous conseille de laisser root de la façon dont il est noté dans le script car cela nous servira pour la suite.

A ce script, nous allons rajouter une petite modification. Nous avons actuellement notre serveur de jeux en realtime si nous exécutons ce script, mais nous allons lui attribuer un niveau de priorité maximum. Pour ce faire, trouvez l'utilisateur qui fait tourner votre serveur de jeu. A titre d'exemple, mon utilisateur s'appelle mic. Donc à la fin de ce script, je rajoute ceci :

nice -n 19 renice -20 -u mic

Faites cette opération pour CHAQUE utilisateur qui lance un serveur si vous en avez plusieurs. 

Une fois ceci fait, nous allons utiliser le programme crontab pour executer ce script toutes les minutes, pour forcer chaque commande à être non prioritaire.

crontab -e

Et rajoutez ceci :

*/1 * * * * /root/realtime.sh > /dev/null 2>&1

Voila nous avons donc une priorité maximum sur les serveurs de jeu et vraiment le strict minimum sur le reste.

Maintenant nous allons nous occuper des « idler ». Ce sont des petits scripts qui vont forcer le processeur à monter à 100% de charge tout le temps, mais qui ne ralentiront pas notre serveur car ils seront en priorité minimum.

nous allons créer un fichier dans le répertoire « /root » nommé « idler.c ».

nano /root/idler.c

Contenant ceci :

int main() {
while(1);
}

(ligne vide)

Pensez à laisser une ligne vide à la fin du fichier pour éviter une erreur de compilation !

Ensuite nous allons le compiler.

gcc /root/idler.c -o /root/idler

Nous allons maintenant créer un script qui sera lancé au démarrage de l'ordinateur, qui permettra de lancer ce « idler ». Ce fichier sera différent si vous avez un simple coeur, un double coeur , un triple coeur ou un quadri coeur.

Créons un fichier nommé « idler.sh » dans le répertoire « /etc/init.d/ »

nano /etc/init.d/idler.sh

Rajoutons dedans ceci pour un processeur simple coeur :

#!/bin/sh

start() {
nice -n +19 screen -AmdS idler1 /root/idler
}
stop() {
killall -9 /root/idler
exit 0
}
case $1 in
stop)
stop
;;
start)
start
;;
*)
echo "Usage: {start|stop}" >&2
exit 3
;;
esac

Rajoutons dedans ceci pour un processeur double coeur :

#!/bin/sh

start() {
nice -n +19 taskset -c 0 screen -AmdS idler1 /root/idler
nice -n +19 taskset -c 1 screen -AmdS idler2 /root/idler
}
stop() {
killall -9 /root/idler
exit 0
}
case $1 in
stop)
stop
;;
start)
start
;;
*)
echo "Usage: {start|stop}" >&2
exit 3
;;
esac

Rajoutons dedans ceci pour un processeur triple coeur :

#!/bin/sh

start() {
nice -n +19 taskset -c 0 screen -AmdS idler1 /root/idler
nice -n +19 taskset -c 1 screen -AmdS idler2 /root/idler
nice -n +19 taskset -c 2 screen -AmdS idler3 /root/idler
}
stop() {
killall -9 /root/idler
exit 0
}
case $1 in
stop)
stop
;;
start)
start
;;
*)
echo "Usage: {start|stop}" >&2
exit 3
;;
esac

Rajoutons dedans ceci pour un processeur quadri coeur :

#!/bin/sh

start() {
nice -n +19 taskset -c 0 screen -AmdS idler1 /root/idler
nice -n +19 taskset -c 1 screen -AmdS idler2 /root/idler
nice -n +19 taskset -c 2 screen -AmdS idler3 /root/idler
nice -n +19 taskset -c 3 screen -AmdS idler4 /root/idler
}
stop() {
killall -9 /root/idler
exit 0
}
case $1 in
stop)
stop
;;
start)
start
;;
*)
echo "Usage: {start|stop}" >&2
exit 3
;;
esac

Rajoutons dedans ceci pour un processeur double quadri coeur :

#!/bin/sh

start() {
nice -n +19 taskset -c 0 screen -AmdS idler1 /root/idler
nice -n +19 taskset -c 1 screen -AmdS idler2 /root/idler
nice -n +19 taskset -c 2 screen -AmdS idler3 /root/idler
nice -n +19 taskset -c 3 screen -AmdS idler4 /root/idler
nice -n +19 taskset -c 4 screen -AmdS idler5 /root/idler
nice -n +19 taskset -c 5 screen -AmdS idler6 /root/idler
nice -n +19 taskset -c 6 screen -AmdS idler7 /root/idler
nice -n +19 taskset -c 7 screen -AmdS idler8 /root/idler
}
stop() {
killall -9 /root/idler
exit 0
}
case $1 in
stop)
stop
;;
start)
start
;;
*)
echo "Usage: {start|stop}" >&2
exit 3
;;
esac

Rendons le executable puis activons le démarrage automatique lors du boot.

chmod 0744 /etc/init.d/idler.sh
cd /etc/init.d 
update-rc.d idler.sh defaults 99

Voila, amusez-vous bien, et n'hésitez pas à poser vos questions.

Propulsé par Drupal