DIKU Systems Seminar

This week we look at transaction management in multidatabase system. On rigorous transaction scheduling

This week we look at designing scalable lock managers A scalable lock manager for multicores

This week we look at scaling concurrency control under heavy contention on multi-cores Design Principles for Scaling Multi-core OLTP Under High Contention

This week we look at concurrency control algorithms in the massively multi-core era, Staring into the Abyss: An Evaluation of Concurrency Control with One Thousand Cores

This week we look at transaction processing in E-Store, E-Store: Fine-Grained Elastic Partitioning for Distributed Transaction Processing

This week we look at transaction processing in H-Store, On predictive modeling for optimizing transaction execution in parallel OLTP systems

Low overhead concurrency control for partitioned main memory databases

This week we look at Schism: a workload-driven approach to database replication and partitioning

This week we look at automatic partitioning and its implications in transaction processing, Skew-aware automatic database partitioning in shared-nothing, parallel OLTP systems

This is an internal meeting for status check and planning for TransparInt.

This week there is an industrial talk on the relevance of the traditional data warehouse in the "big data" arena. We will look into the auto generation of data warehouse structure and ETL-code in Rehfeld's product, Effector. The talk announcement can be found here.

Internal DMSlab review meeting

This week we look at Maat:Effective and scalable coordination of distributed transactions in the cloud and Accordion: Elastic Scalability for Database Systems Supporting Distributed Transactions

This week we look at Exploiting Hardware Transactional Memory in Main-Memory Databases.

This week we discuss the Beckman Database Research Self-Assessment Meeting. The report of the meeting is the entry point of the discussion. All the documents in that page are must read :-).

The previous meeting webpage is available here and the report is can be found here.

Internal DMSlab meeting for code review and design discussion of TransparInt

