@article {19485,
	title = {A study of unpredictability in fault-tolerant middleware},
	journal = {Computer Networks},
	volume = {57},
	year = {2013},
	month = {2013/02/26/},
	pages = {682 - 698},
	abstract = {In enterprise applications relying on fault-tolerant middleware, it is a common engineering practice to establish service-level agreements (SLAs) based on the 95th or the 99th percentiles of the latency, to allow a margin for unexpected variability. However, the extent of this unpredictability has not been studied systematically. We present an extensive empirical study of unpredictability in 16 distributed systems, ranging from simple transport protocols to fault-tolerant, middleware-based enterprise applications, and we show that the inherent unpredictability in the systems examined arises from at most 1\% of the remote invocations. In the normal, fault-free operating mode most remote invocations have a predictable end-to-end latency, but the maximum latency follows unpredictable trends and is comparable with the time needed to recover from a fault. The maximum latency is not influenced by the system{\textquoteright}s workload, cannot be regulated through configuration parameters and is not correlated with the system{\textquoteright}s resource consumption. The high-latency outliers (up to three orders of magnitude higher than the average latency) have multiple causes and may originate in any component of the system. However, after filtering out 1\% of the invocations with the highest recorded response-times, the latency becomes bounded with high statistical confidence (p \&lt; 0.01). We have verified this result on different operating systems (Linux 2.4, Linux 2.6, Linux-rt, TimeSys), middleware platforms (CORBA and EJB), programming languages (C, C++ and Java), replication styles (active and warm passive) and applications (e-commerce and online gaming). Moreover, this phenomenon occurs at all the layers of middleware-based systems, from the communication protocols to the business logic.},
	keywords = {Fault tolerance, latency, Middleware, Remote procedure call, Unpredictability},
	isbn = {1389-1286},
	url = {http://www.sciencedirect.com/science/article/pii/S1389128612003696},
	author = {Tudor Dumitras and Narasimhan, Priya}
}
@conference {15486,
	title = {Prioritizing component compatibility tests via user preferences},
	booktitle = {Software Maintenance, 2009. ICSM 2009. IEEE International Conference on},
	year = {2009},
	month = {2009/09//},
	pages = {29 - 38},
	abstract = {Many software systems rely on third-party components during their build process. Because the components are constantly evolving, quality assurance demands that developers perform compatibility testing to ensure that their software systems build correctly over all deployable combinations of component versions, also called configurations. However, large software systems can have many configurations, and compatibility testing is often time and resource constrained. We present a prioritization mechanism that enhances compatibility testing by examining the ldquomost importantrdquo configurations first, while distributing the work over a cluster of computers. We evaluate our new approach on two large scientific middleware systems and examine tradeoffs between the new prioritization approach and a previously developed lowest-cost-configuration-first approach.},
	keywords = {compatibility testing prioritization, component configurations, computer clusters, Middleware, Middleware systems, object-oriented programming, program testing, software engineering, Software systems, third-party components, user preferences},
	doi = {10.1109/ICSM.2009.5306357},
	author = {Yoon,Il-Chul and Sussman, Alan and Memon, Atif M. and Porter, Adam}
}
@conference {16506,
	title = {Capturing Approximated Data Delivery Tradeoffs},
	booktitle = {Data Engineering, 2008. ICDE 2008. IEEE 24th International Conference on},
	year = {2008},
	month = {2008/04//},
	pages = {1471 - 1473},
	abstract = {This paper presents a middleware data delivery setting with a proxy that is required to maximize the completeness of captured updates, specified in its clients{\textquoteright} profiles, while minimizing at the same time the delay in delivering the updates to clients. The two objectives may conflict when the monitoring budget is limited. Therefore, any solution should consider this tradeoff in satisfying both objectives. We term this problem the "proxy dilemma" and formalize it as a biobjective optimization problem. Such problem occurs in many contemporary applications, such as mobile and sensor networks, and poses scalability challenges in delivering up-to-date data from remote resources to meet client specifications. We present a Pareto set as a formal solution to the proxy dilemma. We discuss the complexity of generating a Pareto set for the proxy dilemma and suggest an approximation scheme to this problem.},
	keywords = {approximation scheme, approximation theory, biobjective optimization problem, Middleware, middleware data delivery tradeoffs, mobile networks, Pareto optimisation, Pareto set, proxy dilemma problem, sensor networks},
	doi = {10.1109/ICDE.2008.4497593},
	author = {Roitman,H. and Gal,A. and Raschid, Louiqa}
}
@conference {17887,
	title = {Comparing the Performance of High-Level Middleware Systems in Shared and Distributed Memory Parallel Environments},
	booktitle = {Parallel and Distributed Processing Symposium, 2005. Proceedings. 19th IEEE International},
	year = {2005},
	month = {2005/04//},
	pages = {30 - 30},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {The utilization of toolkits for writing parallel and/or distributed applications has been shown to greatly enhance developer{\textquoteright}s productivity. Such an approach hides many of the complexities associated with writing these applications, rather than relying solely on programming language aids and parallel library support, such as MPI or PVM. In this work, we evaluate three different middleware systems that have been used to implement a computation and I/O-intensive data analysis application from the domain of computer vision. This study shows the benefits and overheads associated with each of the middleware systems, in different homogeneous computational environments and with different workloads. Our results lead the way toward being able to make better decisions for tuning the application environment, for selecting the appropriate middleware, and also for designing more powerful middleware systems to efficiently build and run highly complex applications in both parallel and distributed computing environments.},
	keywords = {Application software, Computer science, Computer vision, Data analysis, Distributed computing, distributed computing environment, distributed memory parallel environment, distributed shared memory systems, Educational institutions, high-level middleware system, I/O-intensive data analysis application, Libraries, Middleware, parallel computing environment, parallel library support, parallel memories, programming language, programming languages, Runtime environment, shared memory parallel environment, Writing},
	isbn = {0-7695-2312-9},
	doi = {10.1109/IPDPS.2005.144},
	author = {Kim,Jik-Soo and Andrade,H. and Sussman, Alan}
}
@conference {14811,
	title = {Automated cluster-based Web service performance tuning},
	booktitle = {13th IEEE International Symposium on High performance Distributed Computing, 2004. Proceedings},
	year = {2004},
	month = {2004/06/04/6},
	pages = {36 - 44},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Active harmony provides a way to automate performance tuning. We apply the Active Harmony system to improve the performance of a cluster-based web service system. The performance improvement cannot easily be achieved by tuning individual components for such a system. The experimental results show that there is no single configuration for the system that performs well for all kinds of workloads. By tuning the parameters, Active Harmony helps the system adapt to different workloads and improve the performance up to 16\%. For scalability, we demonstrate how to reduce the time when tuning a large system with many tunable parameters. Finally an algorithm is proposed to automatically adjust the structure of cluster-based web systems, and the system throughput is improved up to 70\% using this technique.},
	keywords = {Active Harmony system, automated performance tuning, business, cluster-based Web service system, Clustering algorithms, Computer science, Educational institutions, electronic commerce, Internet, Middleware, performance evaluation, scalability, Throughput, Transaction databases, Web server, Web services, workstation clusters},
	isbn = {0-7695-2175-4},
	doi = {10.1109/HPDC.2004.1323484},
	author = {Chung,I. -H and Hollingsworth, Jeffrey K}
}
@article {12805,
	title = {Formal Modeling Of Middleware-based Distributed Systems},
	journal = {Electronic Notes in Theoretical Computer Science},
	volume = {108},
	year = {2004},
	month = {2004/12/13/},
	pages = {21 - 37},
	abstract = {Effective design of middleware-based systems requires modeling notations that allow the use of process-interaction schemes provided by different middleware packages directly in designs. Traditional design notations typically only support a fixed class of interprocess interaction schemes, and designers wishing to use them for modeling middleware-based systems must devote significant effort to encoding the middleware primitives in the notation. In this paper, we demonstrate how a new graphical design notation, Architectural Interaction Diagrams (AIDs), which provides parameterized support for different interaction schemes, may be used to model a real-life middleware-based system like the Event Heap coordination infrastructure of the i-Room ubiquitous computing environment.},
	keywords = {distributed systems, Formal Methods, Middleware, Software architecture},
	isbn = {1571-0661},
	doi = {10.1016/j.entcs.2004.01.010},
	url = {http://www.sciencedirect.com/science/article/pii/S1571066104051989},
	author = {Ray,Arnab and Cleaveland, Rance}
}
@article {15498,
	title = {Preserving distributed systems critical properties: a model-driven approach},
	journal = {Software, IEEE},
	volume = {21},
	year = {2004},
	month = {2004///},
	pages = {32 - 40},
	abstract = {The need for creating predictability in distributed systems is most often specified in terms of quality-of-service (QoS) requirements, which help define the acceptable levels of dependability with which capabilities such as processing capacity, data throughput, or service availability reach users. For longer-term properties such as scalability, maintainability, adaptability, and system security, we can similarly use persistent software attributes (PSAs) to specify how and to what degree such properties must remain intact as a network expands and evolves over time. The Skoll distributed continuous software quality assurance process helps to identify viable system and software configurations for meeting stringent QOS and PSA requirements by coordinating the use of distributed computing resources. The authors tested their process using the large, rapidly evolving ACE+TAO middleware suite.},
	keywords = {configuration management, formal verification, Middleware, middleware suite, model-driven approach, persistent software attributes, QoS requirements, Quality assurance, quality of service, quality-of-service, Skoll distributed computing resources, software configuration, Software maintenance, Software quality, software quality assurance process, system dependability},
	isbn = {0740-7459},
	doi = {10.1109/MS.2004.50},
	author = {Yilmaz,C. and Memon, Atif M. and Porter, Adam and Krishna,A. S and Schmidt,D. C and Gokhale,A. and Natarajan,B.}
}
@article {18652,
	title = {An adaptive quality of service aware middleware for replicated services},
	journal = {Parallel and Distributed Systems, IEEE Transactions on},
	volume = {14},
	year = {2003},
	month = {2003/11//},
	pages = {1112 - 1125},
	abstract = {A dependable middleware should be able to adaptively share the distributed resources it manages in order to meet diverse application requirements, even when the quality of service (QoS) is degraded due to uncertain variations in load and unanticipated failures. We have addressed this issue in the context of a dependable middleware that adaptively manages replicated servers to deliver a timely and consistent response to time-sensitive client applications. These applications have specific temporal and consistency requirements, and can tolerate a certain degree of relaxed consistency in exchange for better response time. We propose a flexible QoS model that allows clients to specify their timeliness and consistency constraints. We also propose an adaptive framework that dynamically selects replicas to service a client{\textquoteright}s request based on the prediction made by probabilistic models. These models use the feedback from online performance monitoring of the replicas to provide probabilistic guarantees for meeting a client{\textquoteright}s QoS specification. The experimental results we have obtained demonstrate the role of feedback and the efficacy of simple analytical models for adaptively sharing the available replicas among the users under different workload scenarios.},
	keywords = {distributed resource sharing, Middleware, online performance monitoring, probabilistic modeling, QoS specification, quality of service, replica consistency, replicated services, resource allocation, time-sensitive client applications, timeliness constraints},
	isbn = {1045-9219},
	doi = {10.1109/TPDS.2003.1247672},
	author = {Krishnamurthy,Sudha and Sanders,W. H. and Michel Cukier}
}
@conference {17878,
	title = {Improving access to multi-dimensional self-describing scientific datasets},
	booktitle = {3rd IEEE/ACM International Symposium on Cluster Computing and the Grid, 2003. Proceedings. CCGrid 2003},
	year = {2003},
	month = {2003/05/12/15},
	pages = {172 - 179},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Applications that query into very large multidimensional datasets are becoming more common. Many self-describing scientific data file formats have also emerged, which have structural metadata to help navigate the multi-dimensional arrays that are stored in the files. The files may also contain application-specific semantic metadata. In this paper, we discuss efficient methods for performing searches for subsets of multi-dimensional data objects, using semantic information to build multidimensional indexes, and group data items into properly sized chunks to maximize disk I/O bandwidth. This work is the first step in the design and implementation of a generic indexing library that will work with various high-dimension scientific data file formats containing semantic information about the stored data. To validate the approach, we have implemented indexing structures for NASA remote sensing data stored in the HDF format with a specific schema (HDF-EOS), and show the performance improvements that are gained from indexing the datasets, compared to using the existing HDF library for accessing the data.},
	keywords = {Application software, application-specific semantic metadata, Bandwidth, Computer science, database indexing, disk I/O bandwidth, distributed databases, Educational institutions, Indexing, indexing structures, Libraries, meta data, Middleware, multidimensional arrays, multidimensional datasets, Multidimensional systems, NASA, NASA remote sensing data, Navigation, query formulation, self-describing scientific data file formats, structural metadata, very large databases},
	isbn = {0-7695-1919-9},
	doi = {10.1109/CCGRID.2003.1199366},
	author = {Nam,B. and Sussman, Alan}
}
@conference {18684,
	title = {Performance evaluation of a probabilistic replica selection algorithm},
	year = {2002},
	month = {2002///},
	pages = {119 - 127},
	abstract = {When executing time-sensitive distributed applications, a middleware that provides dependability and timeliness is faced with the important problem of preventing timing failures both under normal conditions and when the quality of service is degraded due to replica failures and transient overload on the server. To address this problem, we have designed a probabilistic model-based replica selection algorithm that allows a middleware to choose a set of replicas to service a client based on their ability to meet a client{\textquoteright}s timeliness requirements. This selection is done based on the prediction made by a probabilistic model that uses the performance history of replicas as inputs. In this paper, we describe the experiments we have conducted to evaluate the ability of this dynamic selection algorithm to meet a client{\textquoteright}s timing requirements, and compare it with that of a static and round-robin selection scheme under different scenarios},
	keywords = {client-server systems, Dependability, distributed object management, dynamic selection algorithm, Middleware, probabilistic model, probabilistic model-based replica selection algorithm, probability, quality of service, real-time systems, replica failures, round-robin selection scheme, static scheme, time-sensitive distributed applications, timeliness, timing failures, transient overload},
	doi = {10.1109/WORDS.2002.1000044},
	author = {Krishnamurthy, S. and Sanders,W. H. and Michel Cukier}
}
@conference {16779,
	title = {Integrating distributed scientific data sources with MOCHA and XRoaster},
	booktitle = {Thirteenth International Conference on Scientific and Statistical Database Management, 2001. SSDBM 2001. Proceedings},
	year = {2001},
	month = {2001///},
	pages = {263 - 266},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {MOCHA is a novel middleware system for integrating distributed data sources that we have developed at the University of Maryland. MOCHA is based on the idea that the code that implements user-defined types and functions should be automatically deployed to remote sites by the middleware system itself. To this end, we have developed an XML-based framework to specify metadata about data sites, data sets, and user-defined types and functions. XRoaster is a graphical tool that we have developed to help the user create all the XML metadata elements to be used in MOCHA},
	keywords = {client-server systems, data sets, data sites, Databases, Distributed computing, distributed databases, distributed scientific data source integration, Educational institutions, graphical tool, hypermedia markup languages, IP networks, java, Large-scale systems, Maintenance engineering, meta data, metadata, Middleware, middleware system, MOCHA, Query processing, remote sites, scientific information systems, user-defined types, visual programming, XML, XML metadata elements, XML-based framework, XRoaster},
	isbn = {0-7695-1218-6},
	doi = {10.1109/SSDM.2001.938560},
	author = {Rodriguez-Martinez,M. and Roussopoulos, Nick and McGann,J. M and Kelley,S. and Mokwa,J. and White,B. and Jala,J.}
}
