5790802
Object-oriented symbol management in syntax-directed compiler systems
Each symbol in a source program has a series of attributes that govern the operations performed on it. In this paper, we explore object-oriented techniques for representing the attributes of symbols and translating the operations performed on them. This approach is shown superior in memory and run-time speed to the procedural style traditionally used for writing compilers. We demonstrate object-oriented symbol management in a compiler for an arithmetic subset of C. We have used C++ --- a single-dispatching language --- to implement the same, but we emphasize the need for multiple dispatching to develop programs in a heavily-object-oriented style.
11255660
A flexible contention resolution scheme for QoS provisioning in optical burst switching networks
Contention resolution is a major issue in bufferless optical burst switching (OBS) networks. The existing contention resolution schemes consider priority and arrival time to resolve contention. For most multimedia applications priority and delay are key parameters for QoS provisioning. In this paper, we propose a new signaling protocol for reducing contention in OBS networks and consider three parameters, namely, priority of the burst, number of hops traversed, and burst size into account to resolve contention. The source node in the proposed protocol can be informed of the contention up to halfway along the path of the burst, and thus, can reschedule the burst accordingly. The scheme is adaptable to both prioritized and delay constrained traffic. We call the scheme OBS-Flex. For selecting a data channel, we propose three channel selection algorithms, namely, Least Recently Used (LRU), First Fit (FF), and Priority Set (PS). We simulate OBS-Flex and compare with preemptive priority just-enough-time (PPJET) contention resolution scheme. We show that OBS-Flex outperforms PPJET in terms of burst loss rates. For simulation, we have considered Poisson and bursty traffic models.
20900631
ANCHOR - A Connectionist Architecture for Partitioning Feature Spaces and Hierarchical Nesting of Neural Nets
We present a novel connectionist architecture for handling arbitrarily complex neural computations. The architecture — which we call an Artificial Neural Network Compiler for Hierarchical ORganisation (ANCHOR) — facilitates network hierarchy and the partitioning of the input space into a number of small, simpler sub-mappings. This strategy is a mix of both a modular approach for reduction of the problem complexity, and an ensemble-based approach for increasing prediction accuracy. ANCHOR is implemented around the concept of a Superneuron which is a generalised view of a neuron-processing element; a superneuron is a single (or higher-order) perceptron which can be trained individually with the support of multiple learning algorithms. The indistinguishability between a superneuron, and a neuron is employed in hierarchical nesting of superneurons, up to (theoretically) infinite depth, within other superneurons as well as linear or tree-structured cascading. Hierarchical decomposition of simple boolean functions has been demonstrated as proof-of-concept. It is argued that this strategy of data-partitioning for subsequent mapping onto a hierarchical classifier reduces the learning complexity and offers better generalisation.
6342150
Frame based fair multiprocessor scheduler: a fast fair algorithm for real-time embedded systems
This paper presents frame based fair multiprocessor scheduler (FBFMS) which provides accurate real-time proportional fair scheduling for a set of dynamic tasks on a symmetric multiprocessor environment with O(1) scheduling overhead. FBFMS meets these seemingly contradictory goals by applying the benefits of virtual time round-robin scheduling mechanism along with a frame based scheduling approach. Simulation results show that the algorithm provides 2.5 to 26 times speedup (over O(lg n) complexity schedulers) with distortion in fairness less than 1% in most cases, and less than 15% in the worst case.
6228281
AWA* - A Window Constrained Anytime Heuristic Search Algorithm
This work presents an iterative anytime heuristic search algorithm called Anytime Window A* (AWA*) where node expansion is localized within a sliding window comprising of levels of the search tree/graph. The search starts in depth-first mode and gradually proceeds towards A* by incrementing the window size. An analysis on a uniform tree model provides some very useful properties of this algorithm. A modification of AWA* is presented to guarantee bounded optimal solutions at each iteration. Experimental results on the 0/1 Knapsack problem and TSP demonstrate the efficacy of the proposed techniques over some existing anytime search methods.
47278437
Simulation Based Verification using Temporally Attributed Boolean Logic
We propose a specification logic called temporally attributed Boolean (TAB) logic for assertion based verification which allows us to: (i) represent assertions succinctly, (ii) incorporate data-orientation and (iii) associate timing in design intentions. We present examples to show the motivation for this logic especially in the context of high level modeling of complex real time systems. We formally define TAB logic, formulate the problem of verification on a simulation trace and present efficient algorithms to check TAB assertions. We present results of application of TAB logic for instruction semantics and bus transaction verification of a bus integrated pipelined processor implementation
62235343
A simulation-based study of wireless sensor network middleware
Future wireless sensor networks (WSNs) will transport high-bandwidth, low-latency streaming data, and will host sophisticated processing, such as image fusion and object tracking, in-network on sensor network nodes. Recent middleware proposals provide capabilities for in-network processing, reducing energy drain based on communication costs alone. However, hosting complex processing on WSN nodes incurs additional processing energy and latency costs that impact network lifetime and application performance. There is a need for a WSN planning framework to explore energy saving and application performance trade-offs for models of future sensor networks that account for processing costs in addition to communication costs. In this work, we present a simulation framework to analyze the interplay between resource requirements for compute-and communication-intensive in-network processing for streaming applications. We simulate a surveillance application workload with middleware capabilities for data fusion, adaptive policy-driven migration of data fusion computation across network nodes, and prefetching of streaming data inputs for fusion processing. Our study sheds light on application figures of merit such as latency, throughput, and lifetime with respect to migration policy and node CPU and radio characteristics.
7339641
Efficient beacon placement for network tomography
Recent interest in using tomography for network monitoring has raised the fundamental issue of whether it is possible to use only a small number of probing nodes (beacons) for monitoring all edges of a network in the presence of dynamic routing. Past work has shown that minimizing the number of beacons is NP-hard, and has provided approximate solutions that may be fairly suboptimal. In this paper, we use a two-pronged approach to compute an efficient beacon set: (i) we formulate the need for, and design algorithms for, computing the set of edges that can be monitored by a beacon under all possible routing states; and (ii) we minimize the number of beacons used to monitor all network edges. We show that the latter problem is NP-complete and use an approximate placement algorithm that yields beacon sets of sizes within 1+<i>ln</i>(|<i>E</i>|) of the optimal solution, where E is the set of edges to be monitored. Beacon set computations for several Rocketfuel ISP topologies indicate that our algorithm may reduce the number of beacons yielded by past solutions by more than 50%.
2076832
Iterative adaptation for mobile clients using existing APIs
Iterative adaptation is a novel approach to adaptation for resource-limited mobile and wireless environments that supports powerful application-specific adaptations without requiring modifications to the application's source code. Common productivity applications, such as browsers, word processors, and presentation tools, export APIs that allow external applications to control their operation. The novel premise in iterative adaptation is that these APIs are sufficient to support a wide range of adaptation policies for applications running on resource-limited devices. In addition to allowing adaptation without having to change the application's source code, this approach has a unique combination of advantages. First, it supports centralized management of resources across multiple applications. Second, it makes it possible to modify application behavior after the application has been deployed. This paper evaluates the extent to which existing APIs can be used for the purposes of adapting document-based applications to run on bandwidth-limited devices. In particular, we implement a large number of bandwidth adaptations for applications from the Microsoft Office and the OpenOffice productivity suites and for Internet Explorer. Although we find limitations in their APIs, we are able to implement many adaptation policies without much complexity and with good performance. Moreover, iterative adaptation achieves performance similar to an approach that implements adaptation by modifying the application, while requiring only a fraction of the coding effort.
6817196
Design of Adaptive Overlays for Multi-scale Communication in Sensor Networks
In wireless sensor networks, energy and communication bandwidth are precious resources. Traditionally, layering has been used as a design principle for network stacks; hence routing protocols assume no knowledge of the application behavior in the sensor node. In resource-constrained sensor-nodes, there is simultaneously a need and an opportunity to optimize the protocol to match the application. In this paper, we design a network architecture that efficiently supports multi-scale communication and collaboration among sensors. The architecture complements the previously proposed Abstract Regions architecture for local communication and collaboration. We design a self-organizing hierarchical overlay that scales to a large number of sensors and enables multi-resolution collaboration. We design effective Network Programming Interfaces to simplify the development of applications on top of the architecture; these interfaces are efficiently implemented in the network layer. The overlay hierarchy can adapt to match the collaboration requirements of the application and data both temporally and spatially. We present an initial evaluation of our design under simulation to show that it leads to reduced communication overhead, thereby saving energy. We are currently building our architecture in the TinyOS environment to demonstrate its effectiveness.
2162080
Harbor: software-based memory protection for sensor nodes
Many sensor nodes contain resource constrained microcontrollers where user level applications, operating system components, and device drivers share a single address space with no form of hardware memory protection. Programming errors in one application can easily corrupt the state of the operating system or other applications. In this paper, we propose Harbor, a memory protection system that prevents many forms of memory corruption. We use software based fault isolation ("sandboxing") to restrict application memory accesses and control flow to protection domains within the address space. A flexible and efficient memory map data structure records ownership and layout information for memory regions; writes are validated using the memory map. Control flow integrity is preserved by maintaining a safe stack that stores return addresses in a protected memory region. Run-time checks validate computed control flow instructions. Cross domain calls perform low-overhead control transfers between domains. Checks are introduced by rewriting an application's compiled binary. The sand-boxed result is verified on the sensor node before it is admitted for execution. Harbor's fault isolation properties depend only on the correctness of this verifier and the Harbor runtime. We have implemented and tested Harbor on the SOS operating system. Harbor detected and prevented memory corruption caused by programming errors in application modules that had been in use for several months. Harbor's overhead, though high, is less than that of application-specific virtual machines, and reasonable for typical sensor workloads.