https://wiki.expertiza.ncsu.edu/api.php?action=feedcontributions&feedformat=atom&user=PkadamExpertiza_Wiki - User contributions [en]2026-06-13T05:45:29ZUser contributionsMediaWiki 1.41.0https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81912CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:52:52Z<p>Pkadam: /* Intrdouction */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project (Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and implement it on the existing Expertiza system and test it.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone.[http://rubygems.org/gems/automated_metareview Automated Metareview Gem] <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
To use the Experiza system Go to [http://152.7.99.90:5801/ Expertiza with Gem installed]<br/><br />
For detailed description about the steps to follow to test the automated metareview functionality Click [http://expertiza.ncsu.edu/submitted_content/download/25990?current_folder%5Bname%5D=%2Flocal%2Frails%2Fexpertiza%2Freleases%2F20131018020418%2Fpg_data%2Fefg%2Fcsc517%2Ff13%2Foss%2F3&download=README.docx here].<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81903CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:51:10Z<p>Pkadam: /* Steps to install and use Gem */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone.[http://rubygems.org/gems/automated_metareview Automated Metareview Gem] <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
To use the Experiza system Go to [http://152.7.99.90:5801/ Expertiza with Gem installed]<br/><br />
For detailed description about the steps to follow to test the automated metareview functionality Click [http://expertiza.ncsu.edu/submitted_content/download/25990?current_folder%5Bname%5D=%2Flocal%2Frails%2Fexpertiza%2Freleases%2F20131018020418%2Fpg_data%2Fefg%2Fcsc517%2Ff13%2Foss%2F3&download=README.docx here].<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81863CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:42:48Z<p>Pkadam: /* Steps to create Gem */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone.[http://rubygems.org/gems/automated_metareview Automated Metareview Gem] <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81856CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:41:52Z<p>Pkadam: /* Design */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone.[http://rubygems.org/gems/automated_metareview Automated Metareview Gem] <ref>[http://rubygems.org/gems/automated_metareview Automated Metareview Gem structure]</ref> <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81852CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:40:12Z<p>Pkadam: /* Steps to create Gem */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone. Automated Metareview Gem<ref>[http://rubygems.org/gems/automated_metareview Automated Metareview Gem structure]</ref> <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81843CSC/ECE 517 Fall 2013/oss E812 amp2013-10-31T01:38:05Z<p>Pkadam: /* Steps to create Gem */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed and issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
The existing Expertiza system has an automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory has 18 files which provides features such as spell checker, plagiarism check and the review tone analysis.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We have converted automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system and include all those features in the Gem.Thus we can use the gem to include its functionality like review analysis etc.<br />
<br />
==Motivation==<br />
The Automated metareview functionality is not used in the existing Expertiza system. If this feature is converted into a gem, then it can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
===Steps to create Gem===<br />
<br />
We have turned the automated_metareview folder into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': Code from the automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''automated_metareview.rb''' : This file is loaded when require’automated_metareview’ is run. This file is in charge of setting up your gem’s code and API.<br />
<br />
'''automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' <br/><br />
You can build a gem from gemspec using the following command:<br />
gem build automated_metareview.gemspec<br />
Install the generated gem locally to test it out.<br />
gem install automated_metareview-0.0.2<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br/><br />
In order to make this gem available to everyone, we need to push the gem using : <br/><br />
gem push automated_metareview-0.0.2.gem <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone. This can be viewed in <br />
<br />
<ref>[http://rubygems.org/gems/automated_metareview http://rubygems.org/gems/automated_metareview Automated Metareview Gem structure]</ref> <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br/><br />
gem list -r automated_metareview<br />
<br />
[[File:List.jpg]]<br />
<br />
===Steps to install and use Gem===<br />
<br />
In order to use the gem please follow the below steps:<br/><br />
1. Run the following command to install the gem<br />
gem install automated_metareview-0.0.2<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
In order to use automated_metareview feature of testing whether a phrase /word is suggestive or not, we can use SentenceState methods to test it :<br />
<br />
<br />
[[File:Use.jpg]]<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix==<br />
===Setup Issues===<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/><br />
1.[http://guides.rubygems.org/make-your-own-gem/ Make your own gem]<br><br />
2.[http://repository.lib.ncsu.edu/ir/handle/1840.16/8813 Automated Assessment of Reviews - Lakshmi Ramachandran ]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=81168CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T19:22:56Z<p>Pkadam: </p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Motivation==<br />
The features of Automated metareview were integrated in the existing Expertiza system. If these features were converted into a gem, then these can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
We have turned the automated_metareview feature into a gem called “automated_metareview” which could be used in other review systems.<br />
Here is the basic structure of our gem: <br />
<br />
[[File:Structure.jpg|alt=Structure]]<br />
<br />
<br />
'''Lib''': code of automated_metareview package is placed in this folder. It contains all the 18 files.<br />
<br />
'''Automated_metareview.rb''' : This file gets loaded when require’automated_metareview’ is run. That one file is in charge of setting up your gem’s code and API.<br />
<br />
'''Automated_metareview.gemspec''' : This file gives details of the gem, author, version and other details.<br />
<br />
<br />
'''Build and Install Gem:''' You can build a gem from gemspec. Then you can install the generated gem locally to test it out.<br />
<br />
[[File:Build.jpg]]<br />
<br />
<br />
'''Push gem''' <br />
<br />
[[File:Push.jpg]]<br />
<br />
This gem is now available for installation by anyone. This can be viewed in [http://rubygems.org/gems/automated_metareview http://rubygems.org/gems/automated_metareview] <br />
<br />
OR<br />
<br />
You can check in the list of available gems:<br />
<br />
[[File:List.jpg]]<br />
<br />
<br />
In order to use the gem please follow the following steps:<br />
1. <br />
gem install automated_metareview-0.0.2<br />
<br />
OR<br />
Add following line in gemfile<br />
gem ‘automated_metareview-0.0.2’<br />
Run following command: <br />
bundle install.<br />
2. Add following line in the code where you want to use the gem:<br />
require ‘automated_metareview-0.0.2’<br />
<br />
Example:<br />
<br />
[[File:Use.jpg]]<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix: Setup Issues==<br />
1. There were a lot of problems with the master branch of expertiza.<br><br />
2. There were many missing routes.<br><br />
3. We faced a number of problems installing Aspell dictionary on windows.<br><br />
4. There are a number of steps which need to be followed to activate the metareview feature.<br><br />
5. The automated meta review feature is partly implemented using java due to which there are a number of dependencies. To overcome these dependencies we need to install multiple jar files such as joda-time.jar,stanford-segmenter.jar etc.<br><br />
6. No concrete documentation about the working of the meta review functionality is available due to which a lot of time was required to get the feature running.<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80880CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T17:44:27Z<p>Pkadam: /* Future Work */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Motivation==<br />
The features of Automated metareview were integrated in the existing Expertiza system. If these features were converted into a gem, then these can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
==Future Work==<br />
The current implementation has a few method calls very specific to Expertiza. We can change these methods so that they can be used in any other system. We generalized a few methods, so that it can be used in systems similar to Expertiza. But we can generalize it more such that we can seperate functionalities like Spell checker , plagiarism check in separate gem file.<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80831CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T17:13:31Z<p>Pkadam: </p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Motivation==<br />
The features of Automated metareview were integrated in the existing Expertiza system. If these features were converted into a gem, then these can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Design==<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80830CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T17:11:52Z<p>Pkadam: /* Motivation */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
The features of Automated metareview were integrated in the existing Expertiza system. If these features were converted into a gem, then these can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80829CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T17:11:14Z<p>Pkadam: /* Motivation */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
The features of Automated metareview were intgerated in the existing Expertiza system. If these features were converted into a gem, then these can be used in other review systems, wherein the reviewer will get an automated feedback about the review and he/she can change the review based on the results of automated metreview results. Thus by creating a gem file, other systems can install the gem and get access to all features of automated metareview, thereby increasing reusability.<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80798CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:50:25Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing Expertiza system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80797CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:48:54Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing system had automated_metareview.rb class which was using the text processing functionality from automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
Our goal was to remove the automated_metareview directory from existing Expertiza system. Include all those features in the Gem, and then import the functionality from the Gem file.<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80785CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:43:35Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
Existing system had automated_metareview.rb class which was using the text processing functionality from the in the automated_metareview directory. "automated_metareview" directory had 18 files which included features like spell checker, plagiarism check and the review tone.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80774CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:38:08Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
We had the following code already implemented.<br/><br />
Class: automated_metareview.rb (188 lines) and 18 files in the automated_metareview directory.<br/><br />
'''What it does''': Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
'''What needs to be done''': We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80773CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:37:38Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
We had the following code already implemented.<br/><br />
Class: automated_metareview.rb (188 lines) and 18 files in the automated_metareview directory.<br/><br />
What it does: Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
What needs to be done: We had to convert automated_metareview directory into a gem so that it can be used with other review systems.<br/><br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80770CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:36:54Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
We had the following code already implemented.<br/><br />
Class: automated_metareview.rb (188 lines) and 18 files in the automated_metareview directory.<br/><br />
What it does: Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br/><br />
What needs to be done: We had to convert automated_metareview directory into a gem so that it can be used with other system.<br/><br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80769CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:36:10Z<p>Pkadam: /* Project Description */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
We had the following code already implemented.<br />
Class: automated_metareview.rb (188 lines) and 18 files in the automated_metareview directory.<br />
What it does: Gives automatic feedback to a reviewer, using NLP text analysis, to help the reviewer improve the review.<br />
What needs to be done: We had to convert automated_metareview directory into a gem so that it can be used with other system.<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80762CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:24:06Z<p>Pkadam: /* Intrdouction */</p>
<hr />
<div>==Intrdouction==<br />
This article is a report about our Open Source project(Expertiza) - Turn automated_metareview folder into a gem . It explains the design considerations, steps followed, issues faced while setting up Expertiza. It explains how our team manages to create a new Gem file, and test it on the existing Expertiza system.<br />
<br />
==Project Description==<br />
<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/oss_E812_amp&diff=80761CSC/ECE 517 Fall 2013/oss E812 amp2013-10-30T16:18:36Z<p>Pkadam: Created page with "==Intrdouction== ==Project Description== ==Design== ==Motivation== ==Future Work== ==Appendix: setup issues=="</p>
<hr />
<div>==Intrdouction==<br />
<br />
<br />
==Project Description==<br />
<br />
<br />
==Design==<br />
<br />
<br />
==Motivation==<br />
<br />
<br />
==Future Work==<br />
<br />
<br />
==Appendix: setup issues==</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013&diff=80757CSC/ECE 517 Fall 20132013-10-30T16:07:44Z<p>Pkadam: </p>
<hr />
<div>* [[ CSC/ECE 517 Fall 2012/ch1 1w23 ph ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w30 nn]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w21 w]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w01 aj]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w24 nv]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w29 rkld]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w25 aras]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w30 ps]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w19 rj]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w18 bs]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w17 pk]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w22 ss]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w12 vn]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w14 st]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w08 cc]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w10 ga ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w26 as ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w27 ma ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w13 aa ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w11 sv ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w07 d ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w20 gq ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w03 ss ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w28 nm ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w02 pp ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w6 zs ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w04 y ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w05 st ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w09 hs ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w32 av ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w48 x ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w43 av]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w46 ka]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w33 aa]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w35 sa ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w39 as ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w31 vm ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w43 sm ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w44 s ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w47 ka ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w34 fs ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch1 1w40 ao ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss fmv ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss vna ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss paa ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss mapFeeds ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss ssp ]]<br />
* [[ CSC/ECE 517 Fall 2013/ch2 0e808 nsv ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss aoa ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss cmh ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss ans ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss ssv]]<br />
* [[ CSC/ECE 517 Fall 2013/oss E818 mra ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss SocialMediaFeeds ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss E811 syn ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss E804 spb ]]<br />
* [[ CSC/ECE 517 Fall 2013/oss E812 amp ]]</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78713CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:57:07Z<p>Pkadam: /* Benchmarking */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref name='w'>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Benchmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Benchmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Benchmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional test cases in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce unexpected results. [http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78712CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:56:38Z<p>Pkadam: /* Benchmark.measure method */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref name='w'>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Benchmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional test cases in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce unexpected results. [http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78711CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:55:49Z<p>Pkadam: /* Introduction to Profiling */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref name='w'>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional test cases in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce unexpected results. [http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78709CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:55:00Z<p>Pkadam: /* Conclusion */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional test cases in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce unexpected results. [http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78708CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:52:49Z<p>Pkadam: /* Conclusion */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results. [http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78707CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:52:36Z<p>Pkadam: /* Conclusion */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78705CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:50:03Z<p>Pkadam: /* References */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78704CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:49:27Z<p>Pkadam: /* References */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references><br />
<ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]</ref><br />
</references></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78701CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:48:35Z<p>Pkadam: /* References */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/><br />
<ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]</ref></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78700CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:48:23Z<p>Pkadam: /* References */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/><br />
<ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimization Tutorial]<ref></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78696CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:40:35Z<p>Pkadam: /* Ruby-prof Profiler */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref name='in'>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78695CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:37:39Z<p>Pkadam: /* Benchmarking */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm <ref name='be'>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78693CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:32:16Z<p>Pkadam: /* Ruby-prof Profiler */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <ref>[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]</ref> <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance. For more examples on benchmarking refer <ref>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref><br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78691CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:28:53Z<p>Pkadam: /* Optimizing Ruby Code */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance. For more examples on benchmarking refer <ref>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref><br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
'''Ruby Inline''' <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section6.html Ruby Inline]</ref> allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78683CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:23:41Z<p>Pkadam: /* Benchmark.bmbm method */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance. For more examples on benchmarking refer <ref>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhmark examples]</ref><br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78681CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:23:07Z<p>Pkadam: /* Benchmark.bmbm method */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance. For more examples on benchmarking refer<ref>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhamrk examples]</ref><br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78680CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:22:38Z<p>Pkadam: /* Benchmark.bmbm method */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance. For more examples on benchmarking refer<ref>[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhamrk examples]</rel><br />
<br />
==Optimizing Ruby Code==<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78675CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:20:02Z<p>Pkadam: /* Default Profiler Profiling and optimizing Ruby code */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code using profile.rb(default profiler)]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78673CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:19:16Z<p>Pkadam: /* Ruby Profiling tools */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code]</ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78670CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:18:45Z<p>Pkadam: /* Default Profiler */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler <ref>[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code]<ref>===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78664CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:15:54Z<p>Pkadam: /* Benchmarking */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<ref>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</ref> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage collector. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78658CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:12:32Z<p>Pkadam: /* Benchmarking */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking<rel>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</rel> can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm<rel>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</rel> method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm<rel>[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]</rel> This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage allocator. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78652CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:03:50Z<p>Pkadam: /* Introduction to Profiling */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm. This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage allocator. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78651CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:03:22Z<p>Pkadam: /* References */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>https://www.ruby-lang.org/en/about</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm. This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage allocator. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
<references/></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78650CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T15:02:07Z<p>Pkadam: /* Introduction to Profiling */</p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <ref>https://www.ruby-lang.org/en/about</ref><br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm. This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage allocator. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]<br><br />
[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]<br><br />
[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhamrk examples]<br><br />
[http://pic.dhe.ibm.com/infocenter/aix/v7r1/index.jsp?topic=%2Fcom.ibm.aix.prftools%2Fdoc%2Fprftools%2Feventbasedprofiling.htm Event-based profiling]<br><br />
[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code]<br><br />
[http://www.synbioz.com/blog/optimize_ruby_code Introduction to Ruby code optimization]<br><br />
[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]<br><br />
[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimaization Tutorial]<br></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=File:NewProfiling.jpg&diff=78631File:NewProfiling.jpg2013-09-24T14:33:05Z<p>Pkadam: </p>
<hr />
<div></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2013/ch1_1w02_pp&diff=78630CSC/ECE 517 Fall 2013/ch1 1w02 pp2013-09-24T14:31:27Z<p>Pkadam: </p>
<hr />
<div>==Introduction to Profiling==<br />
<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profiling] in general, is an important feature in computer science. It is a technique, in the most basic terms, by which one can analyze the efficiency of the program or code by measuring the program’s time complexity or space complexity and some other performance related parameters. For example, total running time, CPU time, memory used, time taken by each module or function, function calls, response time and many similar important aspects of our program/application.<br />
Profiling takes into consideration significant steps or program constructs (like loop statements, individual blocks and modules, statements involving operations and functions like aggregate functions) for performance study. <br />
<br />
'''Ruby profiling''' is analysis of Ruby programs. We make use of profiles that are programs, which takes ruby code as input and on execution gives values for a set of parameters that define the performance of the input ruby program. There are many types of profiling methods like event-based and statistical methods. Ruby mostly uses event-based profilers. Here in case of Ruby profiler, we get the analysis results in various formats like table, graphs etc.<br />
<br />
[[Image:NewProfiling.jpg|frame|center|Ruby Profiling Tools]]<br />
<br />
As we can see in the flow diagram, we give the ruby program as input to the Ruby profiling tools and we get a profiler output, which helps us in optimizing out code.<br />
<br />
==Significance of Profiling==<br />
The main purpose of profiling is:<br />
* To analyze the performance of the code, their CPU utilization, memory operations.<br />
<br />
* Based on the results presented by the profiler, one can improve upon the code with better constructs and functions and hence we can easily optimize the code in accord with the system requirements. <br />
<br />
* We can accurately measure how a program functions or performs in one given environment and with different input data.<br />
<br />
* To identify the bottlenecks in a program, the portions that cause program overhead or can slow down the system or need special testing or can raise exception.<br />
<br />
==Ruby Profiling tools==<br />
There are many Profiling tools available for analyzing the ruby programs. Ruby itself has inbuilt profilers in the form of modules. Two such modules are Default profiler and Benchmark module. Also, there is ruby-prof profiler which is a gem file developed to profile ruby code. Below is a description of how one can use these tools to profile ruby codes.<br />
<br />
===Default Profiler===<br />
This is an inbuilt module that can be run by using the command –r profile which in turn imports the profile.rb source file. The profile.rb source file has the program that measures the performance of the system by recording the function calls. Here, the input is a collection of all the function calls made in the code. Specifically, profile.rb uses the method ‘kernel#set_trace_func’ to keep a track of all function calls.<br />
<br />
How to use profile.rb to profile our code:<br><br />
1) Create a ruby file profiler_example.rb<br />
#profile_example.rb code begins<br />
require 'profile'<br />
def slow_method<br />
10000.times do 9999999999999999*999999999<br />
end<br />
end<br />
slow_method<br />
#profile_example.rb code ends<br />
Here, we have declared a function slow_method to simply perform multiplication of two values 10000 times using "times" iterator.<br />
<br />
2. Run the default profiler on profiler_example.rb using command<br />
ruby-rprofile profiler_example.rb<br />
<br />
3. Output of profiler<br />
% cumulative self self total<br />
time seconds seconds calls ms/call ms/call name<br />
65.96 0.06 0.06 1 62.00 94.00 Integer#times<br />
34.04 0.09 0.03 10000 0.00 0.00 Bignum#*<br />
0.00 0.09 0.00 1 0.00 0.00 Array#each<br />
0.00 0.09 0.00 1 0.00 94.00 Object#slow_method<br />
0.00 0.09 0.00 1 0.00 94.00 #toplevel<br><br />
'''Note:''' This output is truncated to show basic functions in ruby. When we run this code, we see a lot of other functions.<br />
<br />
Basically, this is considered as an inefficient profiling tool as this increases the execution time of program considerably and the situation worsens if the code size is huge. So we can use this to profile small pieces of code. <br />
<br />
But on the other hand, it’s a handy tool as it comes with the ruby library and with the –r command line, it becomes even more convenient, so this tool can certainly be used with the small length codes. Also, this profiler provides great uniformity to the code. We can be sure of the accuracy of the result as while it measures the execution time of each function call and method, it slows down everything to the same level.<br />
<br />
Now the output of analysis is displayed in the form of table. Each row represents one method of the program. And the rows are in the sorted order of one of the parameters. It does take into account the time a method takes to run and computes the total as time taken by operation multiplied by number of times operations(or methods) is executed.<br />
<br />
===Ruby-prof Profiler===<br />
[http://ruby-prof.rubyforge.org/ '''ruby-prof'''] is a fast code profiler for Ruby. It is a C extension and therefore is many times faster than the standard Ruby profiler. It supports both flat and graph profiles. For each method, graph profiles show how long the method ran, which methods called it and which all methods were called by it. RubyProf generates both text and html and can output it to a file.<br />
<br />
'''To demonstrate use of ruby-prof profiler we will use flat profile, Steps to be followed :'''<br><br><br />
'''1.''' Install ruby-prof gem <br />
gem install ruby-prof<br />
'''2.''' Create a ruby code file to profile<br />
<br />
#Start of ruby code file to profile<br />
require 'ruby-prof'<br />
RubyProf.start<br />
#code to profile start<br />
def slow_method<br />
for num in 1..10_000 do<br />
is_prime = 1<br />
for x in 2..(num - 1) do<br />
if (num % x == 0)<br />
is_prime = x<br />
break<br />
end<br />
end<br />
if is_prime == 1<br />
puts "#{num} is a prime number"<br />
else<br />
puts "#{num} equals #{is_prime} * #{num/is_prime}"<br />
end<br />
end<br />
end<br />
slow_method<br />
#code to profile end<br />
result = RubyProf.stop<br />
printer = RubyProf::FlatPrinter.new(result)<br />
printer.print(STDOUT)<br />
#End of ruby code file to profile<br />
<br />
'''3.''' Output of ruby-prof profiler<br />
<br />
Thread ID: 17223036<br />
Fiber ID: 20361900<br />
Total: 1.873907<br />
Sort by: self_time<br />
<br />
%self total self wait child calls name<br />
2.70 0.051 0.051 0.000 0.000 20000 IO#write<br />
1.59 1.874 0.030 0.000 1.844 10001 *Range#each<br />
0.47 0.009 0.009 0.000 0.000 27540 Fixnum#to_s<br />
0.39 0.058 0.007 0.000 0.051 10000 IO#puts<br />
0.21 0.004 0.004 0.000 0.000 10000 <Class::Range>#allocate<br />
0.20 0.062 0.004 0.000 0.058 10000 Kernel#puts<br />
0.00 1.874 0.000 0.000 1.874 1 Global#[No method]<br />
0.00 1.874 0.000 0.000 1.874 1 Object#slow_method<br />
0.00 0.000 0.000 0.000 0.000 1 Module#method_added<br />
<br />
The above code displays all the functions that were called and their execution time sorted in descending order of time taken by them. So, we find the method that consumes a lot of time at the top.<br />
<br />
===Benchmarking===<br />
<br />
Benchmarking can be taken as a profiling tool as it provides measurement results after executing the program in question. Based on the analysis results, one can optimize the code accordingly. All we need to do to use this module is to include benchmark, the step goes as, “require ‘benchmark’. The output from benchmark analysis consists of four main parameters shown from left to right- <br />
<br />
User system total real<br />
<br />
User CPU Time - Time taken to process user code instructions.<br> <br />
System CPU time - Time taken to execute kernel code instructions.<br> <br />
Total - User + system CPU time.<br> Total Real time - Time from the start of code execution to the end of code execution measured by clock time.<br> <br />
<br />
In order to measure a part of the code, we can use many methods given in Benchmark. Below are the methods that are used to benchmark code.<br />
<br />
'''Illustrating these methods with an example'''<br />
<br />
===='''Benchmark.measure method'''====<br />
Benchmark.measure is used to measure a part of the code, we can use many methods given in Benchmark. Here only one line at a time can be benchmarked.<br />
<br />
#Code<br />
require 'benchmark'<br />
puts Benchmark.measure { 602214.times { 3.14159 * 6.626068 } }<br />
<br />
#Output<br />
0.062000 0.000000 0.062000 ( 0.056038)<br />
<br />
====Benchmark.bm method'''====<br />
Benchmark.bm method is used to benchmark multiple lines of code. We call the method benchmark bm that takes block as input. The block variable is a special object that has report method, which in turn gives the execution time of the block executed.<br />
<br />
#Code<br />
Benchmark.bm do |x|<br />
x.report("for:") { for i in 1..n; a = "1"; end }<br />
x.report("times:") { n.times do ; a = "1"; end }<br />
x.report("upto:") { 1.upto(n) do ; a = "1"; end }<br />
end<br />
<br />
#Output<br />
user system total real<br />
for: 3.167000 0.000000 3.167000 ( 3.312189)<br />
times: 3.198000 0.000000 3.198000 ( 3.242186)<br />
upto: 3.884000 0.000000 3.884000 ( 3.934225)<br />
<br />
===='''Benchmark.bmbm method'''====<br />
Benchmark.bmbm. This method is similar to benchmark bm but it benchmarks or analyses the code twice. The objects in the initial phase are busy with memory allocation or interacting with garbage allocator. So, in the first run, it initializes all variables and forces garbage collector to run and in second run, it measures the code efficiency. The 1st phase is called rehearsal. So with this method, Ruby first comfortably settles down with allocation task and then measures CPU time and other important parameters.<br />
<br />
#Code<br />
array = (1..1000000).map { rand }<br />
Benchmark.bmbm do |x|<br />
x.report("sort!") { array.dup.sort! }<br />
x.report("sort") { array.dup.sort }<br />
end<br />
<br />
#Output<br />
Rehearsal -----------------------------------------<br />
sort! 6.069000 0.015000 6.084000 ( 6.382365)<br />
sort 4.617000 0.000000 4.617000 ( 4.724270)<br />
------------------------------- total: 10.701000sec<br />
user system total real<br />
sort! 3.323000 0.000000 3.323000 ( 3.590205)<br />
sort 3.135000 0.000000 3.135000 ( 3.267187)<br />
<br />
Benchmarking can be used in places where we have several algorithms for a single problem and we want to test the algorithm in different environment. In this case, each code can be formulated and tested using benchmark. Finally, we get comparisons with respect to real running time. We just need to include benchmarking script that compares various approaches for performance.<br />
<br />
==Optimizing Ruby Code<br />
Now we have seen how to analyze a code using ruby profiling tools. Now we will see the techniques we can use to optimize our code. Using benchmarking we can compare different algorithms and then use the most efficient algorithm. As we saw in the example of benchmarking, we compared for, upto and times and based on the results of comparison, we narrowed down on the method which has the least execution time. We can also use Ruby-Inline which reduces the execution time of program by a huge factor.<br />
<br />
Ruby Inline allows you to write C/Java within your ruby code. It automatically determines if the code in question has changed or not and builds it only when necessary. When we run profilers, we get the time taken by methods/algorithms to execute. Based on it, we can rewrite the methods in C. When we again run the profiler to test the performance, we get surprising results because the execution time reduces. <br />
* Example - how our code will look <br />
<br />
class MyTest<br />
def factorial(n)<br />
f = 1<br />
n.downto(2) { |x| f *= x }<br />
f<br />
end<br />
inline :C do |builder|<br />
builder.c "<br />
long factorial_c(int max) {<br />
int i=max, result=1;<br />
while (i >= 2) { result *= i--; }<br />
return result;<br />
}"<br />
end <br />
end<br />
<br />
To install RubyInline go to [http://danlynn.org/home/2012/1/15/ruby-optimized-using-inline-c-and-java.html Install Ruby-Inline].<br><br />
Also you can go through the [http://www.who-t.net/tips/doku.php?id=ruby_inline_tutorial Ruby-Inline Tutorial].<br />
<br />
==Conclusion==<br />
For large scale applications, where there are thousands of users and transactions, try using Ruby optimizing techniques to optimize the ruby code and improve the performance. Optimization is a special form of refactoring. As such, it is important that you have a good set of unit and functional tests in place before you start optimizing your code. You might want your code to be faster, but you certainly don't want it to produce different results.<br />
<br />
==Realted Topics==<br />
[http://newrelic.com/ Profiling Ruby on Rails using New Relic]<br><br />
[https://www.ruby-toolbox.com/resources/780 Ruby on Rails profiling tools]<br />
<br />
==References==<br />
[http://en.wikipedia.org/wiki/Profiling_(computer_programming) Profling]<br><br />
[http://rubylearning.com/blog/2013/06/19/how-do-i-benchmark-ruby-code/ Benchmark Ruby Code]<br><br />
[http://www.ruby-doc.org/stdlib-2.0/libdoc/benchmark/rdoc/Benchmark.html Becnhamrk examples]<br><br />
[http://pic.dhe.ibm.com/infocenter/aix/v7r1/index.jsp?topic=%2Fcom.ibm.aix.prftools%2Fdoc%2Fprftools%2Feventbasedprofiling.htm Event-based profiling]<br><br />
[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/section3.html Profiling and optimizing Ruby code]<br><br />
[http://www.synbioz.com/blog/optimize_ruby_code Introduction to Ruby code optimization]<br><br />
[http://wiki.vpslink.com/HOWTO:_installing,_updating_and_removing_rubygems#Updating HOWTO: INSTALLING, UPDATING AND REMOVING RUBYGEMS]<br><br />
[http://www.ibm.com/developerworks/opensource/tutorials/os-ruby2/ Ruby code optimaization Tutorial]<br></div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=File:RubyProfiling.jpg&diff=78629File:RubyProfiling.jpg2013-09-24T14:26:50Z<p>Pkadam: uploaded a new version of &quot;File:RubyProfiling.jpg&quot;: Reverted to version as of 14:23, 24 September 2013</p>
<hr />
<div>Process of profiling ruby code</div>Pkadamhttps://wiki.expertiza.ncsu.edu/index.php?title=File:RubyProfiling.jpg&diff=78628File:RubyProfiling.jpg2013-09-24T14:26:45Z<p>Pkadam: uploaded a new version of &quot;File:RubyProfiling.jpg&quot;: Reverted to version as of 14:23, 24 September 2013</p>
<hr />
<div>Process of profiling ruby code</div>Pkadam