Les accès disques sont souvent les goulots d’étranglements de nos systèmes.

Ainsi, installer une machine virtuelle avec l’ensemble de ces logiciels, ou insérer/restaurer des tables conséquentes dans une base donnée MySQL prend parfois énormément de de temps.

Afin de se débarrasser de ces contraintes pour des traitements temporaires, pourquoi ne pas utiliser la RAM de votre machine ?

RAMFS

Sous Linux, on disposait déjà de RAMFS pour monter des volumes qui se réservent une part de RAM. Cependant, il a 2 inconvénient majeurs :

• Celui-ci ne tient pas compte de la limite de taille du volume. Ainsi même avec un volume réservé à 2Go sur 4Go de RAM par exemple, le système vous laisse écrire au-delà de cette limite… Rendant vos fichiers illisibles.
• Vous êtes limité à la taille de la RAM, tout en sachant que si vous atteignez certaines limites, votre système devient instable.

TMPFS

Depuis le noyau 2.6, Linux intègre TMPFS et contrairement à son prédécesseur :

• Il respecte la taille du volume défini.
• Il permet de définir des volumes plus grands que la RAM en utilisant intelligemment le SWAP.

Attention cependant : vous écrivez en RAM , ce volume sera donc vidé au reboot du système.

Comment utiliser TMPFS

Connectez vous en root ou utilisez sudo.

Creation du volume :

mkdir /mnt/voltemporaire
mount -t tmpfs -o size=10000m tmpfs /mnt/voltemporaire

Pour déplacer votre répertoire de données MySQL :

