<?php
$_cachetime = 3600;
$_cacheroot = '/path/to/cache/';
function cacheget($key) {
	global $_cachetime, $_cacheroot;
	$_cachename = sprintf('%x', crc32($key));
	$_cachefolder = $_cacheroot.substr($_cachename,0,2).'/';
	$_cachefile = $_cachefolder.$_cachename;
	if (file_exists($_cachefile) && (filemtime($_cachefile) > time() - $_cachetime || 
		(file_exists($_cachefile.'.lock') && time() - filemtime($_cachefile.'.lock') < 120))) {
		return unserialize(file_get_contents($_cachefile));
	}
	return false;
}
function cachelock($key) {
	global $_cacheroot;
	$_cachename = sprintf("%x", crc32($key));
	$_cachefolder = $_cacheroot.substr($_cachename,0,2).'/';
	$_cachefile = $_cachefolder.$_cachename;
	umask(0);
	if (!file_exists($_cachefolder)) {
		mkdir($_cachefolder,0777);
	}
	touch($_cachefile.'.lock');
}
function cacheset($key, $value) {
	global $_cacheroot;
	$_cachename = sprintf('%x', crc32($key));
	$_cachefolder = $_cacheroot.substr($_cachename,0,2).'/';
	$_cachefile = $_cachefolder.$_cachename;
	umask(0);
	if (!file_exists($_cachefolder)) {
		mkdir($_cachefolder,0777);
	}
	if ($_h = fopen($_cachefile, 'w')) {
		fwrite($_h, serialize($value));
		fclose($_h);
		unlink($_cachefile.'.lock');
	}
}
?>

วิธีติดตั้ง:

include ไฟล์ไปบนสุดเลย แก้ตัวแปร $_cacheroot กับ $_cachetime ด้วยนะครับ
chmod 777 folder ตามที่ตั้งใน $_cacheroot ไว้ด้วย

วิธีเรียกใช้:

สมมติว่า cache คำสั่ง sql นะครับ
ถ้าปกติใช้อย่างนี้

<?php
$query = 'SELECT * FROM table';
$sql = mysql_query($query);
while ($row = mysql_fetch_assoc($sql)) {
        var_dump($row);
}
?>

ก็แก้เป็นประมาณนี้

<?php
$query = 'SELECT * FROM table';
if (!$rows = cacheget($query)) {
        cachelock($query);
        $sql = mysql_query($query);
        $rows = array();
        while ($row = mysql_fetch_assoc($sql))
                $rows[] = $row;
        cacheset($query, $rows);
}
foreach($rows as $row) {
        var_dump($row);
}
?>

code นี้แปะด้านบนสุดของไฟล์ (จะใส่ใน auto prepend เลยก็ยังไหว)

<?php
$_cachetime = 43200;
$_info = parse_url($_SERVER["REQUEST_URI"]);
if (!isset($_info['query'])) $_info['query'] = '';
$_path = end(explode('/', $_info['path']));
$_info['query'] = str_replace('&nocache', '', $_info['query']);
$_info['query'] = str_replace('nocache&', '', $_info['query']);
$_info['query'] = str_replace('nocache', '', $_info['query']);
$_cachename = sprintf("%x", crc32($_path."?".$_info['query']));
$_cachefolder = '/path/to/cache/'.substr($_cachename,0,2).'/';
$_cachefile = $_cachefolder.$_cachename;
if ($_SERVER["REQUEST_URI"] != '/' && $_SERVER["REQUEST_METHOD"] == 'GET' &&
    !isset($_GET["nocache"]) &&
    file_exists($_cachefile) && filemtime($_cachefile) > time() - $_cachetime) {
        readfile($_cachefile);
        exit();
}
function fetch_cache($_buffer) {
        global $_cachefile, $_cachefolder;
        umask( 0);
        if (!file_exists($_cachefolder))
                mkdir($_cachefolder,0777, true);
        if ($_h = fopen($_cachefile, "w")) {
                fwrite($_h, $_buffer);
                fclose($_h);
        }
        return $_buffer;
}
ob_start('fetch_cache');
?>

code นี้ใส่ด้านท้าย (ใน auto append ก็ได้นะครับ)

<?php
ob_end_flush();
?>

