Archives de Catégorie: Tips en vrac

Bookmark WordPress – poster du code

Comment poster du code dans worpress :
http://en.support.wordpress.com/code/posting-source-code/

Mysql et les limites de connections

Si vous avez déjà eu l’insigne honneur d’être gratifié par Mysql d’un ‘Too many connections’ la suite va vous intéresser. Par défaut MySQL accepte 151 connexions en simultanée.

connecter vous à MySQL

Quel est le nombre maximum de connexions qui ont été faites en même temps sur ma base.

mysql> show status like 'max%';
+----------------------+-------+
| Variable_name        | Value |
+----------------------+-------+
| Max_used_connections | 152   |
+----------------------+-------+
1 row in set (0,00 sec)

Quel est le nombre maximum de connexions paramétré dans MySQL

mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 151   |
+-----------------+-------+
1 row in set (0,00 sec)

Vu que le nombre maximum utilisé a dépassé le max paramétré, il est temps d’augmenter la limite, pour l’exemple je la passe à 512.

En live :

mysql> set GLOBAL max_connections=512;
Query OK, 0 rows affected (0,00 sec)
mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 512   |
+-----------------+-------+
1 row in set (0,00 sec)

et pour être sûr de son coup dans /etc/my.cnf ajouter la ligne max_connections=512

Et si vous voulez suivre facilement le nombre de connexions à votre base voila un petit shell fait à la va vite.

#!/bin/ksh

while [ 1 ]
do
        nbCnx=$(mysqladmin processlist | egrep -v '(^\+|^\|\ Id)' | wc -l)
        echo `date`" : "$nbCnx
        sleep 1
done

Electronique : découvrons les 555

Encore un article bookmark mais pour de l’électronique cette fois avec une centaine de montages réalisés avec des 555

http://www.talkingelectronics.com/projects/50%20-%20555%20Circuits/50%20-%20555%20Circuits.html

Shell : Avoir des options en plus des arguments

Rien d’innovant, mais une syntaxe comme celle là il faut l’avoir à portée de main 😉
Quelques contraintes que je ne retrouve pas dans d’autres langages : Les options doivent être passées avant les arguments.
ce bout de code permet d’analyser les options (ici -u qui attend un argument). Le reste des arguments ($1, $2,…) est à récupérer normalement, les options sont supprimées de la ligne d’appel après lecture (et donc ne décalent pas la numérotation des arguments).

#!/bin/ksh

uid=""
while getopts u: option
do
    case $option in
        u) uid="${OPTARG}" ;;
        🙂 echo "option -$OPTARG needs an argument" ;;
        [?]) echo "Usage incorrect : "
                echo "$0 [-u option] arg1 "
                exit 1
                ;;
    esac
done
shift $OPTIND-1

echo "uid : [$uid]"
echo "\$@ : $@"
echo "\$# : $#"

echo "\$1 : $1"

Sinon il y a la méthode complète : http://docstore.mik.ua/orelly/unix3/korn/appb_11.htm

Chasser les pertes de mémoire en C sous Linux

Pour un fois je vais pouvoir parler de ce que je fais pour le boulot. En effet, j’ai planché sur un sujet qui peut servir à autrui.
Un des programmes écrit par un de mes prédécesseur avait une fâcheuse tendance à prendre de plus en plus de mémoire jusqu’à bloquer la machine (tssss un process lancé en root).

Chasser les fuites mémoire est toujours un peu hasardeux, il suffit de peu pour que ça devienne mission impossible.

J’ai travaillé principalement avec deux « outils » : valgrind et /proc

L’approche valgrind

valgrind est un utilitaire dédié à l’inspection de la mémoire d’un programme. Il note toutes les zones allouées et vérifie si elles sont correctement désallouées a la fin de celui-ci.

Il existe de très bons tuto sur le net pour son utilisation, par exemple celui-ci : http://fr.openclassrooms.com/informatique/cours/debuguer-facilement-avec-valgrind