service mysql stop
cp -a /var/lib/mysql/* /mnt/voltemporaire/

Editer la variable datadir de configuration MySQL :

nano /etc/mysql/my.cnf
#datadir = /mnt/voltemporaire
chown dbuser1:mysql /mnt/voltemporaire
service mysql start

Faites vos inserts puis restaurez la configuration originale :

service mysql stop
cp -a /mnt/voltemporaire/* /var/lib/mysql/
nano /etc/mysql/my.cnf
#datadir = /var/lib/mysql
service mysql start
umount /mnt/voltemporaire

Je viens de chercher quelle est la fonction qui sert à faire une redirection JavaScript avec jQuery.

Et bien il n’y a pas d’intérêt d’utiliser jQuery pour cela, le plus simple est de modifier l’attribut location du document de cette manière :

document.location.href="http://www.web.site/";

Avec jQuery, je me suis attardé sur la fonction load(). Perdu ! :

$(location).attr('href',"http://www.web.site/");

• Qu’est que l’IFV ?
• Qu’est que le SI Épicure ?
• Quelles sont les technologies employées ?
• Comment fonctionne l’application ?

Je vous laisse découvrir tout cela dans les vidéos qui suivent.

Visionner les vidéos en HD sur YouTube :

Sous Linux :

#include 

Compiler :

gcc -o nom_executable  source.c -L/usr/X11R6/lib -lglut

Sur Mac OS X : avec Xcode, X11 et les Developper Tools :

#include 	   // Fichier Header pour OpenGL32 Library
#include     // Fichier Header pour GLu32 Library
#include 	  // Fichier Header pour GLut Library

Et utiliser la commande suivante pour la compilation :

gcc -framework GLUT -framework OpenGL -framework Cocoa source.c -o nom_executable

Cube en 3D - OpenGL - Mac OS X

Voici un petit exemple de programme OpenGL : un cube en 3D :

//----------------------------------------------------------------------
// Cube en 3D avec OpenGL
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// LIBRAIRIES
//----------------------------------------------------------------------
// LIBRAIRIES et COMMANDE Linux :
// #include 
// #include 
// gcc -o prog.exe  main.c -L/usr/X11R6/lib -lglut

#include 		// Header File For The OpenGL32 Library
#include 		// Header File For The GLu32 Library
#include 		// Header File For The GLut Library

//----------------------------------------------------------------------
// DECLARATION DES FONCTIONS
//----------------------------------------------------------------------
void keyboard(unsigned char key, int x, int y);
void display();
void mouse(int button, int state, int x, int y);
void mousemotion(int x, int y);
void reshape(int x, int y);

// STRUCTURE
typedef struct {
  float x, y, z, r, g, b;
} point;

//----------------------------------------------------------------------
// VARIABLES GLOBALES
//----------------------------------------------------------------------
float xold, yold, anglex = 0, angley = 0, presse = 0;

// Notre cube :
// Tout les points
point p[8] = {
{-0.5, -0.5, 0.5, 1.0, 0.0, 0.0},
{-0.5, 0.5, 0.5, 0.0, 1.0, 0.0},
{0.5, 0.5, 0.5, 0.0, 0.0, 1.0},
{0.5, -0.5, 0.5, 1.0, 1.0, 1.0},
{-0.5, -0.5, -0.5, 1.0, 0.0, 0.0},
{-0.5, 0.5, -0.5, 0.0, 1.0, 0.0},
{0.5, 0.5, -0.5, 0.0, 0.0, 1.0},
{0.5, -0.5, -0.5, 1.0, 1.0, 1.0}};

// Toutes les faces
int f[6][4] = {
{0, 1, 2, 3},
{3, 2, 6, 7},
{4, 5, 6, 7},
{0, 1, 5, 4},
{1, 5, 6, 2},
{0, 4, 7, 3}};

//----------------------------------------------------------------------
// MAIN
//----------------------------------------------------------------------
int main(int argc, char* argv[]){
  glutInit(&argc, argv);             // Initialise la b. glut
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // param d'affichage
  glutInitWindowPosition(200, 200);  // Fenetre : position
  glutInitWindowSize(250, 250);      // Fenetre : taille
  glutCreateWindow("OpenGL - Cube 3D - Nicotouch.com");          // Fenetre : Nom

  glClearColor(0, 0, 0, 0);          // Défaut : Couleur de fond
  glPointSize(2.0);                  // Taille d'un point
  glEnable(GL_DEPTH_TEST);           // Utilisation du Tampon de Profondeur

  // Gestion des évènement :
  glutDisplayFunc(affichage);        // Fonction qui gère l'affichage
  glutKeyboardFunc(clavier);         // Fonction qui gère les commandes clavier

  glutMouseFunc(mouse);              // Prendre en compte les fonctions
  glutMotionFunc(mousemotion);       // Fonction de gestion du clic de la Souris
  glutReshapeFunc(reshape);          // Fonction de gestion du redimentionnement de la fenêtre
  glutMainLoop();                    // Boucle d'attente des évènements

}

//----------------------------------------------------------------------
// CLAVIER : gère l'activation de différent mode d'affichage
//----------------------------------------------------------------------
void keyboard(unsigned char key, int x, int y){
  switch(key){ // en fonction des touches, on affiche :
    case 'p':
      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Texture
      glutPostRedisplay(); // Raffraichissement
      break;
    case 'f':
      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Arrête
      glutPostRedisplay();
      break;
    case 's':
      glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // Point
      glutPostRedisplay();
      break;
    case 'd':
      glEnable(GL_DEPTH_TEST);  // Avec tampon de profondeur
      glutPostRedisplay();
      break;
    case 'D':
      glDisable(GL_DEPTH_TEST); // Sans tampon de profondeur
      glutPostRedisplay();
      break;
    case 'q':                   // Quitter
	  //close(0);
      break;
  }
}

//----------------------------------------------------------------------
// AFFICHAGE : dessine la forme
//----------------------------------------------------------------------
void display(){
  int i, j;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Reset + double tampon
  for(i = 0; i < 6; i++) {                // Pour chaque face
    glBegin(GL_POLYGON);                  // On dessine un nouveau polygone
    for(j = 0; j < 4; j++) {              // Pour chaque sommet
      glColor3f(p[f[i][j]].r, p[f[i][j]].g, p[f[i][j]].b);
      glVertex3f(p[f[i][j]].x, p[f[i][j]].y, p[f[i][j]].z);
    }
    glEnd();                              // Fin du Polygone
  }

  glFlush();                              // On force l'affichage

  glLoadIdentity();                       // On initialise la matrice de translation
  //gluLookAt(-1.0,0.0,5.0,0.0,0.0,0.0,0.0,1.0,0.0);
  glRotatef(-anglex, 0.0, 1.0, 0.0);      // pour faire des rotation
  glRotatef(-angley, 1.0, 0.0, 0.0);

  glutSwapBuffers();
}

//----------------------------------------------------------------------
// MOUSE : récupère les évènements souris
//----------------------------------------------------------------------
void mouse(int button, int state, int x, int y){
  // Si on appuie sur le bouton gauche
  if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
    presse = 1; // Le booléen passe devient vrai
    xold = x;   // On sauvegarde la position
    yold = y;
  }
  // Si on relache le bouton
  if(button == GLUT_LEFT_BUTTON && state == GLUT_UP) presse = 0;
}

//----------------------------------------------------------------------
// MOUSEOPTION : effectue la rotation
//----------------------------------------------------------------------
void mousemotion(int x, int y) {
  if(presse == 1) {				// Si le bouton est pressé
    anglex = anglex + (x-xold); // On modifie la position actuelle de la souris
    angley = angley + (y-yold); // en fonction de la position actuelle de la
    glutPostRedisplay();        // souris et de la dernière sauvegarde
  }
  xold = x; // On sauvegarde la position actuelle de la souris
  yold = y;
}

//----------------------------------------------------------------------
// RESHAPE : Redimentionnement de la fenêtre
//----------------------------------------------------------------------
void reshape(int x, int y) {
  if(x < y) glViewport(0, (y-x)/2, x, x);
  if(y < x) glViewport((x-y)/2, 0, y, y);
}