* แก้ไขเพิ่ม 2009/05/28

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
user=mysql
# Default to using old password format for compatibility with mysql 3.x
# clients (those using the mysqlclient10 compatibility package).
old_passwords=1
set-variable=local-infile=0
skip-character-set-client-handshake
skip-name-resolve
skip-bdb
max_connections = 600
key_buffer = 512M
myisam_sort_buffer_size = 32M
join_buffer_size = 1M
read_buffer_size = 2M
sort_buffer_size = 4M
table_cache = 1536
thread_cache = 8
thread_concurrency = 4
thread_cache_size = 256
wait_timeout = 600
connect_timeout = 10
max_tmp_tables = 256
tmp_table_size = 64M
max_allowed_packet = 16M
max_connect_errors = 10
query_cache_limit = 1M
query_cache_size = 32M
query_cache_type = 1
query_prealloc_size = 16384
query_alloc_block_size = 16384
log_slow_queries
log_queries_not_using_indexes

[mysqld_safe]
log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid
open_files_limit = 8192

เข้าประเด็นเลยดีกว่า

ช่วงนี้มีงานประเภทนี้เยอะครับ เห็นแล้วก็เซ็งไอ้คนเขียนเว็บคนเก่าที่ทำระบบมาจริงๆ
คุณพี่เขียนไว้อย่างนี้ครับ….

$sql = mysql_query("SELECT * FROM table");
$records = mysql_num_rows($sql);

ไอ้อันที่จริงมันก็ไม่ผิดอะไรหรอกครับถ้าจะใช้แบบนี้ เพราะ code มันก็ทำงานได้ปกติสุขดีของมัน
แต่… ใครจะรู้มั้ยครับ ว่า mysql มันต้องส่งข้อมูลมากขนาดไหน

สมมติว่า ตารางมีขนาด 1 MB
การ query นี้จะทำให้ mysql ต้องส่งข้อมูลขนาด 1 MB ให้ client ที่ทำการ query
แล้ว client จะเป็นผู้นับจำนวนแถวเอง
ลองคิดดูว่าถ้าตารางเราเกิดมีขนาด 10 MB หรือมีคนเข้าเยอะๆ นะครับ
สมมติ ตารางเดิม ขนาด 1 MB
แต่คนเข้า “แค่” นาทีละ 60 ครั้ง (ตกวินาทีละ 1 ครั้ง)
เท่ากับ Database Server ต้องส่งข้อมูลให้ client ถึงวินาทีละ 1 MB
…
ถ้าขนาดฐานข้อมูลใหญ่ขึ้น
ถ้าคนเข้าเยอะขึ้น… ลองคิดดูครับว่ามันจะเปลืองทรัพยากรระบบขนาดไหน

วิธีนับจำนวน record จริงๆ ที่ใช้กันทั่วไปในระบบใหญ่ๆ เค้าใช้กันแบบนี้ครับ

$sql = mysql_query("SELECT COUNT(*) FROM table");
$res = mysql_fetch_array($sql);
$records = $res[0];

จำนวนบรรทัดเยอะขึ้น 1 บรรทัด แต่การทำงานลดลงฮวบฮาบผิดกันลิบๆ

* คำสั่ง SELECT COUNT(*) ห้ามเอาไปใช้กับตารางประเภท InnoDB โดยเด็ดขาดนะครับ
มิเช่นนั้น database server อาจน็อคเอาได้ง่ายๆ

เรื่องนี้ถือเป็นเรื่องใหญ่มากๆ ครับในการออกแบบฐานข้อมูลบน MySQL
เนื่องด้วยมันจะมีผลต่อความเร็วในการค้นหาข้อมูลมาก ถึงมากที่สุด
เคสที่ยังใช้งานน้อยๆ เช่นมีการเรียกใช้แค่ นาทีละไม่ถึงสามสิบครั้ง อะไรอย่างนี้อาจจะไม่ค่อยเห็นผลเท่าไหร่
แต่พอมีการใช้งานเยอะๆ ดูสิครับ… ไม่อยากบรรยายถึงความเละสุดอนาถเลยแหละ

ทีนี้ จะดูยังไงว่าเราควรจะสร้างฐานข้อมูลยังไง ออกแบบยังไงให้มีประสิทธิภาพ
ตรงนี้ต้องดูการเรียกใช้งานของเราครับ เช่น…

อ้อ ลืมไป ยกตัวอย่างไม่ได้ ต้องสร้างตารางก่อน

CREATE TABLE users (
    id INT NOT NULL DEFAULT '0' AUTO_INCREMENT,
    username VARCHAR(24) NOT NULL DEFAULT '',
    password VARCHAR(32) NOT NULL DEFAULT '',
    email VARCHAR(64) NOT NULL DEFAULT '',
    PRIMARY KEY(id)
) Engine=MyISAM;

