Perl vs Java - Revision history

Admin: /* Profiling Java */

2017-03-20T00:14:16Z

Profiling Java

@@ Line 430: / Line 430: @@
 ==Profiling Java==
-To profile the Java code, I used the Java Interactive Profiler (JIP). (See [[Java/Profiling]] for details.) This generates a profile.txt file, which gives a summary of how many times each method was called at each recursive level, plus a summary of the most expensive methods. This helps identify where most of the time was spent.
+To profile the Java code, I used two tools: the Java Interactive Profiler (JIP), and the HPROF tool provided by Oracle. (See [[Java/Profiling]] for details.)
 <pre>
-$ java -javaagent:/Volumes/noospace/Users/charles/Downloads/jip-src-1.2/profile/profile.jar NQueens
+$ java -javaagent:${HOME}/Downloads/jip-src-1.2/profile/profile.jar NQueens
 objc[39911]: Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_102.jdk/Contents/Home/bin/java and /Library/Java/JavaVirtualMachines/jdk1.8.0_102.jdk/Contents/Home/jre/lib/libinstrument.dylib. One of the two will be used. Which one is undefined.
@@ Line 628: / Line 634: @@
 If we add up each of these numbers, except for the depth of 11, or if we just look at the number times the legalRows() method is called, or subtract 2,680 from the number of times the explore() method was called, we get 164,246 - precisely the same number of times Perl calls the for loop to loop over each column.
 ==Interpreting Profiler Output==

Admin: /* Interpreting Profiler Output */

2017-03-20T00:00:31Z

Interpreting Profiler Output

← Older revision		Revision as of 00:00, 20 March 2017
Line 631:		Line 631:
	==Interpreting Profiler Output==		==Interpreting Profiler Output==

	The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.		The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently. Beyond that, it's hard to do intercomparisons, due to the very different output of the profilers.

			The Perl profiler seems like a better tool for a deep, line-by-line comparison, making it possible to drill into specific statements that are bottlenecks, while Java is better for more sprawling call stacks - figuring out what happened at a HIGH level, identify class or method level bottlenecks.

Admin: /* Perl vs. Java */

2017-03-19T23:56:01Z

Perl vs. Java

