Miki Enoki

Location inference using microblog messages

In order to sense and analyze disaster information from social media, microblogs as sources of social data have recently attracted attention. In this paper, we attempt to discover geolocation information from microblog messages to assess disasters. Since microblog services are more timely compared to other social media, understanding the geolocation information of each microblog message is useful for quickly responding to a sudden disasters. Some microblog services provide a function for adding geolocation information to messages from mobile device equipped with GPS detectors. However, few users use this function, so most messages do not have geolocation information. Therefore, we attempt to discover the location where a message was generated by using its textual content. The proposed method learns associations between a location and its relevant keywords from past messages, and guesses where a new message came from.

Event Processing over a Distributed JSON Store: Design and Performance

Web applications are increasingly built to target both desktop and mobile users. As a result, modern Web development infrastructure must be able to process large numbers of events (e.g., for location-based features) and support analytics over those events, with applications ranging from banking (e.g., fraud detection) to retail (e.g., just-in-time personalized promotions). We describe a system specifically designed for those applications, allowing high-throughput event processing along with analytics. Our main contribution is the design and implementation of an in-memory JSON store that can handle both events and analytics workloads. The store relies on the JSON model in order to serve data through a common Web API. Thanks to the flexibility of the JSON model, the store can integrate data from systems of record (e.g., customer profiles) with data transmitted between the server and a large number of clients (e.g., location-based events or transactions). The proposed store is built over a distributed, transactional, in-memory object cache for performance. Our experiments show that our implementation handles high throughput and low latency without sacrificing scalability.

Development of Failure Detection System for Network Control using Collective Intelligence of Social Networking Service in Large-Scale Disasters

When the Great East Japan Earthquake occurred in 2011, it was difficult to immediately grasp all telecommunications network conditions using only information from network monitoring devices because the damage was considerably heavy and a severe congestion control state occurred. Moreover, at the time of the earthquake, telephone and e-mail services could not be used in many cases-although social networking services (SNSs) were still available. In an emergency, such as an earthquake, users proactively convey information on telecommunications network conditions through SNSs. Therefore the collective intelligence of SNSs is suitable as a means of information detection complementary to conventional observation through network monitoring devices. In this paper, we propose a network failure detection system that detects telephony failures with a high degree of accuracy by using the collective intelligence of Twitter, one of the most widely used SNSs. We also show that network control can be performed automatically and autonomically using information on telecommunications network conditions detected with our system.

A Distributed Quorum System for Ensuring Bounded Staleness of Key-Value Stores

Modern storage systems employing quorum replication are often configured to use partial, non-strict quorums to prioritize performance over consistency. These systems return the most recently changed data item only from a set of replicas to respond more quickly to a read request without guaranteeing that the data item is the most recently changed for all of the data. Because these partial quorum mechanisms provide only basic eventual consistency guarantees, with no limit on the freshness of the data returned, sometimes these configurations are not acceptable for certain applications. In this work, we have devised a new key-value store with partial quorums while ensuring bounded staleness. Our store reports the expected bounds on staleness with respect to wall clock. We evaluated our new key-value store with Yahoo! Cloud Service Benchmarks and show its performance.

Performance improvement of OpenJPA by query dependency analysis

OpenJPA is an implementation of the Java persistence API (JPA) for Apache, with a caching layer for databases queries to share cached objects among multiple client sessions. This is a critical component for high performance, since the caching layer can handle many database requests. However the performance is limited when an application includes write transactions, because the current OpenJPA cache invalidation mechanism is course-grained and this results in a low cache hit rate. We have implemented two kinds of finer-grained invalidation mechanisms by using query dependency analysis and integrated them into OpenJPA. In our experiments with TPC-W, the OpenJPA with the finer-grained invalidation mechanisms outperformed the current OpenJPA. In addition, we created many more mixes TPC-W, and found that the finer mechanism is not necessarily the better, that is, the best mechanism varies depending on the mixes.

Memory-Efficient index for cache invalidation mechanism with OpenJPA

OpenJPA is an implementation of the Java Persistence API (JPA) for Apache, with a caching layer for database queries. However the caching performance is poor when an application includes write transactions, because the OpenJPA cache-invalidation mechanism is coarse-grained and this results in a low cache hit rate. In this research, we implemented an index mechanism for cache invalidation optimized for the data access patterns. The sizes of the index can be adjusted for the available cache memory. The results of our benchmark indicated that the optimized index drastically improved the performance of OpenJPA even with a small index size in various data access pattern scenarios.