Context Cache Research Articles

Reinforcement Learning Based Approaches to Adaptive Context Caching in Distributed Context Management Systems

Real-time applications increasingly rely on context information to provide relevant and dependable features. Context queries require large-scale retrieval, inferencing, aggregation, and delivery of context using only limited computing resources, especially in a distributed environment. If this is slow, inconsistent, and too expensive to access context information, the dependability and relevancy of real-time applications may fail to exist. This paper argues, transiency of context (i.e., the limited validity period), variations in the features of context query loads (e.g., the request rate, different Quality of Service (QoS), and Quality of Context (QoC) requirements), and lack of prior knowledge about context to make near real-time adaptations as fundamental challenges that need to be addressed to overcome these shortcomings. Hence, we propose a performance metric driven reinforcement learning based adaptive context caching approach aiming to maximize both cost- and performance-efficiency for middleware-based Context Management Systems (CMSs). Although context-aware caching has been thoroughly investigated in the literature, our approach is novel because existing techniques are not fully applicable to caching context due to (i) the underlying fundamental challenges and (ii) not addressing the limitations hindering dependability and consistency of context. Unlike previously tested modes of CMS operations and traditional data caching techniques, our approach can provide real-time pervasive applications with lower cost, faster, and fresher high quality context information. Compared to existing context-aware data caching algorithms, our technique is bespoken for caching context information, which is different from traditional data. We also show that our full-cycle context lifecycle-based approach can maximize both cost- and performance-efficiency while maintaining adequate QoC solely based on real-time performance metrics and our heuristic techniques without depending on any previous knowledge about the context, variations in query features, or quality demands, unlike any previous work. We demonstrate using a real world inspired scenario and a prototype middleware based CMS integrated with our adaptive context caching approach that we have implemented, how realtime applications that are 85% faster can be more relevant and dependable to users, while costing 60.22% less than using existing techniques to access context information. Our model is also at least twice as fast and more flexible to adapt compared to existing benchmarks even under uncertainty and lack of prior knowledge about context, transiency, and variable context query loads.

Context Caching for IoT-Based Applications: Opportunities and Challenges

Context Caching for IoT-Based Applications: Opportunities and Challenges

Refresh Rate-Based Caching and Prefetching Strategies for Internet of Things Middleware.

One of the research directions in Internet of Things (IoT) is the field of Context Management Platforms (CMPs) which is a specific type of IoT middleware. CMPs provide horizontal connectivity between vertically oriented IoT silos resulting in a noticeable difference in how IoT data streams are processed. As these context data exchanges can be monetised, there is a need to model and predict the context metrics and operational costs of this exchange to provide relevant and timely context in a large-scale IoT ecosystem. In this paper, we argue that caching all transient context information to satisfy this necessity requires large amounts of computational and network resources, resulting in tremendous operational costs. Using Service Level Agreements (SLAs) between the context providers, CMP, and context consumers, where the level of service imperfection is quantified and linked to the associated costs, we show that it is possible to find efficient caching and prefetching strategies to minimize the context management cost. So, this paper proposes a novel method to find the optimal rate of IoT data prefetching and caching. We show the main context caching strategies and the proposed mathematical models, then discuss how a correctly chosen proactive caching strategy and configurations can help to maximise the profit of CMP operation when multiple SLAs are defined. Our model is accurate up to 0.0016 in Root Mean Square Percentage Error against our simulation results when estimating the profits to the system. We also show our model is valid using the t-test value tending to 0 for all the experimental scenarios.

Adaptive Context Caching for IoT-Based Applications: A Reinforcement Learning Approach.

