Despite providing similar functionality, multiple network services may require the use of different interfaces to access the functionality, and this problem will only become worse with the widespread deployment of ubiquitous computing environments. One way around this problem is to use interface adapters that adapt one interface into another. Chaining these adapters allows flexible interface adaptation with fewer adapters, but the loss incurred because of imperfect interface adaptation must be considered. This study outlines a matrix-based mathematical basis for analysing the chaining of lossy interface adapters. The authors also show that the problem of finding an optimal interface adapter chain is NP-complete with a reduction from 3SAT.
The mathematics in this paper was motivated by the interface adapter framework @cite_2 used by the Active Surroundings middleware for ubiquitous computing environments @cite_20 . In order to support a transparent computing experience despite a user moving around locations where similar services may have different interfaces, the framework uses interface adapters to adapt interfaces. @cite_2 defines the problem informally and shows the effectiveness of a greedy algorithm based on uniform cost search @cite_0 .
@cite_0 @cite_20 @cite_2
2132136548 2052260075 2066560342 2074833026
A key feature of ubiquitous computing is service continuity which allows a user to transparently continue his task regardless of his movement. For service continuity, the underlying system needs to not only discover a service satisfying a user's request, but also provide an interface differences resolution scheme if the interface of the service found is not the same as that of the service requested. For resolving interface mismatches, one of solutions is to use an interface adapter. The most serious problem in the interface adapter-based approach is the overhead of adapter generation. There are many research efforts about adapter generation load reduction and this paper focuses on an adapter chaining scheme to reduce the number of necessary adapters among different service interfaces. We propose a construction-time adaptation loss evaluation scheme and an adapter chain construction algorithm, which finds an adapter chain with minimal adaptation loss. Despite providing similar functionality, multiple network services may require the use of different interfaces to access the functionality, and this problem will only become worse with the widespread deployment of ubiquitous computing environments. One way around this problem is to use interface adapters that adapt one interface into another. Chaining these adapters allows flexible interface adaptation with fewer adapters, but the loss incurred because of imperfect interface adaptation must be considered. This study outlines a matrix-based mathematical basis for analysing the chaining of lossy interface adapters. The authors also show that the problem of finding an optimal interface adapter chain is NP-complete with a reduction from 3SAT. The navigation of high-dimensional data spaces remains challenging, making multivariate data exploration difficult. To be effective and appealing for mainstream application, navigation should use paradigms and metaphors that users are already familiar with. One such intuitive navigation paradigm is interactive route planning on a connected network. We have employed such an interface and have paired it with a prominent high-dimensional visualization paradigm showing the N-D data in undistorted raw form: parallel coordinates. In our network interface, the dimensions form nodes that are connected by a network of edges representing the strength of association between dimensions. A user then interactively specifies nodes edges to visit, and the system computes an optimal route, which can be further edited and manipulated. In our interface, this route is captured by a parallel coordinate data display in which the dimension ordering is configured by the specified route. Our framework serves both as a data exploration environment and as an interactive presentation platform to demonstrate, explain, and justify any identified relationships to others. We demonstrate our interface within a business scenario and other applications. This paper proposes a compiler-based programming framework that automatically translates user-written structured grid code into scalable parallel implementation code for GPU-equipped clusters. To enable such automatic translations, we design a small set of declarative constructs that allow the user to express stencil computations in a portable and implicitly parallel manner. Our framework translates the user-written code into actual implementation code in CUDA for GPU acceleration and MPI for node-level parallelization with automatic optimizations such as computation and communication overlapping. We demonstrate the feasibility of such automatic translations by implementing several structured grid applications in our framework. Experimental results on the TSUBAME2.0 GPU-based supercomputer show that the performance is comparable as hand-written code and good strong and weak scalability up to 256 GPUs.