5.1.1 System Installation, Configuration, and Tuning
We were able to get Hadoop installed and running jobs with little
effort. Installing the system only requires setting up data directories
on each node and deploying the system library and configuration
files. Configuring the system for optimal performance was done
through trial and error. We found that certain parameters, such as
the size of the sort buffers or the number of replicas, had no affect
on execution performance, whereas other parameters, such as using
larger block sizes, improved performance significantly.
The DBMS-X installation process was relatively straightforward.
A GUI leads the user through the initial steps on one of the cluster
nodes, and then prepares a file that can be fed to an installer utility in
parallel on the other nodes to complete the installation. Despite this
simple process, we found that DBMS-X was complicated to configure in order to start running queries. Initially, we were frustrated by
the failure of anything but the most basic of operations. We eventually discovered each node’s kernel was configured to limit the total
amount of allocated virtual address space. When this limit was hit,
new processes could not be created and DBMS-X operations would
fail. We mention this even though it was our own administrative error, as we were surprised that DBMS-X’s extensive system probing
and self-adjusting configuration was not able to detect this limitation. This was disappointing after our earlier Hadoop successes.
Even after these earlier issues were resolved and we had DBMSX running, we were routinely stymied by other memory limitations.
We found that certain default parameters, such as the sizes of the
buffer pool and sort heaps, were too conservative for modern systems. Furthermore, DBMS-X proved to be ineffective at adjusting
memory allocations for changing conditions. For example, the system automatically expanded our buffer pool from the default 4MB
to only 5MB (we later forced it to 512 MB). It also warned us that
performance could be degraded when we increased our sort heap
size to 128 MB (in fact, performance improved by a factor of 12).
Manually changing some options resulted in the system automatically altering others. On occasion, this combination of manual
and automatic changes resulted in a configuration for DBMS-X that
caused it to refuse to boot the next time the system started. As most
configuration settings required DBMS-X to be running in order to
adjust them, it was unfortunately easy to lock ourselves out with no
failsafe mode to restore to a previous state.
Vertica was relatively easy to install as an RPM that we deployed
on each node. An additional configuration script bundled with the
RPM is used to build catalog meta-data and modify certain kernel
parameters. Database tuning is minimal and is done through hints
to the resource manager; we found that the default settings worked
well for us. The downside of this simplified tuning approach, however, is that there is no explicit mechanism to determine what resources were granted to a query nor is there a way to manually
adjust per query resource allocation.
The take-away from our efforts is that we found parallel DBMSs
to be much more challenging than Hadoop to install and configure
properly. There is, however, a significant variation with respect to
ease of installation and configuration across the different parallel
database products. One small advantage for the database systems is
that the tuning that is needed is mostly done prior to query execution, and that certain tuning parameters (e.g., sort buffer sizes) are
suitable for all tasks. In contrast, for Hadoop we not only had to
tune the system (e.g., block sizes), but we also occasionally needed
to tune each individual task to work well with the system (e.g.,
changing code). Finally, the parallel database products came with
tools to aid in the tuning process whereas with Hadoop we were
forced to resort to trial and error tuning; clearly a more mature MR
implementation could include such tuning tools as well.