Apakah ada fungsi dalam PHP (atau ekstensi PHP) untuk mengetahui berapa banyak memori yang digunakan variabel tertentu? sizeofhanya memberi tahu saya jumlah elemen / properti.

memory_get_usagemembantu karena memberi saya ukuran memori yang digunakan oleh seluruh skrip. Apakah ada cara untuk melakukan ini untuk satu variabel?

Perhatikan bahwa ini ada di mesin pengembangan, jadi memuat ekstensi atau alat debug dapat dilakukan.

Anda Mungkin membutuhkan Memory Profiler. Saya telah mengumpulkan informasi dari SO tetapi saya telah menyalin beberapa hal penting yang dapat membantu Anda juga.

Seperti yang mungkin Anda ketahui, Xdebug menghentikan dukungan profil memori sejak versi 2. *. Silakan cari string "fungsi yang dihapus" di sini: http://www.xdebug.org/updates.php

Fungsi yang dihapus

Menghapus dukungan untuk Profil memori karena tidak berfungsi dengan benar.

Opsi Profiler Lainnya

php-memory-profiler

https://github.com/arnaud-lb/php-memory-profiler . Inilah yang saya lakukan di server Ubuntu saya untuk mengaktifkannya:

sudo apt-get install libjudy-dev libjudydebian1
sudo pecl install memprof
echo "extension=memprof.so" > /etc/php5/mods-available/memprof.ini
sudo php5enmod memprof
service apache2 restart

Dan kemudian di kode saya:

<?php
memprof_enable();
// do your stuff
memprof_dump_callgrind(fopen("/tmp/callgrind.out", "w"));

Terakhir buka callgrind.outfile dengan KCachegrind

Menggunakan Google gperftools (disarankan!)

Pertama-tama instal Google gperftools dengan mengunduh paket terbaru di sini: https://code.google.com/p/gperftools/

Kemudian seperti biasa:

sudo apt-get update
sudo apt-get install libunwind-dev -y
./configure
make
make install

Sekarang dalam kode Anda:

memprof_enable();

// do your magic

memprof_dump_pprof(fopen("/tmp/profile.heap", "w"));

Kemudian buka terminal Anda dan luncurkan:

pprof --web /tmp/profile.heap

pprof akan membuat jendela baru di sesi browser Anda yang sudah ada dengan sesuatu seperti yang ditunjukkan di bawah ini:

Xhprof + Xhgui (menurut saya yang terbaik untuk profil cpu dan memori)

Dengan Xhprof dan Xhgui Anda dapat membuat profil penggunaan cpu juga atau hanya penggunaan memori jika itu masalah Anda saat ini. Ini adalah solusi yang sangat lengkap, ini memberi Anda kendali penuh dan log dapat ditulis baik di mongo atau di sistem file.

Untuk lebih jelasnya lihat disini .

Api hitam

Blackfire adalah profiler PHP oleh SensioLabs, orang-orang Symfony2 https://blackfire.io/

Jika Anda menggunakan boneka untuk mengatur mesin virtual Anda, Anda akan senang mengetahui bahwa itu didukung ;-)

Xdebug dan melacak penggunaan memori

XDEBUG2 adalah ekstensi untuk PHP. Xdebug memungkinkan Anda untuk mencatat semua panggilan fungsi, termasuk parameter dan mengembalikan nilai ke file dalam format yang berbeda. Ada tiga format keluaran. Satu dimaksudkan sebagai jejak yang dapat dibaca manusia, yang lain lebih cocok untuk program komputer karena lebih mudah untuk diurai, dan yang terakhir menggunakan HTML untuk memformat jejak. Anda dapat beralih di antara dua format berbeda dengan pengaturan. Contoh akan tersedia di sini

forp

forp sederhana, tidak mengganggu, berorientasi pada produksi, profiler PHP. Beberapa fiturnya adalah:

• pengukuran waktu dan memori yang dialokasikan untuk setiap fungsi

• penggunaan CPU

• file dan nomor baris pemanggilan fungsi

• keluaran sebagai format Peristiwa Jejak Google

• keterangan fungsi

• pengelompokan fungsi

• alias fungsi (berguna untuk fungsi anonim)

DBG

DBG adalah debugger php berfitur lengkap, alat interaktif yang membantu Anda men-debug skrip php. Ini bekerja pada server WEB produksi dan / atau pengembangan dan memungkinkan Anda men-debug skrip Anda secara lokal atau jarak jauh, dari IDE atau konsol dan fitur-fiturnya adalah:

• Debugging jarak jauh dan lokal

• Aktivasi eksplisit dan implisit

• Tumpukan panggilan, termasuk panggilan fungsi, panggilan metode dinamis dan statis, dengan parameternya

• Menavigasi melalui tumpukan panggilan dengan kemampuan untuk mengevaluasi variabel di tempat (bertingkat) yang sesuai

• Step in / Step out / Step over / Run to cursor fungsionalitas

• Breakpoint bersyarat

• Breakpoint global

• Logging untuk kesalahan dan peringatan

• Beberapa sesi simultan untuk debugging paralel

• Dukungan untuk GUI dan CLI front-end

