Fuites mémoires ?

**sergeh** · 13/12/2013, 11h14

Bonjour,

J'ai un "drôle" de soucis. Je dois traiter des fichiers. Je fais donc une boucle dessus. Lorsqu'il n'y en a pas beaucoup à traiter, tout va bien. Mais lorsque j'ai beaucoup de fichiers, ma boucle ralenti petit à petit et je vois la mémoire qui augmente.

Pour exemple, au début ma boucle traite 200 fichiers/s mais à l'approche du 2000e, elle ne traite plus qu'un fichier à la seconde. Au delà, ça ralentir encore et toujours. En même temps, je vois la RAM qui monte.

A chaque tour de boucle, toutes les variables ou objets que j'utilise sont réaffectées, je suppose donc que PHP est censé nettoyer la mémoire et virer les anciennes affectations.

Mais je ne sais pas comment vérifier cela, ni comment tracer ce genre de phénomène.

Quelqu'un peut-il m'aider ?

Merci par avance !!

**jurta** · 13/12/2013, 11h43

Salut!

Alors je suis pas sûre à 100% de ce que je dis mais à mon avis à chaque passage dans ta boucle, si tu traite le fichier, il est chargé en ram ce qui la rempli de plus en plus jusqu'à la saturer.

Est-ce que, dans ta boucle, tu supprime la connection au fichier après l'avoir traité? (peut être chercher du côté de la fonction "fclose" )

PS: Si tu peux nous passer ton code, ça nous aiderait à comprendre où se trouve le problème..

**Shuty** · 13/12/2013, 11h44

De manière personnel, j'évite de faire de gros traitement en PHP. Je préfère faire un appel sur un autre dev via un exec();

Un benchmark plutot intéressant :
http://herverenault.fr/comparaison-l...programmation/

La vitesse d’exécution et la gourmandise en RAM peu être corriger en allégeant / corrigeant la logique du code. Le benchmark est donc relatif.

**sergeh** · 13/12/2013, 15h06

@Shuty : Pour tout avouer, un traitement extarne ne m'arrange pas trop même si je conçoit qu'en effet PHP n'est pas trop fait pour les gros traitements.

@jurta : je n'utilise pas de fopen ni de fclose, mais plutôt des classes de chargement de contenu fichiers xml.

Voici le code "allégé" contenant les parties d'affectations de variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
for ($i = 0; $i < $nb_docs; $i++) { // Boucle sur l'ensemble des fichiers
        $filepath = $ar_docs[$i];
        $path_parts = pathinfo($filepath);
        set_time_limit(30);
 
        $document = new DOMDocument;
        if (@$document->loadHTMLFile($filepath) === FALSE) { // Chargement du contenu du fichier
            $logger->addDebug('Cannot load this HTML file');
        } else {
            $xpath = new DOMXPath($document);
 
            // Pour chaque balise <style> contenues dans le document, récupération des selecteurs
            // afin de mettre à jour les balises correspondantes
            $entries = $xpath->query('//html/head/style');
            foreach ($entries as $entry) :
                $matches = NULL;
                if (preg_match_all('/(?<selector>.*){(?<content>.*)}/', $entry->nodeValue, $matches, PREG_SET_ORDER)) :
                    foreach ($matches as $matche) :
 
                        // Transformation d'un selecteur CSS en expression XPath en utilisant
                        // la bibliothèque Zend
                        $domQuery = new Zend_Dom_Query_Css2Xpath();
                        $xpathQuery = $domQuery->transform($matche[1]);
                        foreach ($xpath->query($xpathQuery) as $result) :
                            $attributes = array();
                            if ($result->hasAttribute('style')) :
                                $attributes[] = rtrim($result->getAttribute('style'), ';');
                            endif;
                            $attributes[] = $matche[2];
                            $result->setAttribute('style', implode(';', $attributes));
                        endforeach;
 
                    endforeach;
                endif;
            endforeach;
 
			// Titre du courrier
            $title = $path_parts['filename'];
 
            // Enregistrement du courrier dans la base de données
            foreach ($users as $user) {
                $letterEntity = new Entities\Letters;
                $letterEntity->setUser($user);
                $letterEntity->setTitle($title);
                $letterEntity->setMsg($document->saveHTML($xpath->query('//html/body')->item(0)));
                $letterEntity->setType('contact');
                if (!empty($contactEntity))
                    $letterEntity->setContact($contactEntity);
                $entityManager->persist($letterEntity);
                $entityManager->flush();
            }
            // Courrier enregistré en base de données : on supprime le fichier
            @unlink($filepath);
        }
    }

Merci encore pour votre aide !!

**grunk** · 13/12/2013, 15h57

Tu peux commencer à débugger en utilisant memory_get_usage et memory_get_peak_usage

Après dans ton cas si tu as beaucoup de fichier à traiter et surtout si il sont de grosse taille il sera plus performant de passer par un parseur SAX plutôt que DomDocument et xpath.

**sergeh** · 13/12/2013, 16h55

@grunk : non ce ne sont que de petits fichiers qui font tous moins de 40Ko.
Je vais faire des tests avec les fonctions memory_get_*.

merci

**tdutrion** · 13/12/2013, 21h23

Je vais probablement dire une betise car je ne suis pas du tout specialiste de l'optimisation, mais je mettrais bien un unset sur le $document (ligne 6) en fin de boucle, car là je vois une masse de $document créés.

**jurta** · 16/12/2013, 11h55

Je suis aussi de l’avis de Théocrite.. Essaie déjà de fermer chacune de tes variables que tu déclares dans tes boucles. Personnellement je vois surtout $domQuery (Zend doit bien contenir une fonction de clôture de tes variables et sinon ba unset devrait le faire aussi)

Peut être que la solution n'y est pas mais ça peut jamais faire de mal

**Shuty** · 03/01/2014, 17h18

A priori les unset ne changeront rien au problème selon la doc:

unset() does just what it's name says - unset a variable. It does not force immediate memory freeing. PHP's garbage collector will do it when it see fits - by intention as soon, as those CPU cycles aren't needed anyway, or as late as before the script would run out of memory, whatever occurs first.

If you are doing $whatever = null; then you are rewriting variable's data. You might get memory freed / shrunk faster, but it may steal CPU cycles from the code that truly needs them sooner, resulting in a longer overall execution time.

Bon à savoir:

http://www.php.net/manual/en/feature...iderations.php