Optimització

• Temps execució excessiu
• Consum de memòria
• Variables global vs $GLOBALS

Temps execució excessiu

L'execució excessiva de temps (latència) en PHP es refereix al temps que el servidor triga a processar un script PHP, des que comença fins que genera la resposta completa. Una latència alta és un indicador crític de mal rendiment, ja que resulta en pàgines web que triguen a carregar, una mala experiència d'usuari (UX) i, finalment, en la pèrdua de trànsit i conversions.

Causes de la Latència Excessiva en PHP

La latència alta no sol ser causada per un únic factor, sinó per la combinació de diversos colls d'ampolla:

Formes de Detecció (Mesurament)

Per corregir la latència, primer s'ha de mesurar i determinar el codi exacte que causa el problema.

- Eines a Nivell de Programació (Instrumentació Manual)

Aquest mètode implica afegir codi al propi script per mesurar el temps d'execució de blocs concrets:

Exemple d'ús (microtime):

$inici = microtime(true);

// Codi a mesurar (p. ex., una consulta a BD)
$resultat = executar_consulta_lenta();         //usleep(2000000);

$fi = microtime(true);
$temps_execucio = $fi - $inici;
echo "La consulta ha trigat: " . $temps_execucio . " segons.";

Exemple d'ús (hrtime):

<?php

// 1. Marcar l'inici del temps d'alta resolució.
// hrtime(true) retorna un enter (int) que representa nanosegons.
$temps_inici_nanosegons = hrtime(true);

// =========================================================
// FUNCIÓ A MESURAR (p. ex., un algorisme d'ordenació ràpid)
// =========================================================

function ordenar_i_processar(array $dades): void {
    // Ordenació ràpida (quicksort o similar intern)
    sort($dades);
    
    // Simular un petit processament posterior
    $suma = 0;
    foreach ($dades as $valor) {
        $suma += strlen((string)$valor);
    }
}

// Dades de prova (10.000 elements)
$dades = array_map(fn() => mt_rand(10000, 99999), range(1, 10000));

// Executar la funció
ordenar_i_processar($dades);

// =========================================================
// FI DE LA FUNCIÓ
// =========================================================

// 2. Marcar el final del temps d'alta resolució.
$temps_final_nanosegons = hrtime(true);

// 3. Càlcul de la durada en nanosegons.
$durada_nanosegons = $temps_final_nanosegons - $temps_inici_nanosegons;

// 4. Conversió del resultat per a una millor lectura: de nanosegons a segons.
// (1 segon = 1.000.000.000 nanosegons)
$durada_segons = $durada_nanosegons / 1e9; // 1e9 és 1.000.000.000

echo "<h2>Mesurament amb hrtime()</h2>";
echo "<ul>";
echo "<li>Temps de Càlcul (Nanosegons): **" . number_format($durada_nanosegons, 0, ',', '.') . " ns**</li>";
echo "<li>Temps de Càlcul (Segons): **" . number_format($durada_segons, 8) . " s**</li>";
echo "</ul>";

 

Exemple d'ús (REQUEST_TIME_FLOAT):

<?php

// Aquest valor es va establir automàticament per PHP quan la petició
// al servidor va començar, amb precisió de microsegons.
$temps_inici = $_SERVER['REQUEST_TIME_FLOAT'];

// =========================================================
// INICI DEL CODI DE L'APLICACIÓ (Simulació de càrregues)
// =========================================================

// Simulació d'una operació lenta (p. ex., consultes a BD o I/O)
// Utilitzem 'usleep' per simular una pausa d'1,5 segons (1.500.000 microsegons)
usleep(1500000); 

// 2. Més càlculs...
$dades_processades = [];
for ($i = 0; $i < 100000; $i++) {
    $dades_processades[] = md5(random_bytes(10));
}

// 3. Generació del contingut (p. ex., carregar una plantilla)
echo "<h1>Pàgina carregada amb èxit!</h1>";
// =========================================================
// FI DEL CODI DE L'APLICACIÓ
// =========================================================

// Càlcul del temps d'execució total
$temps_final = microtime(true);
$temps_total = $temps_final - $temps_inici;

// Mostra el resultat a l'usuari
echo "<hr>";
echo "<h3>Diagnòstic de Rendiment (Servidor):</h3>";
// El número es formata per a una millor llegibilitat, mostrant 4 decimals
echo "Temps d'Execució Total de l'Script: <strong>" . number_format($temps_total, 4) . " segons</strong>.";

 

- Eines de Profiling (Anàlisi Detallada)

Aquestes eines són la forma més eficient de detectar colls d'ampolla, ja que registren el temps i la memòria consumida per cada funció o mètode cridat durant l'execució del script.

Eines a Nivell de Configuració (PHP.INI)

La configuració del fitxer php.ini (o del servidor) és vital per controlar i mitigar els efectes d'una execució excessiva de temps:

Consum de memòria

El consum de memòria elevat en PHP és un problema crític que es produeix quan un script utilitza més memòria RAM de la disponible o permesa pel sistema. En l'àmbit d'aplicacions web, pot conduir a una inestabilitat greu del servidor i errors fatals.

Causes del Consum de Memòria Elevat en PHP 

L'ús descontrolat de memòria sol ser causat per la gestió inadequada de grans volums de dades:

Detecció del Consum de Memòria (Mesurament)

Per diagnosticar el consum de memòria, PHP ofereix funcions natives i eines de perfilat avançades.