ในการนี้เราจะได้ตาราง users มี 4 field คือ id, username, password และ email
ทีนี้ สมมติเราต้องการดึงค่า email ออกมาจากตาราง โดยหาจาก username ก็ต้อง query แบบนี้

SELECT email FROM users WHERE username = 'xxxxxxx';

เงื่อนไขการค้นหาก็จะเป็น ค้นหาจาก ตาราง users โดยดูใน field username ที่มีค่าเท่ากับ ‘xxxxxxx’

กรณีที่เรายังไม่ได้ทำ Index ให้ตารางนี้…
MySQL จะเปิดตารางขึ้นมา(จาก harddisk) จากนั้นก็เริ่มตั้งแต่ record แรกสุด
เรียกข้อมูลใน field username ออกมาเทียบค่า ถ้าไม่ใช่ก็หาต่อไปเรื่อยๆ จนกว่าจะเจอ
ซึ่งกรณีเลวร้ายที่สุด คือค้นหาไม่เจอเลย จะทำให้ MySQL ต้องทำการอ่านข้อมูลจากตารางเยอะมาก
กลายเป็นว่า ต้องอ่านข้อมูลทั้งตารางเพื่อหาว่า user นี้อยู่ที่ record ไหน

สมมติพอทำ Index ปุ๊ป MySQL ก็จะเข้ามาอ่าน Index ที่มีอยู่
ซึ่งโดยปกติ index จะพยายามเก็บในแรมครับ แต่ก็มี file ที่เก็บบน harddisk เหมือนกัน
แล้วก็เทียบค่าไปเรื่อยๆ แต่แรมมันเร็วกว่า hdd เยอะครับ…
จากนั้น พอเจอแล้ว เจ้า index นี่ก็จะเป็นตัวบอกว่า ข้อมูลนี้อยู่ที่ตำแหน่งตรงไหนของแฟ้ม
ก็เลยทำให้ MySQL กระโดดไปเอาข้อมูลมาได้เลยครับ

คำสั่งเพิ่ม index ให้ตารางที่มีอยู่แล้วใช้อย่างนี้ครับ

ALTER TABLE users ADD INDEX (username)

.

เดี๋ยวจะมาอธิบายการตรวจสอบ query อีกที ง่วงมากเลยตอนนี้ T_T

สืบเนื่องจาก entry ที่แล้ว
ก็เลยลองไปค้นๆ ข้อมูลเพิ่มเติมดูอีกหน่อยว่าเราลืมอะไรไปบ้าง
เพราะนึกได้ว่ายังไม่ได้ลองทำ MySQL Replicate เลย (ฮาๆ)
ประเด็นคือไม่รู้ว่ามันช้าที่ฐานข้อมูลรึเปล่า เพราะ debug ไม่เจอสาเหตุ
ก็เลยต้องลองทำเท่าที่ทำได้ไปก่อน

ขั้นต้นก็ต้องมี server 2 เครื่องขึ้นไปครับ
โดยสมมติเครื่องแรก ชื่อ web-slave
เครื่องที่สอง ชื่อ db-master

ก่อนอื่นมาที่เครื่อง web-slave สั่งติดตั้ง mysql server ตามนี้ครับ
* อ้างอิง Fedora 8 ครอบคลุม Fedora 4 – 9, CentOS 5.x รวมถึงสาย Redhat ทั้งหมดครับ

# yum install mysql-server

เสร็จแล้วเปิดแฟ้ม /etc/my.cnf เพิ่มเติมข้อมูลต่อไปนี้ครับ

server-id=2
master-host=0000ff;">10.0.0.2
master-port=3306
master-user=ff0000;">replicate
master-password=ff0000;">slavepassword
master-connect-retry=30
replicate-wild-do-table= %.%
report-host=008000;">10.0.0.1

(มันมาอีกละ สีฟ้าแดงเขียวนี่)
แก้ ip อะไรพวกนี้ให้ถูกนะครับ แล้วแก้ตัวแดงๆ ด้วย ตามที่ตั้งค่า

เครื่องนี้เสร็จและ กลับไปที่เครื่อง db-master ต่อ ก่อนอื่นต้องตั้งค่า username / password ก่อนครับ
โดยเข้าไปใน mysql query console (หรือที่ไหนก็ได้ที่สามารถตั้ง user ได้) แล้วรัน query ต่อไปนี้