• Mendukung jaringan IPv6 dan IPv4

• Semua data yang ditransfer oleh debugger dapat secara opsional dilindungi dengan SSL

Tidak ada cara langsung untuk mendapatkan penggunaan memori variabel tunggal, tetapi seperti yang disarankan Gordon, Anda dapat menggunakannya memory_get_usage. Itu akan mengembalikan jumlah total memori yang dialokasikan, sehingga Anda dapat menggunakan solusi dan mengukur penggunaan sebelum dan sesudah untuk mendapatkan penggunaan variabel tunggal. Ini agak hacky, tetapi seharusnya berhasil.

$start_memory = memory_get_usage();
$foo = "Some variable";
echo memory_get_usage() - $start_memory;

Perhatikan bahwa ini sama sekali bukan metode yang dapat diandalkan, Anda tidak dapat memastikan bahwa tidak ada yang menyentuh memori saat menetapkan variabel, jadi ini hanya boleh digunakan sebagai perkiraan.

Anda sebenarnya dapat mengubahnya menjadi fungsi dengan membuat salinan variabel di dalam fungsi dan mengukur memori yang digunakan. Belum menguji ini, tetapi pada prinsipnya, saya tidak melihat ada yang salah dengannya:

function sizeofvar($var) {
    $start_memory = memory_get_usage();
    $tmp = unserialize(serialize($var));
    return memory_get_usage() - $start_memory;
}

Tidak, tidak ada. Tapi Anda bisa serialize($var)dan memeriksa strlenhasilnya untuk perkiraan.

Sebagai jawaban atas jawaban Tatu Ulmanens:

Perlu dicatat, itu $start_memorysendiri akan memakan memori ( PHP_INT_SIZE * 8).

Jadi keseluruhan fungsinya harus menjadi:

function sizeofvar($var) {
    $start_memory = memory_get_usage();
    $var = unserialize(serialize($var));
    return memory_get_usage() - $start_memory - PHP_INT_SIZE * 8;
}

Maaf menambahkan ini sebagai jawaban tambahan, tapi saya belum bisa mengomentari jawaban.

Pembaruan: * 8 tidak pasti. Itu bisa tergantung pada versi php dan mungkin pada 64/32 bit.

Lihat:

• memory_get_usage() - Mengembalikan jumlah memori yang dialokasikan ke PHP
• memory_get_peak_usage() - Mengembalikan puncak memori yang dialokasikan oleh PHP

Perhatikan bahwa ini tidak akan memberi Anda penggunaan memori dari variabel tertentu. Tetapi Anda dapat melakukan panggilan ke fungsi ini sebelum dan sesudah menetapkan variabel dan kemudian membandingkan nilainya. Itu akan memberi Anda gambaran tentang memori yang digunakan.

Anda juga dapat melihat Memtrack ekstensi PECL , meskipun dokumentasinya agak kurang, jika tidak bisa dikatakan, hampir tidak ada.

Anda dapat memilih untuk menghitung perbedaan memori pada nilai balik panggilan balik. Ini adalah solusi yang lebih elegan yang tersedia dalam PHP 5.3+.

function calculateFootprint($callback) {
    $startMemory = memory_get_usage();
    $result = call_user_func($callback);
    return memory_get_usage() - $startMemory;
}

$memoryFootprint = calculateFootprint(
    function() {
        return range(1, 1000000);
    }
);

echo ($memoryFootprint / (1024 * 1024)) . ' MB' . PHP_EOL;

Anda tidak dapat secara retrospektif menghitung footprint variabel yang tepat karena dua variabel dapat berbagi ruang yang dialokasikan sama di memori

Mari kita coba membagi memori antara dua larik, kita melihat bahwa mengalokasikan larik kedua menghabiskan setengah dari memori larik pertama. Saat kami membatalkan setelan yang pertama, hampir semua memori masih digunakan oleh yang kedua.

echo memory_get_usage()."\n"; // <-- 433200
$c=range(1,100);
echo memory_get_usage()."\n"; // <-- 444348 (+11148)
$d=array_slice($c, 1);
echo memory_get_usage()."\n"; // <-- 451040 (+6692)
unset($c);
echo memory_get_usage()."\n"; // <-- 444232 (-6808)
unset($d);
echo memory_get_usage()."\n"; // <-- 433200 (-11032)

Jadi kita tidak bisa menyimpulkan daripada array kedua menggunakan setengah memori, karena menjadi salah ketika kita membatalkan yang pertama.

Untuk gambaran lengkap tentang bagaimana memori dialokasikan dalam PHP dan untuk kegunaan apa, saya sarankan Anda untuk membaca artikel berikut: Seberapa besar array (dan nilai) PHP sebenarnya? (Petunjuk: BESAR!)

The Dasar Referensi Counting dalam dokumentasi PHP juga memiliki banyak informasi tentang penggunaan memori, dan referensi menghitung sampai segmen data bersama.

Solusi berbeda yang diekspos di sini bagus untuk perkiraan tetapi tidak ada yang dapat menangani manajemen halus memori PHP.

1. menghitung ruang yang baru dialokasikan

