JikesRVM

Page edited by Erik Brangs - "added the Compressor project suggestion; don't hesitate to improve it it!" As in previous years, Jikes RVM will apply to Google ... [More] Summer of Code for funding for student projects.The GSoC 2013 timeline has been published. The first date of importance is: Organization application deadline on March 29 2013Our current task is to collate a set of interesting project proposals and encourage students to apply for GSoC. We can re-use ideas from previous proposals, or come up with totally new ideas.Hints for studentsThe application for mentoring organizations hasn't been opened yet. However, it's not too early to read the Google Summer of Code documentation. Students should read at least the GSoC FAQ and Google's advice for students. There's also a lot of helpful information about GSoC that's provided by mentoring organizations and previous GSoC students (use your favorite search engine to find it).If the Jikes RVM project sounds like it could be a good fit for you, you can already start to get familiar with Jikes RVM. Checkout the source code and read the user guide. Build the Jikes RVM, run some tests and take a look at the codebase. You should have your development environment already set up before applying. Don't hesitate to ask on the mailing lists if you need help.If/when we've been accepted as a mentoring organization, students can take a look at our guidelines on making an application. We expect that students get familiar with the Jikes RVM and the Jikes RVM community before applying.What's in it for me?All mentors get a smart Google t-shirt. The project gets some new contributors, and the students get substantial amounts of cash and experience in open source development. The Jikes RVM project has seen substantial benefits from GSoC in previous years, including a new native threading model and additions to the core team of developers.Adding new project suggestionsPlease add your ideas to the wiki below, ideally using the template shown below. You can also contribute an idea if you don't have a wiki account: just describe it on on the researchers mailing list. Project TitlefooRVM area{compiler, classlib, MMTk, infrastructure...}outlineparagraph description of project ideareferenceslinks to related projects, academic papers, etcneeded skillsskills that the student should have and/or needs to acquire during the projectdifficultya difficulty estimate for the project, e.g. easy, medium, difficultinterested mentoryour name and a contact link or "TBD" if you can't mentorProject suggestions (aka idea list) Project TitleImplement the Java Management extensions (JMX) APIRVM areaclasslib, MMTk, threading, compileroutlineThe Java Management Extensions provide a way to monitor and manage Java Virtual machines. The Jikes RVM can collect significantly more profiling data and runtime statistics than an average JVM as a result of it being focussed on research activities. These statistics would ideally be exported using JMX and could potentially provide a standard mechanism for monitoring the performance and health of the virtual machine and its components.As a first step, students should focus on laying groundwork for a suitable implementation of the API:Update the JMX code from GSoC 2007 (written by Andrew John Hughes) to work with the current Jikes RVMImplement all the parts of the API that are requiredWrite automated tests that can be integrated into our test frameworksAfter that has happened, students should implement the optional parts of the API and Jikes RVM-specific features. The exact set of features will need to be discussed with the community at the appropriate time.referencesBlog post about JMX with links to further documentationOur bugtracker entry for JMXWeb view of the JMX branch in the historic svn repository (use "svn checkout svn://svn.code.sf.net/p/jikesrvm/svn/rvmroot/branches/RVM-127-JMX" to checkout the code)needed skillsJavadifficultyeasyinterested mentorTBD  Project TitleImplement the JVM Tool Interface (JVMTI)RVM areathreading, JNIoutlineThe JVM Tool interface is part of the Java Platform Debugger Architecture that JVMs can implement to provide debugging capabilities. We would like to have a full JMVTI implementation to allow debugging of Java applications that are running on Jikes RVM. Another benefit of JVMTI is that it allows low-level access to JVM internals. This can be used for instrumenting and monitoring the Jikes RVM using low-level code.There is already a partial JMVTI implementation that was written by James Bornholt for GSoC 2011. His implementation should be used as a basis for this project.referencesWriteup of James Bornholt on the GSoC 2011 pageWeb view of previous GSoC 2011 JVMTI workneeded skillsC, C++, Java, willingness to deal with low-level detailsdifficultymediuminterested mentorTBD  Project TitleImprove (or rethink) CatTrackRVM areainfrastructureoutlineThe Jikes RVM project currently uses the Ruby-on-Rails application CatTrack to track test results. CatTrack is also responsible for sending regression mails.This project would consist of upgrading CatTrack to use a more recent version of Ruby-on-Rails instead of the ancient Ruby-on-Rails 1.2.6. Potential candidates must have experience in Ruby-on-Rails to be able to take on this project: we don't have the necessary expertise to provide adequate mentoring to RoR beginners. The exact version numbers and the upgrade process need to be coordinated with our contacts at the Australian National University (where the servers are located). New features can be added to CatTrack after the upgrade is complete.An alternative approach would be to get rid of CatTrack completely and move to a more general open-source solution. Note that this would be a much more disruptive change. A student proposal that suggests this approach must be very convincing to be considered. Another constraint for proposals of this kind is that we want to avoid using yet another language in our build infrastructure (see RVM-85 ). It might be acceptable to replace Ruby with another language but this must be discussed before such a proposal is submitted.The X10 language project also uses CatTrack for their regression mails. Candidates should be prepared to coordinate with somebody from the X10 team to ensure that an upgraded version of CatTrack (or a replacement) is also a viable solution for them.referencesWeb view of the CatTrack repositoryneeded skillsprior Ruby-on-Rails experience, XML, basic knowledge about databasesdifficultydifficultinterested mentorTBD  Project TitleImprove testing situation for JIkes RVMRVM areainfrastructure, (additional subsystems as chosen by the student)outlineAn infrastructure for unit tests and some initial unit tests were added to the Jikes RVM in GSoC 2012 by João Reys Santos. However, there is still a lot of work to do before we can consider the codebase to be reasonably well tested. We need more unit tests as well as more black-box tests.Students should pick an area of interest (e.g. compilers, JNI, MMTk, classloading, threading, ...) and/or motivating use cases (e.g. get benchmark X or application Y running on Jikes RVM), identify and fix the corresponding problems and introduce adequate (unit) tests.Note that extra effort will be required if students want to use mocking. Mockito does not work with GNU Classpath-based JVMs and our OpenJDK-port is not yet ready.referencesbook: Michael Feathers, Working effectively with legacy code, Pearson Education, 2004book: Andreas Zeller, Why programs fail: A guide to systematic debugging, Morgan Kaufmann, 2009needed skillsJava, Ant, debugging without a debuggerdifficultyeasy to difficult (depends on the chosen tasks and areas)interested mentorTBD  Project TitleBytecode verifierRVM areaclassloading, compilersoutlineJikes RVM currently does not implement a bytecode verifier. We would like to have a bytecode verifier that can verify classfiles at least up until Java 6 (we don't support Java 7 yet). The verifier needs to work with the baseline compiler as well as the optimizing compiler. Ideally, it should be possible to use the verifier from the command line without actually running the bytecode that is supposed to be checked. This could be done in a similar way to the OptTestHarness which enables users to control the compilers.The verifier should be designed to support custom verification constraints. Some examples for possible constraints are listed in the JIRA issue linked below.referencesJIRA issue for the bytecode verifierJasmin assembler (useful for creating test cases that trigger verifier errors)Chapter 4 of the JVM Specificationneeded skillsJava, reading papers and specifications, implementing algorithms from specifications and papersdifficultymediuminterested mentorTBD  Project TitleGCspyRVM areaMMTkoutlineThe GCspy framework for garbage collector visualization has become out-of-date and needs improving [RVM-388]. GCSpy 2.0 should update the framework to work properly with the latest version of Jikes RVM. In particular, it should support discontiguous spaces and provide drivers for more of MMTk's GC algorithms. In addition, the rewrite might improve modularity, and possibly integrate with the Eclipse Rich Client Platform.referencesGCspy: an adaptable heap visualisation frameworkneeded skillsJava, C++, willingness to deal with low-level details, some understanding of garbage collectiondifficultyfairly straightforwardinterested mentorRichard Jones  Project TitleImplement the Compressor garbage collectorRVM areaMMTkoutlineA Stop-The-World variant of the Compressor garbage collector was implemented for Jikes RVM in  GSoC 2010 by Michael Gendelman. The goal of this project is to improve the stability of Michael Gendelman's implementation so that it can be merged to mainline. Performance tuning may also be needed.Students that are interested in this project should be familiar with garbage collection and MMTk.Hint for very ambitious students: You can work on more complex variants of the Compressor (e.g. a concurrent version) once the the Stop-The-World variant has been merged and the project has determined that its quality is suitable.referencespaper: Haim Kermanya and Erez Petrank, The Compressor: concurrent, incremental, and parallel compaction (ACM link)JIRA issue for the compressor (includes a link to the paper)Michael Gendelman's work on the Compressor (includes a design document on the wiki)needed skillsJava, willingness to deal with low-level details, familiarity with garbage collectiondifficultydifficultinterested mentorTBD View Online · View Changes Online [Less]

