This presentation reveals many important aspects of the CUBRID Database, including its unique features, future roadmap, comparison with other databases, architecture, etc.
This project report analyzes the performance of Docker containers running MySQL databases with increasing I/O workloads. The authors created Docker containers with MySQL images and loaded them with data using the TPC-C benchmark. They collected performance metrics like I/O entries, size, CPU utilization, and read/write ratios using tools like blktrace, iostat, and tpmc as the number of containers increased from 1 to 6. The analysis showed the optimal number of containers was 3, as performance metrics like I/O entries and size peaked at this point before declining with more containers.
Why stop the world when you can change it? Design and implementation of Incre...confluent
Since its initial release, the Kafka group membership protocol has offered Connect, Streams and Consumer applications an ingenious and robust way to balance resources among distributed processes. The process of rebalancing, as it's widely known, allows Kafka APIs to define an embedded protocol for load balancing within the group membership protocol itself. Until now, rebalancing has been working under the simple assumption that every time a new group generation is created, the members join after first releasing all of their resources, getting a whole new load assignment by the time the new group is formed. This allows Kafka APIs to provide task fault-tolerance and elasticity on top of the group membership protocol. However, due to its side-effects on multi-tenancy and scalability this simple approach in rebalancing, also known as stop-the-world effect, is limiting larger scale deployments. Because of stop-the-world, application tasks get interrupted only for most of them to receive the same resources after rebalancing. In this technical deep dive, I'll discuss the proposition of Incremental Cooperative Rebalancing as a way to alleviate stop-the-world and optimize rebalancing in Kafka APIs. We'll cover: * The internals of Incremental Cooperative Rebalancing * Uses cases that benefit from Incremental Cooperative Rebalancing * Implementation in Kafka Connect * Performance results in Kafka Connect clusters
Oracle rac cachefusion - High Availability Day 2015aioughydchapter
RAC Cache Fusion allows Oracle Real Application Clusters instances to share cached data in memory to avoid disk I/O and improve performance. Key aspects of Cache Fusion include global cache services coordinating cached data across instances, maintaining data consistency through modes and roles for cached blocks, and keeping past images of dirty blocks for recovery purposes. Cache blocks can be accessed locally or globally depending on their assigned role and mode.
The document introduces the Infinispan data grid platform. It discusses how Infinispan can be used as a distributed in-memory cache both as a library and server. Key features of Infinispan are clustering, persistence, transactions, querying, and map-reduce capabilities. Examples of using Infinispan for session clustering and as a state store for Storm processing are provided.
고급 자바 8 교육 (6일 중 6일차)
티맥스소프트 연구소에 연구소장으로 재직 중이던 2013년 10월에 진행한 자바 언어 강의 내용입니다.
JVM에 대한 이해와 Java 8에 대한 소개를 포함하려고 노력하였습니다.
아래 강의 동영상이 있습니다.
http://javadom.blogspot.com/2017/07/8-6.html
MySQL and Spark machine learning performance on Azure VMsbased on 3rd Gen AMD...Principled Technologies
If your organization is one of the many that are shifting critical applications to the cloud, you know that cloud service providers offer a staggering number of virtual machine options. In your quest for the best performance, an important factor to consider is the processor that powers the VMs.
This presentation reveals many important aspects of the CUBRID Database, including its unique features, future roadmap, comparison with other databases, architecture, etc.
This project report analyzes the performance of Docker containers running MySQL databases with increasing I/O workloads. The authors created Docker containers with MySQL images and loaded them with data using the TPC-C benchmark. They collected performance metrics like I/O entries, size, CPU utilization, and read/write ratios using tools like blktrace, iostat, and tpmc as the number of containers increased from 1 to 6. The analysis showed the optimal number of containers was 3, as performance metrics like I/O entries and size peaked at this point before declining with more containers.
Why stop the world when you can change it? Design and implementation of Incre...confluent
Since its initial release, the Kafka group membership protocol has offered Connect, Streams and Consumer applications an ingenious and robust way to balance resources among distributed processes. The process of rebalancing, as it's widely known, allows Kafka APIs to define an embedded protocol for load balancing within the group membership protocol itself. Until now, rebalancing has been working under the simple assumption that every time a new group generation is created, the members join after first releasing all of their resources, getting a whole new load assignment by the time the new group is formed. This allows Kafka APIs to provide task fault-tolerance and elasticity on top of the group membership protocol. However, due to its side-effects on multi-tenancy and scalability this simple approach in rebalancing, also known as stop-the-world effect, is limiting larger scale deployments. Because of stop-the-world, application tasks get interrupted only for most of them to receive the same resources after rebalancing. In this technical deep dive, I'll discuss the proposition of Incremental Cooperative Rebalancing as a way to alleviate stop-the-world and optimize rebalancing in Kafka APIs. We'll cover: * The internals of Incremental Cooperative Rebalancing * Uses cases that benefit from Incremental Cooperative Rebalancing * Implementation in Kafka Connect * Performance results in Kafka Connect clusters
Oracle rac cachefusion - High Availability Day 2015aioughydchapter
RAC Cache Fusion allows Oracle Real Application Clusters instances to share cached data in memory to avoid disk I/O and improve performance. Key aspects of Cache Fusion include global cache services coordinating cached data across instances, maintaining data consistency through modes and roles for cached blocks, and keeping past images of dirty blocks for recovery purposes. Cache blocks can be accessed locally or globally depending on their assigned role and mode.
The document introduces the Infinispan data grid platform. It discusses how Infinispan can be used as a distributed in-memory cache both as a library and server. Key features of Infinispan are clustering, persistence, transactions, querying, and map-reduce capabilities. Examples of using Infinispan for session clustering and as a state store for Storm processing are provided.
고급 자바 8 교육 (6일 중 6일차)
티맥스소프트 연구소에 연구소장으로 재직 중이던 2013년 10월에 진행한 자바 언어 강의 내용입니다.
JVM에 대한 이해와 Java 8에 대한 소개를 포함하려고 노력하였습니다.
아래 강의 동영상이 있습니다.
http://javadom.blogspot.com/2017/07/8-6.html
MySQL and Spark machine learning performance on Azure VMsbased on 3rd Gen AMD...Principled Technologies
If your organization is one of the many that are shifting critical applications to the cloud, you know that cloud service providers offer a staggering number of virtual machine options. In your quest for the best performance, an important factor to consider is the processor that powers the VMs.
This document discusses ZooKeeper, an open-source server that enables distributed coordination. It provides instructions for installing ZooKeeper, describes ZooKeeper's data tree and API, and exercises for interacting with ZooKeeper including creating znodes, using watches, and setting up an ensemble across multiple servers.
Connection Pooling in PostgreSQL using pgbouncer Sameer Kumar
The presentation was presented at 5th Postgres User Group, Singapore.
It explain how to setup pgbouncer and also shows a few demonstration graphs comparing the advantages/gains in performance when using pgbouncer instead of direct connections to PostgreSQL database.
This document outlines an agenda for a presentation on Hadoop security. The agenda includes an overview of Hadoop, concepts of Hadoop security, Kerberos, Hadoop security design, and how to implement Hadoop security. The presenter is introduced as the lead of big data platform development at Gruter Inc. and an Apache Tajo committer.
This presentation overviews basic principles of high availability architectures and presents how to deploy in high availability FIWARE data management services.
A brief introduction to Hadoop distributed file system. How a file is broken into blocks, written and replicated on HDFS. How missing replicas are taken care of. How a job is launched and its status is checked. Some advantages and disadvantages of HDFS-1.x
The Google search architecture uses large clusters of commodity servers to power its web search capabilities. It achieves high performance at low cost through extensive parallelization across many servers and by prioritizing overall throughput over peak performance of individual servers. The architecture relies on software for reliability rather than expensive fault-tolerant hardware. This allows Google to build clusters from thousands of inexpensive, standard servers rather than fewer high-end machines.
- The document describes installing Oracle Real Application Clusters (RAC) and Cluster Ready Services (CRS) on a two-node Windows cluster.
- It involves a two phase installation - first installing and configuring CRS, then installing the Oracle Database with RAC.
- Key steps include configuring shared disks and partitions for the Oracle Cluster Registry, voting disk, and Automatic Storage Management; installing and configuring CRS; and then installing Oracle Database with RAC.
Introduction to Apache ZooKeeper | Big Data Hadoop Spark Tutorial | CloudxLabCloudxLab
Big Data with Hadoop & Spark Training: http://bit.ly/2kvXlPd
This CloudxLab Introduction to Apache ZooKeeper tutorial helps you to understand ZooKeeper in detail. Below are the topics covered in this tutorial:
1) Data Model
2) Znode Types
3) Persistent Znode
4) Sequential Znode
5) Architecture
6) Election & Majority Demo
7) Why Do We Need Majority?
8) Guarantees - Sequential consistency, Atomicity, Single system image, Durability, Timeliness
9) ZooKeeper APIs
10) Watches & Triggers
11) ACLs - Access Control Lists
12) Usecases
13) When Not to Use ZooKeeper
Solr Exchange: Introduction to SolrCloudthelabdude
SolrCloud is a set of features in Apache Solr that enable elastic scaling of search indexes using sharding and replication. In this presentation, Tim Potter will provide an architectural overview of SolrCloud and highlight its most important features. Specifically, Tim covers topics such as: sharding, replication, ZooKeeper fundamentals, leaders/replicas, and failure/recovery scenarios. Any discussion of a complex distributed system would not be complete without a discussion of the CAP theorem. Mr. Potter will describe why Solr is considered a CP system and how that impacts the design of a search application.
The document describes the Google File System (GFS), which was developed by Google to handle its large-scale distributed data and storage needs. GFS uses a master-slave architecture with the master managing metadata and chunk servers storing file data in 64MB chunks that are replicated across machines. It is designed for high reliability and scalability handling failures through replication and fast recovery. Measurements show it can deliver high throughput to many concurrent readers and writers.
PostgreSQL is a free and open-source relational database management system that provides high performance and reliability. It supports replication through various methods including log-based asynchronous master-slave replication, which the presenter recommends as a first option. The upcoming PostgreSQL 9.4 release includes improvements to replication such as logical decoding and replication slots. Future releases may add features like logical replication consumers and SQL MERGE statements. The presenter took questions at the end and provided additional resources on PostgreSQL replication.
This document provides an overview of the Google File System (GFS). It describes the key components of GFS including the master server, chunkservers, and clients. The master manages metadata like file namespaces and chunk mappings. Chunkservers store file data in 64MB chunks that are replicated across servers. Clients read and write chunks through the master and chunkservers. GFS provides high throughput and fault tolerance for Google's massive data storage and analysis needs.
This document provides instructions for converting an existing standard 2-node Oracle RAC environment to use Flex Clusters and Flex ASM in Oracle 12c. It describes Flex Clusters, which introduce Hub and Leaf nodes, and Flex ASM, which allows ASM instances to run on separate physical servers. The instructions show how to check the current cluster and ASM modes, and then use the ASM Configuration Assistant GUI to convert to Flex ASM, selecting the default listener and private interconnect for ASM network traffic.
JavaOne 2016
JMS is pretty simple, right? Once you’ve mastered topics and queues, the rest can appear trivial, but that isn’t the case. The queuing system, whether ActiveMQ, OpenMQ, or WebLogic JMS, provides many more features and settings than appear in the Java EE documentation. This session looks at some of the important extended features and configuration settings. What would you need to optimize if your messages are large or you need to minimize prefetching? What is the best way to implement time-delayed messages? The presentation also looks at dangerous bugs that can be introduced via simple misconfigurations with pooled beans. The JMS APIs are deceptively simple, but getting an implementation into production and tuned correctly can be a bit trickier.
Building a near real time search engine & analytics for logs using solrlucenerevolution
Presented by Rahul Jain, System Analyst (Software Engineer), IVY Comptech Pvt Ltd
Consolidation and Indexing of logs to search them in real time poses an array of challenges when you have hundreds of servers producing terabytes of logs every day. Since the log events mostly have a small size of around 200 bytes to few KBs, makes it more difficult to handle because lesser the size of a log event, more the number of documents to index. In this session, we will discuss the challenges faced by us and solutions developed to overcome them. The list of items that will be covered in the talk are as follows.
Methods to collect logs in real time.
How Lucene was tuned to achieve an indexing rate of 1 GB in 46 seconds
Tips and techniques incorporated/used to manage distributed index generation and search on multiple shards
How choosing a layer based partition strategy helped us to bring down the search response times.
Log analysis and generation of analytics using Solr.
Design and architecture used to build the search platform.
Google File System (GFS) is a distributed file system designed for large streaming reads and appends on inexpensive commodity hardware. It uses a master-chunk server architecture to manage the placement of large files across multiple machines, provides fault tolerance through replication and versioning, and aims to balance high throughput and availability even in the presence of frequent failures. The consistency model allows for defined and undefined regions to support the needs of batch-oriented, data-intensive applications like MapReduce.
An investigation into Cluster CPU load balancing in the JVMCalum Beck
This was my dissertation piece for my Software Engineering Degree.
The JVM CPU Cluster Balancer is a scalable, proof of concept system designed to distribute processes over a network to perform multiple tasks at once, in a language of high abstraction. Once distributed, workers return results to an access server, all while monitoring their respective CPUs for computational stress in terms of CPU usage. CPU’s incurring set stress then have their respective processes moved to a less intensive area in the cluster, balancing work overall.
Understanding Data Consistency in Apache CassandraDataStax
This document provides an overview of data consistency in Apache Cassandra. It discusses how Cassandra writes data to commit logs and memtables before flushing to SSTables. It also reviews the CAP theorem and how Cassandra offers tunable consistency levels for both reads and writes. Strategies for choosing consistency levels for writes, such as ANY, ONE, QUORUM, and ALL are presented. The document also covers read repair and hinted handoffs in Cassandra. Examples of CQL queries with different consistency levels are given and information on where to download Cassandra is provided at the end.
The document discusses several applications of parallel processing:
1. Airfoil design optimization utilizes parallel processors to simultaneously evaluate the aerodynamic performance of multiple airfoil geometries, greatly decreasing computational time.
2. Parallel databases can distribute queries across multiple processors, improving response time for online transactions and reducing time for complex queries through intra-query parallelism.
3. Weather forecasting uses parallel computers to quickly process huge volumes of environmental data through thousands of computational iterations needed to generate useful forecasts.
STUDY OF VARIOUS FACTORS AFFECTING PERFORMANCE OF MULTI-CORE PROCESSORSijdpsjournal
Advances in Integrated Circuit processing allow for more microprocessor design options. As Chip Multiprocessor system (CMP) become the predominant topology for leading microprocessors, critical components of the system are now integrated on a single chip. This enables sharing of computation resources that was not previously possible. In addition the virtualization of these computation resources exposes the system to a mix of diverse and competing workloads. On chip Cache memory is a resource of primary concern as it can be dominant in controlling overall throughput. This Paper presents analysis of various parameters affecting the performance of Multi-core Architectures like varying the number of cores, changes L2 cache size, further we have varied directory size from 64 to 2048 entries on a 4 node, 8 node 16 node and 64 node Chip multiprocessor which in turn presents an open area of research on multicore processors with private/shared last level cache as the future trend seems to be towards tiled architecture executing multiple parallel applications with optimized silicon area utilization and excellent performance.
This document discusses ZooKeeper, an open-source server that enables distributed coordination. It provides instructions for installing ZooKeeper, describes ZooKeeper's data tree and API, and exercises for interacting with ZooKeeper including creating znodes, using watches, and setting up an ensemble across multiple servers.
Connection Pooling in PostgreSQL using pgbouncer Sameer Kumar
The presentation was presented at 5th Postgres User Group, Singapore.
It explain how to setup pgbouncer and also shows a few demonstration graphs comparing the advantages/gains in performance when using pgbouncer instead of direct connections to PostgreSQL database.
This document outlines an agenda for a presentation on Hadoop security. The agenda includes an overview of Hadoop, concepts of Hadoop security, Kerberos, Hadoop security design, and how to implement Hadoop security. The presenter is introduced as the lead of big data platform development at Gruter Inc. and an Apache Tajo committer.
This presentation overviews basic principles of high availability architectures and presents how to deploy in high availability FIWARE data management services.
A brief introduction to Hadoop distributed file system. How a file is broken into blocks, written and replicated on HDFS. How missing replicas are taken care of. How a job is launched and its status is checked. Some advantages and disadvantages of HDFS-1.x
The Google search architecture uses large clusters of commodity servers to power its web search capabilities. It achieves high performance at low cost through extensive parallelization across many servers and by prioritizing overall throughput over peak performance of individual servers. The architecture relies on software for reliability rather than expensive fault-tolerant hardware. This allows Google to build clusters from thousands of inexpensive, standard servers rather than fewer high-end machines.
- The document describes installing Oracle Real Application Clusters (RAC) and Cluster Ready Services (CRS) on a two-node Windows cluster.
- It involves a two phase installation - first installing and configuring CRS, then installing the Oracle Database with RAC.
- Key steps include configuring shared disks and partitions for the Oracle Cluster Registry, voting disk, and Automatic Storage Management; installing and configuring CRS; and then installing Oracle Database with RAC.
Introduction to Apache ZooKeeper | Big Data Hadoop Spark Tutorial | CloudxLabCloudxLab
Big Data with Hadoop & Spark Training: http://bit.ly/2kvXlPd
This CloudxLab Introduction to Apache ZooKeeper tutorial helps you to understand ZooKeeper in detail. Below are the topics covered in this tutorial:
1) Data Model
2) Znode Types
3) Persistent Znode
4) Sequential Znode
5) Architecture
6) Election & Majority Demo
7) Why Do We Need Majority?
8) Guarantees - Sequential consistency, Atomicity, Single system image, Durability, Timeliness
9) ZooKeeper APIs
10) Watches & Triggers
11) ACLs - Access Control Lists
12) Usecases
13) When Not to Use ZooKeeper
Solr Exchange: Introduction to SolrCloudthelabdude
SolrCloud is a set of features in Apache Solr that enable elastic scaling of search indexes using sharding and replication. In this presentation, Tim Potter will provide an architectural overview of SolrCloud and highlight its most important features. Specifically, Tim covers topics such as: sharding, replication, ZooKeeper fundamentals, leaders/replicas, and failure/recovery scenarios. Any discussion of a complex distributed system would not be complete without a discussion of the CAP theorem. Mr. Potter will describe why Solr is considered a CP system and how that impacts the design of a search application.
The document describes the Google File System (GFS), which was developed by Google to handle its large-scale distributed data and storage needs. GFS uses a master-slave architecture with the master managing metadata and chunk servers storing file data in 64MB chunks that are replicated across machines. It is designed for high reliability and scalability handling failures through replication and fast recovery. Measurements show it can deliver high throughput to many concurrent readers and writers.
PostgreSQL is a free and open-source relational database management system that provides high performance and reliability. It supports replication through various methods including log-based asynchronous master-slave replication, which the presenter recommends as a first option. The upcoming PostgreSQL 9.4 release includes improvements to replication such as logical decoding and replication slots. Future releases may add features like logical replication consumers and SQL MERGE statements. The presenter took questions at the end and provided additional resources on PostgreSQL replication.
This document provides an overview of the Google File System (GFS). It describes the key components of GFS including the master server, chunkservers, and clients. The master manages metadata like file namespaces and chunk mappings. Chunkservers store file data in 64MB chunks that are replicated across servers. Clients read and write chunks through the master and chunkservers. GFS provides high throughput and fault tolerance for Google's massive data storage and analysis needs.
This document provides instructions for converting an existing standard 2-node Oracle RAC environment to use Flex Clusters and Flex ASM in Oracle 12c. It describes Flex Clusters, which introduce Hub and Leaf nodes, and Flex ASM, which allows ASM instances to run on separate physical servers. The instructions show how to check the current cluster and ASM modes, and then use the ASM Configuration Assistant GUI to convert to Flex ASM, selecting the default listener and private interconnect for ASM network traffic.
JavaOne 2016
JMS is pretty simple, right? Once you’ve mastered topics and queues, the rest can appear trivial, but that isn’t the case. The queuing system, whether ActiveMQ, OpenMQ, or WebLogic JMS, provides many more features and settings than appear in the Java EE documentation. This session looks at some of the important extended features and configuration settings. What would you need to optimize if your messages are large or you need to minimize prefetching? What is the best way to implement time-delayed messages? The presentation also looks at dangerous bugs that can be introduced via simple misconfigurations with pooled beans. The JMS APIs are deceptively simple, but getting an implementation into production and tuned correctly can be a bit trickier.
Building a near real time search engine & analytics for logs using solrlucenerevolution
Presented by Rahul Jain, System Analyst (Software Engineer), IVY Comptech Pvt Ltd
Consolidation and Indexing of logs to search them in real time poses an array of challenges when you have hundreds of servers producing terabytes of logs every day. Since the log events mostly have a small size of around 200 bytes to few KBs, makes it more difficult to handle because lesser the size of a log event, more the number of documents to index. In this session, we will discuss the challenges faced by us and solutions developed to overcome them. The list of items that will be covered in the talk are as follows.
Methods to collect logs in real time.
How Lucene was tuned to achieve an indexing rate of 1 GB in 46 seconds
Tips and techniques incorporated/used to manage distributed index generation and search on multiple shards
How choosing a layer based partition strategy helped us to bring down the search response times.
Log analysis and generation of analytics using Solr.
Design and architecture used to build the search platform.
Google File System (GFS) is a distributed file system designed for large streaming reads and appends on inexpensive commodity hardware. It uses a master-chunk server architecture to manage the placement of large files across multiple machines, provides fault tolerance through replication and versioning, and aims to balance high throughput and availability even in the presence of frequent failures. The consistency model allows for defined and undefined regions to support the needs of batch-oriented, data-intensive applications like MapReduce.
An investigation into Cluster CPU load balancing in the JVMCalum Beck
This was my dissertation piece for my Software Engineering Degree.
The JVM CPU Cluster Balancer is a scalable, proof of concept system designed to distribute processes over a network to perform multiple tasks at once, in a language of high abstraction. Once distributed, workers return results to an access server, all while monitoring their respective CPUs for computational stress in terms of CPU usage. CPU’s incurring set stress then have their respective processes moved to a less intensive area in the cluster, balancing work overall.
Understanding Data Consistency in Apache CassandraDataStax
This document provides an overview of data consistency in Apache Cassandra. It discusses how Cassandra writes data to commit logs and memtables before flushing to SSTables. It also reviews the CAP theorem and how Cassandra offers tunable consistency levels for both reads and writes. Strategies for choosing consistency levels for writes, such as ANY, ONE, QUORUM, and ALL are presented. The document also covers read repair and hinted handoffs in Cassandra. Examples of CQL queries with different consistency levels are given and information on where to download Cassandra is provided at the end.
The document discusses several applications of parallel processing:
1. Airfoil design optimization utilizes parallel processors to simultaneously evaluate the aerodynamic performance of multiple airfoil geometries, greatly decreasing computational time.
2. Parallel databases can distribute queries across multiple processors, improving response time for online transactions and reducing time for complex queries through intra-query parallelism.
3. Weather forecasting uses parallel computers to quickly process huge volumes of environmental data through thousands of computational iterations needed to generate useful forecasts.
STUDY OF VARIOUS FACTORS AFFECTING PERFORMANCE OF MULTI-CORE PROCESSORSijdpsjournal
Advances in Integrated Circuit processing allow for more microprocessor design options. As Chip Multiprocessor system (CMP) become the predominant topology for leading microprocessors, critical components of the system are now integrated on a single chip. This enables sharing of computation resources that was not previously possible. In addition the virtualization of these computation resources exposes the system to a mix of diverse and competing workloads. On chip Cache memory is a resource of primary concern as it can be dominant in controlling overall throughput. This Paper presents analysis of various parameters affecting the performance of Multi-core Architectures like varying the number of cores, changes L2 cache size, further we have varied directory size from 64 to 2048 entries on a 4 node, 8 node 16 node and 64 node Chip multiprocessor which in turn presents an open area of research on multicore processors with private/shared last level cache as the future trend seems to be towards tiled architecture executing multiple parallel applications with optimized silicon area utilization and excellent performance.
ZooKeeper is a distributed coordination service that allows distributed applications to synchronize data and configuration information. It uses a data model of directories and files, called znodes, that can contain small amounts of structured data. ZooKeeper maintains data consistency through a leader election process and quorum-based consensus algorithm called Paxos. It provides applications with synchronization primitives and configuration maintenance in a highly-available and reliable way.
Advanced resource allocation and service level monitoring for container orche...Conference Papers
This document proposes an architecture for advanced resource allocation and service level monitoring for container orchestration platforms. It begins with background on containerization and different container orchestration platforms like Docker Swarm, Kubernetes, and Mesos. It then discusses the need for resource-aware container placement and SLA-based monitoring to minimize container migration and ensure performance. The proposed architecture consists of different components like a request manager, information collector, policy manager, and resource manager to enable advanced scheduling and monitoring of containers on Kubernetes. The proposed solution aims to analyze future resource utilization to improve placement decisions and reduce issues after deployment.
Advanced resource allocation and service level monitoring for container orche...Conference Papers
This document proposes an architecture for advanced resource allocation and service level monitoring for container orchestration platforms. It begins with background on containerization and popular orchestration platforms like Docker Swarm and Kubernetes. It then highlights issues with default scheduling approaches and proposes a resource-aware placement algorithm and SLA-based monitoring to minimize container migration and ensure performance. The key components of the proposed architecture are described and its advantages over default scheduling are discussed. In conclusion, the solution is meant to benefit container orchestrators by improving application performance through more effective scheduling and issues prevention.
This document discusses techniques for efficiently caching query results in database systems. It proposes using a chunk-based caching approach where query results are broken into multidimensional chunks that can be cached and reused to answer future queries. The key components of the proposed system include a cache manager that works closely with the query optimizer to decide what chunks to cache and replace. The system represents queries and cached chunks using a directed acyclic graph to help generate efficient query execution plans that leverage the cached chunks.
The document provides information on MongoDB replication and sharding. Replication allows for redundancy and increased data availability by synchronizing data across multiple database servers. A replica set consists of a primary node that receives writes and secondary nodes that replicate the primary. Sharding partitions data across multiple machines or shards to improve scalability and allow for larger data sets and higher throughput. Sharded clusters have shards that store data, config servers that store metadata, and query routers that direct operations to shards.
This document summarizes a paper that proposes and evaluates the performance of a multithreaded architecture capable of exploiting both coarse-grained parallelism and fine-grained instruction-level parallelism. The architecture distributes processing across multiple processing elements connected by an interconnection network. Each processing element supports multiple concurrently executing threads by grouping instructions from different threads. The architecture introduces a distributed data structure cache to reduce network latency when accessing remote data. Simulation results indicate the architecture achieves high processor throughput and the data structure cache significantly reduces network latency.
This document discusses techniques for improving the speed of web crawling through parallelization using multi-core processors. It provides background on how web crawlers work as part of search engines to index web pages. Traditional single-core crawlers can be improved by developing parallel crawlers that distribute the work of downloading, parsing, and indexing pages across multiple processor cores. This allows different parts of the crawling process to be performed simultaneously, improving overall speed. The document reviews several existing approaches for distributed and parallel web crawling and proposes using a multi-core approach to enhance crawling speed and CPU utilization.
Improved Utilization of Infrastructure of Clouds by using Upgraded Functional...AM Publications
This paper discusses a propose cloud infrastructure that combines On-Demand allocation of resources with
improved utilization, opportunistic provisioning of cycles from idle cloud nodes to other processes. Because for cloud
computing to avail all the demanded services to the cloud consumers is very difficult. It is a major issue to meet cloud
consumer’s requirements. Hence On-Demand cloud infrastructure using Hadoop configuration with improved CPU
utilization and storage utilization is proposed using splitting algorithm by using Map-Reduce. Hence all cloud nodes which
remains idle are all in use and also improvement in security challenges and achieves load balancing and fast processing of
large data in less amount of time. Here we compare the FTP and HDFS for file uploading and file downloading; and
enhance the CPU utilization and storage utilization. Cloud computing moves the application software and databases to the
large data centres, where the management of the data and services may not be fully trustworthy. Therefore this security
problem is solve by encrypting the data using encryption/decryption algorithm and Map-Reducing algorithm which solve
the problem of utilization of all idle cloud nodes for larger data.
The document discusses parallel computing platforms and trends in microprocessor architectures that enable implicit parallelism. It covers topics like pipelining, superscalar execution, limitations of memory performance, and how caches can improve effective memory latency. The key points are:
1) Microprocessor clock speeds have increased dramatically but limitations remain regarding memory latency and bandwidth. Parallelism addresses performance bottlenecks in processors, memory, and communication.
2) Techniques like pipelining and superscalar execution exploit implicit parallelism by executing multiple instructions concurrently, but dependencies and branch prediction limit performance gains.
3) Memory latency is often the bottleneck, but caches can reduce effective latency through data reuse and temporal locality.
Kubernetes is an open-source tool for managing containerized applications across clusters of nodes. It provides capabilities for deployment, maintenance, and scaling of applications. The document discusses Kubernetes concepts like pods, deployments, services, namespaces and components like the API server, scheduler and kubelet. It also covers Kubernetes commands and configuration using objects like config maps, secrets, volumes and labels.
CS 301 Computer ArchitectureStudent # 1 EID 09Kingdom of .docxfaithxdunce63732
This document summarizes the results of simulations run to analyze the performance of different processor configurations with varying levels of instruction-level parallelism. The key findings are:
1) For processors with significant memory latency, there is little performance difference between simple in-order and more complex out-of-order designs, as memory latency dominates execution time.
2) Supporting just two concurrently pending instructions provides most of the benefit of more complex out-of-order execution, while greatly reducing hardware complexity.
3) As the mismatch between processor and memory system performance increases, all designs see similar performance, regardless of the level of instruction-level parallelism exploited.
The document summarizes a project report for a MOOC communication backbone system. It discusses a 5 node cluster with a mesh topology that uses MongoDB as a distributed database. The cluster provides course listing, description, and question/answer functionality to clients. It elects leaders using a Floodmax algorithm and ballot IDs. An inter-MOOC voting strategy is also proposed to decide which cluster hosts a competition.
A Review of Storage Specific Solutions for Providing Quality of Service in St...Editor IJCATR
This document reviews several storage-specific solutions for providing quality of service (QoS) in storage area networks (SANs). It summarizes Stonehenge, pClock, Argon, Façade, and PARDA as approaches that have been developed to implement QoS at the storage level. Each approach aims to provide performance isolation and guarantees for different workloads and applications sharing storage resources, though they require running instances of the algorithms on individual storage devices, increasing overhead. The document concludes that current solutions do not provide end-to-end QoS when data traverses the network in an IP SAN.
Centrifuge is a system for managing in-memory state across servers in a large-scale cloud service like Microsoft's Live Mesh. It uses leasing and partitioning to assign "objects" or pieces of state to servers while load balancing and allowing for server failures. The system includes a manager service that directs leasing and partitioning, lookup libraries that route requests to owners, and owner libraries that hold leased objects and process requests. Centrifuge was shown to handle large numbers of small objects efficiently with low overhead during normal operation and high availability during failure events based on its use in Live Mesh.
Implementing Advanced Caching and Replication Techniques in ...webhostingguy
This document discusses implementing advanced caching and replication techniques in the Apache web server. Three new Apache modules were developed: mod_replication allows servers to track replicated documents and send invalidation messages when they change, mod_cgr upgrades proxy servers to replication servers and controls updating invalidated documents, and mod_wlis extracts replication server information from document headers and stores it in a database. The modules aim to improve document availability, reduce latency and traffic, and enable load balancing through caching and replication.
Performance comparison on java technologies a practical approachcsandit
Performance responsiveness and scalability is a make-or-break quality for software. Nearly
everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The
challenges faced during the life cycle of the project and the mitigation actions performed. It
compares 3 java technologies and shows how improvements are made through statistical
analysis in response time of the application. The paper concludes with result analysis.
PERFORMANCE COMPARISON ON JAVA TECHNOLOGIES - A PRACTICAL APPROACHcscpconf
Performance responsiveness and scalability is a make-or-break quality for software. Nearly everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The challenges faced during the life cycle of the project and the mitigation actions performed. It compares 3 java technologies and shows how improvements are made through statistical analysis in response time of the application. The paper concludes with result analysis.
Survey on caching and replication algorithm for content distribution in peer ...ijcseit
This document summarizes and compares several caching and replication algorithms for content distribution in peer-to-peer networks. It first introduces caching and replication techniques and their benefits, including reliability, availability, fault tolerance, load balancing and performance improvements. It then reviews six specific algorithms: 1) A weighted-rank cache replacement policy, 2) A streaming algorithm using multiple description coding, 3) Two prefetching protocols (full striping and code-based placement), 4) A popularity-aware limited caching approach, 5) Replication algorithms with random load balancing, and 6) An optimal replication strategy characterization. For each algorithm, it describes the approach and how it addresses challenges in peer-to-peer content distribution.
Similar to ZooKeeper Partitioning - A project report (20)
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Zoom is a comprehensive platform designed to connect individuals and teams efficiently. With its user-friendly interface and powerful features, Zoom has become a go-to solution for virtual communication and collaboration. It offers a range of tools, including virtual meetings, team chat, VoIP phone systems, online whiteboards, and AI companions, to streamline workflows and enhance productivity.
SMS API Integration in Saudi Arabia| Best SMS API ServiceYara Milbes
Discover the benefits and implementation of SMS API integration in the UAE and Middle East. This comprehensive guide covers the importance of SMS messaging APIs, the advantages of bulk SMS APIs, and real-world case studies. Learn how CEQUENS, a leader in communication solutions, can help your business enhance customer engagement and streamline operations with innovative CPaaS, reliable SMS APIs, and omnichannel solutions, including WhatsApp Business. Perfect for businesses seeking to optimize their communication strategies in the digital age.
What is Augmented Reality Image Trackingpavan998932
Augmented Reality (AR) Image Tracking is a technology that enables AR applications to recognize and track images in the real world, overlaying digital content onto them. This enhances the user's interaction with their environment by providing additional information and interactive elements directly tied to physical images.
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Measures in SQL (SIGMOD 2024, Santiago, Chile)Julian Hyde
SQL has attained widespread adoption, but Business Intelligence tools still use their own higher level languages based upon a multidimensional paradigm. Composable calculations are what is missing from SQL, and we propose a new kind of column, called a measure, that attaches a calculation to a table. Like regular tables, tables with measures are composable and closed when used in queries.
SQL-with-measures has the power, conciseness and reusability of multidimensional languages but retains SQL semantics. Measure invocations can be expanded in place to simple, clear SQL.
To define the evaluation semantics for measures, we introduce context-sensitive expressions (a way to evaluate multidimensional expressions that is consistent with existing SQL semantics), a concept called evaluation context, and several operations for setting and modifying the evaluation context.
A talk at SIGMOD, June 9–15, 2024, Santiago, Chile
Authors: Julian Hyde (Google) and John Fremlin (Google)
https://doi.org/10.1145/3626246.3653374
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
Software Engineering, Software Consulting, Tech Lead, Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Transaction, Spring MVC, OpenShift Cloud Platform, Kafka, REST, SOAP, LLD & HLD.
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
DDS Security Version 1.2 was adopted in 2024. This revision strengthens support for long runnings systems adding new cryptographic algorithms, certificate revocation, and hardness against DoS attacks.
WhatsApp offers simple, reliable, and private messaging and calling services for free worldwide. With end-to-end encryption, your personal messages and calls are secure, ensuring only you and the recipient can access them. Enjoy voice and video calls to stay connected with loved ones or colleagues. Express yourself using stickers, GIFs, or by sharing moments on Status. WhatsApp Business enables global customer outreach, facilitating sales growth and relationship building through showcasing products and services. Stay connected effortlessly with group chats for planning outings with friends or staying updated on family conversations.
1. 1
Improving Write Throughput Scalability of ZooKeeper by
Partitioning Namespace
CSE 223B Term Project, Spring 2014
Pramod Biligiri
UC San Diego
psubbara@ucsd.edu
Anita Kar
UC San Diego
ankar@ucsd.edu
Anjali Kanak
UC San Diego
akanak@ucsd.edu
_____________________________________________________________________________________
Abstract: We demonstrate that write throughput of a ZooKeeper cluster can be increased by
implementing a partitioning system for the data. By enabling a single ZooKeeper cluster to have
multiple quorums, each with its own leader, client requests that want to access different partitions of
the namespace can be processed in parallel by relaxing the ordering guarantees across partitions.
Experimental evaluation of our implementation shows approximately 14% increase in throughput. The
only extra resource required for each node in the partitioned ZooKeeper is additional hard disk(s) to
cope with the increased throughput.
1. Introduction
ZooKeeper provides a distributed configuration service, synchronization service, and naming registry
for large distributed systems [1]. ZooKeeper nodes store their data in a hierarchical name space (called
znodes), much like a file system or a Trie data structure. Clients can read and write from/to the nodes
and in this way have a shared configuration service.
Partitioned ZooKeeper ZooKeeper follows a primary-backup replication scheme. Currently, the
leader node in a ZooKeeper ensemble processes all incoming client requests sequentially, thus ensuring
strictly ordered access to the znodes.
We created a partitioned version of the ZooKeeper with the goal of improving the write throughput
scalability. This was first suggested on the ZooKeeper wiki page [2] and discussed on the issue tracker
[3]. Thus, the user can specify a set of paths that can be updated independent of each other. This leads
to relaxation in ordering across all the root znodes, where each root znode corresponds to a path.
However for any particular path, the requests are still ordered. Hence, if there are independent
applications using the ZooKeeper ensemble, then partitioning should lead to increased throughput by
removing ordering constraints across independent operations and hence potentially parallelizing
processing and disk writes.
One of the existing suggestions to implement it is by creating completely separated clusters using the
available nodes. Our approach, however, differs from this as we are using the all the nodes while
making independent operations proceed parallelly. To enable this, we created multiple quorums with
the same set of available nodes. All nodes are members of all the quorums. Each quorum can be
visualized as a logical abstraction having its own leader and being responsible for a handling requests
2. 2
corresponding to a particular path. As every node is a part of multiple quorums, it is still involved in
processing of all the operations and its resources and fully utilized. This makes our approach more
economical than the aforementioned one in case of which resources like memory and CPU may remain
underutilized. Moreover, our implementation requires fewer nodes because each quorum comprises of
all the nodes and is contrary to the suggested approach where the nodes need to be distributed across
multiple quorums.
2. Motivation
ZooKeeper service is used in by many companies to provide coordination, synchronization and a
hierarchical namespace of data registers for various distributed applications. Typically, one ZooKeeper
cluster is used by multiple applications. These applications may be unrelated but still all requests are
still written sequentially to the transaction log on the disk since they are ordered and proposed by a
single ZooKeeper leader node. This leads to the possibility of the disk at the nodes becoming the
bottleneck for the cluster throughput. The ZooKeeper administrator’s guide [4] recognizes this issue
as it mentions that disk write into the transaction log is the most performance critical part of
ZooKeeper. Hence, for separate applications, the data can be handled and written separately.
Though one option is to have separate clusters for individual applications, it may end up being
expensive and lead to underutilization of resources. Hence, an ideal scenario would be to use the same
ZooKeeper cluster for multiple applications while removing the ordering guarantees between unrelated
requests coming from these separate applications. Then the independent sets of requests can be written
to different transaction logs which, as discussed earlier, can improve the performance. This is the issue
we tried to address through our implementation of partitioned ZooKeeper.
3. Design
Each ZooKeeper node is part of a quorum of nodes, where it participates in voting on proposals and
leader election. A ZooKeeper node can also service client requests. A client request is processed in
multiple stages. Each stage reads events from an incoming queue, performs its actions and passes the
output to the incoming queue of the next stage. The use of stages and queues is designed to avoid
blocking of incoming requests due to network and disk operations.
In ZooKeeper’s current design, a cluster can have only one leader and an associated quorum. We
modified this design to enable multiple leaders to exist within a cluster, each with their own quorum.
Each node can be part of multiple quorums. A node can be a leader in one quorum and a follower in
others, or a follower in all the quorums that it is part of. Having a node be the leader for multiple
quorums would have no benefit for the performance gains we are trying to obtain, so we did not
experiment with that option.
The namespace of nodes is partitioned among the leaders, with routing logic in each follower to
forward requests to the appropriate leader. Figure 1 below shows the current and modified designs of
ZooKeeper.
3. 3
Figure 1: ZooKeeper cluster with multiple quorums
Whenever a node receives a proposal from the leader, it appends the request to a transaction log on
disk and sends back an acknowledgement. This transaction log is used for recovery in case of leader
failure. The write to disk constitutes a performance critical path of the request processing flow.
Therefore, the ZooKeeper administrator's guide [4] recommends keeping the transaction log on a
separate device from any other reads and writes on the system. Since each node can now be part of
multiple quorums, the transaction log for each quorum needs to be on its own device. We have
modified ZooKeeper to support this. Figure 2 shows this design.
Figure 2: Node operation as a part of multiple quorums
4. 4
4. Implementation
Our initial approach [5] focused on partitioning
incoming requests and handling them in parallel. For
each distinct top-level path that comes in (/app1,
/app2 etc.), we create a new chain of request
processing stages and all subsequent requests on that
path are routed to that chain. Though this gave us a
performance speed up in the request processing stage,
the strict ordering guarantees of ZooKeeper’s atomic
broadcast protocol within a quorum meant that the
requests were getting serialized before being
forwarded to the leader. This led us to the current
design of having multiple quorums, in order to relax
the ordering guarantees across different request paths.
We are able to reuse a significant amount of the
routing logic from the initial implementation.
Figure 3 shows the class diagram for the multiple
quorum approach [6]. A separate thread is created
corresponding to each quorum to handle the request
flow and the inter-node communication. Each
QuorumPeerThread can be allocated one or more
partitions of the request namespace by the routing
logic, which determines the quorum by examining the
request.
Figure 3 Class diagram for the multiple quorum approach
Challenges during implementation
The original ZooKeeper codebase has the following core assumptions:
i. Total ordering of all requests, by a single primary
ii. All requests are treated alike
iii. Each node is part of only one quorum
Our design required changing each of these core assumptions, without compromising on performance
or safety. Further, the code uses multithreading extensively, and has optimized usage patterns for disk
and network I/O. Thus it was a challenge to modify the code-base to suit our needs.
Below we cite a couple of examples:
i. Request specific processing We introduced a new interface called RequestFlushable, along
the lines of the existing Flushable interface. This is implemented by
5. 5
SendAckRequestProcessor, which now needs to examine the request to decide who to send an
acknowledgement to.
ii. Existence of multiple quorums The new class QuorumPeerMulti abstracts the existence of
multiple quorums, by implementing the same interface as the existing QuorumPeer. It is used
selectively by multi-leader aware parts of the code to use the new functionality.
5. Performance Evaluation
We measure the performance implications of the proposed design in terms of write throughput and
compare the results with that of ZooKeeper 3.4.6. This is the current stable version of ZooKeeper
available from Apache. We wrote a test program in Java to measure the total time taken for a given
number of operations. We have documented our results for the create command and expect similar
results for get, set and delete. The following sections describe the experimental setup and discuss the
results from our testing.
Experimental Setup
We ran the experiments on a five node cluster setup on Amazon EC2. Each instance was installed
with Ubuntu 14.04 LTS and ZooKeeper software. Every node is assigned 4 vCPUs, 15 GB RAM and
2 SDD 40 GB each. Two additional volumes 10GB in size were attached to each instance to study
ZooKeeper performance with various disk configurations.
Separate disks are configured for snapshots and transaction logs. The path to the respective directories
is specified in the ZooKeeper configuration file. ZooKeeper service is started on all instances. The tests
are run with globalOutstandingLimit set to 1000 (default) and snapCount set to 500,000. With low
snapCount, snapshots will be taken too frequently. Hence, to eliminate the possibility of deviations in
measurements due to frequent snapshotting, we set this value to a higher number.
We wrote a performance test script that creates a specified number of ZooKeeper nodes under a given
namespace, by connecting to ZooKeeper using the client API and using the asynchronous create
primitive. A warm up phase of 10000 nodes is executed in order to test the system in a stable state.
The results tabulated below are calculated averages over five test runs.
Results
The first experiment involves 400000 create commands on one client, 200000 for /app1/* and
200000 for /app2/*.
ZK Setup # Requests Time (ms) Ops/Sec
Version 3.4.6 400K 37455 10679.48
Multi-Leader 200K + 200K 24594 17176.92
Table 1 Comparison of throughput between ZooKeeper 3.4.6 and partitioned ZooKeeper
6. 6
Table 1 records the total time and throughput. With ZooKeeper 3.4.6, this operation takes 37.45
seconds. With our code changes, we are able to demonstrate that the requests when split between two
different leaders can reduce the total time to approximately 24 seconds, which gives an order of 1.5x
improvement.
ZK
Setup
#
Requests
Client2 Client4
Time
(ms)
Ops/Sec
Time
(ms)
Ops/Sec
Version
3.4.6
200K 27034 7398.091 26282 7609.771
300K 40745 7362.867 40024 7495.503
400K 53843 7429.007 53077 7536.221
Multi-
Leader
200K 24594 8132.065 22112 9044.862
300K 38520 7788.162 32800 9146.342
400K 50600 7905.139 43338 9229.775
Table 2 Comparison of throughput between ZooKeeper 3.4.6 and partitioned ZooKeeper
In our second experiment, we use two separate clients to issue 200K, 300K and 500K create requests
on each in separate runs. Table 2 summarizes the results of this experiment. We observe that with
two clients processing the requests, we overcome the overhead involved in the client dispatching the
request to the leader.
Figure 4 Comparative throughput measurement on two different clients in a 5-node cluster
While ZooKeeper 3.4.6 shows considerable improvement,
experiment repeated with our code changes indicates that the
throughput improved further by approximately 14%. This can
be attributed to the fact that with ZooKeeper 3.4.6, all the
requests are totally ordered. In our multi-leader design, the
different namespaces are processed in parallel.
Table 3 Overall percentage improvement in throughput
0
2000
4000
6000
8000
10000
200K 300K 400K
No.ofOperations/Sec
No. of requests
Comparison of Throughput
Measurement on Client 2
Version 3.4.6 Multi-Leader
0
2000
4000
6000
8000
10000
200K 300K 400K
No.ofOperations/Sec
No. of requests
Comparison of Throughput
Measurement on Client 4
Version 3.4.6 Multi-Leader
# Requests
Overall
improvement (%)
200K 14.35
300K 13.95
400K 14.2
7. 7
6. Future Work
In the current design of the ZooKeeper, a number of messages are exchanged between the leader and
the followers. By introducing two leaders, we do not increase the number of network messages since
the requests are split between the leaders. Hence, no latency is introduced by the partitioned ZooKeeper
design. Network latency can be one of the areas that might be of interest for future work through.
In our current implementation, the leaders for the quorum are statically chosen on system startup. We
have not handled leader failure and election of multiple leaders. The routing code that we have is quite
basic, and can be extended to be user configurable. We have also not studied the impact of network
latency on larger quorums with multiple leaders. For the purpose of performance evaluation, we chose
to implement only one of the primitives (create). This is similar to the rationale mentioned on the
original ZooKeeper ( [7], Section 5.1) paper for their performance evaluations.
7. Conclusion
Thus, using the same set of servers, we have implemented multiple quorums, each of which is
responsible for processing requests for a particular request path. Each quorum has its own leader which
orders only the requests targeted to the path that quorum is associated with. This relaxes the ordering
constraint across operations related to different paths while ensuring that for a particular path, the
ordering guarantee is still maintained. In order to parallelize disk writes, we assigned a separate disk
to each node for every quorum it was a part of. We demonstrated that write throughput of ZooKeeper
can be improved by separating the znode namespace and by having different leaders process
independent paths. We see an approximate improvement of 14% using this method.
8. 8
References
[1] "Apache_ZooKeeper," [Online]. Available: http://en.wikipedia.org/wiki/Apache_ZooKeeper.
[2] "Partitioned ZooKeeper," [Online]. Available:
http://wiki.apache.org/hadoop/ZooKeeper/PartitionedZooKeeper. [Last edited by F. Junqueira, 18
May 2010].
.[3] D. Williams. [Online]. Available: http://ria101.wordpress.com/2010/05/12/locking-and-
transactions-over-cassandra-using-cages/.
[4] "ZooKeeper Adminitrator's Guide," [Online]. Available:
http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html#sc_commonProblems.
[5] "Bitbucket Link to Older Approach (zk-Partition)," [Online]. Available:
https://bitbucket.org/pramodbiligiri/zk-partition.
[6] "Bitbucket link to New approach (zk-Multileader)," [Online]. Available:
https://bitbucket.org/pramodbiligiri/zk-multileader.
[7] Patrick Hunt et al, "ZooKeeper: Wait-free coordination for Internet-scale systems," in
USENIXATC'10 Proceedings of the 2010 USENIX conference on USENIX annual technical conference,
2010-06-23.