Core API Research Articles

Model Checking Distributed Protocols in Must

We describe the design and implementation of Must, a framework for modeling and automatically verifying distributed systems. Must provides a concurrency API that supports multiple communication models, on top of a mainstream programming language, such as Rust. Given a program using this API, Must verifies it by means of a novel, optimal dynamic partial order reduction algorithm that maintains completeness and optimality for all communication models supported by the API. We use Must to design and verify models of distributed systems in an industrial context. We demonstrate the usability of Must's API by modeling high-level system idioms (e.g., timeouts, leader election, versioning) as abstractions over the core API, and demonstrate Must's scalability by verifying systems employed in production (e.g., replicated logs, distributed transaction management protocols), the verification of which lies beyond the capacity of previous model checkers.

Cotton Disease Detection Using TensorFlow Machine Learning Technique

Agriculture is a main source of income for farmers in India. Farmers produce many seasonal local crops based on their location. Cotton is the most produced crop across India. Cotton is a commercial crop, and farmers get good capital from cotton. This will increase the income of the farmer. However, one of the basic problems with cotton is that it is easily exposed to many diseases. These diseases need to be identified as early as possible to avoid production loss. In this paper, the CNN algorithm is used to create the prediction model by leveraging the TensorFlow’s Keras API. This model is further used in mobile app development which helps the farmers identify cotton disease and recommend the pesticides which can be used to overcome the disease. The TensorFlow open-source platform was used to prepare the ML model. The TensorFlow Tflite model is created, and after that, the model is converted into the Core ML model, which is used in iOS app to make the disease predication. Google’s core API is used to convert the TensorFlow model into the Core ML model. The label dataset was used to create the model. The Swift language is used in app development. The model accuracy was around 90%. Currently, boll rot and fungal leafspot disease are detected in this app. However, the app can be further extended for other cotton diseases too.

Matrix multiplication on batches of small matrices in half and half-complex precisions

Machine learning and artificial intelligence (AI) applications often rely on performing many small matrix operations—in particular general matrix–matrix multiplication (GEMM). These operations are usually performed in a reduced precision, such as the 16-bit floating-point format (i.e., half precision or FP16). The GEMM operation is also very important for dense linear algebra algorithms, and half-precision GEMM operations can be used in mixed-precision linear solvers. Therefore, high-performance batched GEMM operations in reduced precision are significantly important, not only for deep learning frameworks, but also for scientific applications that rely on batched linear algebra, such as tensor contractions and sparse direct solvers.This paper presents optimized batched GEMM kernels for graphics processing units (GPUs) in FP16 arithmetic. The paper addresses both real and complex half-precision computations on the GPU. The proposed design takes advantage of the Tensor Core technology that was recently introduced in CUDA-enabled GPUs. With eight tuning parameters introduced in the design, the developed kernels have a high degree of flexibility that overcomes the limitations imposed by the hardware and software (in the form of discrete configurations for the Tensor Core APIs). For real FP16 arithmetic, performance speedups are observed against cuBLAS for sizes up to 128, and range between 1.5× and 2.5×. For the complex FP16 GEMM kernel, the speedups are between 1.7× and 7× thanks to a design that uses the standard interleaved matrix layout, in contrast with the planar layout required by the vendor’s solution. The paper also discusses special optimizations for extremely small matrices, where even higher performance gains are achievable.

Cross-platform application development for measuring program competencies and learning outcomes in the bologna process

This application forecasts learning outcomes from a sentence based on sentence’s verb to detect outcome learning outcomes. Application uses .NET Core API & .NET Standard technology for possible future multi-platform support. It uses Bloom’s taxonomies to determine the potential learning outcomes and export the final document as a “. json” file which is a special text format. One data package for a sentence is including these titles: Methods,Techniques,Approaches, Strategies,Classifications,Measure & Analysis and learning outcomes forecasts underneath these titles. According to the previous version, the changes:UI transformed to new design language “Fluent Design”, which is introduced by Microsoft.Assistant mode for one sentence with Q&A style chat UI.Support for dictionary in different areas.Keywords: Bologna process, measurement and evaluation, learning outcomes forecast program, acquired learning outcomes, cross platform development, xamarin framework, .net core, .net standard, uwp, cocoa framework

POSTER

RCU is, among other things, a well known mechanism for memory reclamation that is meant to be used in languages without an automatic Garbage Collector, unfortunately, it requires operating system support, which is currently provided only in Linux. An alternative is to use Userspace RCU (URCU) which has two variants that can be deployed on other operating systems, named \emph{Memory Barrier} and \emph{Bullet Proof}. We present a novel algorithm that implements the three core APIs of RCU: \texttt{rcu\_read\_lock()}, \texttt{rcu\_read\_unlock()}, and \texttt{synchronize\_rcu()}. Our algorithm uses one mutual exclusion lock and two reader-writer locks with \texttt{trylock()} capabilities, which means it does not need a language with a memory model or atomics API, and as such, it can be easily implemented in almost any language, regardless of the underlying CPU architecture, or operating system.

Implicit Parallelism through Deep Language Embedding