Page edited by Richard Jones As in previous years, Jikes RVM will apply to Google Summer of Code for funding for student projects.The GSoC 2013 timeline has been ... [More] published. The first date of importance is: Organization application deadline on March 29 2013Our current task is to collate a set of interesting project proposals and encourage students to apply for GSoC. We can re-use ideas from previous proposals, or come up with totally new ideas.Hints for studentsThe application for mentoring organizations hasn't been opened yet. However, it's not too early to read the Google Summer of Code documentation. Students should read at least the GSoC FAQ and Google's advice for students. There's also a lot of helpful information about GSoC that's provided by mentoring organizations and previous GSoC students (use your favorite search engine to find it).If the Jikes RVM project sounds like it could be a good fit for you, you can already start to get familiar with Jikes RVM. Checkout the source code and read the user guide. Build the Jikes RVM, run some tests and take a look at the codebase. You should have your development environment already set up before applying. Don't hesitate to ask on the mailing lists if you need help.If/when we've been accepted as a mentoring organization, students can take a look at our guidelines on making an application. We expect that students get familiar with the Jikes RVM and the Jikes RVM community before applying.What's in it for me?All mentors get a smart Google t-shirt. The project gets some new contributors, and the students get substantial amounts of cash and experience in open source development. The Jikes RVM project has seen substantial benefits from GSoC in previous years, including a new native threading model and additions to the core team of developers.Adding new project suggestionsPlease add your ideas to the wiki below, ideally using the template shown below. You can also contribute an idea if you don't have a wiki account: just describe it on on the researchers mailing list. Project TitlefooRVM area{compiler, classlib, MMTk, infrastructure...}outlineparagraph description of project ideareferenceslinks to related projects, academic papers, etcneeded skillsskills that the student should have and/or needs to acquire during the projectdifficultya difficulty estimate for the project, e.g. easy, medium, difficultinterested mentoryour name and a contact link or "TBD" if you can't mentorProject suggestions (aka idea list) Project TitleImplement the Java Management extensions (JMX) APIRVM areaclasslib, MMTk, threading, compileroutlineThe Java Management Extensions provide a way to monitor and manage Java Virtual machines. The Jikes RVM can collect significantly more profiling data and runtime statistics than an average JVM as a result of it being focussed on research activities. These statistics would ideally be exported using JMX and could potentially provide a standard mechanism for monitoring the performance and health of the virtual machine and its components.As a first step, students should focus on laying groundwork for a suitable implementation of the API:Update the JMX code from GSoC 2007 (written by Andrew John Hughes) to work with the current Jikes RVMImplement all the parts of the API that are requiredWrite automated tests that can be integrated into our test frameworksAfter that has happened, students should implement the optional parts of the API and Jikes RVM-specific features. The exact set of features will need to be discussed with the community at the appropriate time.referencesBlog post about JMX with links to further documentationOur bugtracker entry for JMXWeb view of the JMX branch in the historic svn repository (use "svn checkout svn://svn.code.sf.net/p/jikesrvm/svn/rvmroot/branches/RVM-127-JMX" to checkout the code)needed skillsJavadifficultyeasyinterested mentorTBD  Project TitleImplement the JVM Tool Interface (JVMTI)RVM areathreading, JNIoutlineThe JVM Tool interface is part of the Java Platform Debugger Architecture that JVMs can implement to provide debugging capabilities. We would like to have a full JMVTI implementation to allow debugging of Java applications that are running on Jikes RVM. Another benefit of JVMTI is that it allows low-level access to JVM internals. This can be used for instrumenting and monitoring the Jikes RVM using low-level code.There is already a partial JMVTI implementation that was written by James Bornholt for GSoC 2011. His implementation should be used as a basis for this project.referencesWriteup of James Bornholt on the GSoC 2011 pageWeb view of previous GSoC 2011 JVMTI workneeded skillsC, C++, Java, willingness to deal with low-level detailsdifficultymediuminterested mentorTBD  Project TitleImprove (or rethink) CatTrackRVM areainfrastructureoutlineThe Jikes RVM project currently uses the Ruby-on-Rails application CatTrack to track test results. CatTrack is also responsible for sending regression mails.This project would consist of upgrading CatTrack to use a more recent version of Ruby-on-Rails instead of the ancient Ruby-on-Rails 1.2.6. Potential candidates must have experience in Ruby-on-Rails to be able to take on this project: we don't have the necessary expertise to provide adequate mentoring to RoR beginners. The exact version numbers and the upgrade process need to be coordinated with our contacts at the Australian National University (where the servers are located). New features can be added to CatTrack after the upgrade is complete.An alternative approach would be to get rid of CatTrack completely and move to a more general open-source solution. Note that this would be a much more disruptive change. A student proposal that suggests this approach must be very convincing to be considered. Another constraint for proposals of this kind is that we want to avoid using yet another language in our build infrastructure (see RVM-85 ). It might be acceptable to replace Ruby with another language but this must be discussed before such a proposal is submitted.The X10 language project also uses CatTrack for their regression mails. Candidates should be prepared to coordinate with somebody from the X10 team to ensure that an upgraded version of CatTrack (or a replacement) is also a viable solution for them.referencesWeb view of the CatTrack repositoryneeded skillsprior Ruby-on-Rails experience, XML, basic knowledge about databasesdifficultydifficultinterested mentorTBD  Project TitleImprove testing situation for JIkes RVMRVM areainfrastructure, (additional subsystems as chosen by the student)outlineAn infrastructure for unit tests and some initial unit tests were added to the Jikes RVM in GSoC 2012 by João Reys Santos. However, there is still a lot of work to do before we can consider the codebase to be reasonably well tested. We need more unit tests as well as more black-box tests.Students should pick an area of interest (e.g. compilers, JNI, MMTk, classloading, threading, ...) and/or motivating use cases (e.g. get benchmark X or application Y running on Jikes RVM), identify and fix the corresponding problems and introduce adequate (unit) tests.Note that extra effort will be required if students want to use mocking. Mockito does not work with GNU Classpath-based JVMs and our OpenJDK-port is not yet ready.referencesbook: Michael Feathers, Working effectively with legacy code, Pearson Education, 2004book: Andreas Zeller, Why programs fail: A guide to systematic debugging, Morgan Kaufmann, 2009needed skillsJava, Ant, debugging without a debuggerdifficultyeasy to difficult (depends on the chosen tasks and areas)interested mentorTBD  Project TitleBytecode verifierRVM areaclassloading, compilersoutlineJikes RVM currently does not implement a bytecode verifier. We would like to have a bytecode verifier that can verify classfiles at least up until Java 6 (we don't support Java 7 yet). The verifier needs to work with the baseline compiler as well as the optimizing compiler. Ideally, it should be possible to use the verifier from the command line without actually running the bytecode that is supposed to be checked. This could be done in a similar way to the OptTestHarness which enables users to control the compilers.The verifier should be designed to support custom verification constraints. Some examples for possible constraints are listed in the JIRA issue linked below.referencesJIRA issue for the bytecode verifierJasmin assembler (useful for creating test cases that trigger verifier errors)Chapter 4 of the JVM Specificationneeded skillsJava, reading papers and specifications, implementing algorithms from specifications and papersdifficultymediuminterested mentorTBD  Project TitleGCspyRVM areaMMTkoutlineThe GCspy framework for garbage collector visualization has become out-of-date and needs improving [RVM-388]. GCSpy 2.0 should update the framework to work properly with the latest version of Jikes RVM. In particular, it should support discontiguous spaces and provide drivers for more of MMTk's GC algorithms. In addition, the rewrite might improve modularity, and possibly integrate with the Eclipse Rich Client Platform.referencesGCspy: an adaptable heap visualisation frameworkneeded skillsJava, C++, willingness to deal with low-level details, some understanding of garbage collectiondifficultyfairly straightforwardinterested mentorRichard Jones View Online · View Changes Online [Less]