← Older revision		Revision as of 23:56, 19 March 2017
Line 33:		Line 33:
	{{Quote\|I've really come around to what Perl folks were telling me 8 or 9 years ago: 'Dude, not everything is an object.'}}		{{Quote\|I've really come around to what Perl folks were telling me 8 or 9 years ago: 'Dude, not everything is an object.'}}

	The last tool I wrote in Perl was a web scraper called the [Swartz Mechanizer](https://github.com/charlesreid1/swartz-mechanizer).		The last tool I wrote in Perl was a web scraper called the Swartz Mechanizer [https://github.com/charlesreid1/swartz-mechanizer].
	It was an unpleasant and ugly script running to 800 lines; it's main purpose was to navigate a page, click buttons, and download PDF files.		It was an unpleasant and ugly script running to 800 lines; it's main purpose was to navigate a page, click buttons, and download PDF files.
	It worked, and it was entirely action-based, consisting of functions doing actions and passing small parcels of information around.		It worked, and it was entirely action-based, consisting of functions doing actions and passing small parcels of information around.

Admin: /* Background */

2017-03-19T23:55:45Z

Background

← Older revision		Revision as of 23:55, 19 March 2017
Line 13:		Line 13:
	=Background=		=Background=

	Recently I read an [(11 year old) article http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html]		Recently I read an (11 year old) article [http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html]
	by Steve Yegge entitled "Execution in the Kingdom of Nouns." In it, Steve describes the way that in Java,		by Steve Yegge entitled "Execution in the Kingdom of Nouns." In it, Steve describes the way that in Java,

Admin at 22:40, 19 March 2017

2017-03-19T22:40:26Z

← Older revision		Revision as of 22:40, 19 March 2017
Line 1:		Line 1:
	=Summary=		=Summary=

			The outcome, of implementing a solution to the [[N Queens Problem]] using the same recursive depth-first search algorithm in Perl and Java, and measuring the wall time for various values of N:

			[[Image:Perl_vs_Java.png\|700px]]

			Both codes implemented a solution utilizing integer arrays.

			Perl version: https://gist.github.com/charlesreid1/4ce97a5f896ff1c89855a5d038d51535

			Java version: https://gist.github.com/charlesreid1/7b8d7b9dffb7b3090039849d72c5fff5

	=Background=		=Background=

Admin: /* Profiling Perl */

2017-03-19T21:51:21Z

Profiling Perl

← Older revision		Revision as of 21:51, 19 March 2017
Line 379:		Line 379:

	This is a bit cryptic - there are far more calls than there should be. 105 calls to the top level explore method??		This is a bit cryptic - there are far more calls than there should be. 105 calls to the top level explore method??

			===Callgrind (Valgrind tool) format===

			You can also look at the call graph using callgrind, a tool bundled with [[Valgrind]]. (Valgrind is a memory and execution analysis tool.) Call the <code>nytprofcg</code> tool:

			<pre>
			/usr/local/Cellar/perl/5.24.0_1/bin/nytprofcg nytprof.out
			</pre>

			This will result in a file called <code>nytprof.callgrind</code>, which can be analyzed with Valgrind. Now fire up the <code>callgrind_annotate</code> function to print out information contained in the call graph.

			For callgrind annotate options, see the Valgrind manual: http://valgrind.org/docs/manual/cl-manual.html

			<pre>
			$ callgrind_annotate --inclusive=yes nytprof.callgrind
			--------------------------------------------------------------------------------
			Profile data file 'nytprof.callgrind'
			--------------------------------------------------------------------------------
			Profiled target: (unknown)
			Events recorded: Ticks
			Events shown: Ticks
			Event sort order: Ticks
			Thresholds: 99
			Include dirs:
			User annotated:
			Auto-annotation: off

			--------------------------------------------------------------------------------
			Ticks
			--------------------------------------------------------------------------------
			12,396,614 PROGRAM TOTALS (calculated)

			--------------------------------------------------------------------------------
			Ticks file:function
			--------------------------------------------------------------------------------
			4,132,205 nqueens.pl:main::RUNTIME
			4,132,156 /Volumes/noospace/Users/charles/codes/hello-world/perl/nqueens.pl:main::explore
			4,132,155 nqueens.pl:main::explore
			49 /Volumes/noospace/Users/charles/codes/hello-world/perl/nqueens.pl:main::CORE:print
			</pre>

	==Profiling Java==		==Profiling Java==

Admin: /* Profiling Perl */

2017-03-19T21:35:57Z

Profiling Perl

@@ Line 324: / Line 324: @@
 </pre>
-This generates a <code>nytprof.out</code> file that contains a database of profiling information. This information can be extracted to various formats, but here's how to extract it to a CSV file:
+This generates a <code>nytprof.out</code> file that contains a database of profiling information. This information can be extracted to various formats.
 <pre>
@@ Line 352: / Line 356: @@
 One number here in particular is important - the number of times we call the for loop over columns. This gives us a TOTAL count of the number of solutions that were tried by the program. This number, for Perl, is 164,246. We will see that Java explores the exact same number of solutions, so the difference in computational cost between these languages is not coming from a difference in algorithms.
 ==Profiling Java==

Admin: /* Interpreting Differences in Profiling */

2017-03-19T21:28:42Z

Interpreting Differences in Profiling

← Older revision		Revision as of 21:28, 19 March 2017
Line 554:		Line 554:
	If we add up each of these numbers, except for the depth of 11, or if we just look at the number times the legalRows() method is called, or subtract 2,680 from the number of times the explore() method was called, we get 164,246 - precisely the same number of times Perl calls the for loop to loop over each column.		If we add up each of these numbers, except for the depth of 11, or if we just look at the number times the legalRows() method is called, or subtract 2,680 from the number of times the explore() method was called, we get 164,246 - precisely the same number of times Perl calls the for loop to loop over each column.

	==Interpreting ~~Differences in Profiling~~==		==Interpreting Profiler Output==

	The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.		The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.

Admin at 21:20, 19 March 2017

2017-03-19T21:20:41Z

← Older revision		Revision as of 21:20, 19 March 2017
Line 557:		Line 557:

	The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.		The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.


			[[Category:Perl]]
			[[Category:Java]]
			[[Category:Profiling]]
			[[Category:Programming]]
			[[Category:N Queens]]

Admin: /* Profiling Java */

2017-03-19T21:16:06Z

Profiling Java

← Older revision		Revision as of 21:16, 19 March 2017
Line 552:		Line 552:
	* At a depth of 1, the explore() method was called 11 times.		* At a depth of 1, the explore() method was called 11 times.

	If we add up each of these numbers, except for the depth of 11, we get 164,~~245~~ - precisely ~~one shy of~~ the number of times Perl calls the for loop to loop over each column~~, which is called 164,246 times~~.		If we add up each of these numbers, except for the depth of 11, or if we just look at the number times the legalRows() method is called, or subtract 2,680 from the number of times the explore() method was called, we get 164,246 - precisely the same number of times Perl calls the for loop to loop over each column.

	==Interpreting Differences in Profiling==		==Interpreting Differences in Profiling==

	The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.		The fact that both codes are evaluating the same total number of solutions, 164,245 (plus/minus 1), is a reassurance that timing differences between Java and Perl are "real," and not an artifact of different algorithms that explore solutions differently.