कौन सा सबसे तेज़ है? ईआरबी बनाम एचएएमएल बनाम स्लिम

इस लेख में, हम तीन सबसे लोकप्रिय रूबी टेम्प्लेटिंग इंजनों के प्रदर्शन का परीक्षण और विश्लेषण करेंगे:ERB (डिफ़ॉल्ट एक), HAML और SLIM।

बेंचमार्किंग व्यावसायिक प्रक्रियाओं और प्रदर्शन मेट्रिक्स की तुलना उद्योग के सर्वोत्तम और अन्य कंपनियों के सर्वोत्तम अभ्यासों से करने का अभ्यास है। इस बीच, लोड परीक्षण एक सिस्टम पर मांग डालने और उसकी प्रतिक्रिया को मापने की प्रक्रिया है।

हमारा लक्ष्य रूबी बेंचमार्क मॉड्यूल का एक छोटा सा अन्वेषण करना है, जो रूबी कोड को निष्पादित करने के लिए उपयोग किए गए समय को मापने और रिपोर्ट करने के तरीके प्रदान करता है। हम कुछ इनलाइन टेम्प्लेट बनाएंगे, उन्हें परीक्षणों के विरुद्ध चलाएंगे, और तीन अलग-अलग इंजनों पर मेट्रिक निकालेंगे।

उसके बाद, हम कुछ वास्तविक-विश्व टेम्पलेट दृश्य बनाकर लोड परीक्षण में उतरेंगे, उन्हें सर्वर पर लाइव रखेंगे, और फिर हे टूल के माध्यम से कुछ लोड परीक्षण करेंगे। यह हमें किसी विशिष्ट वेब एप्लिकेशन पर लोड भेजने और प्रत्येक समापन बिंदु और इसलिए, प्रत्येक टेम्पलेट इंजन के प्रदर्शन से संबंधित संपूर्ण डेटा प्राप्त करने के लिए कुछ बेहतरीन सुविधाएँ प्रदान करता है।

सेटअप

करने के लिए पहली बात, निश्चित रूप से, यह सुनिश्चित करना है कि आपके पास पहले से ही रूबी स्थापित है। हम इस आलेख के लेखन के रूप में नवीनतम संस्करण, 2.7.0 का उपयोग कर रहे हैं। रेल रत्न भी स्थापित करना सुनिश्चित करें।

रूबी और रेल्स रत्न काफी कुछ हैं जो हमें आरंभ करने की आवश्यकता है। इस ट्यूटोरियल के लिए, विजुअल स्टूडियो कोड कोडिंग के लिए आईडीई है, लेकिन यदि आप चाहें तो बेझिझक दूसरा चुनें।

अब, हमारे रेल प्रोजेक्ट के लिए एक फ़ोल्डर चुनें और निम्न कमांड चलाएँ:

rails new haml-slim-erb

यह सभी आवश्यक निर्भरताओं को डाउनलोड करेगा और हमारी मचान रेल परियोजना तैयार करेगा। आगे बढ़ें और इसे एक्सप्लोर करें।

कोड पर आगे बढ़ने से पहले, हमें अपने Gemfile में SLIM और HAML निर्भरता को जोड़ना होगा :

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 चलाएं निर्भरता डाउनलोड करने के लिए आदेश।

बेंचमार्क मॉड्यूल को एक्सप्लोर करना

लेख के इस भाग के लिए, हम सीधे परीक्षण . के साथ काम करेंगे फ़ोल्डर। इसे खोलें, और आपको कुछ खाली फ़ोल्डर दिखाई देंगे। आइए एक नया बनाएं जिसे बेंचमार्क . कहा जाता है और तीन अन्य फ़ाइलें:example_1_test.rb , example_2_test.rb , और example_3_test.rb. ।

रूबी को परीक्षण . के साथ समाप्त होने की आवश्यकता है एक परीक्षण फ़ाइल माने जाने के लिए।

इसके बाद, पहली फ़ाइल में निम्न सामग्री जोड़ें:

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
}

ध्यान दें कि पहली पंक्ति आवश्यक बेंचमार्क मॉड्यूल आयात करती है। फिर, हम 10.000 आकार के साथ 0 से 50 तक की संख्याओं की एक यादृच्छिक सरणी उत्पन्न करते हैं। ये बड़ी संख्या केवल प्रसंस्करण में कुछ समय लेने के लिए है।

विधि measure यह बहुत उपयोगी है क्योंकि इसे आपके रूबी कोड में कहीं भी रखा जा सकता है ताकि यह पता लगाया जा सके कि इसे संसाधित करने में कितना समय लग रहा है। यह समय puts . द्वारा लौटाया और मुद्रित किया जाता है ।

अंदर, हम प्रत्येक के एक मान को गुणा करने के लिए समान यादृच्छिक-जनरेटेड सरणी के निष्पादन के 20k गुना के लिए लूप कर रहे हैं।

इस परीक्षण फ़ाइल को विशेष रूप से चलाने के लिए, निम्न आदेश जारी करें:

rake test TEST=test/benchmark/example_1_test.rb