Page edited by Erik Brangs - "replaced code block with panel (code block don't seem to be rendered correctly on jikesrvm.org), changed "later than" to ">="; changed spelling of Java and ... [More] Jikes RVM" On Ubuntu, apt-get install mercurial ant gcc g++ gcc-multilib g++-multilib Then check your Java version.  If you are using JDK 7, either ensure you are building a Jikes RVM version >= 3.1.3 or switch to JDK 6.Then,  hg clone http://hg.code.sourceforge.net/p/jikesrvm/code jikesrvmcd jikesrvmbin/buildit localhost prototype-opt             # Change this to select appopriate configuration./dist/prototype-opt_$(uname -m)-linux/rvm -version      # Change dir to use selected host and configuration View Online · View Changes Online [Less]

Page edited by Erik Brangs - "removed erroneously added name" Jikes RVM TeamThe Jikes RVM team is responsible for creating or applying the improvements that go ... [More] into the releases of Jikes RVM. The current team is:Steve Blackburn, Australian National University, (Jikes RVM steering committee)Michael Bond, Ohio State UniversityErik BrangsRobin Garner, Australian National UniversityDavid Grove, IBM Research, (Jikes RVM steering committee)Andrew John Hughes, Red HatJ. Eliot B. Moss, University of MassachusettsPast Jikes RVM Team MembersThe following people have greatly contributed to the success of the Jikes RVM project by having served as Jikes RVM team members:Steve AugartPerry Cheng, IBM ResearchJulian Dolby, IBM ResearchPeter Donald, La Trobe UniversityStephen Fink, IBM ResearchDaniel Frampton, Australian National UniversityMatthias Hauswirth, University of Colorado at BoulderMichael Hind, IBM ResearchChris Hoffmann, University of MassachussettsFilip Pizlo, Purdue UniversityFeng Qian, McGill UniversityIan Rogers, University of ManchesterPeter F. Sweeney, IBM ResearchKris Venstermans, University of GhentContributions From Jikes RVM CommunityThe Jikes RVM project sincerely thanks the following people who have made contributions to the system:Eddie AftandilianSteven AugartMichael BaerJames BornholtGreg BorotaErik BrangsShane BrewerBrian D. CarlstromPeter DonaldPhilippe FaesDa FengChapman FlackDaniel FramptonRobin GarnerGeorgios GousiosAndrew GrayJungwoo HaMatthias HauswirthLaurence HellyerMatthew HertzMark HindessChris HoffmannKenneth HosteXianglong HuangRichard JonesGarrett KolpinChristos-Efthymois KotselidisSergiy KyrylkovAlan LawrenceKien LeHan LeeJohn LeunerLukas LoehrerDmitri MakarovAvery MoonJ. Eliot B. MossElias NaurAnders Biehl NorgaardJeff PalmTuan PhanFilip PizloKathiravelu PradeebanJoão Reys SantosAndreas SeweRifat ShahriyarAleksey ShipilevJeremy SingerStephen SmaldoneSunil SomanDarko StefanovicSuryia SubramanianTom VanDrunenIan WarringtonMark WielaardXi YangYuval YaromLingli ZhangJisheng ZhaoLei ZhaoSoftware Used by Jikes RVMJikes RVM uses either the class libraries produced by the GNU Classpath project or Apache Harmony.Thanks to David R. Hanson,Christoper W. Fraser, and Todd Proebsting for making available the iburg tool, which we've enhanced for use in Jikes RVM.Thanks to Codehaus and Sourceforge for providing hosting services.The Jalapeño Research ProjectJikes RVM was independently developed as part of the Jalapeño research project at the IBM T.J. Watson Research Center. The following IBM Research employees, academic visitors, and student co-ops contributed to the early releases of Jikes RVM:Bowen AlpernAnthony CocchiHan LeeJanice ShepherdMatthew ArnoldJulian DolbyDerek LieberManu SridharanDick AttanasioTracy FergusonMark MergenPeter F. SweeneyDavid BaconStephen FinkTon NgoMartin TrappJohn J. BartonEugene GluzbergJeff PalmKris VenstermansSteve BlackburnDavid GroveIgor PechtchanskiJohn WhaleyRastislav BodikMichael HindVivek SarkarMaria ButricoDave HovemeyerMauricio SerranoPerry ChengSusan HummelArvin ShepherdJong-Deok ChoiSergiy KyrylkovStephen Smith View Online · View Changes Online [Less]

Page edited by Erik Brangs - "minor formatting changes: linked "How to help"" The following sections give a rough overview on existing coding ... [More] conventions.Coding StyleCoding Conventions WarningJikes RVM is a bleeding-edge research project. You will find that some of the code does not live up to product quality standards. Don't hesitate to help rectify this by contributing clean-ups, bug fixes, tests and missing documentation to the project. We are in the process of consolidating and simplifying the codebase at the moment. See also:Editing JikesRVM in an IDECompiler DNAAdding a New GC View Online · View Changes Online [Less]

