ในบทความนี้ เราจะทดสอบและวิเคราะห์ประสิทธิภาพของเครื่องมือสร้างเทมเพลต Ruby ที่ได้รับความนิยมสูงสุด 3 รายการ ได้แก่ ERB (ค่าเริ่มต้น) HAML และ SLIM
การเปรียบเทียบคือแนวปฏิบัติในการเปรียบเทียบกระบวนการทางธุรกิจและตัวชี้วัดประสิทธิภาพกับสิ่งที่ดีที่สุดในอุตสาหกรรมและแนวปฏิบัติที่ดีที่สุดจากบริษัทอื่นๆ ในขณะเดียวกัน การทดสอบโหลดเป็นกระบวนการวางความต้องการระบบและวัดการตอบสนอง
เป้าหมายของเราคือการสำรวจโมดูล Ruby Benchmark เล็กน้อย ซึ่งมีวิธีการวัดและรายงานเวลาที่ใช้ในการรันโค้ด Ruby เราจะสร้างเทมเพลตอินไลน์ ทดสอบกับการทดสอบ และแยกเมตริกออกจากเครื่องมือต่างๆ ทั้งสามแบบ
หลังจากนั้น เราจะเจาะลึกการทดสอบโหลดโดยการสร้างมุมมองเทมเพลตในโลกแห่งความเป็นจริง นำเทมเพลตเหล่านั้นไปใช้งานจริงบนเซิร์ฟเวอร์ จากนั้นทำการทดสอบโหลดผ่านเครื่องมือ hey มันให้คุณสมบัติที่ยอดเยี่ยมแก่เราในการส่งโหลดไปยังเว็บแอปพลิเคชันเฉพาะ และรับข้อมูลโดยละเอียดเกี่ยวกับวิธีการทำงานของแต่ละจุดสิ้นสุด และด้วยเหตุนี้ เครื่องมือเทมเพลตแต่ละรายการจึงทำงาน
ตั้งค่า
สิ่งแรกที่ต้องทำคือต้องแน่ใจว่าคุณติดตั้ง Ruby แล้ว เรากำลังใช้เวอร์ชันล่าสุด 2.7.0 ในขณะที่เขียนบทความนี้ อย่าลืมติดตั้ง Rails gem ด้วย
Ruby and the Rails gem เป็นสิ่งที่เราต้องเริ่มต้น สำหรับบทช่วยสอนนี้ Visual Studio Code คือ IDE สำหรับการเข้ารหัส แต่คุณสามารถเลือกรหัสอื่นได้หากต้องการ
ตอนนี้ เลือกโฟลเดอร์สำหรับโครงการ Rails ของเราและเรียกใช้คำสั่งต่อไปนี้:
rails new haml-slim-erb
สิ่งนี้จะดาวน์โหลดการพึ่งพาที่จำเป็นทั้งหมดและสร้างโครงการ Rails นั่งร้านของเรา ไปข้างหน้าและสำรวจมัน
ก่อนดำเนินการกับโค้ด เราจำเป็นต้องเพิ่มการพึ่งพา SLIM และ HAML ใน Gemfile ของเรา :
group :development, :test do
# Call 'byebug' anywhere in the code to stop execution and get a debugger console
gem 'byebug', platform: :mri
gem 'haml'
gem 'slim'
end
นอกจากนี้ยังมีข้อบกพร่องที่มาพร้อมกับโปรเจ็กต์ที่เกี่ยวข้องกับเวอร์ชัน SQLite โดยค่าเริ่มต้น ค้นหาได้ใน Gemfile และเปลี่ยนเป็นดังต่อไปนี้:
gem 'sqlite3', '~> 1.3.0'
ตอนนี้ ให้เรียกใช้ bundle install คำสั่งดาวน์โหลดการขึ้นต่อกัน
สำรวจโมดูลเกณฑ์มาตรฐาน
สำหรับส่วนนี้ของบทความนี้ เราจะดำเนินการโดยตรงกับ การทดสอบ โฟลเดอร์ เปิดแล้วคุณจะเห็นโฟลเดอร์ว่าง มาสร้างอันใหม่ชื่อ benchmark . กันเถอะ และอีกสามไฟล์:example_1_test.rb , example_2_test.rb และ example_3_test.rb. .
Ruby ต้องการให้จบด้วย test ให้ถือว่าเป็นไฟล์ทดสอบ
ถัดไป เพิ่มเนื้อหาต่อไปนี้ในไฟล์แรก:
require 'benchmark'
number = (0..50).to_a.sort{ rand() - 0.5 }[0..10000]
puts Benchmark.measure {
20_000.times do
number[rand()] * (0..50).to_a.sort{ rand() - 0.5 }[0..10000][rand()]
end
}
โปรดทราบว่าบรรทัดแรกนำเข้าโมดูลเกณฑ์มาตรฐานที่จำเป็น จากนั้น เราสร้างอาร์เรย์สุ่มของตัวเลขตั้งแต่ 0 ถึง 50 ด้วยขนาด 10.000 ตัวเลขจำนวนมากเหล่านี้ใช้เวลาดำเนินการไม่นาน
วิธีการ measure มีประโยชน์มากเพราะสามารถวางไว้ที่ใดก็ได้ในโค้ด Ruby ของคุณเพื่อวัดระยะเวลาที่ใช้ในการประมวลผล เวลานี้จะถูกส่งกลับและพิมพ์โดย puts .
ข้างในเรากำลังวนซ้ำ 20,000 เท่าของการทำงานของอาร์เรย์ที่สร้างแบบสุ่มเดียวกันเพื่อคูณหนึ่งค่าของแต่ละค่า
หากต้องการเรียกใช้ไฟล์ทดสอบนี้โดยเฉพาะ ให้ใช้คำสั่งต่อไปนี้:
rake test TEST=test/benchmark/example_1_test.rb
ผลลัพธ์อาจมีลักษณะดังนี้:
0.702647 0.012353 0.715000 ( 0.721910)
รายงานนี้พิมพ์ตามลำดับ เวลา CPU ของผู้ใช้ เวลา CPU ของระบบ ผลรวมของเวลา CPU ของผู้ใช้และของระบบ และตามเวลาจริงที่ผ่านไปตามลำดับ หน่วยของเวลาคือวินาที
เราจะใช้ประโยชน์จากวิธีเปรียบเทียบอื่นๆ ในทางปฏิบัติต่อไป
การทดสอบเทมเพลตอินไลน์
เมื่อคุณเข้าใจวิธีการทำงานของโมดูลเกณฑ์มาตรฐานของ Ruby มากขึ้นแล้ว เราจะลงลึกในการดำเนินการทดสอบบางอย่างในเทมเพลตทั้งสามนี้
สำหรับสิ่งนี้ เราจะสร้างเทมเพลตเดียว แปลเป็นสามรูปแบบกลไก และสุดท้าย เรียกใช้ภายใต้วิธีการเปรียบเทียบ
เพิ่มข้อมูลต่อไปนี้ในไฟล์ทดสอบที่สอง:
require 'erb'
require 'haml'
require 'slim'
require 'benchmark'
require 'ostruct'
notes = OpenStruct.new title: 'Write an essay', description: 'My essay is about...', randomList: (0..50).to_a.sort{ rand() - 0.5 }[0..10000]
erb_example = <<-ERB_EXAMPLE
<span><%= notes.title %></span>
<span><%= notes.description %></span>
<table>
<tr>
<% notes.randomList.each do |note| %>
<td><%= note %></td>
<% end %>
</tr>
</table>
ERB_EXAMPLE
slim_example = <<-SLIM_EXAMPLE
span= notes.title
span= notes.description
table
tr
- notes.randomList.each do |note|
td= note
SLIM_EXAMPLE
haml_example = <<-HAML_EXAMPLE
%span= notes.title
%span= notes.description
%table
%tr
- notes.randomList.each do |note|
%td= note
HAML_EXAMPLE
context = OpenStruct.new notes: notes
__result = ''
Benchmark.bmbm(20) do |bcmk|
bcmk.report("erb_test") { (1..2000).each { ERB.new(erb_example, 0, '-', '__result').result binding } }
bcmk.report("slim_test") { (1..2000).each{ __result = Slim::Template.new { slim_example }.render(context) } }
bcmk.report("haml_test") { (1..2000).each { __result = Haml::Engine.new(haml_example).render(binding) } }
end
ขั้นแรก นำเข้าโมดูลที่จำเป็น นอกเหนือจากเครื่องมือเทมเพลต เรายังนำเข้า ostruct โมดูล. OpenStruct เป็นโครงสร้างข้อมูลจาก metaprogramming คล้ายกับ Hash ซึ่งช่วยให้สามารถกำหนดคุณลักษณะตามอำเภอใจพร้อมค่าที่มาพร้อมกันได้
มีประโยชน์เพราะเราไม่จำเป็นต้องสร้างโครงสร้างคลาสทั้งหมดเพื่อเก็บค่า เราสามารถกำหนดแบบอินไลน์ได้
struct ของเรานั้นเป็น Note วัตถุที่มีชื่อ คำอธิบาย และรายการตัวเลขสุ่ม ซึ่งเพิ่มเวลาในการดำเนินการ
เราจะไม่เน้นที่กลไกการทำงานของเทมเพลตแต่ละรายการ คุณสามารถอ้างถึงเอกสารอย่างเป็นทางการสำหรับสิ่งนี้ อย่างไรก็ตาม ไวยากรณ์ของพวกมันค่อนข้างง่ายต่อการดูดซึม
เวทย์มนตร์ถูกวางไว้ที่ส่วนท้ายของรหัส ตอนนี้ เรากำลังใช้ bmbm วิธีซึ่งทำมากกว่าวิธีแรกเล็กน้อย บางครั้ง ผลลัพธ์การวัดประสิทธิภาพอาจเบ้เนื่องจากปัจจัยภายนอก เช่น การรวบรวมขยะ หน่วยความจำรั่ว ฯลฯ วิธีนี้พยายามลดผลกระทบนี้ให้น้อยที่สุดโดยทำการทดสอบสองครั้ง:ครั้งแรกเป็นการซ้อมเพื่อให้สภาพแวดล้อมรันไทม์เสถียรและครั้งที่สอง เวลาจริง คุณสามารถอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ที่นี่
สุดท้าย bmbm . แต่ละอัน บรรทัดโค้ดภายในของรันการวนซ้ำ 2,000 ครั้งระหว่างการสร้างแต่ละเทมเพลต โฟกัสอยู่ที่การกำหนดเทมเพลตและแสดงผล
หลังจากรันไฟล์ทดสอบนี้แล้ว ผลลัพธ์ที่ได้คือ:
Rehearsal --------------------------------------------------------
erb_test 0.311534 0.002963 0.314497 ( 0.314655)
slim_test 2.544711 0.004520 2.549231 ( 2.550307)
haml_test 1.449813 0.003169 1.452982 ( 1.454118)
----------------------------------------------- total: 4.316710sec
user system total real
erb_test 0.298730 0.000679 0.299409 ( 0.299631)
slim_test 2.550665 0.004148 2.554813 ( 2.556023)
haml_test 1.432653 0.001984 1.434637 ( 1.435417)
ทั้งสองช่วงผลลัพธ์จะถูกแยกจากกันเพื่อให้คุณซึมซับสิ่งที่เป็นจริงจากการซ้อม
เปลี่ยนสถานการณ์เล็กน้อย
สำหรับผลการทดสอบครั้งล่าสุด คุณอาจสรุปได้ว่า ERB เป็นตัวเลือกที่ดีที่สุด ในขณะที่ SLIM เป็นตัวเลือกที่แย่ที่สุด อีกครั้งก็ขึ้นอยู่กับสถานการณ์
ในการทดสอบนั้น ทุกครั้งที่เราวนซ้ำ เราต้องสร้าง ใหม่ วัตถุเครื่องยนต์แม่แบบ นี่ไม่ใช่โฟลว์ที่เหมาะสมที่สุด
มาเปลี่ยนกันเล็กน้อยและย้ายอินสแตนซ์นี้ไปด้านนอก ดังที่แสดงในข้อมูลโค้ดต่อไปนี้:
erb_engine = ERB.new(erb_example, 0, '-', '__result')
slim_engine = Slim::Template.new { slim_example }
haml_engine = Haml::Engine.new(haml_example)
Benchmark.bmbm(10) do |bcmk|
bcmk.report("erb_test") { (1..2000).each { erb_engine.result binding } }
bcmk.report("slim_test") { (1..2000).each{ __result = slim_engine.render(context) } }
bcmk.report("haml_test") { (1..2000).each { __result = haml_engine.render(binding) } }
end
รหัสทำเหมือนเดิมทุกประการ ตอนนี้ ทำการทดสอบอีกครั้ง แล้วคุณจะเห็นผลลัพธ์ดังนี้:
Rehearsal ----------------------------------------------
erb_test 0.127599 0.002407 0.130006 ( 0.130137)
slim_test 0.046972 0.000841 0.047813 ( 0.047858)
haml_test 0.208308 0.002239 0.210547 ( 0.210769)
------------------------------------- total: 0.388366sec
user system total real
erb_test 0.118002 0.000556 0.118558 ( 0.118618)
slim_test 0.040129 0.000090 0.040219 ( 0.040320)
haml_test 0.205331 0.001163 0.206494 ( 0.206680)
สังเกตว่าอันไหนดีที่สุดและแย่ที่สุดตอนนี้ นี่เป็นเพียงเพื่อแสดงให้เห็นว่าไม่มีกระสุนเงินในแง่ของเครื่องยนต์ที่สมบูรณ์แบบ
คุณต้องทดสอบและวิเคราะห์ว่าคุณลักษณะใดทำงานได้ดีกว่าสำหรับรูปแบบการเขียนโค้ดของคุณ นอกจากนี้ยังมีเครื่องมือเสริมอื่นๆ เช่น Ruby Profiler ที่คุณสามารถใช้เพื่อทำความเข้าใจได้ดีขึ้นว่าโค้ดทำงานอย่างไรและทำไม
โหลดการทดสอบสถานการณ์จริง
ไปที่สิ่งที่ใกล้เคียงกับความเป็นจริงของเรามากขึ้น เราจะเปรียบเทียบเทมเพลตจริงที่มีบันทึกย่อ (สามรายการหนึ่งรายการสำหรับแต่ละเครื่องมือเทมเพลต)
ตั้งแต่ benchmark โมดูลเกิดขึ้นในโค้ด Rails เราสูญเสียมาตรการสำคัญบางอย่างที่เกี่ยวข้องกับกระบวนการภายในของเอ็นจิ้นเทมเพลต
การทดสอบเบนช์มาร์กประเภทนี้ช่วยให้เราเห็นว่าแต่ละเอ็นจิ้นทำงานอย่างไรโดยรวม ตั้งแต่เริ่มต้นกระบวนการผ่านการมาถึงของคำขอ ไปจนถึงการประมวลผลตรรกะทางธุรกิจ จนกระทั่งข้อมูลการตอบสนองไปถึงมุมมอง ขั้นตอนสุดท้ายนี้โดยเฉพาะจะมีขั้นตอนมากมาย เช่น กระบวนการแยกวิเคราะห์และการแสดงผลที่การทดสอบโหลดสามารถวัดได้ และ benchmark ไม่ได้
ขั้นแรก มาสร้างตัวควบคุม Rails สำหรับแต่ละตัวอย่าง:
rails g controller notes_erb index
rails g controller notes_haml index
rails g controller notes_slim index
คำสั่งนี้จะสร้างไฟล์ Rails ทั่วไปจำนวนมากที่คุณคุ้นเคยโดยอัตโนมัติ
ต่อไป มาเปิด notes_erb_controller.rb สร้างไฟล์และเปลี่ยนเนื้อหาเป็น:
class NotesErbController < ApplicationController
def index
@notes = JSON.parse(Constants::NOTES, object_class: OpenStruct)
end
end
นี่คือที่ที่เราป้อนเทมเพลตด้วยข้อมูล โปรดทราบว่าเรามีคลาสคอนโทรลเลอร์หนึ่งคลาสสำหรับแต่ละเอ็นจิ้น
โดยพื้นฐานแล้ว เรากำลังดึง JSON บางส่วนจากค่าคงที่แบบอินไลน์ การตอบสนองจะถูกแยกวิเคราะห์เป็น OpenStruct . ใหม่ วัตถุและกลับสู่เครื่องยนต์
NOTES ต้องวางค่าคงที่ลงในไฟล์ใหม่ชื่อ constants.rb . ไปข้างหน้าและสร้างมัน แล้วเพิ่มเนื้อหาต่อไปนี้:
class Constants
NOTES = '[
{
"title": "Walk the dog",
"description": "Bla bla",
"tasks": [{
"title": "Task #1"
},
{
"title": "Task #2"
},
{
"title": "Task #3"
}]
},
...
{
"title": "Walk the dog",
"description": "Bla bla",
"tasks": [{
"title": "Task #1"
},
{
"title": "Task #2"
},
{
"title": "Task #3"
}]
}
]
'
end
โปรดตรวจสอบให้แน่ใจว่าได้เปลี่ยนจุดไข่ปลาสำหรับองค์ประกอบบันทึกย่อเพิ่มเติม นอกจากนี้ อย่าลืมจำลองตรรกะในตัวควบคุมอื่นๆ แต่ละตัวด้วย
การสร้างมุมมอง ERB
ถึงเวลาสร้างมุมมองของตัวอย่างของเราแล้ว โดยไปที่ views/notes_erb และสร้างไฟล์อีกสองไฟล์:note.html.erb และ task.html.erb . สิ่งเหล่านี้จะช่วยเราสร้างตัวอย่างที่มีมุมมอง บางส่วน และเลย์เอาต์
ด้วยวิธีนี้ เรารับประกันว่าตัวอย่างของเราได้สำรวจเครื่องยนต์ Rails มากที่สุด ตรวจสอบให้แน่ใจว่าได้สร้างไฟล์ที่เทียบเท่ากับทั้ง views/notes_haml และ views/notes_slim .
มาเริ่มกันที่ index.html.erb รหัส:
<style>
h2 {
text-align: center;
}
table, td, th {
border: 1px solid #ddd;
text-align: left;
}
table {
border-collapse: collapse;
width: 80%;
margin: auto;
}
th, td {
padding: 15px;
}
</style>
<h2>List of Notes</h2>
<table>
<thead>
<tr>
<th>Title</th>
<th>Description</th>
<th>Tasks</th>
</tr>
</thead>
<tbody>
<%= render partial: 'notes_erb/note', collection: @notes %>
</tbody>
</table>
ไม่มีอะไรพิเศษเกินไปที่นี่ โปรดทราบว่าเรากำลังนำเข้าบางส่วน _note.html.erb และส่งไฟล์ collection พารามิเตอร์:@notes . ของเรา สร้างขึ้นก่อนหน้านี้ในคอนโทรลเลอร์
นี่คือเนื้อหาของโน้ต:
<tr>
<td>
<span><%= note.title %></span>
</td>
<td>
<span><%= note.description %></span>
</td>
<td>
<ul>
<%= render partial: 'notes_erb/task', collection: note.tasks %>
</ul>
</td>
</tr>
นี่เป็นอีกส่วนหนึ่ง การเข้าถึง tasks คราวนี้
เนื้อหาสำหรับ _task.html.erb ดังต่อไปนี้:
<li><%= task.title %></li>
มุมมองของ HAML
คุณจะสังเกตเห็นว่าไวยากรณ์จากเอ็นจิ้นหนึ่งไปยังอีกเอ็นจิ้นนั้นคล้ายกันมาก การเปลี่ยนแปลงเป็นเพียงการใช้คำฟุ่มเฟือยของแต่ละคน ตัวอย่างเช่น SLIM เป็นสิ่งที่สะอาดที่สุดในบรรดาพวกเขา
ดูโค้ดสำหรับไฟล์ทั้งสาม:
# Content of index.html.haml
:css
h2 {
text-align: center;
}
table, td, th {
border: 1px solid #ddd;
text-align: left;
}
table {
border-collapse: collapse;
width: 80%;
margin: auto;
}
th, td {
padding: 15px;
}
%h2 List of Notes
%table
%thead
%tr
%th Title
%th Description
%th Tasks
%tbody
= render partial: 'notes_haml/note', collection: @notes
# Content of _note.html.haml
%tr
%td
%span= note.title
%td
%span= note.description
%td
%ul
= render partial: 'notes_haml/task', collection: note.tasks
# Content of _task.html.haml
%li= task.title
คล้ายกันมากใช่ไหม
มุมมองของ SLIM
สุดท้ายนี้ เราก็มีความคิดเห็นของ SLIM นี่คือความแตกต่างที่ยิ่งใหญ่ที่สุดจากอีกสองคน โครงสร้างทั้งหมดชัดเจนขึ้น:
# index.html.slim
css:
h2 {
text-align: center;
}
table, td, th {
border: 1px solid #ddd;
text-align: left;
}
table {
border-collapse: collapse;
width: 80%;
margin: auto;
}
th, td {
padding: 15px;
}
h2 List of Notes
table
thead
tr
th Title
th Description
th Tasks
tbody
= render partial: 'notes_haml/note', collection: @notes
# _note.html.slim
tr
td
span= note.title
td
span= note.description
td
ul
= render partial: 'notes_haml/task', collection: note.tasks
# _task.html.slim
li= task.title
คุณจะต้องแปลเลย์เอาต์เป็นไวยากรณ์ของเอ็นจิ้นแต่ละอัน ต้องสร้างไฟล์ใหม่สองไฟล์ภายใต้ มุมมอง/เลย์เอาต์ โฟลเดอร์:application.html.haml และ application.html.slim .
ฉันจะทิ้งงานนั้นให้คุณเป็นการบ้าน อย่างไรก็ตาม หากคุณพบว่ามันยาก คุณสามารถดูเวอร์ชันของฉันได้ในลิงก์โครงการ GitHub ที่ส่วนท้ายของบทความ
การเรียกใช้การทดสอบ
สุดท้าย เรามาทดสอบตัวอย่างกัน ขั้นแรก ให้เปิดแอปพลิเคชันโดยเรียกใช้ rails s สั่งการ. โดยจะเริ่มต้นที่ https://localhost:3000/ address
มุมมองจะมีลักษณะดังนี้:
ตัวอย่างเอ็นจิ้นเทมเพลตแต่ละรายการจะมีอยู่ที่ URL ที่เกี่ยวข้องซึ่งสร้างขึ้นโดยอัตโนมัติใน config/routes.rb ไฟล์.
ในการทดสอบการเปรียบเทียบ เราจะใช้เครื่องมือวัดประสิทธิภาพ มันง่ายมากและให้ข้อมูลที่เป็นประโยชน์สำหรับการวิเคราะห์เกณฑ์มาตรฐาน นี่คือคำสั่ง:
$ hey https://localhost:3000/notes_erb/index
Summary:
Total: 9.3978 secs
Slowest: 9.1718 secs
Fastest: 0.0361 secs
Average: 1.2714 secs
Requests/sec: 21.2816
$ hey https://localhost:3000/notes_haml/index
Summary:
Total: 10.8661 secs
Slowest: 10.2354 secs
Fastest: 0.1871 secs
Average: 1.4735 secs
Requests/sec: 18.4058
$ hey https://localhost:3000/notes_slim/index
Summary:
Total: 11.3384 secs
Slowest: 10.7570 secs
Fastest: 0.0437 secs
Average: 1.5406 secs
Requests/sec: 17.6392
อย่างที่คุณเห็น เครื่องยนต์ทั้งหมดนั้นใกล้เคียงกันมากในแง่ของเวลาดำเนินการ จำนวนคำขอเริ่มต้นที่จะเรียกใช้คือ 200 แต่คุณสามารถเปลี่ยนค่านี้ได้โดยใช้ -n ตัวเลือก
มาดูการทดสอบเดียวกันกับที่ดำเนินการกับคำขอ 1200 รายการ:
$ hey -n 1200 https://localhost:3000/notes_erb/index
Summary:
Total: 52.2586 secs
Slowest: 19.2837 secs
Fastest: 0.0389 secs
Average: 0.6960 secs
Requests/sec: 22.9627
$ hey -n 1200 https://localhost:3000/notes_haml/index
Summary:
Total: 61.7637 secs
Slowest: 18.5290 secs
Fastest: 0.0442 secs
Average: 0.8557 secs
Requests/sec: 19.4289
$ hey -n 1200 https://localhost:3000/notes_slim/index
Summary:
Total: 63.1625 secs
Slowest: 19.9744 secs
Fastest: 0.0874 secs
Average: 0.7959 secs
Requests/sec: 18.9986
เมื่อคุณเพิ่มจำนวนคำขอพร้อมกัน คุณจะเห็นความแตกต่างของเวลาในการดำเนินการทั้งหมดและโดยเฉลี่ยเพิ่มขึ้น เห็นได้ชัดว่าสถานการณ์นี้ซึ่งมีคำขอคู่ขนานนับพันรายการ มีความเฉพาะเจาะจงและไม่ธรรมดามาก อย่างไรก็ตาม การทดสอบโหลดนั้นเกี่ยวกับเรื่องนี้ ทำให้ปลายทางมีขีดจำกัด
เครื่องมือ hey ยังพิมพ์ข้อมูลอื่นๆ เช่น ฮิสโตแกรมเวลาตอบสนอง:
โดยจะแสดงเวลาเฉลี่ยที่แต่ละคำขอใช้ในการดำเนินการให้เสร็จสิ้นโดยสรุปเป็นค่าโดยประมาณ ในตัวอย่างของเรา เห็นได้ชัดว่าคำขอส่วนใหญ่ (1048) เสร็จสิ้นภายใน 1.893 วินาที นี่คือเหตุผลที่ควรทำการทดสอบความเครียดไปพร้อม ๆ กัน
นอกจากนี้ยังมีข้อมูลเพิ่มเติมเกี่ยวกับการกระจายเวลาแฝง รายละเอียดเกี่ยวกับการโทรและการค้นหา DNS การเขียนคำขอ เวลารอและการอ่าน ข้อผิดพลาด ฯลฯ
ตรวจสอบเอกสารสำหรับตัวเลือก/ผลลัพธ์ที่กำหนดเองเพิ่มเติม
สรุป
คุณสามารถค้นหาซอร์สโค้ดสำหรับตัวอย่างนี้ได้ที่นี่
การทดสอบประเภทนี้เหมาะอย่างยิ่งสำหรับการช่วยคุณกำหนดเครื่องมือเทมเพลตที่อาจเหมาะสมกับความต้องการของโครงการของคุณมากกว่า ดังที่เราได้เห็นแล้ว โปรดใช้ความระมัดระวังเกี่ยวกับโค้ดที่ใช้งานไม่ดี เนื่องจากข้อมูลโค้ดขนาดเล็กบางส่วนสามารถเปลี่ยนประสิทธิภาพโดยรวมของการดำเนินการได้ในทันที
อีกจุดที่น่าสนใจคือ ERB ซึ่งเป็นเอ็นจิ้น Rails เริ่มต้นนั้นทำงานได้ดีเช่นกัน นอกจากเอ็นจิ้นอื่นๆ จะเร็วขึ้นในการทดสอบของเราแล้ว ERB ก็อยู่ใกล้พอที่จะพิสูจน์คุณค่าของมันเสมอ
สุดท้ายนี้ เราขอแนะนำให้คุณพิจารณาปัจจัยสำคัญอื่นๆ ในการทดสอบว่าเป็นงานทำการบ้าน รวมถึงการแคช พร็อกซี การใช้ฐานข้อมูล และกลไกการจัดเก็บอื่นๆ ตลอดจนคิวและเครื่องมือในลักษณะที่ไม่ตรงกัน รายการเหล่านี้มักมีบทบาทสำคัญในลักษณะการทำงานของความคิดเห็นหรือเวลาในการประมวลผลที่ใช้ในการแสดงผล ขอให้โชคดี!
