Platforms such as Java provide many software engineering benefits. However, these benefits often come at the cost of significant runtime overhead. In this paper we study the potential for hiding some of that overhead by employing speculative execution techniques. In particular, we study the predictability of class-loading requests and the potential benefits of speculatively preloading classes in interactive applications.
{"title":"The potential of speculative class-loading","authors":"Dmitrijs Zaparanuks, M. Jovic, Matthias Hauswirth","doi":"10.1145/1294325.1294354","DOIUrl":"https://doi.org/10.1145/1294325.1294354","url":null,"abstract":"Platforms such as Java provide many software engineering benefits. However, these benefits often come at the cost of significant runtime overhead. In this paper we study the potential for hiding some of that overhead by employing speculative execution techniques. In particular, we study the predictability of class-loading requests and the potential benefits of speculatively preloading classes in interactive applications.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"379 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131999822","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Today information systems provide services which may be accessed through various types of devices and/or networks and from different locations. Services should be adapted at runtime to the features of the requiring device. Moreover, users may specify additional information when claiming for services, information through which they indicate the quality level required and expected from the provided services. For example, users may request the printing of an image by specifying also the expected resolution, format and/or number of colors. In this context, we propose a mobile-enabled approach to design and implement adaptable services. Our solution defines three different service layers: (1) a low-level network communication layer providing connectivity services among the peers available in a system, (2) a middleware managing the system-specific services and defining a communication protocol for the services requests, and (3) a high-level application layer dealing with domain-specific services. In this paper, attention is focused on the middleware and network communication layers.
{"title":"A Java mobile-enabled environment to access adaptive services","authors":"S. Ceriani, C. Raibulet, Luigi Ubezio","doi":"10.1145/1294325.1294361","DOIUrl":"https://doi.org/10.1145/1294325.1294361","url":null,"abstract":"Today information systems provide services which may be accessed through various types of devices and/or networks and from different locations. Services should be adapted at runtime to the features of the requiring device. Moreover, users may specify additional information when claiming for services, information through which they indicate the quality level required and expected from the provided services. For example, users may request the printing of an image by specifying also the expected resolution, format and/or number of colors.\u0000 In this context, we propose a mobile-enabled approach to design and implement adaptable services. Our solution defines three different service layers: (1) a low-level network communication layer providing connectivity services among the peers available in a system, (2) a middleware managing the system-specific services and defining a communication protocol for the services requests, and (3) a high-level application layer dealing with domain-specific services. In this paper, attention is focused on the middleware and network communication layers.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"75 5 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132087089","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Object pretenuring involves the identification of long-lived objects at or before their instantiation. It is a key optimization for generational garbage collection systems, which are standard in most high performance Java virtual machines. This paper presents a new study of factors that are used to indicate object lifespans. We adopt the information theory measurement of normalized mutual information to compare these various different factors in a common framework. A study of garbage collection traces from four standard Java benchmark programs shows that there is high dependence on some of these factors such as allocation site and object type. We also identify and measure new factors based on object-oriented metrics.
{"title":"Towards intelligent analysis techniques for object pretenuring","authors":"Jeremy Singer, Gavin Brown, M. Luján, I. Watson","doi":"10.1145/1294325.1294353","DOIUrl":"https://doi.org/10.1145/1294325.1294353","url":null,"abstract":"Object pretenuring involves the identification of long-lived objects at or before their instantiation. It is a key optimization for generational garbage collection systems, which are standard in most high performance Java virtual machines. This paper presents a new study of factors that are used to indicate object lifespans. We adopt the information theory measurement of normalized mutual information to compare these various different factors in a common framework. A study of garbage collection traces from four standard Java benchmark programs shows that there is high dependence on some of these factors such as allocation site and object type. We also identify and measure new factors based on object-oriented metrics.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125770411","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Mobile phones present unique challenges to the implementation of a self-contained programming environment. The paper details the design of the M scripting environment for mobile phones. The goal of the environment is to make the breadth and power of the Java libraries available to anyone with a Java-enabled phone. The paper lists some of the design problems that were encountered together with the M solution. M is the only self-contained programming environment for cell phones that executes on cell phones.
{"title":"The design of a Java phone programming environment","authors":"R. Cook","doi":"10.1145/1294325.1294330","DOIUrl":"https://doi.org/10.1145/1294325.1294330","url":null,"abstract":"Mobile phones present unique challenges to the implementation of a self-contained programming environment. The paper details the design of the M scripting environment for mobile phones. The goal of the environment is to make the breadth and power of the Java libraries available to anyone with a Java-enabled phone. The paper lists some of the design problems that were encountered together with the M solution. M is the only self-contained programming environment for cell phones that executes on cell phones.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114952081","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Thomas Würthinger, Christian Wimmer, H. Mössenböck
Whenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check elimination algorithm for the Java HotSpot#8482; VM based on static analysis in the just-in-time compiler. The algorithm works on an intermediate representation in static single assignment form and maintains conditions for index expressions. It fully removes bounds checks if it can be proven that they never fail. Whenever possible, it moves bounds checks out of loops. The static number of checks remains the same, but a check inside a loop is likely to be executed more often. If such a check fails, the executing program falls back to interpreted mode, avoiding the problem that an exception is thrown at the wrong place. The evaluation shows a speedup near to the theoretical maximum for the scientific SciMark benchmark suite (40% on average). The algorithm also improves the execution speed for the SPECjvm98 benchmark suite (2% on average, 12% maximum).
{"title":"Array bounds check elimination for the Java HotSpot#8482; client compiler","authors":"Thomas Würthinger, Christian Wimmer, H. Mössenböck","doi":"10.1145/1294325.1294343","DOIUrl":"https://doi.org/10.1145/1294325.1294343","url":null,"abstract":"Whenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check elimination algorithm for the Java HotSpot#8482; VM based on static analysis in the just-in-time compiler.\u0000 The algorithm works on an intermediate representation in static single assignment form and maintains conditions for index expressions. It fully removes bounds checks if it can be proven that they never fail. Whenever possible, it moves bounds checks out of loops. The static number of checks remains the same, but a check inside a loop is likely to be executed more often. If such a check fails, the executing program falls back to interpreted mode, avoiding the problem that an exception is thrown at the wrong place.\u0000 The evaluation shows a speedup near to the theoretical maximum for the scientific SciMark benchmark suite (40% on average). The algorithm also improves the execution speed for the SPECjvm98 benchmark suite (2% on average, 12% maximum).","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128577832","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Small devices have a specific hardware configuration. In particular, they usually include several types of memories (typically ROM, internal and external RAM, Flash memory) different in quantities and properties. We propose an object memory management where the placement of an object in a given generation is based on different properties. This approach is supported by a domain specific language allowing to write powerful and flexible placement policies. These placement policies completely describe the placement, in the different memories, of the objects handled by the virtual machine.
{"title":"A DSL approach for object memory management of small devices","authors":"K. Marquet, G. Grimaud","doi":"10.1145/1294325.1294346","DOIUrl":"https://doi.org/10.1145/1294325.1294346","url":null,"abstract":"Small devices have a specific hardware configuration. In particular, they usually include several types of memories (typically ROM, internal and external RAM, Flash memory) different in quantities and properties. We propose an object memory management where the placement of an object in a given generation is based on different properties. This approach is supported by a domain specific language allowing to write powerful and flexible placement policies. These placement policies completely describe the placement, in the different memories, of the objects handled by the virtual machine.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"65 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127990106","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Auto-boxing improves code readability by eliminating the need for explicit boxing code, but it does not improve performance, because it does not eliminate boxing code but inserts the code implicitly. Current auto-boxing implementations try to improve performance by caching some of the boxed values in order to avoid wrapper class instance allocation on each boxing operation. Such an implementation, however, sometimes suffers greater performance degradation because it prevents traditional optimizations, such as redundant instance allocation elimination. This paper presents a new optimizing technique that eliminates the boxing code inserted by auto-boxing if the code is found redundant. Estimation using the SPECjbb2005 benchmark showed that this optimization improved performance by 3.6%.
{"title":"Redundant boxing elimination by a dynamic compiler for Java","authors":"Y. Chiba","doi":"10.1145/1294325.1294355","DOIUrl":"https://doi.org/10.1145/1294325.1294355","url":null,"abstract":"Auto-boxing improves code readability by eliminating the need for explicit boxing code, but it does not improve performance, because it does not eliminate boxing code but inserts the code implicitly. Current auto-boxing implementations try to improve performance by caching some of the boxed values in order to avoid wrapper class instance allocation on each boxing operation. Such an implementation, however, sometimes suffers greater performance degradation because it prevents traditional optimizations, such as redundant instance allocation elimination. This paper presents a new optimizing technique that eliminates the boxing code inserted by auto-boxing if the code is found redundant. Estimation using the SPECjbb2005 benchmark showed that this optimization improved performance by 3.6%.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"23 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131067946","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper describes the development of a web-based programming and assessment environment for use in supporting programming fundamentals courses (CS1, CS2) taught in Java. This environment is currently linked with WeBWorK, an open source web-based system developed at the University of Rochester that is popular for administering and assessing mathematics and physics coursework, but is designed for the potential integration with other course management system (CMS) environments. In addition to the traditional multiple-choice and short answer questions that have been augmented with the extensive randomization and customization routines of WeBWorK, this new environment (called WeBWorK-JAG where JAG stands for Java Auto Grader) can automatically collect and grade free-form program fragments written in Java. Novel pedagogy has been developed based on the capabilities of this extension and preliminary classroom results are discussed in this paper. For example, when students contributed to WeBWorK by creating WeBWorK-JAG questions for their peers, they are exposed to the reality of creating comprehensive unit tests and to the wider quality assurance aspects of formulating questions and their solution sets. This work is described in the context of an emerging commercial market for web-based programming assistants and its unique contributions are summarized.
{"title":"Extending and contributing to an open source web-based system for the assessment of programming problems","authors":"O. Gotel, C. Scharff, A. Wildenberg","doi":"10.1145/1294325.1294327","DOIUrl":"https://doi.org/10.1145/1294325.1294327","url":null,"abstract":"This paper describes the development of a web-based programming and assessment environment for use in supporting programming fundamentals courses (CS1, CS2) taught in Java. This environment is currently linked with WeBWorK, an open source web-based system developed at the University of Rochester that is popular for administering and assessing mathematics and physics coursework, but is designed for the potential integration with other course management system (CMS) environments. In addition to the traditional multiple-choice and short answer questions that have been augmented with the extensive randomization and customization routines of WeBWorK, this new environment (called WeBWorK-JAG where JAG stands for Java Auto Grader) can automatically collect and grade free-form program fragments written in Java. Novel pedagogy has been developed based on the capabilities of this extension and preliminary classroom results are discussed in this paper. For example, when students contributed to WeBWorK by creating WeBWorK-JAG questions for their peers, they are exposed to the reality of creating comprehensive unit tests and to the wider quality assurance aspects of formulating questions and their solution sets. This work is described in the context of an emerging commercial market for web-based programming assistants and its unique contributions are summarized.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"28 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121314567","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Most Java Virtual Machines (JVMs) are themselves written in unsafe languages, making it unduly difficult to build trustworthy and safe JVM platforms. While some progress has been made on removing compilers from the trusted computing base (using certifying compilation), JVM interpreters continue to be built almost exclusively in C/C++. We have implemented an alternative approach, in which the JVM interpreter itself is built in Java, and runs atop a host JVM execution environment. Despite benefiting from the additional safety guarantees of the JVM runtime system, the execution overhead of our nested Java interpreter is quite acceptable in practice. Our results suggest that implementors should concentrate their efforts on optimizing just-in-time compilers rather than on interpreters. If a mixed-mode VM environment is desired, a generic JVM interpreter can subsequently be created using Java itself.
{"title":"Implementing fast JVM interpreters using Java itself","authors":"Michael Bebenita, A. Gal, M. Franz","doi":"10.1145/1294325.1294345","DOIUrl":"https://doi.org/10.1145/1294325.1294345","url":null,"abstract":"Most Java Virtual Machines (JVMs) are themselves written in unsafe languages, making it unduly difficult to build trustworthy and safe JVM platforms. While some progress has been made on removing compilers from the trusted computing base (using certifying compilation), JVM interpreters continue to be built almost exclusively in C/C++. We have implemented an alternative approach, in which the JVM interpreter itself is built in Java, and runs atop a host JVM execution environment. Despite benefiting from the additional safety guarantees of the JVM runtime system, the execution overhead of our nested Java interpreter is quite acceptable in practice. Our results suggest that implementors should concentrate their efforts on optimizing just-in-time compilers rather than on interpreters. If a mixed-mode VM environment is desired, a generic JVM interpreter can subsequently be created using Java itself.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"35 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114483143","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The purpose of software metrics is to measure the quality of programs. The results can be for example used to predict maintenance costs or improve code quality. An emerging view is that if software metrics are going to be used to improve quality, they must help in finding code that should be refactored. Often refactoring or applying a design pattern is related to the role of the class to be refactored. In client-based metrics, a project gives the class a context. These metrics measure, how a class is used by other classes in the context. We present a new client-based metric LCIC (Lack of Coherence in Clients), which analyses, if the class being measured has a coherent set of roles in the program. Interfaces represent the roles of classes. If a class does not have a coherent set of roles, it should be refactored, or a new interface should be defined for the class. We have implemented a tool for measuring the metric LCIC for Java projects in the Eclipse environment. We calculated LCIC values for classes of several open source projects. We compare these results with results of other related metrics, and inspect the measured classes to find out, what kind of refactorings are needed. We also analyse the relation of different design patterns and refactorings to our metric. Our experiments reveal the usefulness of client-based metrics to improve the quality of code.
{"title":"A software metric for coherence of class roles in Java programs","authors":"S. Mäkelä, V. Leppänen","doi":"10.1145/1294325.1294333","DOIUrl":"https://doi.org/10.1145/1294325.1294333","url":null,"abstract":"The purpose of software metrics is to measure the quality of programs. The results can be for example used to predict maintenance costs or improve code quality. An emerging view is that if software metrics are going to be used to improve quality, they must help in finding code that should be refactored. Often refactoring or applying a design pattern is related to the role of the class to be refactored. In client-based metrics, a project gives the class a context. These metrics measure, how a class is used by other classes in the context. We present a new client-based metric LCIC (Lack of Coherence in Clients), which analyses, if the class being measured has a coherent set of roles in the program. Interfaces represent the roles of classes. If a class does not have a coherent set of roles, it should be refactored, or a new interface should be defined for the class.\u0000 We have implemented a tool for measuring the metric LCIC for Java projects in the Eclipse environment. We calculated LCIC values for classes of several open source projects. We compare these results with results of other related metrics, and inspect the measured classes to find out, what kind of refactorings are needed. We also analyse the relation of different design patterns and refactorings to our metric. Our experiments reveal the usefulness of client-based metrics to improve the quality of code.","PeriodicalId":169989,"journal":{"name":"Principles and Practice of Programming in Java","volume":"21 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-05","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127895976","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：