Page edited by Erik Brangs - "update title of notes; try to make it more clear that x64 builds are 32-bit" This guide describes how to build Jikes RVM. The ... [More] first section is an overview of the Jikes RVM build process and this is followed by your system requirements and a detailed description of the steps required to build Jikes RVM.Using builditOnce you have things working, as described below, the buildit  script will provide a fast and easy way to build the system.  We recommend you get things working as described below first, so you can be sure you've met the requisite dependencies etc.OverviewCompiling the source codeThe majority of Jikes RVM is written in Java and will be compiled into class files just as with other Java applications. There is also a small portion of Jikes RVM that is written in C that must be compiled with a C compiler such as gcc.  Jikes RVM uses Ant version 1.7.0 or later as the build tool that orchestrates the build process and executes the steps required in building Jikes RVM.Installation of AntJikes RVM requires a complete install of ant, including the optional tasks. These are present if you download and install ant manually. Some Linux distributions have decided to break ant into multiple packages. So if you are installing on a platform such as Debian you may need to install another package such as 'ant-optional'.Generating source codeThe build process also generates Java and C source code based on build time constants such as the selected instruction architecture, garbage collectors and compilers. The generation of the source code occurs prior to the compilation phase.Bootstrapping the RVMJikes RVM compiles Java class files and produces arrays of code and data. To build itself Jikes RVM will execute on an existing Java Virtual Machine and compiles a copy of it's own class files into a boot image for the code and data using the boot image writer tool. The set of files compiled is called the Primordial Class List. The boot image runner is a small C program that loads the boot image and transfers control flow into Jikes RVM.Class librariesThe Java class library is the mechanism by which Java programs communicate with the outside world. Jikes RVM has configurable class library support, the most mature of which is the the GNU Classpath class library. In the release version of Jikes RVM is support for the Apache Harmony class library.For GNU Classpath, the developer can either specify a particular version of GNU Classpath to use. By default the build process will download and build GNU Classpath.Setting the ant property classlib.provider to Harmony (see how to define ant properties) will change the build process to download and build the Apache Harmony class library.Target RequirementsJikes RVM is known to build and work on certain combinations of instruction architectures and operating systems. The following sections detail the supported architectures and operating systems.Architectures The PowerPC (or ppc) and ia32 instruction set architectures are supported by Jikes RVM.IntelIntel's Instruction Set Architectures (ISAs) get known by different names:IA-32 is the name used to describe processors such as 386, 486 and the Pentium processors. It is popularly called x86 or sometimes in our documentation as x86-32.IA-32e is the name used to describe the extension of the IA-32 architecture to support 8 more registers and a 64-bit address space. It is popularly called x86_64 or AMD64, as AMD chips were the first to support it. It is found in processors such AMD's Opteron and Athlon 64, as well as in Intel's own Pentium 4 processors that have EM64T in their name.IA-64 is the name of Intel's Itanium processor ISA.Jikes RVM currently supports the IA-32 ISA. As IA-32e is backward compatible with IA-32, Jikes RVM can be built and run upon IA-32e processors. The IA-64 architecture supports IA-32 code through a compatibility mode or through emulation and Jikes RVM should run in this configuration.Operating SystemsJikes RVM is capable of running on any operating system that is supported by the GNU Classpath library, low level library support is implemented and memory layout is defined. The low level library support includes interaction with the threading and signal libraries, memory management facilities and dynamic library loading services. The memory layout must also be known, as Jikes RVM will attempt to locate the boot image code and data at specific memory locations. These memory locations must not conflict with where the native compiler places it's code and data. Operating systems that are known to work include AIX, Linux and OSX. At one stage a port to win32 was completed but it was never integrated into the main Jikes RVM codebase.Note: Current implementation of Jikes RVM implies that system native libraries (like GTK+) have been compiled with frame pointers. Most of Linux distribution have frame pointers enabled in most of the packages, but some explicitly use -fomit-frame-pointer thus producing the library that can't be used with JikesRVM. See this issue for example.Support MatrixThe following table details the targets that have historically been supported and the current status of the support. The target.name column is the identifier that Jikes RVM uses to identify this target.target.nameOperating SystemInstruction ArchitectureAddress SizeStatusia32-linuxLinuxia3232 bitsOKia32-osxOSXia3232 bitsOKia32-solarisSolarisia3232 bitsOKia32-cygwinWindowsia3232 bitsWIPppc32-aixAIXPowerPC32 bitsOKppc32-linuxLinuxPowerPC32 bitsOKppc32-osxOSXPowerPC32 bitsOKppc64-aixAIXPowerPC64 bitsOKppc64-linuxLinuxPowerPC64 bitsOKx86_64-linuxLinuxia3232 bitsSee note belowx86_64 configurations are actually 32-bitx86_64 is currently only supported using the legacy 32bit addressing mode and instructions (track progress on full 64bit support here). You need to install the 32-bit versions of the required libraries to build and use the x86_64 configurations.Tool RequirementsJava Virtual MachineJikes RVM requires an existing Java Virtual Machine that conforms to Java 6.0 such as Oracle JDK 1.6, OpenJDK/IcedTea 6 or IBM SDK 6.0. We also aim to support the Java 7.0-conformant versions of these virtual machines.Some Java Virtual Machines are unable to cope with compiling the Java class library so it is recommended that you install one of the above mentioned JVMs if they are not already installed on your system. The remaining build instructions assume that a suitable Java Virtual Machine is on your path. You can run "java -version" to check you are using the correct JVM.AntAnt version 1.7.0 or later is the tool required to orchestrate the build process. You can download and install the Ant tool from http://ant.apache.org/ if it is not already installed on your system. The remaining build instructions assume that $ANT_HOME/bin is on your path. You can run "ant -version" to check you are running the correct version of ant.C and C++ compilersThe Jikes RVM build assumes that the GNU Compiler Collection is present on the system. Most modern *nix environments satisfy this requirement.BisonAs part of the build process, Jikes RVM uses the bison tool which should be present on most modern *nix environments.PerlPerl is trivially used as part of the build process but this requirement may be removed in future releases of Jikes RVM. Perl is also used as part of the regression and performance testing framework.AwkGNU Awk is required as part of the regression and performance testing framework but is not required when building Jikes RVM.Extra tools recommended for Solarispkg-get will greatly simplify installing GNU packages on Solaris. Our patches require that GNU patch is picked up in preference to Sun's, to achieve this, for example, you can create a symbolic link to /usr/bin/gpatch from /opt/csw/bin/patch and make sure /opt/csw/bin is in your path before /usr/bin.InstructionsDefining Ant propertiesThere are a number of ant properties that are used to control the build process of Jikes RVM. These properties may either be specified on the command line by "-Dproperty=variable" or they may be specified in a file named ".ant.properties" in the base directory of the jikesrvm source tree. The ".ant.properties" file is a standard Java property file with each line containing a "property=variable" and comments starting with a # and finishing at the end of the line. The following table describes some properties that are commonly specified.PropertyDescriptionDefaulthost.nameThe name of the host environment used for building Jikes RVM. The host environment defines the paths to the tools used during the build, e.g. the path to the C compiler. The name should match one of the files located in the build/hosts/ directory minus the '.properties' extension.Nonetarget.nameThe name of the target environment for Jikes RVM. The name should match one of the files located in the build/targets/ directory minus the '.properties' extension. This should only be specified when cross compiling the Jikes RVM. See Cross-Platform Building for a detailed description of cross compilation.${host.name}config.nameThe name of the configuration used when building Jikes RVM. The name should match one of the files located in the build/configs/ directory minus the '.properties' extension. This setting is further described in the section Configuring the RVM.Nonepatch.nameAn identifier for the current patch applied to the source tree. See Building Patched Versions for a description of how this fits into the standard usage patterns of Jikes RVM.""components.dirThe directory where Ant looks for external components when building the RVM.${jikesrvm.dir}/componentsdist.dirThe directory where Ant stores the final Jikes RVM runtime.${jikesrvm.dir}/distbuild.dirThe directory where Ant stores the intermediate artifacts generated when building the Jikes RVM.${jikesrvm.dir}/targetprotect.config-filesDefine this property if you do not want the build process to update configuration files when auto downloading components.(Undefined)components.cache.dirThe directory where Ant caches downloaded components.  If you explicitly download a component, place it in this directory.(Undefined, forcing download)require.rvm-unit-testsIf set to true, run unit tests on the built rvm image. Use with care as it will significantly increase build times for configurations that are compiled using a non-optimizing compiler (see below).(Undefined, tests are not run)require.checkstyleOnly useful if you want to contribute changes to the Jikes RVM. If set to true, run checkstyle during the build to check for violations of the Jikes RVM Coding Style. Coding Conventions for assertions must be checked manually.(Undefined, no checks run)At a minimum it is recommended that the user specify the host.name property in the ".ant.properties" file.The configuration files in "build/targets/" and "build/hosts/" are designed to work with a typical install but it may be necessary to overide specific properties. The easiest way to achieve this is to specify the properties to override in the ".ant.properties" file.Selecting a ConfigurationA "configuration" in terms of Jikes RVM is the combination of build time parameters and component selection used for a particular Jikes RVM image. The Configuring the RVM section describes the details of how to define a configuration. Typical configuration names include;production: This configuration defines a fully optimized version of the Jikes RVM.development: This configuration is the same as production but with debug options enabled. The debug options perform internal verification of Jikes RVM which means that it builds and executes more slowly.prototype: This configuration is compiled using an unoptimized compiler and includes minimal components which means it has the fastest build time.prototype-opt: This configuration is compiled using an unoptimized compiler but it includes the adaptive system and optimizing compiler. This configuration has a reasonably fast build time.If a user is working on a particular configuration most of the time they may specify the config.name ant property in ".ant.properties" otherwise it should be passed in on the command line "-Dconfig.name=...".Fetching DependenciesThe Jikes RVM has a build time dependency on the GNU Classpath class library and depending on the configuration may have a dependency on GCSpy. The build system will attempt to download and build these dependencies if they are not present or are the wrong version.To just download and install the GNU Classpath class library you can run the command "ant -f build/components/classpath.xml". After this command has completed running it should have downloaded and built the GNU Classpath class library for the current host. See the Using GCSpy page for directions on building configurations with GCSpy support.If you wish to manually download components (for example you need to define a proxy, so ant is not correctly downloading), you can do so and identify the directory containing the downloads using "-Dcomponents.cache.dir=<download directory>" when you build with ant.Building the RVMThe next step in building Jikes RVM is to run the ant command "ant" or "ant -Dconfig.name=...". This should build a complete RVM runtime in the directory "${dist.dir}/${config.name}_${target.name}". The following table describes some of the ant targets that can be executed. A complete list of documented targets can be listed by executing the command "ant -projecthelp"TargetDescriptioncheck-propertiesCheck that all the required properties are defined.compile-mmtkCompile MMTk toolkit.prepare-sourceGenerate configuration independent source code if required or force.generation property is set.prepare-config-sourceGenerate source code for the current configuration if required or force.generation property is set.main or runtimeBuild a runtime image.cleanRemove the build and image directory for the current configuration.very-cleanAs with clean but also remove Java files generated by scripts.real-cleanAs with very-clean but remove all compiled images.profiled-imageCompile a baseline version of the RVM for profiling then use the profile information to recompile the given config.name image.Running the RVMJikes RVM can be executed in a similar way to most Java Virtual Machines. The difference is that the command is "rvm" and resides in the runtime directory (i.e. "${dist.dir}/${config.name}_${target.name}"). See Running the RVM for a complete list of command line options. View Online · View Changes Online [Less]

