Sundar Balasubramaniam

What is a file synchronizer

Nloblle computing devices intended for disconnected operation, such as laptops and personal organizers, must employ optimistic replication strategi~ for user files. Unlike traditional distributed systems. such devices do not attempt to present a “single filesystem” semanti~ users are aware that their fles are replicated, and that updates to one rephca till not be seen in another until some point of synchronization is reached (often under the user’s exphcit control). A variety of tools, collectively called file synchronizers, support this mode of operation. Unfortunately, present-day synchronizers seldom give the user enough information to predict how they will behave under all circumstances. Simple slogans fike “Non-confecting updates are propagated to other replicas” ignore numerous subtletim—e.g., Precisely what constitutes a confict be @een updates in different replicas? What does the synchronizer do if updatw confict? What happens when fles are renamed? What if the directory structure is reorganized in one replica? Our god is to offer a simple, concrete, and precise frame work for describing the behavior of file synchronizers. To this end, n?edivide the synchronization task into two conceptually distinct phasm update detection and Reconciliation. We dEcuss each phase in detail and develop a straightforn’ard specification of each. We sketch our on prototype implementation of these specifications and discuss how they apply to some existing synchronization tools.

A Method to Support Variability of Enterprise Services on the Cloud

Web-business platforms offer business capabilities as enterprise services hosted in a multi-tenant cloud environment. Often there is a need to create heavyweight variants of these enterprise services to support: inherent variability in the underlying business process, industry-specific requirements, globalization concerns and customer-specific requirements. These variability concerns affect both the service interface and the service provider implementation and hence are crosscutting in nature. In this paper, we use principles of aspect-oriented software development to modularize these variability concerns. We also provide an aspect specification scheme to specify these concerns. We propose an approach to create heavyweight service variants centered on a Service Kernel, which forms a common service core across tenants. Heavyweight service variants are created by weaving aspects into the service kernel. Our approach provides improved governance for the provider while offering maximum flexibility for the consumers.

An MOF2-based Services Metamodel

As Service-Oriented Computing is gaining mainstream adoption, Services are emerging as core-building blocks of today’s applications. In particular, web services have become the most common technology manifestation of the service-oriented computing paradigm. Basic open-standards that enable web services such as WSDL, SOAP etc. have evolved and stabilized over a period of time. However issues such as service composition, policy definition and enforcement, support for semantics are among the few issues that still remain open. With increased adoption of service-oriented computing and rapidly evolving technologies and standards to address these open-issues, heterogeneity has emerged in service development approaches leading to complexity and risks. In this paper, we address this problem by introducing modeling abstractions that could be used in the early-stage service development lifecycle of web-based electronic services. We present a holistic approach to services modeling using six model views. These views represent different perspectives of services modeling and form our core Services Metamodel with a grounding in the formal foundations of MOF2.

A Model-driven Approach to Service Policies

A Service represents an underlying capability offered by a service provider. A service description describes two facets of a service – the service functionality (capability onoffer) and the terms at which the service is offered (terms of offer). The capability onoffer satisfies the goal of a service consumer under the constraints of the terms of offer. Service Policies are used to define the terms of offer of a service offering. Policies could potentially apply to service-level, domain-level or technical (infrastructural) aspects. In this paper, we present a systematic model-driven development approach to deal with service policies from the perspective of a service provider. Our approach addresses the entire development spectrum of service policies. It addresses definition of service policies using visual models and attaching these policy models to service capability description models. It also addresses transforming these policy models to executable specifications and finally enforcing these policies during service invocation.

Evaluation of priority based real time scheduling algorithms: choices and tradeoffs

Real time scheduling algorithms like RM and EDF have been analyzed extensively in the literature. Many recent works on scheduling address energy consumption as a performance metric. In this work we analyze priority scheduling algorithms RM, EDF, and LLF along with a few power-aware scheduling algorithms: MLLF, RM_RCS and EDF_RCS. Our analysis addresses the following metrics: response time, response time jitter, latency, time complexity, preemptions, and energy consumption. We extend past work in this direction by characterizing the performance of the scheduling algorithms -- theoretically as well as experimentally. Results of our analysis can be used to control design choices for real time systems.

Parallelizing OPTICS for Commodity Clusters

In this paper, we propose an algorithm, DOPTICS, a parallelized version of a popular density based cluster-ordering algorithm OPTICS. Parallelizing OPTICS is challenging because of its strong sequential data access behavior. To achieve high parallelism, a data parallel approach that exploits the underlying indexing structure is proposed. We implement the proposed algorithm for processor nodes in a commodity cluster as well as across cores in a processor. Moreover, the clusters obtained by our algorithm are exactly same as that of classical OPTICS unlike the only existing implementation of the parallel OPTICS. We demonstrate the performance of the proposed algorithm on a commodity cluster which is typically a combination of distributed and shared memory systems. Experimental results on several large real and synthetic data sets with varying dimensions are presented to show speed up and scalability achieved. The speed up obtained is remarkable and is found to scale well with increasing number of processing elements. Performance improvements of the proposed DOPTICS algorithm are due to algorithmic optimizations and parallelization strategy.

