Browsing by Subject "Java"
Now showing 1 - 14 of 14
Results Per Page
Sort Options
Item BusyBeeTaskManager : visual, hosted, collaborative task management(2013-08) Vijayan, Sreejitha; Aziz, AdnanPeople today increasingly use software utilities which help create ‘to-do’ lists or reminders to stay efficient and productive. This has spurred a new industry into designing products for Business Management, Project Planning and Schedule Management on web and device platforms. However, these tools are either designed for novices or industrial level managers. A large number of individuals fall in between; their projects require intensive planning but not at the level of industrial projects. To address this category of users, I propose BusyBeeTaskManager, a web-based application that helps visually plan projects and efficiently communicate progress within the team. The user interface is designed for novice users but features such as document sharing, task dependency graph and automatic task updates allow users to carry outsophisticated team-based projects.Item Catweetegories : machine learning to organize your Twitter stream(2013-12) Simoes, Christopher Francis; Aziz, AdnanWe want to create a web service that will help users better organize the flood of tweets they receive every day by using machine learning. This was done by experimenting with ways to manually classify training sets of tweets such as using Amazon’s Mechanical Turk and crawling the Internet for large quantities of tweets. Once we acquired good training data, we began building a classifier. We tried NLTK and Stanford NLP as libraries for creating a classifier, and we ultimately created a classifier that is 87.5% accurate. We then built a web service to expose this classifier and to allow any user on the Internet to organize their tweets. We built our web service by using many open source tools, and we discuss how we integrated these tools to create a production quality web service. We run our web service in the Amazon cloud, and we review the costs associated with running in Amazon. Finally we review the lessons we learned and share our thoughts on further work we would like to do in the future.Item Compression of a context-based marshalling methodology in Java(2016-12) Harrod, Ryan William; Khurshid, SarfrazThis report focuses on a method for serializing messages in Java which is somewhere between a customized solution and Java’s built-in serialization. Customized serialization will lead to the fastest, most optimized code, but will require more development time. Java’s built in serialization, on the other hand, requires almost no effort to use but is slow, and uses more than is strictly necessary. This project gives a third option which requires a little more effort than Java’s built in serialization, but still provides fast serialization speed, and low message sizes. The tool presented here can take in requirements for a message to transmit, which includes numbers, strings, booleans, and enumerations, and the output is a collection of Java classes which will serialize and deserialize that message. In turn, this generated library can be shared between projects within an organization, or even with third parties. The original message definition becomes a sort of interface control document, while the resulting code becomes a library which can be used to communicate with the defined messages, without requiring users of that message to develop their own code.Item Dynamic software updates : a VM-centric approach(2010-05) Subramanian, Suriya; McKinley, Kathryn S.; Blackburn, Steve; Hicks, Michael; Lin, Calvin; Pingali, KeshavBecause software systems are imperfect, developers are forced to fix bugs and add new features. The common way of applying changes to a running system is to stop the application or machine and restart with the new version. Stopping and restarting causes a disruption in service that is at best inconvenient and at worst causes revenue loss and compromises safety. Dynamic software updating (DSU) addresses these problems by updating programs while they execute. Prior DSU systems for managed languages like Java and C# lack necessary functionality: they are inefficient and do not support updates that occur commonly in practice. This dissertation presents the design and implementation of Jvolve, a DSU system for Java. Jvolve's combination of flexibility, safety, and efficiency is a significant advance over prior approaches. Our key contribution is the extension and integration of existing Virtual Machine services with safe, flexible, and efficient dynamic updating functionality. Our approach is flexible enough to support a large class of updates, guarantees type-safety, and imposes no space or time overheads on steady-state execution. Jvolve supports many common updates. Users can add, delete, and change existing classes. Changes may add or remove fields and methods, replace existing ones, and change type signatures. Changes may occur at any level of the class hierarchy. To initialize new fields and update existing ones, Jvolve applies class and object transformer functions, the former for static fields and the latter for object instance fields. These features cover many updates seen in practice. Jvolve supports 20 of 22 updates to three open-source programs---Jetty web server, JavaEmailServer, and CrossFTP server---based on actual releases occurring over a one to two year period. This support is substantially more flexible than prior systems. Jvolve is safe. It relies on bytecode verification to statically type-check updated classes. To avoid dynamic type errors due to the timing of an update, Jvolve stops the executing threads at a DSU safe point and then applies the update. DSU safe points are a subset of VM safe points, where it is safe to perform garbage collection and thread scheduling. DSU safe points further restrict the methods that may be on each thread's stack, depending on the update. Restricted methods include updated methods for code consistency and safety, and user-specified methods for semantic safety. Jvolve installs return barriers and uses on-stack replacement to speed up reaching a safe point when necessary. While Jvolve does not guarantee that it will reach a DSU safe point, in our multithreaded benchmarks it almost always does. Jvolve includes a tool that automatically generates default object transformers which initialize new and changed fields to default values and retain values of unchanged fields in heap objects. If needed, programmers may customize the default transformers. Jvolve is the first dynamic updating system to extend the garbage collector to identify and transform all object instances of updated types. This dissertation introduces the concept of object-specific state transformers to repair application heap state for certain classes of bugs that corrupt part of the heap, and a novel methodology that employes dynamic analysis to automatically generate these transformers. Jvolve's eager object transformation design and implementation supports the widest class of updates to date. Finally, Jvolve is efficient. It imposes no overhead during steady-state execution. During an update, it imposes overheads to classloading and garbage collection. After an update, the adaptive compilation system will incrementally optimize the updated code in its usual fashion. Jvolve is the first full-featured dynamic updating system that imposes no steady-state overhead. In summary, Jvolve is the most-featured, most flexible, safest, and best-performing dynamic updating system for Java and marks a significant step towards practical support for dynamic updates in managed language virtual machines.Item Exploiting hardware heterogeneity and parallelism for performance and energy efficiency of managed languages(2015-12) Jibaja, Ivan; Witchel, Emmett; McKinley, Kathryn S.; Blackburn, Stephen M; Batory, Don; Lin, CalvinOn the software side, managed languages and their workloads are ubiquitous, executing on mobile, desktop, and server hardware. Managed languages boost the productivity of programmers by abstracting away the hardware using virtual machine technology. On the hardware side, modern hardware increasingly exploits parallelism to boost energy efficiency and performance with homogeneous cores, heterogenous cores, graphics processing units (GPUs), and vector instructions. Two major forms of parallelism are: task parallelism on different cores and vector instructions for data parallelism. With task parallelism, the hardware allows simultaneous execution of multiple instruction pipelines through multiple cores. With data parallelism, one core can perform the same instruction on multiple pieces of data. Furthermore, we expect hardware parallelism to continue to evolve and provide more heterogeneity. Existing programming language runtimes must continuously evolve so programmers and their workloads may efficiently utilize this evolving hardware for better performance and energy efficiency. However, efficiently exploiting hardware parallelism is at odds with programmer productivity, which seeks to abstract hardware details. My thesis is that managed language systems should and can abstract hardware parallelism with modest to no burden on developers to achieve high performance, energy efficiency, and portability on ever evolving parallel hardware. In particular, this thesis explores how the runtime can optimize and abstract heterogenous parallel hardware and how the compiler can exploit data parallelism with new high-level languages abstractions with a minimal burden on developers. We explore solutions from multiple levels of abstraction for different types of hardware parallelism. (1) For asymmetric multicore processors (AMP) which have been recently introduced, we design and implement an application scheduler in the Java virtual machine (JVM) that requires no changes to existing Java applications. The scheduler uses feedback from dynamic analyses that automatically identify critical threads and classifies application parallelism. Our scheduler automatically accelerates critical threads, honors thread priorities, considers core availability and thread sensitivity, and load balances scalable parallel threads on big and small cores to improve the average performance by 20% and energy efficiency by 9% on frequency-scaled AMP hardware for scalable, non-scalable, and sequential workloads over prior research and existing schedulers. (2) To exploit vector instructions, we design SIMD.js, a portable single instruction multiple data (SIMD) language extension for JavaScript (JS), and implement its compiler support that together add fine-grain data parallelism to JS. Our design principles seek portability, scalable performance across various SIMD hardware implementations, performance neutral without SIMD hardware, and compiler simplicity to ease vendor adoption on multiple browsers. We introduce type speculation, compiler optimizations, and code generation that convert high-level JS SIMD operations into minimal numbers of SIMD native instructions. Finally, to accomplish wide adoption of our portable SIMD language extension, we explore, analyze, and discuss the trade-offs of four different approaches that provide the functionality of SIMD.js when vector instructions are not supported by the hardware. SIMD.js delivers an average performance improvement of 3.3× on micro benchmarks and key graphic algorithms on various hardware platforms, browsers, and operating systems. These language extension and compiler technologies are in the final approval process to be included in the JavaScript standards. This thesis shows using virtual machine technologies protects programmers from the underlying details of hardware parallelism, achieves portability, and improves performance and energy efficiency.Item Framework for testing Java concurrency(2010-12) Heidt, David Patrick; Garg, Vijay K. (Vijay Kumar), 1963-; Krasner, HerbConcurrent programming has become ubiquitous in the arena of application development, requiring most production quality systems to deal with at least some degree of multi-threaded execution. An increasing level of maturity is developing around the impact of concurrency on the design and testing processes. Much of this knowledge focuses on the functional aspect of the design and execution with success measures typically related to the correctness of a program. However, there exists a gap in the research to date around the process for concurrent performance testing. While many companies acknowledge that performance is a major source of complaints in production environments, performance testing historically receives low priority and is often little more than an extension of the functional testing. Possibly the most widely discussed and understood implementation language today, in terms of multi-threaded programming, is Java. The report outlines a standard framework for concurrent performance testing targeted towards Java based applications. In an effort to vet the framework, we execute a series of practical concurrent testing that address some of the most common aspects of concurrent programming in Java, with a particular focus on the Java Concurrency package. As a result, this report presents a portable, extensible framework that designers can use in evaluating the range of concurrency options available in Java within their particular environment. Additionally, it provides specific insight into the performance of these options in a typical run-time environment. This includes particular attention to the comparison of traditional lock based approach to non-blocking algorithms.Item Improving RNA folding prediction algorithms with enhanced interactive visualization software(2016-08) Grant, Kevin Marcus; Markey, Mia Kathleen; Gutell, RobinSoftware improvements from this project will enable new algorithms for RNA folding prediction to be explored. Issues with capacity, extensibility, multi-tasking, usability, efficiency, accuracy and testing in the original program have been addressed, and the corresponding software architecture changes are discussed herein. Previously limited to just hundreds of helices, the software can now display and manipulate million-helix RNAs. Actions on large data sets are now feasible, such as continuous zooming. A new scripting interface adds flexibility and is especially useful for repetitive tasks and software testing. Structural analysis of RNA can be streamlined using the new mechanisms for organizing experiments, running other programs and displaying results (helices, or arbitrary text and images such as statistics). Finally, usability has been enhanced with more documentation, controls and settings.Item Intelligent, remote-controlled home protection system(2013-12) Das, Anindita; Barber, SuzanneAs our society gets increasingly mobile, it is becoming commonplace for residences to remain vacant for a significant amount of time every day. Unfortunately, emergencies can occur during those time, which may require immediate mitigatory action. This project proposes an approach that allows the resident to be notified of such emergencies and to perform mitigatory actions, even when she is hundreds of miles away. Our infrastructure includes three components: (1) programmable sensor devices to detect emergency situations; (2) a Web service hosted in the resident's home computer to send a notification to the smartphone of the user; and (3) a smartphone app that communicates with this Web service to notify the user, and provides a interface for the user to perform any mitigatory action. We develop a prototype system for detecting fire and intrusion emergencies. Our prototype system uses two sunSPOTs as sensors, an iRobot Create® as a mitigatory device, an Android app for user notification.Item IT-SNAPS multi-user implementation utilizing NVIDIA's compute-unified device architecture and Java XML Web Services(2012-05) Bryant, Benjamin; Sari-Sarraf, Hamed; Saed, MohammedThis thesis describes a multi-user implementation of the Interactive Texture-Snapping System (IT-SNAPS) as a Java XML web service. The system uses a Java applet as the client interface, while the server side is composed of Java, C, and compiled Matlab code. NVIDIA’s Compute Unified Device Architecture (CUDA) is also used on the server, and is capable of managing one or more graphics processing units (GPUs). The server creates and stores data within the GPU(s), pushing most of the workload onto them to reduce processing times, and increases the number of potential users per server. This thesis discusses the hardware, software, and concepts used in its creation.Item JavaFlow : a Java DataFlow Machine(2014-12) Ascott, Robert John; Swartzlander, Earl E., Jr., 1945-The JavaFlow, a Java DataFlow Machine is a machine design concept implementing a Java Virtual Machine aimed at addressing technology roadmap issues along with the ability to effectively utilize and manage very large numbers of processing cores. Specific design challenges addressed include: design complexity through a common set of repeatable structures; low power by featuring unused circuits and ability to power off sections of the chip; clock propagation and wire limits by using locality to bring data to processing elements and a Globally Asynchronous Locally Synchronous (GALS) design; and reliability by allowing portions of the design to be bypassed in case of failures. A Data Flow Architecture is used with multiple heterogeneous networks to connect processing elements capable of executing a single Java ByteCode instruction. Whole methods are cached in this DataFlow fabric, and the networks plus distributed intelligence are used for their management and execution. A mesh network is used for the DataFlow transfers; two ordered networks are used for management and control flow mapping; and multiple high speed rings are used to access the storage subsystem and a controlling General Purpose Processor (GPP). Analysis of benchmarks demonstrates the potential for this design concept. The design process was initiated by analyzing SPEC JVM benchmarks which identified a small number methods contributing to a significant percentage of the overall ByteCode operations. Additional analysis established static instruction mixes to prioritize the types of processing elements used in the DataFlow Fabric. The overall objective of the machine is to provide multi-threading performance for Java Methods deployed to this DataFlow fabric. With advances in technology it is envisioned that from 1,000 to 10,000 cores/instructions could be deployed and managed using this structure. This size of DataFlow fabric would allow all the key methods from the SPEC benchmarks to be resident. A baseline configuration is defined with a compressed dataflow structure and then compared to multiple configurations of instruction assignments and clock relationships. Using a series of methods from the SPEC benchmark running independently, IPC (Instructions per Cycle) performance of the sparsely populated heterogeneous structure is 40% of the baseline. The average ratio of instructions to required nodes is 3.5. Innovative solutions to the loading and management of Java methods along with the translation from control flow to DataFlow structure are demonstrated.Item ProxStor : flexible scalable proximity data storage & analysis(2014-12) Giannoules, James Peter; Aziz, AdnanProxStor is a cloud-based human proximity storage and query informational system taking advantage of both the near ubiquity of mobile devices and the growing digital infrastructure in our everyday physical world, commonly referred to as the Internet of Things (IoT). The combination provides the opportunity for mobile devices to identify when entering and leaving the proximity of a space based upon this unique identifying infrastructure information. ProxStor provides a low-overhead interface for storing these proximity events while additionally offering search and query capabilities to enable a richer class of location aware applications. ProxStor scales up to store and manage more than one billion objects, while enabling future horizontal scaling to expand to multiple systems working together supporting even more objects. A single seamless web interface is presented to clients system.. More than 18 popular graph database systems are supported behind ProxStor. Performance benchmarks while running on Neo4j and OrientDB graph database systems are compared to determine feasibility of the design.Item StarMapper : an android-based application to map celestial objects(2013-12) O'Donnell, John Jason; Aziz, AdnanThis report describes StarMapper, a mobile appliation designed for the Android platform that interactively maps the celestial sky and can provide information from Wikipedia about celestial objects to the user. The stars, constellations, planets, sun, and moon are all rendered in real-time and the user can navigate the celestial map simply by pointing the device around the sky to find and identify the different celestial objects. However, if the user prefers, a manual touch-based map navigation feature is also available in StarMapper. While other Android applications currently exist for mapping the sky, such as Google's Sky Map, StarMapper aims to enhance the experience by also providing additional information about celestial objects to the user by means of a simple click on the screen. For obtaining more information about a particular constellation or other celestial object, the user only needs to click on the object's name in the map, and the device's web browser opens to the Wikipedia page of the clicked object. Through this simple mechanism, the user can learn much more about astronomy than just locations of celestial objects.Item The Borobudur Vessels in Context(2014-07-28) Inglis, Douglas AndrewEleven boats are depicted in the bas-reliefs that cover the walls of Borobudur, a ninth century C.E. Buddhist monument located in central Java. These vessels are an important source of information about the complexities of classical Indonesian shipbuilding, and contain data about rigging elements, rope use, fastening, rowing configurations, and outrigger construction. They represent critical evidence of physical structures that have not survived in the archaeological record. Scholars such as Hornell, Mookerji, Needham, Horridge, Manguin, Ray, and others have used the reliefs to improve our understanding of maritime trade, seafaring, and ship construction in ancient Southeast Asia. While the technical merits of the Borobudur Ships have been thoroughly discussed, a great deal of cultural data has been overlooked. The objective of this thesis is to place the Borobudur Vessels in their proper religious, artistic, and narrative context. It addresses three central questions: 1.) What can the Buddhist narratives tell us about the seafaring scenes depicted at Borobudur? 2.) How did the artistic framework influence the representation of the vessels in the reliefs? 3.) What do Borobudur?s reliefs tell us about contemporaneous seafaring in the region? This study will demonstrate that the narrative and religious context of the Borobudur Vessels directly influenced how the panels were designed, how the ships were portrayed, and how we should interpret them. The Buddhist narratives associated with the vessels provide deeper context for everything we see happening on board. The stories reveal the stakes involved in seafaring, explain what was expected of a mariner, and illustrate the skills and mindset needed to survive on an ocean-going vessel. The reliefs themselves provide a window on how seafaring stories were envisioned in ninth century C.E. Java. The 94 mariners depicted aboard the ships portray emotions, such as fear, courage, torpor, and astonishment, as well as abstract concepts such a teamwork, self-sacrifice, and leadership. This thesis will show that the Borobudur Vessels represent a concentrated effort to capture the struggles, heroism, and drama of sailing. They are material evidence of the intimate connection between Buddhism and seafaring, and provide unique insights into the Javanese perception of sailing, the ocean, and its dangers.Item TSS : a Trading Strategy System(2010-05) Amirdache, Salim K.; Aziz, AdnanThis report presents TSS - a Trading Strategy System developed to let traders define arbitrarily complex trading strategies in the Java programming language and evaluate them using historical stock information. In addition, TSS provides access to Google Trends data for use in meta-strategy definition, and has the ability to return the best strategy from a family of strategies using data mining algorithms. Finally, TSS is highly extensible - we can integrate new data feeds by simply extending the interface and database.