Page edited by Erik Brangs - "fixed typos" This guide describes how to build Jikes RVM. The first section is an overview of the Jikes RVM build process and ... [More] this is followed by your system requirements and a detailed description of the steps required to build Jikes RVM.NoteOnce you have things working, as described below, the buildit  script will provide a fast and easy way to build the system.  We recommend you get things working as described below first, so you can be sure you've met the requisite dependencies etc.OverviewCompiling the source codeThe majority of Jikes RVM is written in Java and will be compiled into class files just as with other Java applications. There is also a small portion of Jikes RVM that is written in C that must be compiled with a C compiler such as gcc.  Jikes RVM uses Ant version 1.7.0 or later as the build tool that orchestrates the build process and executes the steps required in building Jikes RVM.NoteJikes RVM requires a complete install of ant, including the optional tasks. These are present if you download and install ant manually. Some Linux distributions have decided to break ant into multiple packages. So if you are installing on a platform such as Debian you may need to install another package such as 'ant-optional'.Generating source codeThe build process also generates Java and C source code based on build time constants such as the selected instruction architecture, garbage collectors and compilers. The generation of the source code occurs prior to the compilation phase.Bootstrapping the RVMJikes RVM compiles Java class files and produces arrays of code and data. To build itself Jikes RVM will execute on an existing Java Virtual Machine and compiles a copy of it's own class files into a boot image for the code and data using the boot image writer tool. The set of files compiled is called the Primordial Class List. The boot image runner is a small C program that loads the boot image and transfers control flow into Jikes RVM.Class librariesThe Java class library is the mechanism by which Java programs communicate with the outside world. Jikes RVM has configurable class library support, the most mature of which is the the GNU Classpath class library. In the release version of Jikes RVM is support for the Apache Harmony class library.For GNU Classpath, the developer can either specify a particular version of GNU Classpath to use. By default the build process will download and build GNU Classpath.Setting the ant property classlib.provider to Harmony (see how to define ant properties) will change the build process to download and build the Apache Harmony class library.Target RequirementsJikes RVM is known to build and work on certain combinations of instruction architectures and operating systems. The following sections detail the supported architectures and operating systems.Architectures The PowerPC (or ppc) and ia32 instruction set architectures are supported by Jikes RVM.IntelIntel's Instruction Set Architectures (ISAs) get known by different names:IA-32 is the name used to describe processors such as 386, 486 and the Pentium processors. It is popularly called x86 or sometimes in our documentation as x86-32.IA-32e is the name used to describe the extension of the IA-32 architecture to support 8 more registers and a 64-bit address space. It is popularly called x86_64 or AMD64, as AMD chips were the first to support it. It is found in processors such AMD's Opteron and Athlon 64, as well as in Intel's own Pentium 4 processors that have EM64T in their name.IA-64 is the name of Intel's Itanium processor ISA.Jikes RVM currently supports the IA-32 ISA. As IA-32e is backward compatible with IA-32, Jikes RVM can be built and run upon IA-32e processors. The IA-64 architecture supports IA-32 code through a compatibility mode or through emulation and Jikes RVM should run in this configuration.Operating SystemsJikes RVM is capable of running on any operating system that is supported by the GNU Classpath library, low level library support is implemented and memory layout is defined. The low level library support includes interaction with the threading and signal libraries, memory management facilities and dynamic library loading services. The memory layout must also be known, as Jikes RVM will attempt to locate the boot image code and data at specific memory locations. These memory locations must not conflict with where the native compiler places it's code and data. Operating systems that are known to work include AIX, Linux and OSX. At one stage a port to win32 was completed but it was never integrated into the main Jikes RVM codebase.Note: Current implementation of Jikes RVM implies that system native libraries (like GTK+) have been compiled with frame pointers. Most of Linux distribution have frame pointers enabled in most of the packages, but some explicitly use -fomit-frame-pointer thus producing the library that can't be used with JikesRVM. See this issue for example.Support MatrixThe following table details the targets that have historically been supported and the current status of the support. The target.name column is the identifier that Jikes RVM uses to identify this target.target.nameOperating SystemInstruction ArchitectureAddress SizeStatusia32-linuxLinuxia3232 bitsOKia32-osxOSXia3232 bitsOKia32-solarisSolarisia3232 bitsOKia32-cygwinWindowsia3232 bitsWIPppc32-aixAIXPowerPC32 bitsOKppc32-linuxLinuxPowerPC32 bitsOKppc32-osxOSXPowerPC32 bitsOKppc64-aixAIXPowerPC64 bitsOKppc64-linuxLinuxPowerPC64 bitsOKx86_64-linuxLinuxia3232 bits*OKx86_64 is currently only supported using the legacy 32bit addressing mode and instructions (track progress on full 64bit support here)Tool RequirementsJava Virtual MachineJikes RVM requires an existing Java Virtual Machine that conforms to Java 6.0 such as Oracle JDK 1.6, OpenJDK/IcedTea 6 or IBM SDK 6.0. We also aim to support the Java 7.0-conformant versions of these virtual machines.Some Java Virtual Machines are unable to cope with compiling the Java class library so it is recommended that you install one of the above mentioned JVMs if they are not already installed on your system. The remaining build instructions assume that a suitable Java Virtual Machine is on your path. You can run "java -version" to check you are using the correct JVM.AntAnt version 1.7.0 or later is the tool required to orchestrate the build process. You can download and install the Ant tool from http://ant.apache.org/ if it is not already installed on your system. The remaining build instructions assume that $ANT_HOME/bin is on your path. You can run "ant -version" to check you are running the correct version of ant.C and C++ compilersThe Jikes RVM build assumes that the GNU Compiler Collection is present on the system. Most modern *nix environments satisfy this requirement.BisonAs part of the build process, Jikes RVM uses the bison tool which should be present on most modern *nix environments.PerlPerl is trivially used as part of the build process but this requirement may be removed in future releases of Jikes RVM. Perl is also used as part of the regression and performance testing framework.AwkGNU Awk is required as part of the regression and performance testing framework but is not required when building Jikes RVM.Extra tools recommended for Solarispkg-get will greatly simplify installing GNU packages on Solaris. Our patches require that GNU patch is picked up in preference to Sun's, to achieve this, for example, you can create a symbolic link to /usr/bin/gpatch from /opt/csw/bin/patch and make sure /opt/csw/bin is in your path before /usr/bin.InstructionsDefining Ant propertiesThere are a number of ant properties that are used to control the build process of Jikes RVM. These properties may either be specified on the command line by "-Dproperty=variable" or they may be specified in a file named ".ant.properties" in the base directory of the jikesrvm source tree. The ".ant.properties" file is a standard Java property file with each line containing a "property=variable" and comments starting with a # and finishing at the end of the line. The following table describes some properties that are commonly specified.PropertyDescriptionDefaulthost.nameThe name of the host environment used for building Jikes RVM. The host environment defines the paths to the tools used during the build, e.g. the path to the C compiler. The name should match one of the files located in the build/hosts/ directory minus the '.properties' extension.Nonetarget.nameThe name of the target environment for Jikes RVM. The name should match one of the files located in the build/targets/ directory minus the '.properties' extension. This should only be specified when cross compiling the Jikes RVM. See Cross-Platform Building for a detailed description of cross compilation.${host.name}config.nameThe name of the configuration used when building Jikes RVM. The name should match one of the files located in the build/configs/ directory minus the '.properties' extension. This setting is further described in the section Configuring the RVM.Nonepatch.nameAn identifier for the current patch applied to the source tree. See Building Patched Versions for a description of how this fits into the standard usage patterns of Jikes RVM.""components.dirThe directory where Ant looks for external components when building the RVM.${jikesrvm.dir}/componentsdist.dirThe directory where Ant stores the final Jikes RVM runtime.${jikesrvm.dir}/distbuild.dirThe directory where Ant stores the intermediate artifacts generated when building the Jikes RVM.${jikesrvm.dir}/targetprotect.config-filesDefine this property if you do not want the build process to update configuration files when auto downloading components.(Undefined)components.cache.dirThe directory where Ant caches downloaded components.  If you explicitly download a component, place it in this directory.(Undefined, forcing download)require.rvm-unit-testsIf set to true, run unit tests on the built rvm image. Use with care as it will significantly increase build times for configurations that are compiled using a non-optimizing compiler (see below).(Undefined, tests are not run)require.checkstyleOnly useful if you want to contribute changes to the Jikes RVM. If set to true, run checkstyle during the build to check for violations of the Jikes RVM Coding Style. Coding Conventions for assertions must be checked manually.(Undefined, no checks run)At a minimum it is recommended that the user specify the host.name property in the ".ant.properties" file.The configuration files in "build/targets/" and "build/hosts/" are designed to work with a typical install but it may be necessary to overide specific properties. The easiest way to achieve this is to specify the properties to override in the ".ant.properties" file.Selecting a ConfigurationA "configuration" in terms of Jikes RVM is the combination of build time parameters and component selection used for a particular Jikes RVM image. The Configuring the RVM section describes the details of how to define a configuration. Typical configuration names include;production: This configuration defines a fully optimized version of the Jikes RVM.development: This configuration is the same as production but with debug options enabled. The debug options perform internal verification of Jikes RVM which means that it builds and executes more slowly.prototype: This configuration is compiled using an unoptimized compiler and includes minimal components which means it has the fastest build time.prototype-opt: This configuration is compiled using an unoptimized compiler but it includes the adaptive system and optimizing compiler. This configuration has a reasonably fast build time.If a user is working on a particular configuration most of the time they may specify the config.name ant property in ".ant.properties" otherwise it should be passed in on the command line "-Dconfig.name=...".Fetching DependenciesThe Jikes RVM has a build time dependency on the GNU Classpath class library and depending on the configuration may have a dependency on GCSpy. The build system will attempt to download and build these dependencies if they are not present or are the wrong version.To just download and install the GNU Classpath class library you can run the command "ant -f build/components/classpath.xml". After this command has completed running it should have downloaded and built the GNU Classpath class library for the current host. See the Using GCSpy page for directions on building configurations with GCSpy support.If you wish to manually download components (for example you need to define a proxy, so ant is not correctly downloading), you can do so and identify the directory containing the downloads using "-Dcomponents.cache.dir=<download directory>" when you build with ant.Building the RVMThe next step in building Jikes RVM is to run the ant command "ant" or "ant -Dconfig.name=...". This should build a complete RVM runtime in the directory "${dist.dir}/${config.name}_${target.name}". The following table describes some of the ant targets that can be executed. A complete list of documented targets can be listed by executing the command "ant -projecthelp"TargetDescriptioncheck-propertiesCheck that all the required properties are defined.compile-mmtkCompile MMTk toolkit.prepare-sourceGenerate configuration independent source code if required or force.generation property is set.prepare-config-sourceGenerate source code for the current configuration if required or force.generation property is set.main or runtimeBuild a runtime image.cleanRemove the build and image directory for the current configuration.very-cleanAs with clean but also remove Java files generated by scripts.real-cleanAs with very-clean but remove all compiled images.profiled-imageCompile a baseline version of the RVM for profiling then use the profile information to recompile the given config.name image.Running the RVMJikes RVM can be executed in a similar way to most Java Virtual Machines. The difference is that the command is "rvm" and resides in the runtime directory (i.e. "${dist.dir}/${config.name}_${target.name}"). See Running the RVM for a complete list of command line options. View Online · View Changes Online [Less]