L’approche /proc/*/status

Bon ce n’est pas vraiment une méthode très académique, mais elle permet de se rendre compte précisément de la consommation mémoire en temps réel de son programme.

Le noyau Linux met a disposition de l’utilisateur un grand nombre d’information sur les processus en cours d’exécution.

Beaucoup de ses informations sont disponibles dans le point de montage /proc.

En ce qui nous concerne, chaque processus, connu par son pid met a disposition les informations sur sa conso mémoire dans le fichier /proc/<pid du processus>/status.

 $ cat /proc/523/status
 Name: firefox
 State: S (sleeping)
 Tgid: 523
 Pid: 523
 PPid: 1
 TracerPid: 0
 Uid: 1000 1000 1000 1000
 Gid: 1000 1000 1000 1000
 FDSize: 128
 Groups: 4 20 24 25 29 30 33 44 46 103 104 114 115 126 146 147 148 1000 1004 1010
 VmPeak: 1259364 kB
 VmSize: 1164072 kB
 VmLck: 0 kB
 VmPin: 0 kB
 VmHWM: 412984 kB
 VmRSS: 365880 kB
 VmData: 622216 kB
 VmStk: 200 kB
 VmExe: 92 kB
 VmLib: 116232 kB
 VmPTE: 1784 kB
 VmSwap: 0 kB
 Threads: 34
 SigQ: 0/95953
 SigPnd: 0000000000000000
 ShdPnd: 0000000000000000
 SigBlk: 0000000000000000
 SigIgn: 0000000000001000
 SigCgt: 0000000f800144af
 CapInh: 0000000000000000
 CapPrm: 0000000000000000
 CapEff: 0000000000000000
 CapBnd: ffffffffffffffff
 Cpus_allowed: f
 Cpus_allowed_list: 0-3
 Mems_allowed: 00000000,00000001
 Mems_allowed_list: 0
 voluntary_ctxt_switches: 3852953
 nonvoluntary_ctxt_switches: 874330
 

La zone qui m’intéresse dans le cas d’une zone mémoire c’est la ligne VmRSS (qui vaut ici 365880 kB).
Celle-ci reflete la quantité de mémoire alloué actuellement par le processus. Attention à la valeur des autres zones, certaines comme VmSize comptabilisent aussi les librairies partagées et les fichiers ouverts (même s’il ne sont pas chargés en mémoire !), il ne s’agit donc pas forcement de mémoire utilisée !

Grace à la lecture de ce pseudo fichier il est possible de vérifier en cours d’utilisation la mémoire consommée et de tracer son évolution à partir du programme.

En somme Valgrind permet de chasser la mémoire utilisée et /proc de vérifier qu’il n’y a pas de cas tordus qui pourraient passer à travers.

Pour automatiser la chose

un petit script

pid=`ps -fe | grep [nom du process] |grep -v grep | awk '{print $2}'` && cat /proc/$pid//status |grep Vm

une petite fonction

Vu qu’on me l’a demandé j’ai aussi une petite fonction (très fortement inspirée de celle-ci ) pour afficher dans la log l’état de la mémoire (en même temps que les éléments clef du programme)

int memStats()
{
  char * line;
  char *vmsize;
  char *vmdata;
  char *vmrss;
  char *vmstk;

  size_t len;

  FILE *f;
 
  vmsize = NULL;
  vmdata = NULL;
  vmrss = NULL;
  vmstk = NULL;
  len = 128;
  line = malloc ( len * sizeof( char ) ) ;

  char * path2status = malloc( 128 * sizeof( char ) );
  sprintf (path2status, "/proc/%d/status", getpid() );

  f = fopen(path2status, "r");
  if (!f)
  {
    free ( path2status );
    free ( line );
    return 1;
  }
  free ( path2status );
  /* Read memory size data from /proc/pid/status */
  while (!vmsize || !vmrss || !vmdata || !vmstk )
  {
    if ( fgets ( line, len, f ) == NULL )
    {
      /* Some of the information isn't there, die */
      free(line);
      fclose( f ) ;
      return 1;
    }

    /* Find VmSize */
    else if (!strncmp(line, "VmSize:", 7))
    {
      vmsize = strdup(&line[7]);
    }

    /* Find VmRSS */
    else if (!strncmp(line, "VmRSS:", 6))
    {
      vmrss = strdup(&line[7]);
    }

    /* Find VmData */
    else if (!strncmp(line, "VmData:", 7))
    {
      vmdata = strdup(&line[7]);
    }
    /* Find VmStk */
    else if (!strncmp(line, "VmStk:", 6))
    {
      vmstk = strdup(&line[7]);
    }

  }
  free(line);

  fclose(f);

  /* Get rid of " kB\n"*/
  len = strlen(vmsize);
  vmsize[len - 4] = 0;
  len = strlen(vmstk);
  vmstk[len - 4] = 0;
  len = strlen(vmrss);
  vmrss[len - 4] = 0;
  len = strlen(vmdata);
  vmdata[len - 4] = 0;

  /* Output results to stderr */
  fprintf( stderr, "<%s;%s;%s;%s>\n", vmrss, vmsize, vmstk, vmdata);

  free(vmstk);
  free(vmsize);
  free(vmrss);
  free(vmdata);
  return 0;
}

