How to maximize performance with PHP7
PHP7 has been released. As the largest version upgrade and the largest performance upgrade of PHP in 10 years, PHP7 has shown obvious performance improvements in multiple tests. However, in order to maximize its performance, I There are still a few things I would like to remind you.
PHP7 VS PHP5.6
1. Opcache
Remember to enable Zend Opcache, because even if PHP7 does not Enabling Opcache is also faster than enabling Opcache in PHP-5.6, so during the previous testing period, someone did not enable Opcache. Enabling Opcache is very simple, just add:
zend_extension= in the php.ini configuration file opcache.so
opcache.enable=1
opcache.enable_cli=1"
2. Use the new compiler
Use a newer compiler, GCC 4.8 or above is recommended, because only GCC 4.8 or above PHP will enable Global Register for opline and execute_data support, which will bring about a 5% performance improvement (measured from the QPS perspective of Wordpres)
In fact, versions before GCC 4.8 also support it, but we found that there are bugs in its support, so this feature must be enabled in version 4.8 or above.
3. HugePage
My previous article also introduced: Hugepage to make your PHP7 faster, first enable HugePages in the system, and then enable Opcache's huge_code_pages.
Take my CentOS 6.5 as an example, through :
$sudo sysctl vm.nr_hugepages=512
Allocate 512 reserved huge page memory:
$ cat /proc/meminfo | grep Huge
AnonHugePages: 106496 kB
HugePages_Total: 512
HugePages_Free: 504
HugePages_Rsvd: 27
HugePages_Surp: 0
##Hugepagesize : 2048 kBThen add in php.ini: opcache.huge_code_pages=1In this way, PHP will store its own text segment and the memory allocation Huges are stored in large memory pages to reduce TLB misses and thereby improve performance.4. Opcache file cache
Enable Opcache File Cache (experimental), pass By turning this on, we can let Opcache cache the opcode cache in an external file. For some scripts, there will be a significant performance improvement.Add in php.ini:opcache.file_cache =/tmpIn this way, PHP will cache some Opcode binary export files in the /tmp directory, which can exist across the PHP life cycle.5. PGO
My previous article: Make your PHP7 faster (GCC PGO) also introduced that if your PHP is specifically for one project, such as just for your WordPress, or drupal, or something else, then you You can try to use PGO to improve PHP, specifically to improve the performance of your project. Specifically, take wordpress 4.1 as the optimization scenario. First, when compiling PHP: $ make prof-genThen use your project to train PHP, for example for WordPress:$ sapi/cgi/php-cgi -T 100 /home/huixinchen/local/www/htdocs /wordpress/index.php >/dev/nullThat is, let php-cgi run 100 times on the wordpress homepage, thereby generating some profile information in the process. Recommended tutorial: "PHP7"
The above is the detailed content of How to maximize performance with PHP7. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

AI Hentai Generator
Generate AI Hentai for free.

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics



Ollama is a super practical tool that allows you to easily run open source models such as Llama2, Mistral, and Gemma locally. In this article, I will introduce how to use Ollama to vectorize text. If you have not installed Ollama locally, you can read this article. In this article we will use the nomic-embed-text[2] model. It is a text encoder that outperforms OpenAI text-embedding-ada-002 and text-embedding-3-small on short context and long context tasks. Start the nomic-embed-text service when you have successfully installed o

Performance comparison of different Java frameworks: REST API request processing: Vert.x is the best, with a request rate of 2 times SpringBoot and 3 times Dropwizard. Database query: SpringBoot's HibernateORM is better than Vert.x and Dropwizard's ORM. Caching operations: Vert.x's Hazelcast client is superior to SpringBoot and Dropwizard's caching mechanisms. Suitable framework: Choose according to application requirements. Vert.x is suitable for high-performance web services, SpringBoot is suitable for data-intensive applications, and Dropwizard is suitable for microservice architecture.

The performance comparison of PHP array key value flipping methods shows that the array_flip() function performs better than the for loop in large arrays (more than 1 million elements) and takes less time. The for loop method of manually flipping key values takes a relatively long time.

Effective techniques for optimizing C++ multi-threaded performance include limiting the number of threads to avoid resource contention. Use lightweight mutex locks to reduce contention. Optimize the scope of the lock and minimize the waiting time. Use lock-free data structures to improve concurrency. Avoid busy waiting and notify threads of resource availability through events.

The performance of different PHP functions is crucial to application efficiency. Functions with better performance include echo and print, while functions such as str_replace, array_merge, and file_get_contents have slower performance. For example, the str_replace function is used to replace strings and has moderate performance, while the sprintf function is used to format strings. Performance analysis shows that it only takes 0.05 milliseconds to execute one example, proving that the function performs well. Therefore, using functions wisely can lead to faster and more efficient applications.

Static function performance considerations are as follows: Code size: Static functions are usually smaller because they do not contain member variables. Memory occupation: does not belong to any specific object and does not occupy object memory. Calling overhead: lower, no need to call through object pointer or reference. Multi-thread-safe: Generally thread-safe because there is no dependence on class instances.

A way to benchmark the performance of Java functions is to use the Java Microbenchmark Suite (JMH). Specific steps include: Adding JMH dependencies to the project. Create a new Java class and annotate it with @State to represent the benchmark method. Write the benchmark method in the class and annotate it with @Benchmark. Run the benchmark using the JMH command line tool.

In PHP, the conversion of arrays to objects will have an impact on performance, mainly affected by factors such as array size, complexity, object class, etc. To optimize performance, consider using custom iterators, avoiding unnecessary conversions, batch converting arrays, and other techniques.