परिणाम इस तरह दिख सकता है:

0.702647   0.012353   0.715000 (  0.721910)

यह रिपोर्ट क्रमशः उपयोगकर्ता CPU समय, सिस्टम CPU समय, उपयोगकर्ता और सिस्टम CPU समय का योग, और बीता हुआ वास्तविक समय प्रिंट करती है। समय की इकाई सेकंड है।

व्यवहार में हम अन्य बेंचमार्क विधियों का उपयोग करेंगे।

इनलाइन टेम्प्लेट परीक्षण

अब जब आप रूबी के बेंचमार्क मॉड्यूल के काम करने के तरीके के बारे में थोड़ा और समझ गए हैं, तो हम तीन टेम्प्लेट पर कुछ परीक्षणों के निष्पादन में गोता लगाएंगे।

इसके लिए, हम एक एकल टेम्प्लेट बनाएंगे, इसे तीन इंजन सिंटैक्स में अनुवादित करेंगे, और अंत में, इसे बेंचमार्क विधि के तहत चलाएंगे।

दूसरी परीक्षण फ़ाइल में निम्नलिखित जोड़ें:

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 मेटाप्रोग्रामिंग से एक डेटा संरचना है, जो Hash . के समान है , जो उनके साथ के मूल्यों के साथ मनमानी विशेषताओं की परिभाषा की अनुमति देता है।

यह उपयोगी है क्योंकि हमें मूल्यों को संग्रहीत करने के लिए एक संपूर्ण वर्ग संरचना बनाने की आवश्यकता नहीं है। हम इसे इनलाइन परिभाषित कर सकते हैं।

हमारी संरचना मूल रूप से एक Note है एक शीर्षक, विवरण और यादृच्छिक संख्याओं की सूची के साथ वस्तु, जो प्रसंस्करण समय को बढ़ाती है।

हम इस बात पर ध्यान नहीं देंगे कि प्रत्येक टेम्पलेट इंजन कैसे काम करता है; आप इसके लिए उनके आधिकारिक डॉक्स का उल्लेख कर सकते हैं। हालांकि, उनके सिंटैक्स को आत्मसात करना बहुत आसान है।

जादू कोड के अंत में रखा गया है। अब, हम bmbm . का उपयोग कर रहे हैं विधि, जो पहले वाले की तुलना में थोड़ा अधिक करती है। कभी-कभी, बाहरी कारकों, जैसे कचरा संग्रहण, मेमोरी लीक आदि के कारण बेंचमार्क परिणाम विषम हो सकते हैं। यह विधि दो बार परीक्षण चलाकर इस प्रभाव को कम करने का प्रयास करती है:पहली बार रनटाइम वातावरण को स्थिर करने के लिए पूर्वाभ्यास के रूप में और दूसरा वास्तविक के लिए समय। आप इस पर और अधिक यहाँ पढ़ सकते हैं।

अंत में, प्रत्येक bmbm प्रत्येक टेम्पलेट के निर्माण के दौरान आंतरिक कोड लाइनें 2000 बार लूप निष्पादित करती हैं। टेम्प्लेट असाइन करने और उसे रेंडर करने पर ध्यान दिया जाता है.

इस परीक्षण फ़ाइल को निष्पादित करने के बाद, यहाँ परिणाम है:

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_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)

ध्यान दें कि अब कौन सा सबसे अच्छा और सबसे खराब है। यह सिर्फ यह दिखाने के लिए है कि एक आदर्श इंजन के मामले में कोई चांदी की गोली नहीं है।

आपको परीक्षण और विश्लेषण करना चाहिए कि आपकी कोडिंग शैली के लिए कौन सी सुविधाएँ बेहतर प्रदर्शन करती हैं। साथ ही, रूबी प्रोफाइलर जैसे अन्य सहायक उपकरण भी हैं, जिनका उपयोग आप यह समझने के लिए कर सकते हैं कि कोड इस तरह से कैसे और क्यों व्यवहार करता है।

एक वास्तविक-विश्व परिदृश्य का परीक्षण लोड करें

आइए अपनी वास्तविकता के करीब कुछ की ओर बढ़ते हैं। हम एक वास्तविक टेम्पलेट को बेंचमार्क करने जा रहे हैं जिसमें कुछ नोट सूचीबद्ध हैं (तीन, प्रत्येक टेम्पलेट इंजन के लिए एक)।

चूंकि benchmark मॉड्यूल रेल कोड में होता है, हम टेम्पलेट इंजन आंतरिक प्रक्रियाओं से संबंधित कुछ महत्वपूर्ण उपायों को खो देते हैं।

इस प्रकार का बेंचमार्क परीक्षण हमें यह देखने की अनुमति देता है कि प्रत्येक इंजन एक अनुरोध के आगमन के माध्यम से प्रक्रिया की शुरुआत से लेकर व्यावसायिक तर्क प्रसंस्करण तक प्रतिक्रिया डेटा प्राप्त होने तक समग्र रूप से कैसा प्रदर्शन करता है। यह अंतिम चरण, विशेष रूप से, चरणों का एक समूह होगा, जैसे पार्सिंग और रेंडरिंग प्रक्रियाएं जिन्हें लोड परीक्षण माप सकता है, और benchmark नहीं कर सकता।