Bonne chasse …

Mettre de la couleur dans vos shell en perl

En balayant mes archives je tombe sur une librairie que j’avais écrite il y a quelques années.

Elle permet de changer « simplement » les attributs d’un texte écrit par un script shell Unix (ou Linux).
La librairie propose 4 fonctions :

  • color_fg_set_str , modifie la couleur d’écriture du texte
  • color_bg_set_str , modifié la couleur de fond d’écran du texte
  • curs_pos_str , déplace le curseur
  • decoration_set_str , bascule en gras, souligné, clignotant, …

use constant ESC_FMT		=> "\033[%sm";
use constant ESC_FMT1	=> "\033[%dm";
use constant ESC_FMT2	=> "\033[%d;%dm";
use constant ESC_FMT3	=> "\033[%d;%d;%dm";
#use constant CLR_SCR		=> "\f";
use constant CLR_SCR		=> "\033[2J";
use constant CLR_EOL		=> "\033[K";
use constant POS_CUR		=> "\033[%d;%dH";
use constant CUR_SAV		=> "\033[s";
use constant CUR_RES		=> "\033[u";
use constant FLUSH		=> CUR_SAV . "\n" . CUR_RES;
use constant ESC_FMTC1	=> "\033[%d%s";
use constant ESC_FMTC2	=> "\033[%d;%d%s";
use constant ESC_DEFAULT	=> "\033[0m\033[37;40m";

#	DECORATIONS
use constant OFF	  	=>  0;
use constant BOLD		  =>  1;
use constant UNDER	  =>  4;
use constant BLINK	  =>  5;
use constant REVERSE	=>  7;
use constant CONCEAL  =>  8;

#	COULEURS
use constant BLACK		=>  30;
use constant RED			=>  31;
use constant GREEN		=>  32;
use constant YELLOW		=>  33;
use constant BLUE			=>  34;
use constant MAGENTA	=>  35;
use constant CYAN			=>  36;
use constant WHITE		=>  37;

sub color_fg_set_str
{
	my $color = shift;	#couleur désiré
	$color = $default_fg_color if (! $color);
	if ($color >= BLACK && $color <= WHITE)	# couleur connue
	{
		return sprintf ESC_FMT1, $color;				# changement de couleur
	}
	return "";
}

sub curs_pos_str
{
	my ($lig, $col)= ( @_ );

	if ( $lig > 0 and $col > 0 )
	{ return sprintf(POS_CUR, $lig, $col); }
	else
	{	return ""; }
}

sub color_bg_set_str
{
	my $color = shift;	#couleur désiré
	$color = $default_bg_color if (! $color);
	if ( ( $color>=BLACK && $color<=WHITE ) )	# couleur connue
	{
		return sprintf ESC_FMT1, ($color + 10);			# changement de couleur
	}
	return "";
}

sub decoration_set_str
{
	my $decoration = shift;	#decoration désiré
	$decoration = $default_decoration if (! $decoration );
	if ( ( $decoration>=OFF && $decoration<=CONCEAL ) )	# decoration connue
	{
		return sprintf ESC_FMT1, ($decoration);			# changement de decoration
	}
	return "";
}


En espérant que cela serve à quelqu’un un jour

PS : Une mine d’info https://wiki.archlinux.org/index.php/Color_Bash_Prompt