Abstract: The use of virtual machines to provide cloud-based services is becoming increasingly popular. A key consideration for cloud hosts is maximizing server usage while maintaining reliable levels of service. In most situations, this is no issue: a single high-end machine can comfortably run many VMs under common usage. However, in certain scenarios one VM can degrade performance for other VMs on the same node. High rates of reads or writes can crowd out other I/O operations in the remaining guests. Commercial clouds are built upon billable units of computing power and resource access, and thus no guest should suffer performance decreases due to other VMs activity. If this model is disrupted by hardware contention, the illusion is broken. Currently, the only solution to this problem is to over-provision hardware for customers. Lacking an efficient quality guarantee mechanism hosts must dedicated single machines to guarantee performance. In order to ensure a stable computing environment, resource limits must be introduced into VMs. Restricting each VM to a fixed ceiling for IOPS, CPU, and memory allows customers to pay for exactly what they use. Further this prevents an inflated perception of performance that is broken when neighboring VMs receive heavy traffic. We consider two options for future implementation: a counter-based hard limiting mechanism and a buffer-managing solution that injects false requests as necessary.
Poster | Presentation | Final project report | Back to topAbstract: NoSQL databases are a new category of databases that break from the traditional relational model. Modern relational databases have been shown to have poor performance for certain applications, such as storing a large number of documents or serving high-traffic content over distributed systems. NoSQL databases, in general, sacrifice consistency for higher availability and often employ a distributed model for higher scalability. Our project focuses on evaluating the differences and potential uses of NoSQL databases as compared to relational databases such as MySQL. Toward that end, we have developed a demo application implemented using MySQL and two NoSQL databases, Cassandra and HBase, and compared the throughput and latency of HBase and Cassandra by generating and benchmarking various workloads.
Poster | Presentation | Final project report | Back to topAbstract: In modern day distributed systems computing, good
performance is essential to accomplish the work that the system has
been tasked for. For a lot of distributed systems, this performance
comes in terms of its abilities to pass messages across the system to
perform its tasks. For optimum performance, a good scalable message
system needs to be used.
We teamed up with Rackspace US, with the help of Gabe Westmaas. On
their systems, they use a variant of the Advanced Message Queuing
Protocol (AMQP), called RabbitMQ. RabbitMQ is used as a broker to
control the sending and receiving of messages. It can be used in two
ways, one with a queue-like system, and the other in a
publisher-subscribe message system using an exchange. We were given
access to six servers with RabbitMQ installed upon them, three in
Dallas and three in Chicago. Our goal was to analyze the scalability
of the RabbitMQ architecture, and to see if it is a feasible system to
use in large-scale applications. We tested by varying the number of
subscribers and publishers in a node, which was accomplished by
clustering nodes into groups and seeing how performance increased or
decreased with the combinations of node. Another parameter that we
controlled for scalability was the number of messages sent in a
test. For us, we used either 4K messages a set or 16K messages a set.
Our results were gathered by timing the transit time of the messages,
if they were received in order, and the latency that would occur
between different locations.