Like sands through the hourglass, so are the days of our lives. And with that, the H-Store project is pleased to announce the release of the latest version of its high-performance, distributed transaction processing database management system. This version contains a significant new advancement in main memory NewSQL systems called anti-caching. H-Store now includes a disk-resident, block storage anti-cache to store “cold” data that has been removed from the memory-resident storage in order to free up space for new data. Preliminary experiments show that H-Store with anti-caching outperforms traditional DBMSs even for databases that are larger than the amount of memory available on a single node.

If the amount of memory used in the partitions for an HStoreSite goes above an administrator-defined threshold, then H-Store will evict the least recently used tuples and write them out to the anti-cache storage disk. H-Store still maintains index information in memory for any evicted tuples stored on disk. If a transaction attempts to access one of these evicted tuples, then it is switched into a “pre-pass” mode where the engine records all tuples that it tried to access. Once that transaction attempts to do something with those tuples (e.g., modify them, return them to the stored procedure), then it is aborted and put in a queue while the AntiCacheManager thread asynchronously retrieves those records and merge them back into memory.

Additional information about the new anti-caching architecture in H-Store is available on-line:

• Anti-Caching and Non-Volatile Memory for Transactional DBMSs (Pavlo / Stonebraker)
• The Traditional Wisdom is All Wrong (DeBrabant)

Major highlights of this release:

1. New anti-caching feature allows H-Store to support databases that are larger than the amount of memory available to an HStoreSite. This initial implementation uses BerkeleyDB’s hash table (which is now included in the source code).
2. Improved H-Store’s built-in implementation of the YCSB benchmark. The data generator is now multi-threaded and the transactions are guaranteed to be deterministic. [2ec227a] [7302cd8] [5747a41] [9791e1d]
3. Improved runtime performance of command logging. The PartitionExecutors will now send completed transactions to the TransactionPostProcessor threads. This helps to reduce the latency of transactions. [9d66da2] [88550be] [1292376] [3b13cd4]
4. Reduced the number of TransactionCleaner threads needed to clean-up finished transactions and return them to internal object pools. [844db91]
5. Various performance optimizations and stability fixes. [fb81eb9] [5b15079] [8de21a6] [2895a38] [4a12097] [2fa67a0] [923e155] [831ab1c] [06e8144] [7ee989d]

The source code for this release can be downloaded via Github:

https://github.com/apavlo/h-store/tarball/release-2013-04

The H-Store project is pleased to announce the release of the latest version of its high-performance, distributed OLTP database management system. This version consists of mostly stability, performance, and memory improvements. New features include more aggressive speculative execution of single-partition transactions, improved internal statistics gathering and reporting for benchmarks. We have also added over 200 new test cases for H-Store. As a result, this release is dedicated to the memory of Aaron Elmore.

The next release in early 2013 will contain significant new research features.

Major highlights of this release:

1. Rewrote incoming network request processing, transaction queue processing, and execution flow path. This greatly improves the performance of a single HStoreSite on multi-core nodes, reduces the amount of memory used by each HStoreSite instance, and improves server-side connection throttling. [54e2df0] [668e7d5] [bcc481f] [ce0d3fd]
2. Improved performance of command logging (i.e., op log) and fixed a rare dead-lock problem. [0e9c385d] [cff105d] [0e9c385]
3. Integrated new Speculative Execution Scheduler to find non-conflicting transactions to execute whenever a distributed transaction is stalled at a partition. The project compiler now automatically computes the read-write and write-write conflicts between the queries in each stored procedure. [68576a3] [6795bb2]
4. Mispredicted transactions do not count queries against replicated tables or secondary indexes when computing which partition to redirect the transaction request. This makes the TM1/TATP benchmark entirely single-partitioned and greatly improves performance. [9a9ef76b]
5. Added the ability to enable/disable JVM asserts for either the database cluster nodes or the benchmark framework using the new site.jvm_asserts and client.jvm_asserts parameters. [f21a8f6]
6. New client-side benchmark result output options. This allows the BenchmarkFramework to automatically retrieve CSV files from H-Store’s internal statistics catalog. [08d310a] [52ab623] [1038ded] [f47ebff]
7. New @GetConfiguration and @SetConfiguration system procedures to retrieve/manipulate HStoreConf parameters at run time. [cae1f0a] [ab4f5c0]
8. The default version of the JVM used in H-Store is now Java 1.7. This fixes a bug in Java 1.6 where the transaction prediction models that causes the JVM to SIGSEV. [945f590] [5b7f6a79].