Differentiating Commoditized Services in a Services Marketplace

In a services marketplace where a service is provided by multiple service providers, service offerings have to be differentiated against competitor services. Differentiation helps to sustain as well as grow market share. Strategies to differentiate service offerings have to be unintrusive - without requiring major changes to the existing service realization mechanisms. In this paper, we present a strategy for service providers to differentiate their commoditized services. We show how to identify and document differentiating aspects of a service. By unintrusively manipulating these differentiation aspects we can differentiate services from that of competition. We specify these differentiating aspects as service policies using the WS-Policy framework.

Real-time monitoring of network latency in Software Defined Networks

Latency in a network is an important parameter that can be utilized by Service providers and end users alike. Delay on a network path is often measured using end-to-end probing packets. When multiple end systems measure end-to-end latency, there are overlaps in their paths. Since end systems do not have this knowledge, it results in redundant work and network overhead. In this paper, we propose a method to measure end-to-end path latency in Software Defined Networks (SDN). This method avoids redundant work and measures latency in real-time. Our proposal is an improvement over the looping technique. We simplified the looping technique by using IP TTL as a counter. In order to avoid duplicate work, latency is measured per link and stored in the controller. End systems may register their flow labels with the SDN controller to receive latency information. For each registered flow, controller composes individual link latencies on that path to compute end-to-end latency. We also propose another approach to measure latency using queue lengths at network switches. This technique removes network overhead. In our simulations, improved looping technique is found to be giving better results with reduced computational and network overhead, while the proposed queue length technique shows comparable results.

Scalable Parallel Algorithms for Shared Nearest Neighbor Clustering

Clustering is a popular data mining technique which discovers structure in unlabeled data by grouping objects together on the basis of a similarity criterion. Traditional similarity measures lose their meaning as the number of dimensions increases and as a consequence, distance or density based clustering algorithms become less meaningful. Shared Nearest Neighbor (SNN) is a solution to clustering high-dimensional data with the ability to find clusters of varying density. SNN assigns objects to a cluster, which share a large number of their nearest neighbors. However, SNN is compute and memory intensive for data of large size and/or dimensionality. Nearest neighbor queries are responsible for a major proportion of computations in SNN, resulting in lower efficiency for higher value of number of nearest neighbors (k). The main motivation of this work is to improve the efficiency of SNN and to parallelize it so that it can be used for clustering large high-dimensional datasets and for large values of k. Existing SNN algorithms become inefficient in these situations. In this paper, we present a new sequential SNN algorithm, R-SNN, which uses R-tree for executing neighborhood queries efficiently and exploiting spatial locality to minimize memory usage. R-SNN is benchmarked against the best available implementation of SNN and is found up to 77 times faster when tested on various real datasets. R-SNN is parallelized for distributed memory, shared memory, and hybrid systems. Significant speedup and scalability achieved can be attributed to parallelization and good load balancing strategies and also to exploitation of spatial locality. Experimental results demonstrate the same for datasets of varying dimensionality and size. The maximum speedup achieved for shared, distributed, and hybrid models are 427.19 using 48 threads, 394.24 using 32 processes, and 1380.69 on 32 nodes (with each node spawning 4 threads), respectively. Super-linear speedup for some datasets is attributed to optimized neighborhood queries. All the proposed algorithms produce identical clustering results as that of the classical SNN.

A Parallel Framework for Grid-Based Bottom-Up Subspace Clustering

Clustering is a popular data mining and machine learning technique which discovers interesting patterns from unlabeled data by grouping similar objects together. Clustering high-dimensional data is a challenging task as points in high dimensional space are nearly equidistant from each other, rendering commonly used similarity measures ineffective. Subspace clustering has emerged as a possible solution to the problem of clustering high-dimensional data. In subspace clustering, we try to find clusters in different subspaces within a dataset. Many subspace clustering algorithms have been proposed in the last two decades to find clusters in multiple overlapping subspaces of high-dimensional data. Subspace clustering algorithms iteratively find the best subset of dimensions for a cluster from 2d–1 possible combinations in d-dimensional data. Subspace clustering is extremely compute intensive because of exhaustive search of subspaces, especially in the bottom-up subspace clustering algorithms. To address this issue, an efficient parallel framework for grid-based bottom-up subspace clustering algorithms is developed, considering popular algorithms belonging to this category. The framework is implemented for shared memory, distributed memory, and hybrid systems and is tested for three grid-based bottom-up subspace clustering algorithms: CLIQUE, MAFIA, and ENCLUS. All parallel implementations exhibit impressive speedup and scalability on real datasets.