View source for DMelt:Programming/1 Introduction

{{sidebar box|[[DMelt:Start|Table of contents]]}}

= Using Jython/Python =


* [http://www.jython.org/jythonbook/en/1.0/  The Definitive Guide to JYTHON]
* [https://datamelt.org/book/|Scientific data analysis using Jython and Java]
* [http://wiki.python.org/jython/UserGuide Jython user guide]
* [https://datamelt.org/jython_manuals/j-jython1-ltr.pdf Jython tutorial. Part. 1 by  developerWorks]
* [https://datamelt.org/jython_manuals/j-jython2-ltr.pdf Jython tutorial. Part. 2 by  developerWorks]
* [http://docs.python.org/tutorial/  PYTHON tutorial]
  
= Benchmarking Jython =
 
Here you can find some benchmark results for Jython and BeanShell scripting.

As explained in Section [[DMelt:General/2_Running_DMelt|Running DMelt]], one can execute macros/source files  using the "run" button: DataMelt recognizes file formats on the fly.  Read also online resources in Sect.[[DMelt:Programming/3_Jython|Running Jython]]. 

Here is an example which benchmarks several arrays implemented in the native Java (ArrayList), Python (list) and DataMelt <javadoc>jhplot.P0D</javadoc>  array.
The script below checks the CPU time needed to fill these arrays with Gaussian-distributed random numbers:

<jcode lang="python">
from java.util import *
from jhplot import *
import time

a=P0D("high-performance")
b=ArrayList()
c=[]
r=Random()

Ntot=3000000 # number of events for testing

start = time.clock()
for i in range(Ntot):
      x=r.nextGaussian()
      a.add(x)
print ' CPU time for P0D (s) in Jython Loop=',time.clock()-start

start = time.clock()
a.randomNormal(Ntot, 0, 1)
print ' CPU time for P0D (s) native method =',time.clock()-start

start = time.clock()
for i in range(Ntot):
      x=r.nextGaussian()
      c.append(x)
print ' CPU time for Jython list (s)=',time.clock()-start

start = time.clock()
for i in range(Ntot):
      x=r.nextGaussian()
      b.add(x)
print ' CPU time for Java ArrayList (s)=',time.clock()-start

</jcode>

A typical result (using G2030, Dell Insperon 660s) of this benchmark is shown below:

<jcode lang="python">
 CPU time for P0D (s) in Jython Loop= 2.792909833
 CPU time for P0D (s) native method = 0.390237158
 CPU time for Jython list (s)= 2.443057156
 CPU time for Java ArrayList (s)= 3.608499232
</jcode>

As you can see, the performance of P0D when using its native method is a factor 10 better.


<jnote>To speed up your applications, use the native methods of the DataMelt classes when possible</jnote>

= Benchmarking BeanShell =
 
You  can also use the BeanShell as an alternative scripting language. Generally, BeanShell is slower the Jython in loops,
but if you call the native methods of high-performance classes (as for P0D in the example above), then the execution speed will be very similar:

<jcode lang="bash">   
import java.util.*;
import jhplot.*;
import time.*;

a=new P0D("high-performance");
b=new ArrayList();
r=new Random();

Ntot=3000000; ''  number of events for testing

start= System.currentTimeMillis();
for (i=0; i<Ntot; i++){
      x=r.nextGaussian();
      a.add(x);
      };

print("CPU time for P0D (s) in Jython Loop=");
print(0.001*(System.currentTimeMillis()-start));

start= System.currentTimeMillis();
a.randomNormal(Ntot, 0, 1);
print("CPU time for P0D (s) native  Loop=");
print(0.001*(System.currentTimeMillis()-start));

start= System.currentTimeMillis();
for (i=0; i<Ntot; i++){
      x=r.nextGaussian();
      b.add(x);
      };

print("CPU time for Java ArrayList Loop=");
print(0.001*(System.currentTimeMillis()-start));
</jcode>

Running the above code in the DataMelt gives:

<jcode lang="python">
bsh % 
CPU time for P0D (s) in Jython Loop= 7.118
CPU time for P0D (s) native  Loop=0.377
CPU time for Java ArrayList Loop=7.131
</jcode>

<jnote>BeanShell is a factor two  slower then Jython in loops, but the performance is very similar to Jython when  calling the native Java-implemented methods</jnote>

= Benchmarking Groovy  =

You  can also use Groovy as an alternative scripting language. 

<jcode lang="groovy">  
import jhplot.P0D 

a=new P0D("high-performance")
r=new java.util.Random()
 
Ntot=3000000 
start=System.currentTimeMillis();
for (i=0; i<Ntot; i++){
      x=r.nextGaussian()
      a.add(x)
}
end_time=System.currentTimeMillis();
println  (end_time-start)/1000
</jcode>

The output printed in JRubyShell is
<jcode lang="python">
   0.8 
</jcode>
(0.8 seconds with a spread of  0.1)

= Benchmarking JRuby  =
You  can also use JRuby as an alternative scripting language.

<jcode lang="ruby">
include_class Java::jhplot.P0D

a=P0D.new("high-performance")
r=java.util.Random.new()

Ntot=3000000 # number of events for testing
start=Time.now
for i in 1..Ntot
      x=r.nextGaussian()
      a.add(x)
end

end_time= Time.now
puts "Time elapsed #{(end_time - start)} seconds"
</jcode>

The output printed  is
<jcode lang="python">
  Time elapsed 0.8 seconds
</jcode>

<jnote>Loops implemented in Groovy and JRuby are faster than in Jython by 20 percent, and much  faster than in BeanShell</jnote>


 --- ''[[dmelt@jwork.org|Sergei Chekanov]] 2011/07/02 19:52''