You possibly also want to end your benchmark after the output is flushed.
<?php
your_benchmark_start_function();
ob_start ();
for ($i = 0; $i < 5000; $i++)
echo str_repeat ("your string blablabla bla bla", (rand() % 4) + 1)."<br>\n";
<----------
echo your_benchmark_end_function(); |
ob_end_flush (); ------------------------
?>
CXI. Output Control(Controle de Saída)
Introdução
As funções de Controle de Saída permitem a você controlar quando a saída é enviada do script. Isto pode ser util em várias situações diversas, especialmente se você precisa enviar cabeçalhos para o browser depois que seu script começou a enviar dados. As funções de controle de saída não afetam os cabeçalhos enviados usando header() ou setcookie(), somente funções como echo() e dados entre blocos de código PHP.
Dependências
Nenhuma biblioteca externa é necessária para compilar esta extensão.
Instalação
Não há nenhuma instalação necessária para utilizar estas funções, elas fazem parte do núcleo do PHP.
Configurações em execução
O comportamento dessas funções podem ser modificado pelas configurações do php.ini.
Tabela 1. Opções de configuração de controle de saída
| Nome | Padrão | Modificavel |
|---|---|---|
| output_buffering | "0" | PHP_INI_PERDIR|PHP_INI_SYSTEM |
| output_handler | NULL | PHP_INI_PERDIR|PHP_INI_SYSTEM |
| implicit_flush | "0" | PHP_INI_PERDIR|PHP_INI_SYSTEM |
Breve descrição das diretivas de configuração.
- output_buffering boolean/integer
Você pode ativar o buffer de saída para todos os arquivos definindo esta dretiva para 'On'. Se você quiser limitar o tamanho do buffer para um certo limite - você pode usar um número máximo de bytes ao invés de 'On', como valor para esta diretiva (ex., output_buffering=4096).
- output_handler string
Você pode redirecionar toda a saída do seu script para uma função. Por exemplo, se você definir set output_handler para mb_output_handler(), a codificação dos caracteres será transparentemente convertida para a codificação especificada. Definindo qualquer função para gerenciar a saída ativa o buffer de saída.
Nota: Você não pode usar mb_output_handler() com ob_inconv_handler() e você não pode usar ob_gzhandler() e zlib.output_compression.
- implicit_flush boolean
FALSE por padrão. Mudando isto para TRUE diz ao PHP para dizer para a camada de saída descarregar a si mesma automaticamente a cada bloco de saída. Isto é equivalente a utilizar a função do PHP flush() a cada print() ou echo() e a cada bloco de HTML.
Quando estiver usando o PHP em um ambiente web, ativando esta opção tem uma séria implicação na performance e geralmente é recomendada apenas para debug. O valor padrão é TRUE quando operando sobre CLI SAPI.
Veja também ob_implicit_flush().
Tipos Resource
Esta extensão não possui nenhum tipo resource.
Constantes pré-definidas
Esta extensão não possui nenhuma constante.
Exemplos
No exmplo acima, a saída de echo() será guardada no bffer de saída até que ob_end_flush() seja chamada. Em quanto isto, a chamada para setcookie() guadará o cookie sem causar um erro. (Normalmente você não pode enviar cabeçalhos para o browser depois que dados já foram enviados.)
Nota: Quando atualizando a partir do PHP 4.1 (e 4.2) para 4.3 note que devido a um bug nas versões anteriores, você deve ter certeza que implict_flush esta em OFF no seu php.ini, se não qualquer saída com ob_start() não será escondida da saída.
Veja também
Veja também header() e setcookie().
- Índice
- flush -- Descarrega o buffer de saída
- ob_clean -- Limpa (apaga) o buffer de saída
- ob_end_clean -- Limpa (apaga) o buffer de saída e desativa o buffer de saída
- ob_end_flush -- Descarrega (envia) o buffer de saída e desativa o buffer de saída
- ob_flush -- Descarrega (envia) o conteúdo do buffer de saída
- ob_get_clean -- Obtém o conteudo do buffer e exclui o buffer de saída atual
- ob_get_contents -- Retorna o conteúdo do buffer de saída
- ob_get_flush -- Flush the output buffer, return it as a string and turn off output buffering
- ob_get_length -- Retorna o tamanho do buffer de saída
- ob_get_level -- Retorna o nível do mecanismo de buffer de saída
- ob_get_status -- Obtém a situação dos buffers de saída
- ob_gzhandler -- Função de callback para ob_start para compactar com gzip o buffer de saída
- ob_implicit_flush -- Ativa ou desativa o descarregar implicito
- ob_list_handlers -- List all output handlers in use
- ob_start -- Ativa o buffer de saída
- output_add_rewrite_var -- Add URL rewriter values
- output_reset_rewrite_vars -- Reset URL rewriter values
Sometimes users are blaming about slow pages ... not being aware that mostly this is due to network issues.
So I've decided to add some statistics at the end of my pages:
At beginning I start the counters:
<?php
function microtime_float() {
if (version_compare(PHP_VERSION, '5.0.0', '>')) return microtime(true);
list($u,$s)=explode(' ',microtime()); return ((float)$u+(float)$s);
}
$initime=microtime_float();
ob_start();
ob_implicit_flush();
?>
And at the end I show the statistics:
<?php
echo "PHP Time: ".round((microtime_float()-$initime)*1000)." msecs. ";
echo "Size: ".round_byte(strlen(ob_get_contents()));
ob_end_flush();
?>
(round_byte is my function to print byte sizes)
It seems that while using output buffering, an included file which calls die() before the output buffer is closed is flushed rather than cleaned. That is, ob_end_flush() is called by default.
<?php
// a.php (this file should never display anything)
ob_start();
include('b.php');
ob_end_clean();
?>
<?php
// b.php
print "b";
die();
?>
This ends up printing "b" rather than nothing as ob_end_flush() is called instead of ob_end_clean(). That is, die() flushes the buffer rather than cleans it. This took me a while to determine what was causing the flush, so I thought I'd share.
Please note that most browsers don't display a table unless they passed its end-tag "</table>".
Thats why using this feature in HTML-tables might not result in what you expected...
best regards
BasicArtsStudios
Sometimes you might not want to include a php-file under the specifications defined in the functions include() or require(), but you might want to have in return the string that the script in the file "echoes".
Include() and require() both directly put out the evaluated code.
For avoiding this, try output-buffering:
<?php
ob_start();
eval(file_get_contents($file));
$result = ob_get_contents();
ob_end_clean();
?>
or
<?php
ob_start();
include($file);
$result = ob_get_contents();
ob_end_clean();
?>
which i consider the same, correct me if I'm wrong.
Best regards, BasicArtsStudios
Unfortunately, the PHP guys didn't build support into any of the image output functions to return the image instead of outputting it.
Fortunately, we have output buffering to fix that.
<?php
$im = imagecreatetruecolor(200, 200);
// Other image functions here...
ob_start();
imagepng($im);
$imageData = ob_get_contents();
ob_clean();
?>
You can now use the $imageData variable to either create another GD image, save it, put it in a database, make modifications to the binary, or output it to the user. You can easily check the size of it as well without having to access the disk...just use strlen();
Now this just blew my mind. I had a problem with MySQL being incredibly slow on Windows 2003 running IIS... on ASP/VBScript pages. PHP is also installed on the server and so is Microsoft SQL 2005 Express. (Yes, we're running ASP, PHP, MySQL and MS SQL on the same Windows 2003 Server using IIS.)
I was browsing the internet for a solution and saw a suggestion that I change output_buffering to on if MySQL was slow for PHP pages. Since we also served PHP pages with MySQL from the same server, it caught my eye. For the hell of it, I went into php.ini and changed output_buffering to on and suddenly MySQL and ASP was faster... MySQL and PHP was faster... Microsoft SQL Server 2005 Express and ASP was faster.... everything was faster... even stuff that had no PHP!
And I didn't even have to restart IIS. As soon as I saved the php.ini file with the change, everything got faster.
Apparently PHP and MySQL and IIS are so intertwined somehow that changing the buffering setting really effects the performance of the entire server.
So, if you are having performance problems on Windows 2003 & IIS, you might try setting output_buffering = On in php.ini if you happen to have PHP installed. Having it set to off apparently effects the performance of Windows 2003 and IIS severely... even for webpages that do not use PHP or MySQL.
Output buffering is set to '4096' instead of 'Off' or '0' by default in the php-5.0.4-10.5 RPM for Fedora Core release 4 (Stentz). This has cost me much time!
I ran out of memory, while output buffering and drawing text on imported images. Only the top portion of the 5MP image was displayed by the browser. Try increasing the memory limit in either the php.ini file( memory_limit = 16M; ) or in the .htaccess file( php_value memory_limit "16M" ). Also see function memory_get_usage() .
For those who are looking for optimization, try using buffered output.
I noticed that an output function call (i.e echo()) is somehow time expensive. When using buffered output, only one output function call is made and it seems to be much faster.
Try this :
<?php
your_benchmark_start_function();
for ($i = 0; $i < 5000; $i++)
echo str_repeat ("your string blablabla bla bla", (rand() % 4) + 1)."<br>\n";
echo your_benchmark_end_function();
?>
And then :
<?php
your_benchmark_start_function();
ob_start ();
for ($i = 0; $i < 5000; $i++)
echo str_repeat ("your string blablabla bla bla", (rand() % 4) + 1)."<br>\n";
echo your_benchmark_end_function();
ob_end_flush ();
?>
Trying to benchmark your server when using output_buffering ?
Don't forget that the value 4096 in the php.ini will give you complete different loadtimes compares to the value of 1.
In the first case the output will be sent after buffering 4096 and the loadtime timed at the end of the page will contain the loadtime needed to download the complete page in the clientbrowser while the second value will contain the loadtime needed to place the complete page in the buffer. The time needed for sending is not clocked.
This can be very frustrating if you don't see the differance between server and the 1st is using 4096 instead of 1.
Although technically much faster than the second server the second server was providing much better loadtime results.
This result will grow when using large amounts of output.
But this becomes interesting if you want to measure the time needed for the page to be loaded for the client.