सबसे पहले, प्रत्येक उदाहरण के लिए रेल नियंत्रक बनाते हैं:

rails g controller notes_erb index
rails g controller notes_haml index
rails g controller notes_slim index

यह आदेश सामान्य रेल फ़ाइलों का एक समूह स्वतः उत्पन्न करेगा जिनका आप उपयोग कर सकते हैं।

इसके बाद, आइए 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

कृपया, अधिक नोट तत्वों के लिए इलिप्सिस को बदलना सुनिश्चित करें। साथ ही, प्रत्येक अन्य नियंत्रकों में तर्क को दोहराना न भूलें।

ईआरबी दृश्य बनाना

अब, हमारे उदाहरण के विचार बनाने का समय आ गया है। ऐसा करने के लिए, views/notes_erb . पर जाएं फ़ोल्डर और दो अन्य फ़ाइलें बनाएँ:note.html.erb और task.html.erb . वे हमें एक उदाहरण बनाने में मदद करेंगे जिसमें दृश्य, आंशिक और लेआउट शामिल हैं।

इस तरह, हम गारंटी देते हैं कि हमारे उदाहरण ने रेल इंजनों की सबसे अधिक खोज की है। दोनों 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/ पते पर शुरू होगा।

यह नज़ारा कैसा दिखेगा:

प्रत्येक टेम्पलेट इंजन उदाहरण config/routes.rb में अपने-आप उत्पन्न होने वाले संबंधित URL पर उपलब्ध होगा फ़ाइल।

बेंचमार्क इन उदाहरणों का परीक्षण करने के लिए, हम हे बेंचमार्क टूल का उपयोग करेंगे। यह बहुत आसान है और बेंचमार्क विश्लेषण के लिए कुछ उपयोगी जानकारी प्रदान करता है। ये आदेश हैं:

$ 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

जब आप समवर्ती अनुरोधों की संख्या बढ़ाते हैं, तो आप देखेंगे कि कुल और औसत प्रसंस्करण समय में अंतर बढ़ जाता है। जाहिर है, हजारों समानांतर अनुरोधों के साथ यह परिदृश्य बहुत विशिष्ट है और बहुत सामान्य नहीं है। हालांकि, लोड टेस्टिंग केवल उसी के बारे में है, जो अंतिम बिंदुओं को सीमा तक ले जाती है।

हे टूल अन्य जानकारी भी प्रिंट करता है, जैसे प्रतिक्रिया समय हिस्टोग्राम:

यह अनुमानित शब्दों में प्रत्येक अनुरोध को पूरा करने में लगने वाला औसत समय दिखाता है। हमारे उदाहरण में, यह स्पष्ट है कि अधिकांश अनुरोध (1048) 1.893 सेकंड में पूरे हो गए। यही कारण है कि एक ही समय में तनाव परीक्षण करना वांछनीय है।

विलंबता वितरण, DNS डायलअप और लुकअप, अनुरोध लेखन, प्रतीक्षा और पढ़ने के समय, त्रुटियों आदि के बारे में अधिक जानकारी है।

अधिक कस्टम विकल्पों/परिणामों के लिए दस्तावेज़ देखें।

सारांश

आप इस उदाहरण के लिए स्रोत कोड यहां पा सकते हैं।

इस प्रकार का परीक्षण यह निर्धारित करने में आपकी सहायता करने के लिए बहुत अच्छा है कि आपकी परियोजना आवश्यकताओं के लिए कौन सा टेम्पलेट इंजन अधिक उपयुक्त हो सकता है। जैसा कि हमने देखा है, खराब तरीके से लागू किए गए कोड के बारे में सावधान रहें क्योंकि कुछ छोटे कोड स्निपेट आपके निष्पादन के समग्र प्रदर्शन को अचानक बदल सकते हैं।

एक और दिलचस्प बात यह है कि ईआरबी, डिफ़ॉल्ट रेल इंजन के रूप में, अपने काम में भी बहुत अच्छा है। हमारे कुछ परीक्षणों में अन्य इंजनों के तेज़ होने के अलावा, ERB हमेशा अपने मूल्य को साबित करने के लिए काफी करीब होता है।

अंत में, मैं अनुशंसा करता हूं कि आप परीक्षणों में कुछ अन्य महत्वपूर्ण कारकों पर एक होमवर्क कार्य के रूप में विचार करें, जिसमें कैशिंग, प्रॉक्सी, डेटाबेस का उपयोग, और अन्य भंडारण तंत्र, साथ ही कतार और एसिंक प्रकृति के ऐसे किसी भी उपकरण शामिल हैं। ये आइटम हमेशा आपके विचारों के व्यवहार या उन्हें प्रस्तुत करने में लगने वाले प्रसंस्करण समय में महत्वपूर्ण भूमिका निभाते हैं। शुभकामनाएँ!