The source code for this release can be downloaded via Github:

https://github.com/apavlo/h-store/tarball/release-2012-12

Major highlights of this release:

1. New Feature: Added new command logger that can write out successfully executed transactions to a log file at each node. The logger uses a separate thread and group commits transactions with minimum overhead to throughput. This log can then be replayed for recovery (work in progress). [ceb6a49] [ae4c82b] [abdc371] [99ffc9f] [d53afcc]
2. New Feature: Defer the execution of queries in single-partition transactions until a later point in time when the partition’s execution thread is idle. [8037dfe]
3. New Feature: Added support for ad-hoc queries. This allows you to execute single queries that are not part of a stored procedure. The H-Store distribution also provides a command-line terminal to connect to an H-Store cluster. [faf297c] [fda4c41]
4. New Benchmarks: VoltDB’s voter benchmark, Wikipedia, Yahoo!’s ycsb benchmark, and TPC-E (per David DeWitt’s persistent request). [5992d22] [0caa40c] [9cc5895] [#68]
5. Complete overhaul of the server-side infrastructure from processing incoming transaction requests from clients. This great improves scalability for workloads with very short single-partition transactions on machines with many cores (>10). [d03ba80]
6. Optimized and improve client side execution in benchmark framework. Reduced CPU overhead of each client thread. Added support for multiple JVM instances per client host. Added ability to specify whether client threads share a connection to the database cluster. [9f3c2d62] [df150881] [e44b3314]
7. Improve query plan optimization for distributed OLAP-style queries [e889abb] [89d06c8]
8. Major refactoring of the source code repository: all of the benchmark code has been moved in src/benchmarks. [a321847]

The source code for this release can be downloaded via Github:

https://github.com/apavlo/h-store/tarball/release-2012-06

Major highlights of this release:

1. Significant speed optimizations for single-partition transactions. [cf9be4a] [c67babd] [f2659fd] [0425253] [243f99d] [5abd178]
2. Fixed several memory leaks for aborted/read-only transactions. [ddf2f23] [e429821]
3. Fixed several stability issues when transactions share lock-free data structures [4956be9]
4. Fixed predicate/aggregate pushdowns for distributed query plans [4956be9] [31eff68]
5. Restored the ability for transactions to return the proper status codes on failures that mimic VoltDB’s protocol. [ae4a6a4] [f374d49]
6. H-Store’s Fabric automatic deployment script for EC2 now supports multiple concurrent “virtual” clusters. This allows you to easily assign instances to independent clusters under a single AWS account. [1202f4e]
7. Restored preliminary support for VoltDB’s regression test suite. [1f4f465] [c434fa2] [1945aba0]
8. Fixed building on OS X Lion [0328973]

The source code for this release can be downloaded via Github:

https://github.com/apavlo/h-store/tarball/release-2012-03

Important: The major change in this release is that the source code repository has been moved entirely to Github. The original Subversion will remain online for the time being but all new features and fixes will be in Github.

This latest release includes several performance optimizations for both single-partition and distributed transactions, as well as support for new features, such as MapReduce transactions.

Major highlights of this release:

1. Complete re-write of the distributed transaction coordination protocol. H-Store no longer uses the centralized Canadian-style transaction coordinator and instead uses a VoltDB-style timestamp-based ordering protocol (r2365, r2366)
2. When the database cluster is brought online, the HStoreCoordinator at each node will use an NTP-style algorithm to estimate the clock skew between all other nodes. It will then offset its internal logical clock used when generating globally unique transaction ids to minimize the discrepency between nodes. This improves throughput for distributed transactions on large deployments using Amazon EC2. (r2609)
3. The clients in H-Store’s built-in benchmark framework are now multi-threaded. The client.processesperclient parameter now specifies the number of client threads to use per JVM. This has been tested to scale to thousands of threads per JVM. (r2429, r2430)
4. Restored support for VoltDB’s bingo benchmark (r2534, r2535). Renamed the expanded Airline benchmark to SEATS (r2572)
5. Removed unused object pool pre-loading configuration parameters. (r2406)
6. Various improvements to reduce to amount of memory used store the internal state of transactions in the system. (r2379, r2377, r2376)

The source code for this release can be downloaded via Github:

https://github.com/apavlo/h-store/tarball/release-2012-01

Major highlights of this release:

1. The BatchPlanner can now quickly determine whether a query batch will execute entirely on the local partition and will use a cached batch plan if it is. This provides a significant speed improvement for single-partition transactions. (r2343, r2344)
2. Added the ability to pin the ExecutionSite’s Java thread to a fixed number of cores (using taskset). All other HStoreSite threads are only allowed to execute on the remaining CPU cores. See the ${site.cpu_affinity} parameter documentation for more information. (r2339)
3. New parameter ${client.txn_hints} that allows clients to route transaction requests to the proper node in the cluster, thereby reducing two extra network hops. (r2312, r2313)
4. Fixed automatic distribution of vertically partitioned tables when using the @LoadMultipartitionTable sysproc. (r2317)
5. Fixed hstore-benchmark so that it exits with a non-zero status code when the benchmark fails to execute to completion. (r2266)
6. H-Store now includes an automatic deployment script for Amazon EC2 based on Fabric and Boto. More information can be found here.

The source code for this release can be downloaded via anonymous SVN:

https://database.cs.brown.edu/svn/hstore/tags/release-2011-09

Major highlights of this release:

1. Improved speculative execution of single-partition transactions. All transactions can be speculatively executed whenever a multi-partition is blocking waiting to be executed. Use the site.exec_speculative_execution configuration to enable. (r2137, r2145, r2192)
2. New TransactionEstimator can automatically determine whether a transaction is single-partition at runtime. Distributed transactions are executed with the minimum number of partitions. Alternatively, you can use site.exec_force_singlepartitioned to force all transactions to execute as single-partitioned, and any mistakes are automatically rolled back and restarted as multi-partitioned.
3. Fixed concurrency/synchronization issues in ProtoRpcChannel/Server and VoltProcedureListener for write available callbacks. (r2183, r2155). Fixed synchronization issues for MarkovPathEstimator and TransactionEstimator (r2198)
4. Can now configure output directories for HStoreSite, Dtxn.Coordinator, and Client log files.
5. All node.* configuration parameters have been renamed to site.*.
6. Fixed a race condition when the middle PlanFragment for three-way joins would not get queued up for all partitions at the same time. This would cause the Dtxn.Coordinator to halt. (r2127)
7. Reduced JUnit test time by allowing each test case in a single JVM invocation to reuse benchmark project jar files. (r2139)

The source code for this release can be download via anonymous SVN:

https://database.cs.brown.edu/svn/hstore/tags/release-2011-07

Note also that the supplemental resource files (e.g., sample workload trace logs) have been moved out of the source code repository into a separate external repository:

https://database.cs.brown.edu/svn/hstore-files/

Major highlights of this release:

1. Significant optimizations of single-partition transactions. Added heavy use of object pooling and cached query batch planning.
2. Added support for general transactions that touch an arbitrary number of partitions.
3. Improved distributed query planner. Unlike VoltDB’s query planner, we can now push down projection operators and parallelize all aggregates supported by H-Store (except for COUNT(DISTINCT)). This greatly reduces the amount of data that needs to be sent from all of the partitions to the initiating partition.
   Update: VoltDB’s query planner now does predicate push-down as of May 2011.
4. The system can predict the execution path of arbitrary transactions. The developer no longer needs to annotate stored procedures with the @ProcInfo that VoltDB requires (more details coming soon).
5. Many bug fixes for interacting with the transaction coordinator (support for larger batch sizes).
6. New tuning parameters.
7. Improved the H-Store Catalog Viewer Tool

The source code for this release can be download via anonymous SVN:

https://database.cs.brown.edu/svn/hstore/tags/release-2011-03

Or from a pre-packaged source code tarball.

• TPC-E Benchmark Port
• Airline Booking OLTP Benchmark
• System Development & Optimization
• Universal OLTP Benchmark Framework

TPC-E Benchmark Port

Estimated Time: 20-30 hours.
We currently have a partial implementation of the TPC-E Benchmark written for H-Store. We are looking for a student to complete the port and get the benchmark fully running on the H-Store system (or as close to the official specification as possible). There are two tasks in this project: (1) integrate the official TPC-E C++ workload generator into H-Store’s Java-based benchmark framework and (2) refactor any complex queries that contain SQL features that are currently not supported by H-Store into equivalent multiple queries and Java code. For the former task, we have already integrated the TPC-E EGenLoader into an H-Store benchmark data loader, but we still need to add JNI hooks into the EGenClient driver in order to generate the transactional workload (e.g., store procedure invocations with input parameters). Once this is done, the next step is go through the TPC-E stored procedures written for H-Store and refactor them as needed in order to produce the correct results. For example, the H-Store distributed planner has trouble with the seven table join query in the BrokerVolume transaction; the student will need to break the single large query up into multiple queries and combine the results in the Java-portion of the stored procedure. Students will need some previous C++ and Java development experience.

Airline Booking OLTP Benchmark

Estimated Time: 30-40 hours.
Much like TPC-E, we also have a half-completed implementation of a new OLTP benchmark that is based on airline ticket booking systems. This work is an enhancement of a ticketing system benchmark designed by Mike Stonebraker in 2008. We are looking to add non-deterministic transactions that are more complex than the original benchmark specification. Specifically we are interested in adding affinity-based skew in the data based real world information (e.g., flights out of Madison, WI are more likely to fly to Chicago, IL than any other destination). This project consists of (1) writing a synthetic data loader that is based on publicly available air travel information from the FAA, (2) creating stored procedures that model an airline ticketing system, and (3) writing documentation on the data loader and workload generator. All code will be written in Java using the H-Store benchmark framework.

System Development & Optimization

Estimated Time: 10-40 hours.
The original VoltDB transaction coordination system was completely removed and rewritten in H-Store in order to support more complex transaction workloads in our research projects. As such, it is obviously not as optimized as VoltDB. We are looking for a resourceful student to profile the Java-based frontend code in order to identify performance bottlenecks and then work with one of the H-Store developers to optimize the code. The complexity and scope of this project can vary based on the student’s skill set. Some issues may be as simple as correcting bad coding practices, while others could involve integrating a shared memory message passing subsystem. Familiarity with Java-based profiling tools (e.g., JProfiler) is preferred but not required.

Universal OLTP Benchmark Framework

Estimated Time: 30-50 hours.
We are working in conjunction with the RelationalCloud project to develop a general benchmark framework for comparing parallel OLTP systems. This project is similar to the Yahoo! Cloud Serving Benchmark platform. Possible responsibilities could include (1) integrating a harness for benchmarks written using the H-Store benchmark framework, (2) writing plug-ins for other DBMSs (e.g., Oracle, DB2), and (3) collecting workload samples and analyzing performance results. This project is more research-focused than the other ones listed above.