We present a Java bytecode translation scheme for implementing dflow pointcut, which is an extension of aspect-oriented language AspectJ. With dflow pointcut, the programmer can concisely specify join points based on data dependency. Our translation inserts bytecode instructions into bytecode generated by the AspectJ compiler in order to keep track of dependency between values at runtime. By using a static analysis on data dependency, our scheme inserts instructions for the dependencies that can not statically be predicted. Therefore, our translation can generate less overhead in output code than a naive translation method that doesn't use any static analysis would do. Our experiments, which compared overheads between the code translated by our scheme and by a naive scheme, demonstrated the effectiveness of our scheme.
There are two approaches to analysis of functional programs: abstract interpretation and type inference systems. A remarkable work of strictness analysis in the latter approach is an algorithm using a special kind of type, called a lazy type. However, this algorithm is defined as an abstract machine, and it is not so easy to analyze the algorithm. This paper defines a theoretical framework of lazy types, and proposes a new algorithm of strictness analysis on the basis of lazy types. We also examine the properties of the algorithm including correctness and termination. Moreover we show that our algorithm is convenient to implementation with pattern matching in functional programming languages.
This paper proposes a novel transport-layer protocol called Sender Initiated Congestion Control (SICC) which provides congestion control for Small Group Multicast (SGM). SGM is an effective solution for carrying a large number of simultaneous small-sized group communications. We provide simulated and experimental results to show that SICC is capable of achieving fast congestion avoidance and significantly increases throughput at receivers while still remaining TCP friendly. In SICC, multiple transmission rates are pre-defined as constant values for a given session, and each rate is associated with a different SICC CLASS. Each CLASS corresponds to an SGM group containing receivers with similar acceptable sending rates. The acceptable sending rate of each receiver is estimated at the sender using TCP-Friendly Rate Control (TFRC) in response to the loss event rate reported by the receiver. Based on receiver's reports, the rate that a sender uses to transmit packets to a receiver can be dynamically changed by assigning the receiver to one of the other SICC CLASS. These are the first reported results for congestion control in SGM.
Manual parameter-tuning of Internet servers causes high administrative costs because it requires administrator's expertise and huge amounts of time. The keep-alive parameter, which is one of major parameters in web servers, may cause severe degradation if it is not set properly. In this paper, we present an automatic tuning technique of the keep-alive parameter. Our mechanism adjusts the parameter without administrator's intervention so as to maintain active connections between clients and a server while closing inactive connections by observing request-waiting intervals. We implemented a prototype for Apache web server. Experimental results show that our prototype automatically adjusted the parameter and successfully yielded the nearly optimal server performance on two different workloads.
In this paper, we characterize runaway projects using risk factors in software projects. At first, we applied association rule mining technique to questionnaire data collected from actual software development. Then as the result of the association rule mining, we derived several characterizing rules on risk factors, which will enable us to predict runaway status of projects. Finally we evaluated the usefulness of the derived rules by comparing with the prediction model constructed by logistic regression analysis. The result of evaluation implies that both the derived rules and their related risk factors are effective to characterize runaway projects.
This paper presents a denotational semantics for patten matching compilation, and develops a simple algorithm to compile pattern matching into efficient code. We interpret a given set of patterns as a disjoint set of subsets of values that partition the domain of a given type, and define a semantics of a pattern matching construct as an operation to determine the subset to which a given value belongs. By developing tree representations for subsets of values, this semantics yields a simple tree-expansion algorithm to compile a pattern matching construct into a sequence of primitive tests. The resulting algorithm is shown to be correct with respect to the denotational semantics. The algorithm produces efficient code performing each test only once, and detects redundancy and non-exhaustiveness of a given set of patterns without introducing any additional mechanism. The presented method has been implemented for SML#, an extension of the Standard ML language being developed at Research Institute of Electrical Communication, Tohoku University.
Aspect-oriented programming (AOP) has the good characteristic called obliviousness that enables a programmer to design a class without considering crosscutting concerns. On the other hand, it is not necessarily easy for the programmer to know the overall behavior of a woven program because weaving modifies the behavior of a method defined in a class. Unexpected errors might be embedded in the woven program. To tackle this problem, we propose WbC (Weaving by Contract), a technique for verifying the correctness of weaving based on contracts. Contracts in WbC consist of pre-conditions, post-conditions, and invariants of weaving. By introducing WbC, we can specify how a program should behave before and after weaving. We also provide a language called COW (COntract Writing language) for supporting WbC. In COW, a programmer describes contracts by predicate logic that represents the behavior of a program as a property of control and data flow. WbC can restrict weaving to keep the intention of the programmer.
Server/client programs for Internet services have to be updated every time application-layer protocols are revised, e.g., from HTTP/1.0 to HTTP/1.1, to cope with the extensions. This makes it difficult to properly maintain the server/client programs. To resolve this problem, this paper proposes a system that automatically generates protocol processing codes for both server and client programs from the descriptions of the server/client's state transitions, which are caused by message exchanges between a server and a client. The proposed system introduces two mechanisms, namely inheritance and override of state transitions, that enable us to specify only the differences between the old and new versions of the protocols. Using this system, both server and client programs are expected to be easier to reuse and maintain.
We propose a Java library BiXJ for bidirectional XML transformation. A bidirectional transformation generates target XML documents from source XML documents in forward transformations, and updates source documents in backward transformations by reflecting back modifications on target documents. The benefit of using BiXJ is that users can get the corresponding backward transformation automatically just by writing one forward transformation. BiXJ has addressed several limitations of the existing bidirectional transformation languages, and can be used for general purpose XML processing. For example, bidirectional XPath expressions written in BiXJ can be used to locate and extract data from XML documents. To validate the usability and expressiveness of BiXJ, we have bidirectionalized some typical examples of XQuery and XSLT with this library. The results of these experiments are promising.