Making internet-of-things (IoT)-based applications context-aware demands large amounts of raw data to be collected, interpreted, stored, and reused or repurposed if needed from many domains and applications. Context is transient but interpreted data can be distinguished from IoT data in many aspects. Managing context in cache is a novel area of research that has been given very little attention. Performance metric-driven adaptive context caching (ACOCA) can have a profound impact on the performance and cost efficiency of context-management platforms (CMPs) when responding to context queries in realtime. Our paper proposes an ACOCA mechanism to maximize both the cost and performance efficiency of a CMP in near realtime. Our novel mechanism encompasses the entire context-management life cycle. This, in turn, distinctively addresses the problems of efficiently selecting context for caching and managing the additional costs of context management in the cache. We demonstrate that our mechanism results in long-term efficiencies for the CMP that have not been observed in any previous study. The mechanism employs a novel, scalable, and selective context-caching agent implemented using the twin delayed deep deterministic policy gradient method. It further incorporates an adaptive context-refresh switching policy, a time-aware eviction policy, and a latent caching decision management policy. We point out in our findings that the additional complexity of adaptation introduced to the CMP through ACOCA is significantly justified, considering the cost and performance gains achieved. Our algorithm is evaluated using a real-world inspired heterogeneous context-query load and a data set based on parking-related traffic in Melbourne, Australia. This paper presents and benchmarks the proposed scheme against traditional and context-aware caching policies. We demonstrate that ACOCA outperforms the benchmarks in both cost and performance efficiency, i.e., up to 68.6%, 84.7%, and 67% more cost efficient compared to traditional data caching policies to cache context, redirector mode, and context-aware adaptive data caching under real-world-like circumstances.

Estimating the dynamic lifetime of transient context in near real-time for cost-efficient adaptive caching

Context-awareness in Internet of Things (IoT) applications has significant impact on how IoT data can be processed, stored if needed, reused, and repurposed across multiple IoT applications. Emerging Context Management Platforms (CMP) mediate between context providers and context consumers in order to unify access to context and, provide interoperability that allows cross-domain context querying. This paper proposes an approach to adaptive context caching which enables CMPs to serve context queries from multiple IoT applications. It presents the transient nature of context which is a unique challenge when caching context that requires regular refreshing. The paper proposes two adaptive refreshing strategies based on online-estimated lifetimes (i.e., how long before data is estimated to have changed and refreshing is needed) - reactive and full-coverage. They are evaluated by developing mathematical models and simulations. We further assess the impact of different parameters on context cache performance. The results demonstrate the efficiency of adaptive context caching to minimize operational costs whilst preserving good enough refresh rate and compliance with Service Level Agreements.

Context Management Scheme Optimization of Coarse-Grained Reconfigurable Architecture for Multimedia Applications

Due to the combination of flexibility and efficiency, coarse-grained reconfigurable architectures (CGRAs) are suitable for the implementation of computing-intensive applications. However, with the growing performance requirements, the scale of CGRA increases exponentially, which leads to configuration performance degradation and configuration power rise. Based on the analysis of configuration context features, we optimize the context management scheme of CGRA from the aspects of context cache structure and replacement strategy. The context cache is structured hierarchically to reduce the memory overhead without configuration performance degradation and a hybrid context replacement algorithm is proposed to further increase the configuration efficiency with a novel context frequency weight factor. Experimental results show that the proposed context management scheme improves the configuration performance of the base CGRA significantly by 13.6%–20.5% for H.264 decoding and 13.6%–20.5% for MPEG2 decoding with only 43% context cache cost. Compared with other works, the proposed context management scheme shows the advantages of 2.3– $6\times$ less normalized context cache size and 2.3– $2.7\times$ cache efficiency.

Coarse-grained reconfigurable architecture with hierarchical context cache structure and management approach

Coarse-grained reconfigurable architecture with hierarchical context cache structure and management approach

Efficient and flexible memory architecture to alleviate data and context bandwidth bottlenecks of coarse-grained reconfigurable arrays