- Eines de Programació (Instrumentació Manual)

Les funcions natives de PHP permeten obtenir la memòria utilitzada en un moment precís de l'execució:

Exemple d'ús per detectar un pic de memòria:

<?php
// Mesurar l'ús de memòria abans de carregar dades
$mem_inici = memory_get_usage(true);

// 1. Càrrega massiva simulada
$grans_dades = array_fill(0, 100000, str_repeat('X', 100)); // 100k strings de 100 bytes cadascun

// 2. Mesurar el pic de memòria durant l'operació
$mem_pic = memory_get_peak_usage(true);

// 3. Alliberament de memòria (ajuda al GC)
unset($grans_dades);

// 4. Mesurar l'ús després de l'alliberament
$mem_final = memory_get_usage(true);

echo "<h3>Diagnòstic de Memòria:</h3>";
echo "<li>Memòria Abans de Càrrega: " . round($mem_inici / 1024 / 1024, 2) . " MB</li>";
echo "<li>**Pic Màxim de Memòria:** **" . round($mem_pic / 1024 / 1024, 2) . " MB**</li>";
echo "<li>Memòria Després d'Alliberar: " . round($mem_final / 1024 / 1024, 2) . " MB</li>";

- Eines de Profiling (Anàlisi Detallada)

Les eines de profiling proporcionen un mapa visual de quines funcions exactament augmenten el consum de memòria:

 

Eines de Configuració (PHP.INI i Servidor)

La configuració del sistema és el primer nivell de defensa per prevenir que els scripts ineficients col·lapsin el servidor.

- Directives de PHP.INI

 

 

- Optimització del Codi per Minimitzar l'Ús

La millor "eina" és un codi ben escrit. Les tècniques per mitigar el consum de memòria inclouen:

Variables global vs $GLOBALS

A PHP, l'àmbit o scope de les variables és local per defecte dins de les funcions. Per fer accessible una variable definida fora d'una funció (àmbit global) dins d'aquesta, hi ha dues tècniques principals: la paraula clau global i l'ús de l'array $GLOBALS.

Array $GLOBALS

L'array $GLOBALS és la forma més fiable i consistent d'accedir a les variables globals.

Característiques

Exemple

Aquest mètode permet tant llegir com modificar el valor de la variable global des de dins de la funció.

<?php
$comptador_global = 10; // Variable a l'àmbit global

function incrementa_global_array() {
    // Accedim i modifiquem la variable global usant l'array $GLOBALS
    $GLOBALS['comptador_global'] += 5;
}

incrementa_global_array();
echo "Valor després d'usar \$GLOBALS: " . $comptador_global; // Sortida: 15
?>

La paraula global

La paraula clau global s'utilitza dins d'una funció per importar una variable que ja existeix a l'àmbit global cap a l'àmbit local de la funció, creant un àlies o una referència.

Característiques

Exemple

<?php
$comptador_global = 10; // Variable a l'àmbit global

function incrementa_global_keyword() {
    // Declarem la variable global a l'àmbit local
    global $comptador_global;
    
    // Treballem directament amb la variable
    $comptador_global += 5; 
}

incrementa_global_keyword();
echo "Valor després d'usar global: " . $comptador_global; // Sortida: 15
?>

Quin Mètode Escollir?

Recomanació: L'ús de $GLOBALS és generalment considerat una pràctica lleugerament millor, ja que fa explícita la intenció de modificar una variable global i és consistent amb la resta de superglobals de PHP (com $_POST, $_GET, $_SESSION).

$GLOBALS crea la variable a l'àmbit global de manera immediata, mentre que global només crea la referència a l'àmbit local fins que li assignes un valor.

Comparativa de variables Globals no existents

<?php

// ----------------------------------------
// ESCENARI 1: Usant la Paraula Clau 'global'
// ----------------------------------------
function crear_variable_amb_global() {
    global $variable_global_keyword;
    // Si no assignem res, PHP la tracta com a NULL a l'àmbit local
}

crear_variable_amb_global();

echo "<h2>1. Amb la paraula clau 'global':</h2>";
if (isset($variable_global_keyword)) {
    echo "La variable \$variable_global_keyword **existeix** a l'àmbit global.<br>";
    echo "Valor: **" . var_export($variable_global_keyword, true) . "** (És NULL per defecte).";
} else {
    echo "ERROR: La variable no es va crear."; 
}

echo "<hr>";


// ----------------------------------------
// ESCENARI 2: Usant l'Array Superglobal '$GLOBALS'
// ----------------------------------------
function crear_variable_amb_globals_array() {
    // Assignem un valor directament a l'array superglobal
    $GLOBALS['variable_global_array'] = "Creat amb \$GLOBALS";
}

crear_variable_amb_globals_array();

echo "<h2>2. Amb l'array superglobal \$GLOBALS:</h2>";
// Accedim directament a la variable creada
if (isset($variable_global_array)) {
    echo "La variable \$variable_global_array **existeix** a l'àmbit global.<br>";
    echo "Valor: **$variable_global_array**";
} else {
    echo "ERROR: La variable no es va crear.";
}
// També podem comprovar-ho mirant l'array $GLOBALS
// echo "<pre>"; print_r($GLOBALS['variable_global_array']); echo "</pre>";
?>

Per aquesta raó, molts programadors prefereixen $GLOBALS perquè és més explícita sobre la seva intenció de modificar o crear dades globals persistents.