What happens if you change the benchmark to use the array class and DO OVER?
________________________________________
From: IBM Mainframe Discussion List <IBM-MAIN@LISTSERV.UA.EDU> on behalf of
Rony G. Flatscher <rony.flatsc...@wu.ac.at>
Sent: Tuesday, February 28, 2023 9:38 AM
To: IBM-MAIN@LISTSERV.UA.EDU
Subject: Badmouthing Rexx and ooRexx - again (Re: zOSMF and zOWE for
non-mainframers
On 28.02.2023 13:44, David Crayford wrote:
> ooRexx has two main issues: its a superset of REXX, which is a subpar
> programming language, and it
> consumes a lot of CPU resources. Each language clause in ooRexx is a C++
> object that invokes
> dynamic dispatch whenever it's executed. Unlike most other sensible
> programming languages, which
> compile to bytecode and use a virtual machine, ooRexx does not. When I
> benchmarked OoRexx against
> Lua, I was surprised to find that it was almost 100 times slower. I used
> valgrind to profile
> ooRexx's performance and discovered that most of the time was spent
> allocating and marking objects
> for garbage collection. These objects were language metadata used by the
> interpreter. ooRexx is an
> example of how not to implement a language interpreter in C++.
A lot of badmouthing and red herrings here (again), comparing apples with
oranges (again). Totally
ignoring what has been discussed and concluded a year ago, so no reliability on
you.
Last year there was a discussion with the subject that over time got
superceeded with mailings of
different focuses:
- "Top 8 Reasons for using Python instead of REXX for z/OS", which then ended
in the subject:
- "Speedy, speedier, speedest (Re: Ad message paradigm (Re: Ad NetRexx (Re: Ad
programming features
(Re: ... Re: Top 8 Reasons for using Python instead of REXX for z/OS"
In that thread I demonstrated a little ooRexx program that did beat your
impertinent "test program"
that you implemented in C++, Lua and Python last year (still wondering why you
did not implement
that simple benchmark in Assembler and show those figures). After learning
about that ooRexx program
that actually performed faster than C++ (Lua and Python of course as well) you
preferred to stop
that thread of discussion about a year ago. Now you are back, maybe speculating
everyone forgot
about it?
The purpose of your "test program" was quite obviously to make Rexx and ooRexx
look as bad as
possible. The same intent as your current message in your posting like: "ooRexx
is an example of how
not to implement a language interpreter in C+." (which is nonsense).
Your artificial "test/benchmark program" that let C++, Lua, Python shine at
first and make
Rexx/ooRexx look quite bad was designed exactly for that purpose: let strictly
typed and compiled
languages be way ahead of dynamically typed and interpreted languages, so:
- create an array of size of ten million (sic!) of (primitive) type long
- fill the array in a loop and assign each index the result of taking the index
value (an int being
cast to long) to the square
- go through that array and get the largest stored long value and display it
BTW, who has a real need for such programs in her/his daily life here? (In this
community who would
really come up with the idea of implementing such a task in Rexx/ooRexx and not
in Assembler if a
real need existed?)
So this everyday (not!) "benchmark" is designed to make dynamically typed and
interpreted languages
look as bad as possible compared to strictly typed, compiled languages! It
would be like comparing
number crunching Rexx/ooRexx programs with the same programs implemented in
Assembler and concluding
Assembler is much better in general and forego Rexx/ooRexx (and ignoring the
many other use cases in
which Rexx/ooRexx is much better than Assembler can possibly be; any language
has its strengths and
its weaknesses, of course, including C++, Lua, Python, ...)!
It is an artificial test program. Still, it is possible to beat strictly typed,
compiled languages
with dynamically typed, interpreted languages like ooRexx as demonstrated last
year in this mailing
list! You just need to use your brain and the infrastructure that is available
to you.
The technique has been rather simple: like it is the case with external
function packages for
Rexx/ooRexx (to e.g. interact with system services, RDBMS etc.) look for a
package/environment that
is strictly typed and compiled and which one can take advantage of. In this
particular show case I
picked Java/NetRexx (NetRexx compiles to Java byte code, so one can write with
the Rexx syntax
genuinely Java programs; NetRexx is rather easy to learn for Rexx-savvy
programmers) as an external
package.
BTW, in the meantime I added the respective ooRexx examples to the ooRexx-Java
bridge named
"BSF4ooRexx850" (makes all Java class libraries directly available to ooRexx
and camouflages Java as
ooRexx, i.e. making Java objects understand ooRexx messages, in general
allowing for ignoring strict
casing and much more) to demonstrate how to exploit Java/NetRexx for this kind
of use case from ooRexx.
Here the ooRexx program exploiting Java
("samples/4-601_compileAndRunEmbeddedJava1.rxj") for
carrying out that stupid task, the Java code is given in the resource directive
(allows for placing
and retrieving any text in an ooRexx program) named "squares.java":
--- cut ---
signal on syntax /* in case a condition gets raised */
/* A compiled Java program has a static main method that expects an
array of type String (representing supplied command line arguments). */
say "ooRexx: use embedded Java program: fetch, compile & run it ..."
d1=.dateTime~new /* for timings */
clzSquares=bsf.compile("squares", .resources~squares.java, "Java")
d2=.dateTime~new /* for timings */
clzSquares~main(.nil) /* run the Java program */
d3=.dateTime~new /* for timings */
say "compiling Java program:" d2-d1 /* show duration */
say "running Java program :" d3-d2 /* show duration */
exit
syntax: /* in case of an error */
co=condition('object') /* get all condition information */
say ppJavaExceptionChain(co) /* show Java exception chain */
say "---> this program needs ooRexx 5.0 or later"
raise propagate /* let ooRexx interpreter handle it */
::RESOURCE squares.java /* Java source code */
/* Java: squares.java */
import java.util.Arrays;
public class squares
{
public static void main (String args[])
{
int items = 10000000;
long [] s = new long [items];
for (int i=1; i<=items; i++)
{
long n=i;
s[i-1] = n * n;
}
System.out.println(Arrays.stream(s).max().getAsLong());
}
}
::END
::requires BSF.CLS /* get full bidirectional Java support */
--- cut ---
Here that ooRexx program exploiting NetRexx
("samples/4-600_compileAndRunEmbeddedNetRexx1.rxj") for
carrying out that stupid task which allows one to compare the Java code with
the equivalent NetRexx
code which is much simpler than the Java code; the NetRexx code is given in the
resource directive
(allows for placing and retrieving any text in an ooRexx program) named
"squares.nrx":
--- cut ---
signal on syntax /* in case a condition gets raised */
/* A compiled NetRexx program has a static main method that expects an
array of type String (representing supplied command line arguments). */
say "ooRexx: use embedded NetRexx program: fetch, compile & run it ..."
d1=.dateTime~new /* for timings */
clzSquares=bsf.compile("squares", .resources~squares.nrx, "NetRexx")
d2=.dateTime~new /* for timings */
clzSquares~main(.nil) /* run the NetRexx program */
d3=.dateTime~new /* for timings */
say "compiling NetRexx program:" d2-d1 /* show duration */
say "running NetRexx program :" d3-d2 /* show duration */
exit
syntax: /* in case of an error */
co=condition('object') /* get all condition information */
say ppJavaExceptionChain(co) /* show Java exception chain */
say "---> this program needs NetRexx and ooRexx 5.0 or later"
raise propagate /* let ooRexx interpreter handle it */
::RESOURCE squares.nrx /* NetRexx source code */
/* NetRexx: squares.nrx */
options binary /* in this case we want speed */
items = 10000000
s = long[items] /* define a Java array of type long */
loop i=1 to items
n=long i /* for multiplication we want to use long */
s[i-1] = n * n
end
/* use java.util.Arrays' stream() (introduced with Java 8) */
say Arrays.stream(s).max.getAsLong
::END
::requires BSF.CLS /* get full bidirectional Java support */
--- cut ---
These ooRexx samples demonstrate in general how one can create any logic in
Java/NetRexx (having the
source code in the ooRexx program), compile it and then use it right away from
the very same ooRexx
program. Also, this solution allows for letting C++, Lua and Python bite even
more dust if not only
going after the max values of that abmysal artificial array of longs, but in
addition to calculate
the average, count, min and sum (cf. the samples BSF4ooRexx850 samples in
"samples/4-610_compileAndUseEmbeddedNetRexx2.rxj",
"samples/4-611_compileAndUseEmbeddedJava2.rxj")! :)
One quite nice thing about ooRexx and BSF4ooRexx850 is: no matter whether you
write the programs on
your Windows, your macOS or your Linux PC, you can take those programs and run
them on any of the
other operating systems including Linux on IBM Z for which ooRexx 5 [1] and
BSF4ooRexx850 [2] ports
exist!
--
Usually one would use specilaized libraries and function packages for any
features for which
specialized knowledge has been developed and used for implementations over many
years, e.g. like
interfacing with RDBMS, data analysis packages etc. There are plentiful and
powerful Java packages
out there which you can immediately take advantage of with ooRexx, and easily
so!
As ooRexx is CMake based it can be easily compiled by yourself for your
platform (and of course to
Linux on IBM Z) at any time.
---
Last year we also discussed about the great features the message based nature
(after SmallTalk [3])
of ooRexx offers to programmers, e.g. making it very easy (saving a lot of
time!) for the programmer
to interact with e.g. OLE or Java or DBus and the like.
C++, Lua and Python by contrast totally lack such an important feature, that
Alan Kay on Wikipedia
[4] characterizes as follows:
I'm sorry that I long ago coined the term "objects" for this topic because
it gets many people
to focus on the lesser idea. The big idea is "messaging
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FMessage_passing&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=fvvFF%2BuRr4Pk3FCvZJjBIb2VGTNlQq7fSEmy9iyvZd0%3D&reserved=0>".
This "bigger idea" is something that you seem to not have understood and have
been ignoring.
By contrast ooRexx implements that bigger idea (being itself implemetned in
C++) opening up new
opportunities to Rexx programmers.
---
ooRexx is Rexx and adds object-orientation and the message paradigm to the
language. Everyone here
with Rexx skills can immediately take advantage of ooRexx.
BSF4ooRexx850 bridges ooRexx with Java, effectively camouflaging Java objects
as ooRexx objects (!),
making it a breeze to interact with Java. (BTW, BSF4ooRexx850 also allows for
implementing abstract
Java classes in ooRexx classes, believe it or not! This feature allows for
dealing with Java
callbacks in Rexx code, which is much simpler.)
---rony
[1] ooRexx 5.0:
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fsourceforge.net%2Fprojects%2Foorexx%2Ffiles%2Foorexx%2F5.0.0%2F&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=vZcXIK2bgk2MKZIqtcapCnKH85aas167limfWNJkq0k%3D&reserved=0>
[2] BSF4ooRexx850:
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fsourceforge.net%2Fprojects%2Fbsf4oorexx%2Ffiles%2Fbeta%2F20221004%2F&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=n3G4ei9bXl9scvFJTul6cn2Wpo6kOO2DhfoIdbNYAQ4%3D&reserved=0>
included in
the installation package "BSF4ooRexx_install_v850-20230109-beta.zip"
(Dubbed a beta, however quality has been of release; this version takes
advantage of ooRexx 5.0
features, e.g. allowing to dynamically add Rexx command handlers that are
implemented in Java! It
comes with a showcase, a Rexx command handler named JDOR - "Java2D for ooRexx".
Here the JDOR Rexx
commands with a simple example at the beginning:
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwi.wu.ac.at%2Frgf%2Frexx%2Fmisc%2Fjdor_doc.tmp%2Fjdor_doc.html&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=hKB8pFw1w%2FVXzrI74ucLprJ70FcjVIeKQ6WdlGYdlqk%3D&reserved=0>)
[3] SmallTalk:
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FSmalltalk&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=2ZWUupm87bZlSWwsZ4Oc3Sq1APmiuCHDYQg4IIauddQ%3D&reserved=0>
[4] Alan Kay:
<https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FAlan_Kay&data=05%7C01%7Csmetz3%40gmu.edu%7C5a24ad61d54f4c7bee0708db199994f8%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C638131919648698898%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&sdata=0HhEgS5kbIViAB1fbV6iABoaNMsxk89OVehLg8p0ZE4%3D&reserved=0>
> On 28/2/23 20:28, Seymour J Metz wrote:
>> What about Java? How well does JIT work?
>>
>> The gold standard for REXX is ooRexx, but IBM has not seen fit to integrate
>> it into z/OS or z/VM.
>>
>> However, for off the shelf package libraries, Perl and Python are admittedly
>> ahead of REXX. What
>> are the Python and Ruby equivalents of CPAN?
>>
>> I've found extending REXX for CMS and TSO to be easy, although admittedly
>> assembler is mothers'
>> milk to me and I didn't have to deal with LE issues.
>>
>>
>> --
>> Shmuel (Seymour J.) Metz
>> http://mason.gmu.edu/~smetz3
>>
>> ________________________________________
>> From: IBM Mainframe Discussion List [IBM-MAIN@LISTSERV.UA.EDU] on behalf of
>> David Crayford
>> [dcrayf...@gmail.com]
>> Sent: Tuesday, February 28, 2023 12:47 AM
>> To: IBM-MAIN@LISTSERV.UA.EDU
>> Subject: Re: zOSMF and zOWE for non-mainframers
>>
>> On 25/2/23 01:23, Farley, Peter wrote:
>>> Python on the mainframe is pretty good, but still can't beat out Rexx in
>>> performance even when
>>> the Rex script needs to use BPXWUNIX and friends to access z/OS Unix file
>>> systems,
>>>
>> I have conducted a series of benchtests, and the results suggest that
>> REXX is not as fast as Python. In my testing, I compare the performance
>> of C, Lua, Python, and REXX, and the results are clear: C is the
>> fastest, followed by Lua, which is within an order of magnitude of C.
>> Python comes next, within an order of magnitude of Lua, and REXX
>> consistently performs the poorest. In addition to the performance
>> factor, the vast Python ecosystem compared to the limited options
>> available for REXX also make it an easy decision. Python is also simpler
>> to extend with packages, while REXX requires more effort and potentially
>> complex steps, such as using modern libraries that require Language
>> Environment (LE).
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@listserv.ua.edu with the message: INFO IBM-MAIN