The computational capability of a coarse-grained reconfigurable array (CGRA) can be significantly restrained due to data and context memory bandwidth bottlenecks. Traditionally, two methods have been used to resolve this problem. One method loads the context into the CGRA at run time. This method occupies very small on-chip memory but induces very large latency, which leads to low computational efficiency. The other method adopts a multi-context structure. This method loads the context into the on-chip context memory at the boot phase. Broadcasting the pointer of a set of contexts changes the hardware configuration on a cycle-by-cycle basis. The size of the context memory induces a large area overhead in multi-context structures, which results in major restrictions on application complexity. This paper proposes a Predictable Context Cache (PCC) architecture to address the above context issues by buffering the context inside a CGRA. In this architecture, context is dynamically transferred into the CGRA. Utilizing a PCC significantly reduces the on-chip context memory and the complexity of the applications running on the CGRA is no longer restricted by the size of the on-chip context memory. Data preloading is the most frequently used approach to hide input data latency and speed up the data transmission process for the data bandwidth issue. Rather than fundamentally reducing the amount of input data, the transferred data and computations are processed in parallel. However, the data preloading method cannot work efficiently because data transmission becomes the critical path as the reconfigurable array scale increases. This paper also presents a Hierarchical Data Memory (HDM) architecture as a solution to the efficiency problem. In this architecture, high internal bandwidth is provided to buffer both reused input data and intermediate data. The HDM architecture relieves the external memory from the data transfer burden so that the performance is significantly improved. As a result of using PCC and HDM, experiments running mainstream video decoding programs achieved performance improvements of 13.57%–19.48% when there was a reasonable memory size. Therefore, 1080p@35.7fps for H.264 high profile video decoding can be achieved on PCC and HDM architecture when utilizing a 200 MHz working frequency. Further, the size of the on-chip context memory no longer restricted complex applications, which were efficiently executed on the PCC and HDM architecture.

A survey on context aware system & intelligent Middleware’s