Parallel collection processing based on second-order functions such as map and reduce has been widely adopted for scalable data analysis. Initially popularized by Google, over the past decade this programming paradigm has found its way in the core APIs of parallel dataflow engines such as Hadoop's MapReduce, Spark's RDDs, and Flink's DataSets. We review programming patterns typical of these APIs and discuss how they relate to the underlying parallel execution model. We argue that fixing the abstraction leaks exposed by these patterns will reduce the cost of data analysis due to improved programmer productivity. To achieve that, we first revisit the algebraic foundations of parallel collection processing. Based on that, we propose a simplified API that (i) provides proper support for nested collection processing and (ii) alleviates the need of certain second-order primitives through comprehensions -- a declarative syntax akin to SQL. Finally, we present a metaprogramming pipeline that performs algebraic rewrites and physical optimizations which allow us to target parallel dataflow engines like Spark and Flink with competitive performance.

Understanding the API usage in Java

ContextApplication Programming Interfaces (APIs) facilitate the use of programming languages. They define sets of rules and specifications for software programs to interact with. The design of language API is usually artistic, driven by aesthetic concerns and the intuitions of language architects. Despite recent studies on limited scope of API usage, there is a lack of comprehensive, quantitative analyses that explore and seek to understand how real-world source code uses language APIs. ObjectiveThis study aims to understand how APIs are employed in practical development and explore their potential applications based on the results of API usage analysis. MethodWe conduct a large-scale, comprehensive, empirical analysis of the actual usage of APIs on Java, a modern, mature, and widely-used programming language. Our corpus contains over 5000 open-source Java projects, totaling 150 million source lines of code (SLoC). We study the usage of both core (official) API library and third-party (unofficial) API libraries. We resolve project dependencies automatically, generate accurate resolved abstract syntax trees (ASTs), capture used API entities from over 1.5 million ASTs, and measure the usage based on our defined metrics: frequency, popularity and coverage. ResultsOur study provides detailed quantitative information and yield insight, particularly, (1) confirms the conventional wisdom that the usage of APIs obeys Zipf distribution; (2) demonstrates that core API is not fully used (many classes, methods and fields have never been used); (3) discovers that deprecated API entities (in which some were deprecated long ago) are still widely used; (4) evaluates that the use of current compact profiles is under-utilized; (5) identifies API library coldspots and hotspots. ConclusionsOur findings are suggestive of potential applications across language API design, optimization and restriction, API education, library recommendation and compact profile construction.

AnnotateGenomicRegions: a web application

AnnotateGenomicRegions: a web application

Easy Development and Integration of Science Gateways with Vine Toolkit

Science Gateways are web portal environments targeted for a given community and dedicated to specific scientific needs. Scientists require a different set of tools, applications, visualizations, data integration patterns, to be able to satisfy unique requirements of different research domains. To enable users to benefit from remote computational and storage resources, a web portal framework should support an easy integration and access to the e-Infrastructure. In this paper we present results of our research and development activities leading to the release of the Vine Toolkit framework integrated with Adobe Flex/BlazeDs technologies. It offers a set of unified and abstract APIs for different Grid middleware and a rich graphic presentation layer. Additionally, it automates the integration process with portal frameworks, such as Liferay or GridSphere. Vine Toolkit introduces a concept of subprojects which extend core APIs or define new low level components and web applications. This way, a Science Gateway prototyping process is definitely shortened. Consequently, it allows programmers to build software components that can be reused in a simple manner for different Science Gateways.

An Entity-Component Model for Extensible Virtual Worlds

The open source realXtend project has developed a freely available open source virtual world platform that lets anyone create 3D applications. RealXtend is fully implemented in the new Tundra SDK and in an add-on for the OpenSimulator server. The framework treats fundamental elements of virtual worlds (such as support for avatars) as an add-in functionality, so the overall architecture can accommodate a wider range of virtual worlds. Attribute values are automatically synchronized among the participants in a networked environment. A core API provides basic functionality for GUIs, controller input, audio, and means for 3D scene manipulation for application code.

Simulating multiple inheritance in Java

Multiple inheritance is a feature whose worth has been vigorously debated, and even now there is no agreement as to whether a language should include it. Java does not have multiple inheritance, but its designers claim that many of the benefits of multiple inheritance can be gained through the use of a new feature, the interface. In this paper we explore the claims of the Java designers, and show how the interface may be used to simulate multiple inheritance. We first discuss the benefits of inheritance and multiple inheritance, and then demonstrate how the need for them arises in program development, using an extended example based on a real application. We then present the technique for simulating multiple inheritance, showing how it allows the main benefits of multiple inheritance to be achieved in Java. Finally, we discuss the limitations of the approach. In particular, we show how the approach faces difficulties when used with class libraries, such as the Java Core API, and we suggest a convention for Java class library designers that will mitigate this problem.

Java Input Method Engine

Internationalization (I18N) gained much momentum in recent years. Even the latest HTML 4.0 public draft has taken great strides towards the internationalization of documents, with the goal of making the Web truly “World Wide”. This paper starts with describing the various development in HTML standards that has made the Web a more global definition. It then points out the fact that the correct display and rendering of multilingual text is only half the scenario for I18N. Users not only wish to view I18N HTML document, they want to create them! With this in mind, it then goes on to explain why Java had not completely fulfilled its role as an I18N development platform, especially in the area on native keyboard input methods. To meet this shortcoming, this paper explains how the development of a Java Input Method Engine (JIME) fills the gap. It continues with description of the design issues and implementation of the framework—an applet, a Netscape Composer plug-in and a Unicode-based multilingual text editor. It ends with an account of ongoing development on JIME. In conclusion, it would be ideal if Java have included full native keyboard input method support in the core APIs. An early preview of JDK 1.2 sees an input methods being introduced but perhaps only the next iteration of Java releases may offer full input method support regardless of the locale of the host platform.