performance.md 5.88 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Performance Tuning
==================

Application performance consists of two parts. First is the framework performance
and the second is the application itself. Yii has a pretty low performance impact
on your application out of the box and can be fine-tuned further for production
environment. As for the application, we'll provide some of the best practices
along with examples on how to apply them to Yii.

Preparing framework for production
----------------------------------

### Disabling Debug Mode

First thing you should do before deploying your application to production environment
is to disable debug mode. A Yii application runs in debug mode if the constant
17 18 19 20 21 22 23 24 25 26
`YII_DEBUG` is defined as `true` in `index.php` so to disable debug the following
should be in your `index.php`:

```php
defined('YII_DEBUG') or define('YII_DEBUG', false);
```

Debug mode is very useful during development stage, but it would impact performance
because some components cause extra burden in debug mode. For example, the message
logger may record additional debug information for every message being logged.
27 28 29 30

### Enabling PHP opcode cache

Enabling the PHP opcode cache improves any PHP application performance and lowers
31 32
memory usage significantly. Yii is no exception. It was tested with
[APC PHP extension](http://php.net/manual/en/book.apc.php) that caches
33 34 35 36 37 38 39 40 41 42 43
and optimizes PHP intermediate code and avoids the time spent in parsing PHP
scripts for every incoming request.

### Turning on ActiveRecord database schema caching

If the application is using Active Record, we should turn on the schema caching
to save the time of parsing database schema. This can be done by setting the
`Connection::enableSchemaCache` property to be `true` via application configuration
`protected/config/main.php`:

```php
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
return array(
	// ...
	'components' => array(
		// ...
		'db' => array(
			'class' => 'yii\db\Connection',
			'dsn' => 'mysql:host=localhost;dbname=mydatabase',
			'username' => 'root',
			'password' => '',
			'enableSchemaCache' => true,

			// Duration of schema cache.
			// 'schemaCacheDuration' => 3600,

			// Name of the cache component used. Default is 'cache'.
			//'schemaCache' => 'cache',
		),
		'cache' => array(
			'class' => 'yii\caching\FileCache',
		),
	),
);
66 67
```

68 69
Note that `cache` application component should be configured.

70 71
### Combining and Minimizing Assets

72
TBD
73 74 75

### Using better storage for sessions

76
By default PHP uses files to handle sessions. It is OK for development and
77 78 79 80 81
small projects but when it comes to handling concurrent requests it's better to
switch to another storage such as database. You can do so by configuring your
application via `protected/config/main.php`:

```php
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
return array(
	// ...
	'components' => array(
		'session' => array(
			'class' => 'yii\web\DbSession',

			// Set the following if want to use DB component other than
			// default 'db'.
			// 'db' => 'mydb',

			// To override default session table set the following
			// 'sessionTable' => 'my_session',
		),
	),
);
97 98
```

99
You can use `CacheSession` to store sessions using cache. Note that some
100
cache storage such as memcached has no guarantee that session data will not
101
be lost leading to unexpected logouts.
102

103 104
If you have [Redis](http://redis.io/) on your server, it's highly recommended as session storage.

105 106 107
Improving application
---------------------

108
### Using Serverside Caching Techniques
109 110 111 112 113 114 115 116 117 118

As described in the Caching section, Yii provides several caching solutions that
may improve the performance of a Web application significantly. If the generation
of some data takes long time, we can use the data caching approach to reduce the
data generation frequency; If a portion of page remains relatively static, we
can use the fragment caching approach to reduce its rendering frequency;
If a whole page remains relative static, we can use the page caching approach to
save the rendering cost for the whole page.


119
### Leveraging HTTP to save processing time and bandwidth
120 121 122

TBD

123 124 125 126 127 128 129 130 131 132 133 134 135 136
### Database Optimization

Fetching data from database is often the main performance bottleneck in
a Web application. Although using caching may alleviate the performance hit,
it does not fully solve the problem. When the database contains enormous data
and the cached data is invalid, fetching the latest data could be prohibitively
expensive without proper database and query design.

Design index wisely in a database. Indexing can make SELECT queries much faster,
but it may slow down INSERT, UPDATE or DELETE queries.

For complex queries, it is recommended to create a database view for it instead
of issuing the queries inside the PHP code and asking DBMS to parse them repetitively.

137
Do not overuse Active Record. Although Active Record is good at modeling data
138 139 140 141 142 143 144 145 146 147
in an OOP fashion, it actually degrades performance due to the fact that it needs
to create one or several objects to represent each row of query result. For data
intensive applications, using DAO or database APIs at lower level could be
a better choice.

Last but not least, use LIMIT in your SELECT queries. This avoids fetching
overwhelming data from database and exhausting the memory allocated to PHP.

### Using asArray

148 149 150 151
A good way to save memory and processing time on read-only pages is to use
ActiveRecord's `asArray` method.

```php
152 153 154 155 156
class PostController extends Controller
{
	public function actionIndex()
	{
		$posts = Post::find()->orderBy('id DESC')->limit(100)->asArray()->all();
157
		return $this->render('index', array(
158 159 160 161
			'posts' => $posts,
		));
	}
}
162 163
```

164
In the view you should access fields of each individual record from `$posts` as array:
165 166

```php
resurtm committed
167
foreach ($posts as $post) {
168 169 170 171 172 173
	echo $post['title']."<br>";
}
```

Note that you can use array notation even if `asArray` wasn't specified and you're
working with AR objects.
174

175 176 177 178 179 180
### Processing data in background

In order to respond to user requests faster you can process heavy parts of the
request later if there's no need for immediate response.

- Cron jobs + console.
181 182
- queues + handlers.

183
TBD