You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by "Jiutao Nie (JIRA)" <ji...@apache.org> on 2010/05/21 13:48:15 UTC
[jira] Created: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
-------------------------------------------------------------------------------------------------------------------
Key: HARMONY-6517
URL: https://issues.apache.org/jira/browse/HARMONY-6517
Project: Harmony
Issue Type: New Feature
Components: DRLVM
Environment: OS: Linux or Windows
Hardware: X86 or X86_64 with SSE4.2
Reporter: Jiutao Nie
The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
1) IR extension for vector types and operators (middle-end);
2) vector instruction (SSE) description and code generation (back-end);
3) optimization pass of automatic vectorization for loops (middle-end);
4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
**** Hardware requirement ****
X86 or X86_64 with SSE4.2 instruction set
**** Usage of automatic vectorization ****
The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
**** Usage of JVI ****
Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
**** Performance improvement ****
The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
**** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
Automatic vectorization testing with SPECjvm2008:
* Argument: -Xem:server_static_autovect
* On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
* On 32-bit linux machine: All workloads except derby have passed.
* All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
* Argument: -Xem:server_autovect
* On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
* All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
JVI-based vectorization testing with jvi_basic.java:
* Argument: -Xem:server_static
* On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Attachment: javavect.patch
jvi.patch
jvi_basic.java
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Hudson (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876177#action_12876177 ]
Hudson commented on HARMONY-6517:
---------------------------------
Integrated in Harmony-select-1.5-head-linux-x86_64 #16 (See [http://hudson.zones.apache.org/hudson/job/Harmony-select-1.5-head-linux-x86_64/16/])
Reverting commit r952017 of the javavect.patch from "[#HARMONY-6517] New
optimization and interface for either automatically or manually
vectorizing Java programs with SSE instructions".
Will apply again once I've clarified the authorship of:
drlvm/vm/jitrino/src/shared/SIMD.*
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876525#action_12876525 ]
Jiutao Nie commented on HARMONY-6517:
-------------------------------------
The author information in vm/jitrino/src/shared/SIMD.h is irrelevant
to this contribution. The comments may be copied from other file
together with the copyright header incautiously. The other author
Buqi Cheng appearing in vm/jitrino/src/shared/SIMD.cpp did some early
work for this contribution (including an early version of JVI though
it has been changed a lot, and most instruction patterns of SSE
instructions). For simplicity, he has granted me the ownership of all
those material before the submission of this work.
I've removed the inappropriate author information form the two files
and updated the patch file. Do you think I still need to complete a
bulk contribution checklist? If so, which kind of written agreement
in Part III c) should Buqi and I sign? The CC recipient is Buqi Cheng
registered on the ASF JIRA website.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12870007#action_12870007 ]
Mark Hindess commented on HARMONY-6517:
---------------------------------------
Thanks for this contribution. Could you (and any other contributors) please complete ICLAs and ACQs as mentioned at:
http://harmony.apache.org/contribution_policy.html
Sign them, scan them and email them to private@harmony.apache.org.
Thanks,
Mark.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12871211#action_12871211 ]
Mark Hindess commented on HARMONY-6517:
---------------------------------------
Documents received. Thanks.
Now I just need to find a machine that has SSE4.2.
FYI: I think:
+ if (num_to_be_vectorized)
+ {
+ ir_manager.getMethodDesc().printFullName (std::cout);
+ std::cout << ": " << num_to_be_vectorized
+ << " loops to be vectorized"
+ << std::endl;
+ }
needs:
if (Log::isEnabled ()) {
...
}
around it.
I also notice that some of the changes don't seem to be specific to your improvements. For future reference, it would be better to receive those as separate jira/patches.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Attachment: (was: javavect.patch)
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Attachment: (was: javavect.patch)
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12871489#action_12871489 ]
Jiutao Nie commented on HARMONY-6517:
-------------------------------------
Yes, this will be better. I've updated the javavect.patch. Now the
code becomes:
+ if (Log::isEnabled () && num_to_be_vectorized)
+ {
+ ir_manager.getMethodDesc().printFullName (Log::out ());
+ Log::out() << ": " << num_to_be_vectorized
+ << " loop(s) to be vectorized"
+ << std::endl;
+ }
Yes, this patch also includes several bug fixes relating to encoding
longer instructions, which are found during the vectorization work,
but not specific to it. I'll keep your advice in mind in future.
2010/5/25 Mark Hindess (JIRA) <ji...@apache.org>:
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Assigned: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Mark Hindess reassigned HARMONY-6517:
-------------------------------------
Assignee: Mark Hindess
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Priority: Minor (was: Major)
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876096#action_12876096 ]
Mark Hindess commented on HARMONY-6517:
---------------------------------------
I've applied the javavect.patch at r952017. I'll apply the other two patches when I figure out how best to integrate them.
Thanks,
Mark.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Attachment: javavect.patch
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Hudson (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876097#action_12876097 ]
Hudson commented on HARMONY-6517:
---------------------------------
Integrated in Harmony-1.5-head-linux-x86_64 #823 (See [http://hudson.zones.apache.org/hudson/job/Harmony-1.5-head-linux-x86_64/823/])
Applying the most recent javavect.patch from "[#HARMONY-6517] New
optimization and interface for either automatically or manually
vectorizing Java programs with SSE instructions".
I'll apply the other patches when I can figure out how best to integrate
them.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12870523#action_12870523 ]
Mark Hindess commented on HARMONY-6517:
---------------------------------------
Thanks. I'm on that list but I've not seen the mail yet. Probably they are waiting to be moderated through to the list. I'll chase this up today (and get myself added as moderator for the future).
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Jiutao Nie updated HARMONY-6517:
--------------------------------
Attachment: javavect.patch
Removed inappropriate author information from SIMD.h and SIMD.cpp.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Hudson (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876104#action_12876104 ]
Hudson commented on HARMONY-6517:
---------------------------------
Integrated in Harmony-select-1.5-head-linux-x86_64 #15 (See [http://hudson.zones.apache.org/hudson/job/Harmony-select-1.5-head-linux-x86_64/15/])
Applying the most recent javavect.patch from "[#HARMONY-6517] New
optimization and interface for either automatically or manually
vectorizing Java programs with SSE instructions".
I'll apply the other patches when I can figure out how best to integrate
them.
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12870533#action_12870533 ]
Jiutao Nie commented on HARMONY-6517:
-------------------------------------
I've just sent the documents to the list again. Can you receive it?
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Jiutao Nie (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12870502#action_12870502 ]
Jiutao Nie commented on HARMONY-6517:
-------------------------------------
I have submitted the signed and scanned ICLA and ACQ to private@harmony.apache.org on last Friday. The subject of the email was "ICLA and ACQ", and it mentioned this JIRA entry in its body. I am responsible for this whole contribution, so it doesn't require any other people's legal documents further.
Thanks,
Jiutao
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Mark Hindess (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876152#action_12876152 ]
Mark Hindess commented on HARMONY-6517:
---------------------------------------
I've reverted the commit (at r952128) because I'd like clarification of the authorship of the contribution. Earlier you stated:
I am responsible for this whole contribution
but these two files:
vm/jitrino/src/shared/SIMD.h
vm/jitrino/src/shared/SIMD.cpp
have Author comments that appear to contradict this statement. Both of the authors have previously contributed to Harmony so we have ACQs on file from them so I am not greatly concerned but I think it makes sense to clarify this.
>From my perspective, the simplest way to clarify this would be to treat this as a bulk contribution and for you to complete the appropriate checklist:
http://harmony.apache.org/bulk_contribution_checklist.html
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HARMONY-6517) New optimization and interface for
either automatically or manually vectorizing Java programs with SSE
instructions
Posted by "Hudson (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HARMONY-6517?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12876180#action_12876180 ]
Hudson commented on HARMONY-6517:
---------------------------------
Integrated in Harmony-1.5-head-linux-x86_64 #824 (See [http://hudson.zones.apache.org/hudson/job/Harmony-1.5-head-linux-x86_64/824/])
Reverting commit r952017 of the javavect.patch from "[#HARMONY-6517] New
optimization and interface for either automatically or manually
vectorizing Java programs with SSE instructions".
Will apply again once I've clarified the authorship of:
drlvm/vm/jitrino/src/shared/SIMD.*
> New optimization and interface for either automatically or manually vectorizing Java programs with SSE instructions
> -------------------------------------------------------------------------------------------------------------------
>
> Key: HARMONY-6517
> URL: https://issues.apache.org/jira/browse/HARMONY-6517
> Project: Harmony
> Issue Type: New Feature
> Components: DRLVM
> Environment: OS: Linux or Windows
> Hardware: X86 or X86_64 with SSE4.2
> Reporter: Jiutao Nie
> Assignee: Mark Hindess
> Priority: Minor
> Attachments: javavect.patch, jvi.patch, jvi_basic.java
>
>
> The patch file "javavect.patch" for DRLVM provides new features for vectorizing Java programs either automatically or manually. The work consists of four parts:
> 1) IR extension for vector types and operators (middle-end);
> 2) vector instruction (SSE) description and code generation (back-end);
> 3) optimization pass of automatic vectorization for loops (middle-end);
> 4) Java vector interface (JVI, see below) translator for manually writing vectorized Java programs with JVI (front-end).
> Parts 1) and 2) provides the basic facility for internally representing vectorized code and generating SSE instructions. Based on that, part 3) provides an automatic approach and part 4) provides a manual approach for vectorizing Java programs.
> The patch file "jvi.patch" for vmmagic provides a Java class library for programmers to write vectorized Java program explicitly. It contains 6 classes representing the types of vectors of 8-, 16-, 32- and 64-bit integers, and 32- and 64-bit floating point numbers. Each class contains appropriate methods representing supported vector operators on that type. The JVI class references and method callings in a Java program are translated into appropriate internal vector IR by the extended front-end, i.e. the work of part 4).
> The Java source file "jvi_basic.java" provides a simple test suite for JVI, covering all implemented JVI operations. It can also be used as examples of the usage of JVI.
> **** Hardware requirement ****
> X86 or X86_64 with SSE4.2 instruction set
> **** Usage of automatic vectorization ****
> The patch file contains two new configuration files: server_autovect.emconf and server_static_autovect.emconf, which are copied from server.emconf and servre_static.emconf, and inserted "autovect" optimization pass into their optimization paths. To try automatic vectorization, only need to add one of the following arguments: "-Xem:server_autovect" or "-Xem:server_static_autovect" to run the VM.
> **** Usage of JVI ****
> Write programs with JVI (see jvi_basic.java), compile them and run them with the argument "-Xem:server_static" (This is must because the JVI code cannot be executed without being translated into the vector IR by Jitrino's optimizing compiler).
> **** Performance improvement ****
> The performance of two computation intensive workloads (LU and FFT) is improved by 30% to 100%.
> **** Testing of the patch based on the Harmony revision 935818 (2010-04-20) ****
> Automatic vectorization testing with SPECjvm2008:
> * Argument: -Xem:server_static_autovect
> * On 64-bit linux machine: All workloads except crypto.aes, derby and xml.transform have passed.
> * On 32-bit linux machine: All workloads except derby have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server_static), meaning that the failures are caused by bugs of the original code base.
> * Argument: -Xem:server_autovect
> * On both 64-bit and 32-bit linux machines: All workloads except xml.transform and serial have passed.
> * All the above failed workloads also fail when autovect is disabled (-Xem:server), meaning that the failures are caused by bugs of the original code base.
> JVI-based vectorization testing with jvi_basic.java:
> * Argument: -Xem:server_static
> * On both 64-bit and 32-bit linux machines: all test cases have passed.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.