This week we look at the H-Store project. H-store: a high-performance, distributed main memory transaction processing system and the paper laying the ground for it, The end of an architectural era: (it's time for a complete rewrite)

OLTP through the looking glass, and what we found there

We do not have any specific technical focus paper but a group of them. This week we look at the current buzzwords in the Big Data world.

• SQL databases v. NoSQL databases
• Eventually consistent
• Don't Settle for Eventual Consistency
• New opportunities for New SQL
• 10 rules for scalable performance in 'simple operation' datastores
• How will the database incumbents respond to NoSQL and NewSQL?

• New SQL: An Alternative to NoSQL and Old SQL for New OLTP Apps

Internal discussion about possible projects around data integration and privacy, distributed systems, database technologies and business opportunities.

We look at insights into implementing OLTP systems on modern hardware to eliminate unscalable patterns in the design, Eliminating unscalable communication in transaction processing

OLTP on hardware islands gives a detailed performance analysis of OLTP deployments on modern multi-core and multi-processor hardware.

Internal DMS lab talk on design of partitioned transactions.

Follow up on previous talk on Feb 10, 2014

We look at spatial join algorithms and their performance for distance queries. An experimental analysis of iterated spatial joins in main memory is the focus paper for this week.

A Benchmark for Evaluating Moving Object Indexes provides more details on the benchmarks used in the paper. Indexing the Positions of Continuously Moving Objects provides more background for TPR trees. Spatial join techniques provides a detailed survey on spatial join processing.

We look at the performance of the classical join algorithms discussed last week. Multi-core, main-memory Joins : Sort vs. Hash Revisited evaluates the performance of join algorithms on modern hardware.

Sort vs Hash Revisited is a comparison of these two families of join algorithms.

We look at the classic paper on Join processing in Database Systems with Large Main Memories.

For a more detailed survey on query evaluation, see this. For a more recent survey on join processing and its implementations see here.

We look at Crescando, a scalable, distributed relational table implementation with guaranteed access latency, Predicatable Performance for Unpredictable Workloads

We look at the paper countering the attack of NoSQL systems on classical RDBMS Can the elephants handle the NoSQL onslaught

We look at the large scale incremental index processing system from Google called Percolator

Percolator uses Google's distributed storage service Bigtable and Google's lock service for distributed systems Chubby

We look at the distributed relational database from Google -> F1

F1 is built using Spanner

Using "datapro" techniques to "cook" spatial data for better map visualizations.

The chalk talk will reference the following papers

• Declarative Cartography: In-Database Map Generalization of Geospatial Datasets

A chalk talk discussing distributed optimistic concurrency control protocol

The chalk talk will reference the following papers

• Cache craftiness for fast multicore key-value storage
• Speedy transactions in multicore in-memory databases
• On optimistic methods for concurrency control

With B trees being the theme for the past couple of weeks, this week we look at the survey paper A survey of B-tree locking techniques

The classic B tree paper is Ubiquitous B tree and the other classic paper for efficient concurrent operations on b trees is the paper on B-link trees.

We look at the paper PALM: Parallel Architecture-Friendly Latch-Free. Modifications to B+ Trees on Many-Core Processors

We look at the paper in the additional read for last week Cache craftiness for fast multicore key-value storage

We look at the paper Speedy transactions in multicore in-memory databases

We look at the paper Serializable isolation for snapshot databases

We look at the classic paper A critique of ANSI SQL isolation levels

The well known paper on the locking granularity, Granularity of locks and degrees of consistency in a shared data base

This week we look at the classic optimistic concurrency control papers. On optimistic methods for concurrency control

This week we look at one of the supplemental papers of the previous week in detail. We look at the paper for Exokernel: an operating system architecture for application-level resource management

The MIT exokernel project page

The goal is to understand Docker from an academic point of view (good luck with that). We will read and discuss K42: Building a Complete Operating System as the primary paper.

Supplemental papers are Exokernel: an operating system architecture for application-level resource management, Embassies, Native Client, Mesos and Xen.

Understanding Docker from a practical perspective: virtualization, Docker README, PaaS under the hood, episode 1: kernel namespaces, PaaS Under the Hood, Episode 2: cgroups, aufs − another unionfs, LXC - chroot on steroids.

Some important terms used in the Docker-mentation: images, container, layer, filesystem.

It's time to look into the RAMCloud project and its crash recovery mechanism.
The paper for discussion is Fast crash recovery in RAMCloud.
An interesting RAMCloud tech talk is here.

The introduction paper for the RAMCloud project is The case for RAMCloud.

It's time to take a dive into history.
This week we visit the classic paper on how it all started A History and Evaluation of System R.

And then we look into the relatively modern next generation system. The POSTGRES next generation database management system.

This week we have focus paper on disk failures which is Failure trends in a large disk drive population

And we also have a special video lined up on designing systems for internet scalability

The end of an architectural era: (it's time for a complete rewrite)
This is the kickoff paper for the H-Store project.

The critique paper on "One Size fits all" is "One Size Fits All": An Idea Whose Time Has Come and Gone
For the sceptics, read the counter paper on classical relational systems. Is there a contradiction here ? Can the elephants handle the NoSQL onslaught?

• DBMSs on a Modern Processor: Where Does Time Go?
• Database architectures for new hardware, a tutorial

In light of papers

• Impossibility of distributed consensus with one faulty process.
• Effectively Nonblocking Consensus Procedures Can Execute Forever - a Constructive Version of FLP

• Eric Brewer's PODC Keynote, July 19, 2000 (origin of CAP theorem, rightly a conjecture at the time)
• The Consistency Alphabet Soup (E. Gün Sirer, personal blog 2013)
• Problems with CAP, and Yahoo’s little known NoSQL system (Daniel Abedi, personal blog 2010)

Main paper is Paxos Made Simple (ACM SIGACT '01). A short video on Paxos (6 min).

Related to other papers:

• Paxos Made Live - An Engineering Perspective (PODC '07)
• Part-time Parliament, the original paper for the archaelogists (TOCS '98)
• Implementing fault-tolerant services using the state machine approach: a tutorial (ACM Comput. Surv.'90)
• The Byzantine Generals Problem (TPLS '82)
• A blog commentary on Paxos
• Paxos made code

Systems using Paxos (tentative list):

• ZooKeeper: wait-free coordination for internet-scale systems (USENIX '10)
• Keyspace: A Consistently Replicated, Highly-Available Key-Value Store (Scalien '10)
• The Chubby lock service for loosely-coupled distributed systems (OSDI '06)
• Petal: distributed virtual disks (SIGOPS '96)