Page edited by Jeremy Singer - "affiliation updates" Jikes RVM TeamThe Jikes RVM team is responsible for creating or applying the improvements that go into the ... [More] releases of Jikes RVM. The current team is:Steve Blackburn, Australian National University, (Jikes RVM steering committee)Michael Bond, Ohio State UniversityErik BrangsRobin Garner, Australian National UniversityDavid Grove, IBM Research, (Jikes RVM steering committee)Andrew John Hughes, Red HatJ. Eliot B. Moss, University of MassachusettsPast Jikes RVM Team MembersThe following people have greatly contributed to the success of the Jikes RVM project by having served as Jikes RVM team members:Steve AugartPerry Cheng, IBM ResearchJulian Dolby, IBM ResearchPeter Donald, La Trobe UniversityStephen Fink, IBM ResearchDaniel Frampton, Australian National UniversityMatthias Hauswirth, University of Colorado at BoulderMichael Hind, IBM ResearchChris Hoffmann, University of MassachussettsFilip Pizlo, Purdue UniversityFeng Qian, McGill UniversityIan Rogers, University of ManchesterPeter F. Sweeney, IBM ResearchKris Venstermans, University of GhentContributions From Jikes RVM CommunityThe Jikes RVM project sincerely thanks the following people who have made contributions to the system:Eddie AftandilianSteven AugartMichael BaerJames BornholtGreg BorotaErik BrangsShane BrewerBrian D. CarlstromPeter DonaldPhilippe FaesDa FengChapman FlackDaniel FramptonRobin GarnerGeorgios GousiosAndrew GrayJungwoo HaMatthias HauswirthLaurence HellyerMatthew HertzMark HindessChris HoffmannKenneth HosteXianglong HuangRichard JonesGarrett KolpinChristos-Efthymois KotselidisSergiy KyrylkovAlan LawrenceKien LeHan LeeJohn LeunerLukas LoehrerDmitri MakarovAvery MoonJ. Eliot B. MossElias NaurAnders Biehl NorgaardJeff PalmFilip PizloTuan PhanJoão Reys SantosAndreas SeweRifat ShahriyarAleksey ShipilevJeremy SingerStephen SmaldoneSunil SomanDarko StefanovicSuryia SubramanianTom VanDrunenIan WarringtonMark WielaardXi YangYuval YaromLingli ZhangJisheng ZhaoLei ZhaoSoftware Used by Jikes RVMJikes RVM uses either the class libraries produced by the GNU Classpath project or Apache Harmony.Thanks to David R. Hanson,Christoper W. Fraser, and Todd Proebsting for making available the iburg tool, which we've enhanced for use in Jikes RVM.Thanks to Codehaus and Sourceforge for providing hosting services.The Jalapeño Research ProjectJikes RVM was independently developed as part of the Jalapeño research project at the IBM T.J. Watson Research Center. The following IBM Research employees, academic visitors, and student co-ops contributed to the early releases of Jikes RVM:Bowen AlpernAnthony CocchiHan LeeJanice ShepherdMatthew ArnoldJulian DolbyDerek LieberManu SridharanDick AttanasioTracy FergusonMark MergenPeter F. SweeneyDavid BaconStephen FinkTon NgoMartin TrappJohn J. BartonEugene GluzbergJeff PalmKris VenstermansSteve BlackburnDavid GroveIgor PechtchanskiJohn WhaleyRastislav BodikMichael HindVivek SarkarMaria ButricoDave HovemeyerMauricio SerranoPerry ChengSusan HummelArvin ShepherdJong-Deok ChoiSergiy KyrylkovStephen Smith View Online · View Changes Online [Less]