mysql> GRANT REPLICATION SLAVE ON *.*
TO ‘ff0000;">replicate‘@’008000;">10.0.0.1‘ IDENTIFIED BY ‘ff0000;">slavepassword‘;

เสร็จแล้วออกมาสั่ง stop service mysql ได้เลยครับ แล้วก็แก้แฟ้ม /etc/my.cnf อีกนิดหน่อย ตามนี้ครับ

log-bin=ff00ff;">mysql-bin
server-id=1
innodb_flush_log_at_trx_commit=1
sync_binlog=1
expire_logs_days=ff00ff;">3
max_binlog_size=ff00ff;">50M

ตรงนี้ปรับค่าตามความเหมาะสมนะครับ แล้วแต่ว่าจะเก็บ log กี่วันยังไง
โดยบรรทัดแรกสุดจะเป็น path + ชื่อแฟ้มที่ใช้เก็บ log (สามารถใส่ full path ได้ครับ เช่น /var/log/mysqld/binlog)
แล้วก็ย้ำว่าควรจะใส่ option สองบรรทัดด้านล่าง เพื่อป้องกัน hdd เต็ม (ฮา)
เคยเจอมาแล้วครับ เก็บ log เพลินไปหน่อย เศร้าเลย

ต่อจากนี้ก็ copy ข้อมูลจาก db-master ไปยังเครื่อง web-slave ครับ
ถ้าใน fedora/centos default install ก็อยู่ใน /var/lib/mysql
สั่ง tar ไปทั้ง folder เลยก็ยังไหวครับ (แต่ข้อแม้คือต้องเป็น mysql version เดียวกันนะ)

จากนั้นก็สั่ง service mysqld start ทั้งสองเครื่อง
แล้ว connect เข้า mysql ของเครื่อง db-master สั่ง query ต่อไปนี้ครับ

mysql> FLUSH TABLES WITH READ LOCK;

แล้วก็ connect เข้า mysql ของเครื่อง web-slave สั่ง query ต่อไปนี้ครับ

mysql> START SLAVE;

เท่านี้ก็เรียบร้อย ทีนี้ก็รอดูผลงาน… ถ้าเวิร์กจะเอาไปใส่เว็บ bitthai ด้วย (ฮาๆ)

โจทย์มีมาให้ค่อนข้าง… เอ่อ… ระดับนึงละครับ
server 2 เครื่อง เครื่องแรก Core 2 Duo E6600 / RAM 3 GB
เครื่องที่สอง Core 2 Quad Q6xxx อะไรซักอย่าง จำรุ่นไม่ได้ / RAM 3GB

จะบอกว่ามันใช้งานหนักเอามากๆ
งานนี้ก็เลยต้องทดลองมันสารพัดวิธีเลยครับ

เริ่มจาก level แรกสุด apache + squid reverse proxy ไม่ผ่านเลยครับ (load avg 50.xx)
level ที่สอง เพิ่ม DNS Round Robin เข้าช่วย เอาเครื่อง DB มาช่วยรันเว็บด้วย ก็ยังไม่ผ่าน แต่ดีขึ้นหน่อยนึง (load เหลือ 30.xx)
level ที่สาม ลง memcache ช่วยระบบ session + SMF memcache ก็ไม่ผ่านอยู่ดี แต่ดีขึ้นใช้ได้ (load เหลือ ~25.xx)

level สุดท้าย เลิกใช้ apache ลบ squid ทิ้ง แล้วลง lighttpd 1.4 + mod fastcgi แทน
load average ลดลงมาเหลือประมาณ 5-6 แต่ page generation time ก็ยังไม่ค่อยจะน่าพอใจ
แบบว่าหน้า index พี่ซัดไป 300 KB เยอะโคดเลย

งานนี้ขอเวลาไปสัปดาห์นึง ต้องนั่งเฝ้าอีก เห้อ… ไหนจะงานรับน้องด้วย งิดๆๆๆ

เพิ่มเติมทางเทคนิค:

NFS service บน Fedora 7 เป็นต้นมา มีการเปลี่ยนแปลงชื่อ service นิดๆ หน่อยๆ
ทำเอางงกันใช้ได้ (ฮาๆ) ตามรายการต่อไปนี้ครับ

• nfs ยังคงสภาพเดิม คำสั่งเดิมได้เลย
• portmap เปลี่ยนชื่อไปเป็น rpcbind
• เพิ่มเติม service nfslock ไว้ทำ nfs remote lock เวลาต้องการ lock access file ต่างๆ