Jika Anda menginginkan ruang yang baru dialokasikan setelah tugas, maka Anda harus menggunakan memory_get_usage()sebelum dan sesudah alokasi, karena menggunakannya dengan salinan memberi Anda pandangan yang salah tentang kenyataan.

// open output buffer
echo "Result: ";
// call every function once
range(1,1); memory_get_usage();

echo memory_get_usage()."\n";
$c=range(1,100);
echo memory_get_usage()."\n";

Ingatlah bahwa jika Anda ingin menyimpan hasil pertama memory_get_usage(), variabel harus sudah ada sebelumnya, dan memory_get_usage()harus dipanggil lain waktu sebelumnya, dan setiap fungsi lainnya juga.

Jika Anda ingin menggemakan seperti pada contoh di atas, buffer keluaran Anda harus sudah dibuka untuk menghindari memori akuntansi yang diperlukan untuk membuka buffer keluaran.

2. menghitung ruang yang dibutuhkan

Jika Anda ingin mengandalkan fungsi untuk menghitung ruang yang diperlukan untuk menyimpan salinan variabel, kode berikut menangani pengoptimalan yang berbeda:

<?php
function getMemorySize($value) {
    // existing variable with integer value so that the next line
    // does not add memory consumption when initiating $start variable
    $start=1;
    $start=memory_get_usage();
    // json functions return less bytes consumptions than serialize
    $tmp=json_decode(json_encode($value));
    return memory_get_usage() - $start;
}

// open the output buffer, and calls the function one first time
echo ".\n";
getMemorySize(NULL);

// test inside a function in order to not care about memory used
// by the addition of the variable name to the $_GLOBAL array
function test() {
    // call the function name once 
    range(1,1);

    // we will compare the two values (see comment above about initialization of $start)
    $start=1;
    $start=memory_get_usage();
    $c=range(1,100);
    echo memory_get_usage()-$start."\n";
    echo getMemorySize($c)."\n";
}
test();

// same result, this works fine.
// 11044
// 11044

Perhatikan bahwa ukuran nama variabel penting dalam memori yang dialokasikan.

3. Periksa kode Anda !!

Variabel memiliki ukuran dasar yang ditentukan oleh struktur C bagian dalam yang digunakan dalam kode sumber PHP. Ukuran ini tidak berfluktuasi dalam hal angka. Untuk senar, itu akan menambah panjang senar.

typedef union _zvalue_value {
    long lval;                  /* long value */
    double dval;                /* double value */
    struct {
        char *val;
        int len;
    } str;
    HashTable *ht;              /* hash table value */
    zend_object_value obj;
} zvalue_value;

Jika kita tidak memperhitungkan inisialisasi nama variabel, kita sudah tahu berapa banyak variabel yang digunakan (dalam hal angka dan string):

44 byte dalam kasus angka

+ 24 byte untuk string

+ panjang string (termasuk karakter NUL terakhir)

(angka-angka itu bisa berubah tergantung pada versi PHP)

Anda harus membulatkan hingga kelipatan 4 byte karena penyelarasan memori. Jika variabel berada di ruang global (bukan di dalam fungsi), itu juga akan mengalokasikan 64 byte lagi.

Jadi jika Anda ingin menggunakan salah satu kode di dalam halaman ini, Anda harus memeriksa apakah hasilnya menggunakan beberapa kasus uji sederhana (string atau angka) cocok dengan data tersebut dengan mempertimbangkan setiap indikasi dalam posting ini (array $ _GLOBAL, panggilan fungsi pertama, buffer keluaran, ...)

Saya memiliki masalah serupa, dan solusi yang saya gunakan adalah menulis variabel ke file kemudian menjalankan filesize () di atasnya. Secara kasar seperti ini (kode yang belum diuji):

function getVariableSize ( $foo ) 
{
    $tmpfile = "temp-" . microtime(true) . ".txt";
    file_put_contents($tmpfile, $foo);
    $size = filesize($tmpfile);
    unlink($tmpfile);
    return $size;
}

Solusi ini tidak terlalu cepat karena melibatkan IO disk, tetapi akan memberi Anda sesuatu yang jauh lebih tepat daripada trik memory_get_usage. Itu hanya tergantung pada seberapa banyak presisi yang Anda butuhkan.

Belum pernah mencoba, tetapi jejak Xdebug dengan xdebug.collect_assignment s mungkin cukup.

function mesure($var){
    $start = memory_get_usage();
    if(is_string($var)){
        $newValue = $var . '';
    }elseif(is_numeric($var)){
        $newValue = $var + 0;
    }elseif(is_object($var)){
        $newValue = clone $var;
    }elseif(is_array($var)){
        $newValue = array_flip($var, []);
    }
    return memory_get_usage() - $start;
}

Skrip berikut menunjukkan penggunaan memori total dari satu variabel.

function getVariableUsage($var) {
  $total_memory = memory_get_usage();
  $tmp = unserialize(serialize($var));
  return memory_get_usage() - $total_memory; 
}

$var = "Hey, what's you doing?";
echo getVariableUsage($var);

Lihat ini

http://www.phpzag.com/how-much-memory-do-php-variables-use/