Page edited by Jeremy Singer - "Jikes RVM benefits" As in previous years, Jikes RVM will apply to Google Summer of Code for funding for student projects.The ... [More] GSoC 2013 timeline has been published. The first date of importance is: Organization application deadline on March 29 2013Our current task is to collate a set of interesting project proposals and encourage students to apply for GSoC. We can re-use ideas from previous proposals, or come up with totally new ideas.Hints for studentsThe application for mentoring organizations hasn't been opened yet. However, it's not too early to read the Google Summer of Code documentation. Students should read at least the GSoC FAQ and Google's advice for students. There's also a lot of helpful information about GSoC that's provided by mentoring organizations and previous GSoC students (use your favorite search engine to find it).If the Jikes RVM project sounds like it could be a good fit for you, you can already start to get familiar with Jikes RVM. Checkout the source code and read the user guide. Build the Jikes RVM, run some tests and take a look at the codebase. You should have your development environment already set up before applying. Don't hesitate to ask on the mailing lists if you need help.If/when we've been accepted as a mentoring organization, students can take a look at our guidelines on making an application. We expect that students get familiar with the Jikes RVM and the Jikes RVM community before applying.What's in it for me?All mentors get a smart Google t-shirt. The project gets some new contributors, and the students get substantial amounts of cash and experience in open source development. The Jikes RVM project has seen substantial benefits from GSoC in previous years, including a new native threading model and additions to the core team of developers.Adding new project suggestionsPlease add your ideas to the wiki below, ideally using the template shown below. You can also contribute an idea if you don't have a wiki account: just describe it on on the researchers mailing list. Project TitlefooRVM area{compiler, classlib, MMTk, infrastructure...}outlineparagraph description of project ideareferenceslinks to related projects, academic papers, etcneeded skillsskills that the student should have and/or needs to acquire during the projectdifficultya difficulty estimate for the project, e.g. easy, medium, difficultinterested mentoryour name and a contact link or "TBD" if you can't mentorProject suggestions (aka idea list) Project TitleImplement the Java Management extensions (JMX) APIRVM areaclasslib, MMTk, threading, compileroutlineThe Java Management Extensions provide a way to monitor and manage Java Virtual machines. The Jikes RVM can collect significantly more profiling data and runtime statistics than an average JVM as a result of it being focussed on research activities. These statistics would ideally be exported using JMX and could potentially provide a standard mechanism for monitoring the performance and health of the virtual machine and its components.As a first step, students should focus on laying groundwork for a suitable implementation of the API:Update the JMX code from GSoC 2007 (written by Andrew John Hughes) to work with the current Jikes RVMImplement all the parts of the API that are requiredWrite automated tests that can be integrated into our test frameworksAfter that has happened, students should implement the optional parts of the API and Jikes RVM-specific features. The exact set of features will need to be discussed with the community at the appropriate time.referencesBlog post about JMX with links to further documentationOur bugtracker entry for JMXWeb view of the JMX branch in the historic svn repository (use "svn checkout svn://svn.code.sf.net/p/jikesrvm/svn/rvmroot/branches/RVM-127-JMX" to checkout the code)needed skillsJavadifficultyeasyinterested mentorTBD  Project TitleImplement the JVM Tool Interface (JVMTI)RVM areathreading, JNIoutlineThe JVM Tool interface is part of the Java Platform Debugger Architecture that JVMs can implement to provide debugging capabilities. We would like to have a full JMVTI implementation to allow debugging of Java applications that are running on Jikes RVM. Another benefit of JVMTI is that it allows low-level access to JVM internals. This can be used for instrumenting and monitoring the Jikes RVM using low-level code.There is already a partial JMVTI implementation that was written by James Bornholt for GSoC 2011. His implementation should be used as a basis for this project.referencesWriteup of James Bornholt on the GSoC 2011 pageWeb view of previous GSoC 2011 JVMTI workneeded skillsC, C++, Java, willingness to deal with low-level detailsdifficultymediuminterested mentorTBD  Project TitleImprove (or rethink) CatTrackRVM areainfrastructureoutlineThe Jikes RVM project currently uses the Ruby-on-Rails application CatTrack to track test results. CatTrack is also responsible for sending regression mails.This project would consist of upgrading CatTrack to use a more recent version of Ruby-on-Rails instead of the ancient Ruby-on-Rails 1.2.6. Potential candidates must have experience in Ruby-on-Rails to be able to take on this project: we don't have the necessary expertise to provide adequate mentoring to RoR beginners. The exact version numbers and the upgrade process need to be coordinated with our contacts at the Australian National University (where the servers are located). New features can be added to CatTrack after the upgrade is complete.An alternative approach would be to get rid of CatTrack completely and move to a more general open-source solution. Note that this would be a much more disruptive change. A student proposal that suggests this approach must be very convincing to be considered. Another constraint for proposals of this kind is that we want to avoid using yet another language in our build infrastructure (see RVM-85 ). It might be acceptable to replace Ruby with another language but this must be discussed before such a proposal is submitted.The X10 language project also uses CatTrack for their regression mails. Candidates should be prepared to coordinate with somebody from the X10 team to ensure that an upgraded version of CatTrack (or a replacement) is also a viable solution for them.referencesWeb view of the CatTrack repositoryneeded skillsprior Ruby-on-Rails experience, XML, basic knowledge about databasesdifficultydifficultinterested mentorTBD  Project TitleImprove testing situation for JIkes RVMRVM areainfrastructure, (additional subsystems as chosen by the student)outlineAn infrastructure for unit tests and some initial unit tests were added to the Jikes RVM in GSoC 2012 by João Reys Santos. However, there is still a lot of work to do before we can consider the codebase to be reasonably well tested. We need more unit tests as well as more black-box tests.Students should pick an area of interest (e.g. compilers, JNI, MMTk, classloading, threading, ...) and/or motivating use cases (e.g. get benchmark X or application Y running on Jikes RVM), identify and fix the corresponding problems and introduce adequate (unit) tests.Note that extra effort will be required if students want to use mocking. Mockito does not work with GNU Classpath-based JVMs and our OpenJDK-port is not yet ready.referencesbook: Michael Feathers, Working effectively with legacy code, Pearson Education, 2004book: Andreas Zeller, Why programs fail: A guide to systematic debugging, Morgan Kaufmann, 2009needed skillsJava, Ant, debugging without a debuggerdifficultyeasy to difficult (depends on the chosen tasks and areas)interested mentorTBD  Project TitleBytecode verifierRVM areaclassloading, compilersoutlineJikes RVM currently does not implement a bytecode verifier. We would like to have a bytecode verifier that can verify classfiles at least up until Java 6 (we don't support Java 7 yet). The verifier needs to work with the baseline compiler as well as the optimizing compiler. Ideally, it should be possible to use the verifier from the command line without actually running the bytecode that is supposed to be checked. This could be done in a similar way to the OptTestHarness which enables users to control the compilers.The verifier should be designed to support custom verification constraints. Some examples for possible constraints are listed in the JIRA issue linked below.referencesJIRA issue for the bytecode verifierJasmin assembler (useful for creating test cases that trigger verifier errors)Chapter 4 of the JVM Specificationneeded skillsJava, reading papers and specifications, implementing algorithms from specifications and papersdifficultymediuminterested mentorTBD View Online · View Changes Online [Less]