ขั้นตอนการติดตั้ง nfs บน Fedora 8 ง่ายมากจนน่าตกใจ ดังนี้ครับ

# yum install nfs-utils

จบเลย คำสั่งเดียวสั้นๆ ง่ายๆ เลย
เสร็จแล้วก็ตั้งค่าให้รันตั้งแต่เริ่มเปิดเครื่อง (สำหรับเครื่อง nfs server เท่านั้น)

# chkconfig nfs on
# chkconfig nfslock on
# chkconfig rpcbind on

แล้วแก้แฟ้ม /etc/exports ตามคู่มือ (รายละเอียดค่อนข้างเยอะ ไว้ค่อยสาธยาย ง่วงมาก)
พร้อมด้วยการแก้ /etc/hosts.allow เพื่อเพิ่มความปลอดภัยให้แก่ nfs server
แก้เสร็จแล้วก็สั่ง start service ทั้งสามตัวได้เลย ตามลำดับต่อไปนี้

# service rpcbind start
# service nfs start
# service nfslock start

จากนั้นไปที่เครื่อง client ที่จะ mount nfs partition แล้วทดลองสั่งค้นหา partition ที่อนุญาตให้ mount ดู ตามนี้

# showmount -e ff6600;">10.0.0.1

* กรุณาแก้ IP เป็น IP ของเครื่อง nfs server ของท่านครับ พอ list ได้ที่แล้วก็สั่ง mount ได้เลย

# mount ff0000;">10.0.0.1:339966;">/path/to/exports 0000ff;">/path/to/exports

กรณีการทำ load balancing แนะนำให้ mount ลงไปที่ path เดียวกันกับเครื่อง server ครับ
จะช่วยลดปัญหายุ่งยากลงได้เยอะ

กลับเข้าเรื่องกันดีกว่า
วันนี้จะมาว่าด้วย MySQL Memory Engine ครับ

Memory Engine เป็นรูปแบบตารางของ MySQL แบบหนึ่ง
ซึ่งมีโครงสร้างคล้ายๆ กับ MyISAM บ้าง นิดๆ หน่อยๆ
เพียงแต่แทนที่จะเก็บไว้เป็นไฟล์ .MYD ไว้บนเครื่อง ก็เปลี่ยนมาเป็น
เก็บลง shared memory ของ master process แทน
แน่นอนครับ ผลลัพท์ที่ได้มันก็มาจากความเร็วของ RAM ที่ท่านใช้
ว่ามันจะเร็วได้แค่ไหน ซึ่งปกติ ประสิทธิภาพความเร็วที่ทำได้จะอยู่ราวๆ 0000ff;">50-150 เท่าของ MyISAM ครับ

อ๊ะๆ เห็นมันเร็วกันบ้าพลังขนาดนี้นี่ อย่ามาคิดเชียวว่าทำไมไม่เก็บไว้ใน Memory ให้หมด
สาเหตุมันก็เพราะปัจจัยตามนี้ครับ

1. เครื่องมีแรมเท่าไหร่ มันก็เก็บได้ไม่เกิน 1/2 ของแรมนั่นแหละครับ
2. ใช้ field ประเภท text/blob ทุกชนิดไม่ได้ (ใช้ varchar ได้อยู่นะครับ)
3. restart mysql ปุ๊ป ข้อมูลหายเรียบ (ก็มันเก็บในแรมนี่)
4. เปลืองพื้นที่มากกว่า MyISAM เยอะ (ตาราง MyISAM ขนาด 10 MB เวลาแปลงเป็น Memory จะใช้แรมประมาณ 40 MB)
5. ต้อง allocate memory เป็น block แต่ละ block ขนาดประมาณ 4-8 MB (เอาเป็นว่าหารเลขฐานสองลงตัวอะ)

ว่าแต่ร่ายซะเสียเลยแฮะเรา (ฮาๆ)
เอาเป็นว่า เนื่องด้วยเหตุผลข้อ 3 ทำให้เราไม่สามารถเก็บข้อมูลลงใน Memory Engine ได้ถาวรแน่นอนครับ
ดังนั้น ตารางแบบนี้เหมาะสำหรับเก็บค่า “ชั่วคราว” มากกว่า
เช่นพวกสถิติ user online, session ของเว็บไซต์ อะไรพวกนี้
ซึ่งวิธีแปลงก็ง่ายๆ ครับ

