TMPFS : Faites vos install de machines virtuelles et vos db inserts en RAM

RAM

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 :

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

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

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

Editer la variable datadir de configuration MySQL :

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

Faites vos inserts puis restaurez la configuration originale :

1
2
3
4
5
6
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
Publié dans Linux, MySQL | Mots-clefs : , , , | Laisser un commentaire

Premier test de Silverlight et de WPF : Echecs d’Alice

Voici un test de Silverlight et de WPF avec un jeu d’Echecs d’Alice, la particularité « d’Alice » c’est de basculer de l’autre coté du « miroir » à chaque coups :

nicolas forcato echecs alice

Publié dans C#, C#, DotNet Framework | Mots-clefs : , , , | 1 réponse

jQuery et location.href ou redirection JavaScript avec une URL

jQuery

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/");
Publié dans JavaScript | Mots-clefs : , | 30 réponses

Application Web sur Smartphone (iPhone, Palm Pre, Android) réalisé pour l'Institut Français de la Vigne et du Vin

Web Application iPhone Nicolas Forcato
Voilà, comme promis je poste ici un screencast qui décrit et fait la démontration de l’application web que j’ai réalisé pour l’Institut Français de la Vigne et du Vin avec Christian Debord et Sylvain Guittard. Celle-ci complète un système d’information dédié à la prévision des risques épidémiques sur la vigne.

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

Vigne Mildiou Oidium Black-Rot maladies Nicolas Forcato

Visionner les vidéos en HD sur YouTube :

Publié dans AJAX, PHP, XML | Mots-clefs : , , , , , , , | 4 réponses

Compiler un projet 3D OpenGL en C sous Mac OS X ou Linux

« Hello Word » de programmation OpenGL en C sous Linux (Debian).
Pour cela ont peut utiliser la librairie GLUT pour réaliser un cube manipulable.

Sous Linux :

#include 

Compiler :

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

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

1
2
3
#include <openGL/gl.h>	   // Fichier Header pour OpenGL32 Library
#include <openGL/glu.h>    // Fichier Header pour GLu32 Library
#include <glut/glut.h>	  // Fichier Header pour GLut Library

Et utiliser la commande suivante pour la compilation :

1
gcc -framework GLUT -framework OpenGL -framework Cocoa source.c -o nom_executable
Cube en 3D - OpenGL - Mac OS X

Cube en 3D - OpenGL - Mac OS X

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
//----------------------------------------------------------------------
// Cube en 3D avec OpenGL
//----------------------------------------------------------------------
 
//----------------------------------------------------------------------
// LIBRAIRIES
//----------------------------------------------------------------------
// LIBRAIRIES et COMMANDE Linux :
// #include <gl/glut.h>
// #include <stdlib.h>
// gcc -o prog.exe  main.c -L/usr/X11R6/lib -lglut
 
#include <openGL/gl.h>		// Header File For The OpenGL32 Library
#include <openGL/glu.h>		// Header File For The GLu32 Library
#include <glut/glut.h>		// 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);
}
Publié dans C / C++, OpenGL | Mots-clefs : , , , , , , | 7 réponses
  • Flux RSS Nico dev'blog