Page edited by Erik Brangs - "inserted horizontal rules in an effort to make the idea list look better on jikesrvm.org" As in previous years, Jikes RVM will to ... [More] Google Summer of Code for student projects.The GSoC 2013 timeline has been published. The first date of importance is: Organization application deadline on March 29 2013Our current task is to collate a set of interesting project proposals and encourage students to apply for GSoC. We can re-use ideas from previous proposals, or come up with totally new ideas.Hints for studentsThe application for mentoring organizations hasn't been opened yet. However, it's not too early to read the Google Summer of Code documentation. Students should read at least the GSoC FAQ and Google's advice for students. There's also a lot of helpful information about GSoC that's provided by mentoring organizations and previous GSoC students (use your favorite search engine to find it).If the Jikes RVM project sounds like it could be a good fit for you, you can already start to get familiar with Jikes RVM. Checkout the source code and read the user guide. Build the Jikes RVM, run some tests and take a look at the codebase. You should have your development environment already set up before applying. Don't hesitate to ask on the mailing lists if you need help.Once we've been accepted as a mentoring organization, students can take a look at our guidelines on making an application. We expect that students get familiar with the Jikes RVM and the Jikes RVM community before applying.What's in it for me?All mentors get a smart Google t-shirt. The project gets some new contributors, and the students get substantial amounts of cash and experience in open source development.Adding new project suggestionsPlease add your ideas to the wiki below, ideally using the template shown below. You can also contribute an idea if you don't have a wiki account: just describe it on on the researchers mailing list. Project TitlefooRVM area{compiler, classlib, MMTk, ...}outlineparagraph description of project ideareferenceslinks to related projects, academic papers, etcneeded skillsskills that the student should have and/or needs to acquire during the projectdifficultya difficulty estimate for the project, e.g. easy, medium, difficultinterested mentoryour name and a contact link or "TBD" if you can't mentorProject suggestions (aka idea list) Project TitleImplement the Java Management extensions (JMX) APIRVM areaclasslib, MMTk, threading, compileroutlineThe Java Management Extensions provide a way to monitor and manage Java Virtual machines. The Jikes RVM can collect significantly more profiling data and runtime statistics than an average JVM as a result of it being focussed on research activities. These statistics would ideally be exported using JMX and could potentially provide a standard mechanism for monitoring the performance and health of the virtual machine and its components.As a first step, students should focus on laying groundwork for a suitable implementation of the API:Update the JMX code from GSoC 2007 (written by Andrew John Hughes) to work with the current Jikes RVMImplement all the parts of the API that are requiredWrite automated tests that can be integrated into our test frameworksAfter that has happened, students should implement the optional parts of the API and Jikes RVM-specific features. The exact set of features will need to be discussed with the community at the appropriate time.referencesBlog post about JMX with links to further documentationOur bugtracker entry for JMXWeb view of the JMX branch in the historic svn repository (use "svn checkout svn://svn.code.sf.net/p/jikesrvm/svn/rvmroot/branches/RVM-127-JMX" to checkout the code)needed skillsJavadifficultyeasyinterested mentorTBD  Project TitleImplement the JVM Tool Interface (JVMTI)RVM areathreading, JNIoutlineThe JVM Tool interface is part of the Java Platform Debugger Architecture that JVMs can implement to provide debugging capabilities. We would like to have a full JMVTI implementation to allow debugging of Java applications that are running on Jikes RVM. Another benefit of JVMTI is that it allows low-level access to JVM internals. This can be used for instrumenting and monitoring the Jikes RVM using low-level code.There is already a partial JMVTI implementation that was written by James Bornholt for GSoC 2011. His implementation should be used as a basis for this project.referencesWriteup of James Bornholt on the GSoC 2011 pageWeb view of previous GSoC 2011 JVMTI workneeded skillsC, C++, Java, willingness to deal with low-level detailsdifficultymediuminterested mentorTBD  Project TitleImprove (or rethink) CatTrackRVM areainfrastructureoutlineThe Jikes RVM project currently uses the Ruby-on-Rails application CatTrack to track test results. CatTrack is also responsible for sending regression mails.This project would consist of upgrading CatTrack to use a more recent version of Ruby-on-Rails instead of the ancient Ruby-on-Rails 1.2.6. Potential candidates must have experience in Ruby-on-Rails to be able to take on this project: we don't have the necessary expertise to provide adequate mentoring to RoR beginners. The exact version numbers and the upgrade process need to be coordinated with our contacts at the Australian National University (where the servers are located). New features can be added to CatTrack after the upgrade is complete.An alternative approach would be to get rid of CatTrack completely and move to a more general open-source solution. Note that this would be a much more disruptive change. A student proposal that suggests this approach must be very convincing to be considered. Another constraint for proposals of this kind is that we want to avoid using yet another language in our build infrastructure (see RVM-85 ). It might be acceptable to replace Ruby with another language but this must be discussed before such a proposal is submitted.The X10 language project also uses CatTrack for their regression mails. Candidates should be prepared to coordinate with somebody from the X10 team to ensure that an upgraded version of CatTrack (or a replacement) is also a viable solution for them.referencesWeb view of the CatTrack repositoryneeded skillsprior Ruby-on-Rails experience, XML, basic knowledge about databasesdifficultydifficultinterested mentorTBD  Project TitleImprove testing situation for JIkes RVMRVM areainfrastructure, (additional subsystems as chosen by the student)outlineAn infrastructure for unit tests and some initial unit tests were added to the Jikes RVM in GSoC 2012 by João Reys Santos. However, there is still a lot of work to do before we can consider the codebase to be reasonably well tested. We need more unit tests as well as more black-box tests.Students should pick an area of interest (e.g. compilers, JNI, MMTk, classloading, threading, ...) and/or motivating use cases (e.g. get benchmark X or application Y running on Jikes RVM), identify and fix the corresponding problems and introduce adequate (unit) tests.Note that extra effort will be required if students want to use mocking. Mockito does not work with GNU Classpath-based JVMs and our OpenJDK-port is not yet ready.referencesbook: Michael Feathers, Working effectively with legacy code, Pearson Education, 2004book: Andreas Zeller, Why programs fail: A guide to systematic debugging, Morgan Kaufmann, 2009needed skillsJava, Ant, debugging without a debuggerdifficultyeasy to difficult (depends on the chosen tasks and areas)interested mentorTBD  Project TitleBytecode verifierRVM areaclassloading, compilersoutlineJikes RVM currently does not implement a bytecode verifier. We would like to have a bytecode verifier that can verify classfiles at least up until Java 6 (we don't support Java 7 yet). The verifier needs to work with the baseline compiler as well as the optimizing compiler. Ideally, it should be possible to use the verifier from the command line without actually running the bytecode that is supposed to be checked. This could be done in a similar way to the OptTestHarness which enables users to control the compilers.The verifier should be designed to support custom verification constraints. Some examples for possible constraints are listed in the JIRA issue linked below.referencesJIRA issue for the bytecode verifierJasmin assembler (useful for creating test cases that trigger verifier errors)Chapter 4 of the JVM Specificationneeded skillsJava, reading papers and specifications, implementing algorithms from specifications and papersdifficultymediuminterested mentorTBD View Online · View Changes Online [Less]