ALTER TABLE 0000ff;">table ENGINE=Memory;

แค่นี้เอง สั้นๆ ง่ายๆ ได้ใจความ
รูปแบบการใช้งานที่เหมาะสม (และผมใช้อยู่ปัจจุบัน)คือ ตาราง peers ของเว็บ bittorrent ครับ
reset ไปมันก็เข้าใหม่ได้ ไม่มีปัญหาอะไรมาก แถมตารางนี้ access หนักมาก ถี่ยิบๆ
ก็เลยเหมาะต่อการใช้ Memory Engine ที่สุดเลย

รองลงมาก็คือ download session ของเว็บฝากไฟล์
พวกนี้ปล่อยๆ มันได้ครับ ใช้ไม่่ค่อยเยอะหรอก

ทีนี้ ปัญหาที่จะเจอคือ Error ต่อไปนี้

The table ‘ff0000;">table‘ is full

ทั้งนี้เนื่องมาจาก MySQL มีการกำหนดขนาดสูงสุดของตารางประเภท Memory ไว้ครับ
ว่า 1 ตารางสามารถจุข้อมูลได้ทั้งหมดกี่ MB ใน variable ที่ชื่อ 0000ff;">max_heap_table_size ครับ
โดยค่าปกติของ MySQL 5.0 คือ 16 MB
อยากให้มันใหญ่ได้เท่าไหร่ก็ใส่ไปโลด /etc/my.cnf ในส่วนของ mysqld สั้นๆ ง่ายๆ ครับ

จบและ คราวหน้าถ้าไม่ลืมจะมาพูดถึง MySQL Indexes ครับ

และแล้วก็ผ่านพ้นกันไปเป็นที่เรียบร้อยสำหรับการประกาศผล admission 2551
ซึ่งผมก็ได้ไปร่วม ในฐานะเบื้องหลังของเว็บไซต์ http://admissions.bodinzone.com/ (อีกครั้ง)

สรุปคร่าวๆ ก็…
งานนี้ทีแรกนึกว่าจะหินมากกว่านี้ครับ
แต่เจอเข้าไป “แค่” 20 คำร้องต่อวินาที
(ย้ำว่าไอ้ 20 req/sec นี่ “แค่” จริงๆ สำหรับผม)

มาดูสถิติกันดีกว่าครับ
กราฟ CPU ไม่มีอะไรเปลี่ยนแปลง ขี้เกียจ cap ขอผ่านละกัน
เอาที่น่าสนใจหน่อย

กราฟ connection คงค้างในเซิฟเวอร์ครับ
ตั้งแต่เริ่มประกาศ คือก่อนเวลาประมาณ 18.00 น. นิดหน่อย มาจนถึงปัจจุบัน
ก็ยังมีการเรียกใช้งานอยู่เรื่อยๆ เห็นได้จากที่มีกราฟพุ่งปรี๊ดไปพอประมาณ

สรุปเทคนิค optimize ที่ใช้

1. DNS Round Robin
2. MySQL Indexes
3. MySQL Memory Engine

เอาไว้เดี๋ยวค่อยเขียนรายละเอียดของข้อ 2-3 ละกัน
จะได้ดูแล้วมีเนื้อหาเยอะๆ หน่อย blog นี้ (ฮา)

ว่าแต่ น้องๆ ทุกคนเป็นไงกันมั่งครับ
หวังว่าคงได้คณะที่อยากได้กันนะครับ ^^

กราฟบน เป็นปริมาณ traffic
ส่วนกราฟล่าง เป็นปริมาณการใช้งาน CPU ครับ

ด้านการใช้งาน CPU สรุปได้สั้นๆ ง่ายๆ ว่า ไม่ต่าง…
แล้วตูจะปิด gzip ไปทำไมเนี่ย ในเมื่อกราฟบนมันบอกว่า
ปิด gzip ไปแล้ว เปลือง bandwidth ขึ้นตั้งสองเท่าแน่ะ

สังเกตตรงที่ลูกศรชี้นะครับ ตรงนั้นคือผมสั่งเปิดการทำงานของ gzip compression อีกรอบ
แล้วก็ลงมาดูกราฟ CPU ที่ตำแหน่งเดียวกัน ไม่เห็นมันจะเปลือง CPU มากขึ้นเลยซักนิด

ว่าแต่งานนี้คงต้อง compile PHP ใหม่ละมั้งนี่ เห้อ…