Context aware system or Sentient system is the most profound concept in the ubiquitous computing. In the cloud system or in distributed computing building a context aware system is difficult task and programmer should use more generic programming framework. On the basis of layered conceptual design, we introduce Context aware systems with Context aware middleware's. On the basis of presented system we will analyze different approaches of context aware computing. There are many components in the distributed system and these components should interact with each other because it is the need of many applications. Plenty Context middleware's have been made but they are giving partial solutions. In this paper we are giving analysis of different middleware's and comprehensive application of it in context caching. The Context aware or Sentient systems are comes under pervasive computing. Weiser (1991) introduced pervasive which refers to the integration of mobile devices such as notebook, PDAs, smartphones etc into the humans everyday life. It is expected that the services should react specifically to their time, places and current locations. Context can be refer as location, identities of nearby people and object, and changes to those objects. The situation of entity can be characterized by context. Users profile, device status, networking information or sensors are the ways to retrieve context information. The first context aware application is developed by Want et. al. (1992) which is based on Active badge Location System. According to the users current location, location-aware tour guide applications developed in middle 1990s. (Abowd et. al., 1997; Sumi et. al., 1998; Cheverest et. al., 2000) Person's emotional state, focus of attention, place, time and date, people in the user's environment can be defined as the sentient defined by Dey (1998). Hull et al. (1997) describe context as the aspects of the current situation. Brown defines context to be the elements of the user's environment which the computer knows about. Most context aware systems make use of external sentient factors as they provide useful data, such as place information. Furthermore, external attributes are easy to sense by using off-the-shelf sensing technologies. Watson Project used logical data (Budzik and Hammond, 2000) and the IntelliZap Project (Finkelstein et al., 2001) which support the user by giving useful information due to information read out of web pages, records etc. When dealing with sentient, three entities can be differentiated (Dey and Abowd, 2001): places (rooms, buildings etc.), people (individuals or groups) and things (physical objects, Mobile Component, computer components etc.). These entities may be given by various attributes which can be classified into four categories: identity (each entity has a unique identifier), location (an entity's position, co-location etc.), status (or activity, meaning the properties of an entity, e.g., heat and lightning for a room, processes running currently on a mobile etc.) and time (used for timestamps to define events etc.). II. APPROACHES

Context caches in the Clouds

In context-aware systems, the contextual information about human and computing situations has a strong temporal aspect i.e. it remains valid for a period of time. This temporal property can be exploited in caching mechanisms that aim to exploit such locality of reference. However, different types of contextual information have varying temporal validity durations and a varied spectrum of access frequencies as well. Such variation affects the suitability of a single caching strategy and an ideal caching mechanism should utilize dynamic strategies based on the type of context data, quality of service heuristics and access patterns and frequencies of context consuming applications. This paper presents an investigation into the utility of various context-caching strategies and proposes a novel bipartite caching mechanism in a Cloud-based context provisioning system. The results demonstrate the relative benefits of different caching strategies under varying context usage scenarios. The utility of the bipartite context caching mechanism is established both through simulation and deployment in a Cloud platform.

Reducing Handoff Delay In WLan Using Selective Proactive Context Caching

In IEEE 802.11 wireless networks, continuous connectivity which allows user mobility and maintains network utilization is one of the most important requirements. In order to establish and keep service state information during the handoff process, the context transfer protocol is used to transfer service state from the originally associated base station to another base station. These base stations exchange messages to establish a secure channel between the APs for transmitting the STA context information. The entire process, however, inevitably increases the overall handoff latency. To resolve the predicament, we propose the Selective Proactive Context Caching (SPCC) technique to proactively propagate security context of the mobile client to a selected set of neighboring base stations before re-association occurs. Unlike the conventional 802.11 handoff mechanism in which cooperation among neighboring base stations does not exist, a selected neighboring base stations in SPCC exchange link quality information of the mobile client through LAN and this information is stored into cache memory. Based on the link quality information, the originally associated AP selects a set of neighboring APs and forwards the security context of mobile station through the LAN. Simulation results show an improvement of 62% in reducing the re-association handoff delay. Specifically, the re-association delay is reduced from 3.2 ms in the 802.11 handoff mechanism to 1.2 ms when SPCC is applied.

Performance of a context cache for a multithreaded pipeline

Hardware-multithreading is a technique in the design of high performance machines that is currently the subject of much active research. Such machines are characterised by the exploitation of instruction-level concurrency, extracted from simultaneously active multiple threads of control. The main advantage of this technique is in the elimination of performance-debilitating processor latencies, and the technique is therefore useful in the design of both single-processor systems and parallel-processor systems. In this paper we discuss the design and simulated performance of a novel operand-buffering system for a high-performance multithreaded pipelined uniprocessor.

High-throughput, low-memory applications on the Pica architecture

This paper describes Pica, a fine-grain, message-passing architecture designed to efficiently support high-throughput, low-memory parallel applications, such as image processing, object recognition, and data compression. By specializing the processor and reducing local memory (4,096 36-bit words), multiple nodes can be implemented on a single chip. This allows high-performance systems for high-throughput applications to be realized at lower cost. The architecture minimizes overhead for basic parallel operations. An operand-addressed context cache and round-robin task manager support fast task swapping. Fixed-sized activation contexts simplify storage management. Word-tag synchronization bits provide low-cost synchronization. Several applications have been developed for this architecture, including thermal relaxation, matrix multiplication, JPEG image compression, and Positron Emission Tomography image reconstruction. These applications have been executed using an instrumented instruction-level simulator. The results of these experiments and an evaluation of Pica's architectural features are presented.

Swamp: a fast processor for Smalltalk-80

A processor for the Smalltalk-80↑ programming language is described. This machine is implemented using a standard bit slice ALU and sequencer, TTL MSI, and NMOS LSI RAMS. It executes an instruction set similar to the Smalltalk-80 virtual machine instruction set. The data paths of the machine are optimized for rapid Smalltalk-80 execution by the inclusion of a context cache, tag checking, and a hardware method cache. Each context is only partly initialized when created, and has no memory allocated for it until a possibly non-LIFO reference to it is created. The machine is microprogrammed, and uses a simple next micro-address prediction strategy to obtain most of the performance of pipelining without the attendant complexity. The machine can execute simple instructions at over 7M bytecodes per second and has a predicted average throughput of 1.9M bytecodes per second. A processor for the Smalltalk-80↑ programming language is described. This machine is implemented using a standard bit slice ALU and sequencer, TTL MSI, and NMOS LSI RAMS. It executes an instruction set similar to the Smalltalk-80 virtual machine instruction set. The data paths of the machine are optimized for rapid Smalltalk-80 execution by the inclusion of a context cache, tag checking, and a hardware method cache. Each context is only partly initialized when created, and has no memory allocated for it until a possibly non-LIFO reference to it is created. The machine is microprogrammed, and uses a simple next micro-address prediction strategy to obtain most of the performance of pipelining without the attendant complexity. The machine can execute simple instructions at over 7M bytecodes per second and has a predicted average throughput of 1.9M bytecodes per second.