• Operating Systems

  • CentOS/RHEL 7.0 or later

  • Ubuntu 18.04 or later

• Additional Components

  • OpenJDK version 8 or higher

  • EPEL

  • wget or curl

  • Kernel headers

  • Kernel development packages

  • log4j 2.15.0 or higher

• NVIDIA hardware and software (for GPU installs only)

  • Hardware: Ampere, Turing, Volta, or Pascal series GPU cards. HEAVY.AI recommends that each GPU card in a server or distributed environment be of the same series.

  • Software:

    • NVIDIA CUDA drivers, version 470 or higher. Run nvidia-smi to determine the currently running driver.

    • Up-to-date Vulkan drivers.

• Supported web browsers (Enterprise Edition, Immerse). Latest stable release of:

  • Chrome

  • FireFox

  • Safari version 15.x or higher

What Will I Learn?

For Analysts

Learn how to use Immerse to gain new insights to your data with fast, responsive graphics and SQL queries.

For Administrators

Learn how to Install and configure your HEAVY.AI instance, then load data for analysis.

For Developers and Data Scientists

Learn how to extend HEAVY.AI with an integrated data science foundation and custom charts and interfaces. Contribute to the HEAVY.AI Core Open Source project.

Release Highlights

For more complete release information, see the Release Notes.

Release 6.4

HEAVY.AI continues to refine and extend the data connectors ecosystem. This release features general availability of data connectors for PostGreSQL, beta Immerse connectors for Snowflake and Redshift, and SQL support for Google BigQuery and Hive (beta). These managed data connections let you use HEAVY.AI as an acceleration platform, wherever your source data lives. Scheduling and automated caching ensure that from an end-user perspective, fast analytics are always running on the latest available data.

Immerse features four new chart types: Contour, Cross-section, Wind barb and Skew-t. While these are especially useful for atmospheric and geotechnical data visualization, Contour and Cross-section also have more general application.

Major improvements for time series analysis have been added. This includes time series comparison via window functions, and a large number of SQL window function additions and performance enhancements.

This release also includes two major architectural improvements:

• The ability to perform cross-database queries in SQL, increasing flexibility across the board.

• Render queries no longer block other GPU queries. In many use cases, renders can be significantly slower than other common queries. This should result in significant performance gains, particularly in map-heavy dashboards.

Release 6.2

Heavy Immerse

• Chart animation through cross filter replay, allowing controlled playback of time-based data such as weather maps or GPS tracks.

• You can now directly export your charts and dashboards as image files.

• New control panel enables administrators to view the configuration of the system and easily access logs and system tables.

• HeavyConnect now provides graphical Heavy Immerse support for Redshift, Snowflake, and PostGIS connections.

• For CPU-only systems, mapping capabilities are improved with the introduction of multilayer CPU-rendered geo.

General Analytics

• Numerous improvements to core SQL and geoSQL capabilities.

• Support for string to numeric, timestamp, date, and time types with the new TRY_CAST operator.

• Explicit and implicit cast support for numeric, timestamp, date, and time types.

• Advanced string functions facilitate extraction of data from JSON and externally encoded string formats.

• Improvements to COUNT DISTINCT reduces memory requirements considerably in cases with very large cardinalities or highly skewed data distributions.

• Added MULTIPOINT and MULTILINESTRING geo types.

• Convex and concave hull operators, allowing generation of polygons from points and multipoints. For example, you could generate polygons from clusters of GPS points.

• Syntax and performance optimizations across all geometry types, table orderings, and commonly nested functions.

• Significant functionality extension of window functions; define windows directly in temporal terms, which is particularly important in time series with missing observations. Window frame support allows improved control at the edges of windows.

Advanced Analytics

• Two new functions now support direct loading of LiDAR data: tf_point_cloud_metadata quickly searches tile metadata and helps you find data to import, and tf_load_point_cloud does the actual import importing.

• Network graph analytics functions have been added. These can work on networks alone, including non-geographic networks, or can find the least-cost path along a geographic network.

• New spatial aggregation and smoothing functions. Aggregations work particularly well with LiDAR data--for example to pass through only the highest point within an area to create building or canopy height maps. Smoothing helps with noisy datasets and can reveal larger-scale patterns while minimizing visual distractions.

Release 6.1

Release 6.1.0 features more granular administrative monitoring dashboards based on logs. These have been accessible in an open format on the server side, and now they are available in Immerse, by specific dashboards, users, or queries. Intermediate and advanced SQL support continues to mature, with INSERT, window functions, and UNION ALL.

This release contains a number of user interface polish items requested by customers. Cartography now supports polygons with colorful borders and transparent fills. Table presentation has been enhanced in various ways, from alignment to zebra striping. And dashboard saving reminders have been scaled back, based on customer feedback.

The extension framework now features an enhanced “custom source” dialog, as well as new SQL commands to see installed extensions and their parameters. We introduce three new extensions. The first, tf_compute_dwell_times, reduces GPS event stream data volumes considerably while keeping relevant information. The others compute feature similarity scores and are very general.

This release also includes initial public betas of our PostgreSQL Immerse connector, and SQL support for COPY FROM ODBC database connections, making it easier to connect to your enterprise data.

Release 6.0

This release features large advances in data access, including intelligent linking to enterprise data (HeavyConnect) and support for raster geodata. SQL support includes high-performance string functions, as well as enhancements to window functions and table unions. Performance improvements are noticeable across the product, including fundamental advances in rendering, query compilation, and data transport. Our system administration tools have been expanded with a new Admin Portal, as well as additional system tables supporting detailed diagnostics. Major strides in extensibility include new charting options and a new extensions framework (beta).

Name Changes

• Rebranded platform from OmniSci to HEAVY.AI, with OmniSciDB now HeavyDB, OmniSci Render now HeavyRender, and OmniSci Immerse now Heavy Immerse.

HeavyConnect and Data Import

• HeavyConnect allows the HEAVY.AI platform to work seamlessly as an accelerator for data in other data lakes and data warehouses. For Release 6.0, CSV and Parquet files on local file systems and in S3 buckets can be linked or imported. Other SQL databases are also supported via ODBC (beta).

• HeavyConnect enables users to specify a data refresh schedule, which ensures access to up-to-date data.

• Heavy Immerse now supports import of dozens of raster data formats, including geoTIFF, geoJPEG , and PNG. HeavySQL now supports most any vector GIS file format.

• Support is included for multidimensional arrays common in the sciences, including Grib2, NetCDF, and hd5.

• Immerse now supports linking or import of files on the server filesystem (local or mounted). This help prevent slow data transfers when client bandwidth is limited.

• File globbing and filtering allow import of thousands of files at once.

Other Immerse Enhancements

• New Gauge chart for easy visualization of key metrics relative to target thresholds.

• New landing page and Help Center.

• Enhanced mapping workflows with automated column picking.

SQL Enhancements

• Support for a wide range of performant string operations using a new string dictionary translation framework, as well as the ability to on-the-fly dictionary encode none-encoded strings with a new ENCODE_TEXT operator.

• Support for UNION ALL is now enabled by default, with significant performance improvements from the previous release (where it was beta flagged).

• Significant functionality and performance improvements for window functions, including the ability to support expressions in PARTITION and ORDER clauses.

Performance

• Parallel compilation of queries and a new multi-executor shared code cache provide up to 20% throughput/concurrency gains for interactive usage scenarios.

• 10X+ performance improvements in many cases for initial join queries via optimized Join Hash Table framework.

• New result set recycler allows for expensive query sub-steps to be cached via the SQL hint /*+ keep_result */, which can significantly increase performance when a subquery is used across multiple queries.

• Arrow execution endpoints now leverage the parallel execution framework, and Arrow performance has been significantly improved when high-cardinality dictionary-encoded text columns are returned

• Introduces a novel polygon rendering algorithm that does not require pre-triangulated or pre-grouped polygons and can render dynamically generated geometry on the fly (via ST_Buffer). The new algorithm is comparable to its predecessor in terms of both performance and memory and enables optimizations and enhancements in future releases.

• New binary transport protocol to Heavy Immerse that significantly increases performance and interactivity for large result sets

System Administration

• A new Admin Portal provides information on system resources usage and users.

• System table support under a new information_schema database, containing 10 new system tables providing system statistics and memory and storage utilization.

Extensibility

• New system and user-defined UDF framework (beta), comprising both row (scalar) and table (UDTF) functions, including the ability to define fast UDFs via Numba Python using the RBC framework, which are then inlined into the HeavyDB compiled query code for performant CPU and GPU execution.

• System-provided table functions include generate_series for easy numeric series generation, tf_geo_rasterize_slope for fast geospatial binning and slope/aspect computation over elevation data, and others, with more capabilities planned for future releases.

• Leveraging the new table function framework, a new HeavyRF module (licensed separate) includes tf_rf_prop and tf_rf_prop_max_signal table functions for fast radio frequency signal propagation analysis and visualization.

• New Iframe chart type in Heavy Immerse to allow easier addition of custom chart types. (BETA)

Release 5.10

• Row-level security (RLS) can be used by an administrator to apply security filtering to queries run as a user or with a role.

• Support for import from dozens of image and raster file types, such as jpeg, png, geotiff, and ESRI grid, including remote files.

• Significantly more performant, parallelized window functions, executing up to 10X faster than in Release 5.9.

• Automatic use of columnar output (instead of the default row-wise output) for large projections, reducing query times by 5-10X in some cases.

• Support for full set of ST_TRANSFORM SRIDs supported by geos/proj4 library.

• Support for numerous vector GIS files (100+ formats supported by current GDAL release).

• Support for multidimensional array import from formats common in science and meteorology.

• Improved Table chart export to access all data represented by a Table chart.

• Introduced dashboard-level named custom SQL.

Release 5.9

• Significant speedup for POINT and fixed-length array imports and CTAS/ITAS, generally 5-20X faster.

• The PNG encoding step of a render request is no longer a blocking step, providing improvement to render concurrency.

• Adds support to hide legacy chart types from add/edit chart menu in preparation for future deprecation (defaults to off).

• BETA - Adds custom expressions to table columns, allowing for reusable custom dimensions and measures within a single dashboard (defaults to off).

• BETA - Adds Crosslink feature with Crosslink Panel UI, allowing crossfilters to fire across different data sources within the same dashboard (defaults to off).

• BETA - Adds Custom SQL Source support and Custom SQL Source Manager, allowing the creation of a data source as a SQL statement (defaults to off)

Release 5.8

• Parallel execution framework is on by default. Running with multiple executors allows parts of query evaluation, such as code generation and intermediate reductions, to be executed concurrently. Currently available for single-node deployments.

• Spatial joins between geospatial point types using the ST_Distance operator are accelerated using the overlaps hash join framework, with speedups up to 100x compared to Release 5.7.1.

• Significant performance gains for many query patterns through optimization of query code generation, particularly benefitting CPU queries.

• Window functions can now be executed without a partition clause being specified (to signify a partition encompassing all rows in the table).

• Window functions can now execute over tables with multiple fragments and/or shards.

• Native support for ST_Transform between all UTM Zones and EPSG:4326 (Lon/Lat) and EPSG:900913 (Web Mercator).

• ST_Equals support for geospatial columns.

• Support for the ANSI SQL WIDTH_BUCKET operator for easier and more performant numeric binning, now also used in Immerse for all numeric histogram visualizations

• The Vulkan backend renderer is now enabled by default. The legacy OpenGL renderer is still available as a fallback if there are blocking issues with Vulkan. You can disable the Vulkan renderer using the renderer-use-vulkan-driver=false configuration flag.

  • Vulkan provides improved performance, memory efficiency, and concurrency.

  • You are likely to see some performance and memory footprint improvements with Vulkan in Release 5.8, most significantly in multi-GPU systems.

• Support for file path regex filter and sort order when executing the COPY FROM command.

• New ALTER SYSTEM CLEAR commands that enable clearing CPU or GPU memory from Immerse SQL Editor or any other SQL client.

Release 5.7

• Extensive enhancements to Immerse support for parameters. Parameters can now be used in chart column selectors, chart filters, chart titles, global filters, and dashboard titles. Dashboards can have parameter widgets embedded on them, side-by-side with charts. Parameter values are visible in chart axes/labels, legends, and tooltips, and you can toggle parameter visibility.

• In Immerse Pointmap charts, you can specify which color-by attribute always render on top, which is useful for highlight anomalies in data.

• Significantly faster and more accurate "lasso" tool filters geospatial data on Immerse Pointmap charts, leveraging native geospatial intersection operations.

• Immerse 3D Pointmap chart and HTML support in text charts are available as a beta feature.

• Airplane symbol shape has been added as a built-in mark type for the Vega rendering API.

• Vega symbol and multi-GPU polygon renders have been made significantly faster.

• User-interrupt of query kernels is now on by default. Queries can be interrupted using Ctrl + C in omnisql, or by calling the interrupt API.

• Parallel executors is in public beta (set with --num-executors flag).

• Support for APPROX_QUANTILE aggregate.

• Support for default column values when creating a table and across all append endpoints, including COPY TO, INSERT INTO TABLE SELECT, INSERT, and binary load APIs.

• Faster and more robust ability to return result sets in Apache Arrow format when queried from a remote client (i.e. non-IPC).

• More performant and robust high-cardinality group-by queries.

• ODBC driver now supports Geospatial data types.

Release 5.6

• Custom SQL dimensions, measures, and filters can now be parameterized in Immerse, enabling more flexible and powerful scenario analysis, projections, and comparison use cases.

• New angle measure added to Pointmap and Scatter charts, allowing orientation data to be visualized with wedge and arrow icons.

• Custom SQL modal with validation and column name display now enabled across all charts in Immerse.

• Significantly faster point-in-polygon joins through a new range join hash framework.

• Approximate Median function support.

• INSERT and INSERT FROM SELECT now support specification of a subset of columns.

• Automatic metadata updates and vacuuming for optimizing space usage.

• Significantly improved OmniSciDB startup time, as well as a number of significant load and performance improvements.

• Improvements to line and polygon stroke rendering and point/symbol rendering.

Release 5.5

• Ability to set annotations on New Combo charts for different dimension/measure combinations.

• New ‘Arrow-over-the-wire’ capability to deliver result sets in Apache Arrow format, with ~3x performance improvement over Thrift-based result set serialization.

• Support for concurrent SELECT and UPDATE/DELETE queries for single-node installations

• Initial OmniSci Render support for CPU-only query execution ("Query on CPU, render on GPU"), allowing for a wider set of deployment infrastructure choices.

• Cap metadata stored on previous states of a table by using MAX_ROLLBACK_EPOCHS, improving performance for streaming and small batch load use cases and modulating table size on disk

Release 5.4

• Added initial compilation support for NVIDIA Ampere GPUs.

• Improved performance for UPDATE and DELETE queries.

• Improved the performance of filtered group-by queries on large-cardinality string columns.

• Added SQL function SAMPLE_RATIO, which takes a proportion between 0 and 1 as an input argument and filters rows to obtain a sampling of a dataset.

• Added support for exporting geo data in GeoJSON format.

• Dashboard filter functionality is expanded, and filters can be saved as views.

• You can perform bulk actions on the dashboard list.

• New UI Setting panel in Immerse for customizing charts.

• Tabbed dashboards.

• SQL Editor now handles Vega JSON requests.

Release 5.3

• New Combo chart type in Immerse provides increased configurability and flexibility.

• Immerse chart-specific filters and quick filters add increased flexibility and speed.

• Updated Immerse Filter panel provides a Simple mode and Advanced mode for viewing and creating filters.

• On multilayer charts, layer visibility can be set by zoom level.

• Different map charts can be synced together for pan and zoom actions, regardless of data source.

• Array support for the Array type over JDBC.

• SELECT DISTINCT in UNION ALL is supported. (UNION ALL is prerelease and must be explicitly enabled.

• Support for joins on DECIMAL types.

• Performance improvements on CUDA GPUs, particularly Volta and Turing.

Release 5.2

• NULL support for geospatial types, including in ALTER TABLE ADD COLUMN.

• SQL SHOW commands: SHOW TABLES, SHOW DATABASES, SHOW CREATE TABLE, and SHOW USER SESSIONS.

• Ability to perform updates and deletes on temporary tables.

• Updates to JDBC driver, including escape syntax handling for the fn keyword and added support to get table metadata.

• Notable performance improvements, particularly for join queries, projection queries with order by and/or limit, queries with scalar subqueries, and multicolumn group-by queries.

• Query interrupt capability improved to allow canceling long-running queries, also supports JDBC now.

• Completely overhauled SQL Editor, including query formatting, snippets, history and more.

• Database switching from within Immerse, as well as dashboard URLs that contain the database name.

• Over 50% reduction in load times for the dashboards list initial load and search.

• Cohort builder now supports count (# records) in aggregate filter.

• Improved error handling and more meaningful error messages.

• Custom logos can now be configured separately for light and dark themes.

• Logos can be configured to deep-link to a specific URL.

Release 5.1

• Added support for UPDATE via JOIN with a subquery in the WHERE clause.

• Initial support for TEMPORARY (that is, non-persistent) tables.

• Improved performance for multi-column GROUP BY queries, as well as single column GROUP BY queries with high cardinality. Performance improvement varies depending on data volume and available hardware, but most use cases can expect a 1.5 to 2x performance increase over OmniSciDB 5.0.

• Improved support for EXISTS and NOT EXISTS subqueries.

• Added support for LINESTRING, POLYGON, and MULTIPOLYGON in user defined functions.

• Immerse log-ins are fully sessionized and persist across page refreshes.

• Pie chart now supports "All Others" and percentage labels.

• Cohorts can now be built with aggregation-based filters.

• New filter sets can be created through duplicating existing filter sets.

• Dashboard URLs now link to individual filter sets.

Release 5.0

• The new filter panel in Immerse enables the ability to toggle filters on and off, and introduces Filter Sets to provide quick access to different sets of filters in one dashboard.

• Immerse now supports using global and cross-filters to interactively build cohorts of interest, and the ability to apply a cohort as a dashboard filter, either within the existing filter set or in a new filter set.

• Data Catalog, located within Data Import, is a repository of datasets that users can use to enhance existing analyses.

  • To see these new features in action, please watch this video from Converge 2019, where Rachel Wang demonstrates how you can use them.

• Added support for binary dump and restore of database tables.

• Added support for compile-time registered user-defined functions in C++, and experimental support for runtime user-defined SQL functions and table functions in Python via the Remote Backend Compiler.

• Support for some forms of correlated subqueries.

• Support for update via subquery, to allow for updating a table based on calculations performed on another table.

• Multistep queries that generate large, intermediate result sets now execute up to 2.5x faster by leveraging new JIT code generator for reductions and optimized columnarization of intermediate query results.

• Frontend-rendered choropleths now support the selection of base map layers.

This sitemap link is for the benefit of the search crawler.

In this section, you will find recipes to install HEAVY.AI platform and NVIDIA drivers using package manager like apt or tarball.

This is an end-to-end recipe for installing HEAVY.AI on a Red Hat Enterprise 8.x machine using CPU and GPU devices.

Assumptions

These instructions assume the following:

• You are installing a "clean" Rocky Linux / RHEL 8 host machine with only the operating system.

• Your HEAVY.AI host only runs the daemons and services required to support HEAVY.AI.

• Your HEAVY.AI host is connected to the Internet.

Preparation

Prepare your machine by updating your system and optionally enabling or configuring a firewall.

Update and Reboot

Update the entire system and reboot the system if needed.

sudo dnf -y update
sudo reboot

Install the utilities needed to create HEAVY.AI repositories and download installation binaries.

sudo dnf -y install dnf-utils curl libldap2-dev

JDK

Follow these instructions to install a headless JDK and configure an environment variable with a path to the library. The “headless” Java Development Kit does not provide support for keyboard, mouse, or display systems. It has fewer dependencies and is best suited for a server host. For more information, see https://openjdk.java.net.

1. Open a terminal on the host machine.

2. Install the headless JDK using the following command:

sudo dnf -y install java-1.8.0-openjdk-headless

Create the HEAVY.AI User

Create a group called heavyai and a user named heavyai, who will own HEAVY.AI software and data on the file system.

You can create the group, user, and home directory using the useradd command with the --user-group and --create-home switches:

sudo useradd --user-group --create-home --groups wheel heavyai

Set a password for the user using the passwd command.

sudo passwd heavyai

Log in with the newly created user.

sudo su - heavyai

Installation

There are two ways to install the heavy.ai software

• DNF Installation To install software using DNF's package manager, you can utilize DNF's package management capabilities to search for and then install the desired software. This method provides a convenient and efficient way to manage software installations and dependencies on your system.

• Tarball Installation Installing via a tarball involves obtaining a compressed archive file (tarball) from the software's official source or repository. After downloading the tarball, you would need to extract its contents and follow the installation instructions provided by the software developers. This method allows for manual installation and customization of the software.

Install Nvidia Drivers ᴳᴾᵁ ᴼᴾᵀᴵᴼᴺ

If your system includes NVIDIA GPUs but the drivers are not installed, it is advisable to install them before proceeding with the suite installation.

See Install NVIDIA Drivers and Vulkan on Rocky Linux and RHEL for details.

Installing with DNF

Create a DNF repository depending on the edition (Enterprise, Free, or Open Source) and execution device (GPU or CPU) you will use.

sudo  dnf config-manager --add-repo \
https://releases.heavy.ai/ee/yum/stable/cuda

sudo yum-config-manager --add-repo \
https://releases.heavy.ai/ee/yum/stable/cpu

sudo yum-config-manager --add-repo \
https://releases.heavy.ai/os/yum/stable/cuda

sudo yum-config-manager --add-repo \
https://releases.heavy.ai/os/yum/stable/cpu

Add the GPG-key to the newly added repository.

sudo dnf config-manager --save \
--setopt="releases.heavy*.gpgkey=https://releases.heavy.ai/GPG-KEY-heavyai"

Use DNF to install the latest version of HEAVY.AI.

sudo dnf -y install heavyai.x86_64

Installing with a Tarball

Let's begin by creating the installation directory.

sudo mkdir /opt/heavyai && sudo chown $USER /opt/heavyai

Download the archive and install the latest version of the software. The appropriate archive is downloaded based on the edition (Enterprise, Free, or Open Source) and the device used for runtime.

curl \
https://releases.heavy.ai/ee/tar/heavyai-ee-latest-Linux-x86_64-render.tar.gz \
| sudo tar zxf - --strip-components=1 -C /opt/heavyai

curl \
https://releases.heavy.ai/ee/tar/heavyai-ee-latest-Linux-x86_64-cpu.tar.gz \
| sudo tar zxf - --strip-components=1 -C /opt/heavyai

curl \
https://releases.heavy.ai/os/tar/heavyai-os-latest-Linux-x86_64.tar.gz \
| sudo tar zxf - --strip-components=1 -C /opt/heavyai

curl \
https://releases.heavy.ai/os/tar/heavyai-os-latest-Linux-x86_64-cpu.tar.gz \
| sudo tar zxf - --strip-components=1 -C /opt/heavyai

Configuration

Follow these steps to configure your HEAVY.AI environment.

Set Environment Variables

For your convenience, you can update .bashrc with these environment variables

echo "# HEAVY.AI variable and paths
export HEAVYAI_PATH=/opt/heavyai
export HEAVYAI_BASE=/var/lib/heavyai
export HEAVYAI_LOG=\$HEAVYAI_BASE/storage/log
export PATH=\$HEAVYAI_PATH/bin:$PATH" \
>> ~/.bashrc
source ~/.bashrc

Initialization

Run the script that will initialize the HEAVY.AI services and database storage located in the systemd folder.

cd $HEAVYAI_PATH/systemd
./install_heavy_systemd.sh

Accept the default values provided or make changes as needed.

The script creates a data directory in $HEAVYAI_BASE/storage (typically /var/lib/heavyai) with the directories catalogs, dataand log, which will contain the metadata, the data of the database tables, and the log files from Immerse's web server and the database. The log folder is particularly important for database administrators. It contains data about the system's health, performance, and user activities.

Activation

The first step to activate the system is starting HeavyDB and the Web Server service that Heavy Immerse needs. ¹

Start the services and enable the automatic startup of the service at reboot and start the HEAVY.AI services.

sudo systemctl enable heavydb --now
sudo systemctl enable heavy_web_server --now

sudo systemctl enable heavydb --now

Configure the Firewall ᴼᴾᵀᴵᴼᴺᴬᴸ

If a firewall is not already installed and you want to harden your system, install and start firewalld.

sudo dnf -y install firewalld
sudo systemctl start firewalld
sudo systemctl enable firewalld
sudo systemctl status firewalld

To use Heavy Immerse or other third-party tools, you must prepare your host machine to accept incoming HTTP(S) connections. Configure your firewall for external access:

sudo firewall-cmd --zone=public --add-port=6273-6274/tcp --add-port=6278/tcp --permanent
sudo firewall-cmd --reload

For more information, see https://fedoraproject.org/wiki/Firewalld?rd=FirewallD.

Licensing HEAVY.AI ᵉᵉ⁻ᶠʳᵉᵉ ᵒⁿˡʸ

If you are on Enterprise or Free Edition, you need to validate your HEAVY.AI instance with your license key. You can skip this section if you are using Open Source Edition. ²

1. Copy your license key from the registration email message. If you have not received your license key, contact your Sales Representative or register for your 30-day trial here.

2. Connect to Heavy Immerse using a web browser connected to your host machine on port 6273. For example, http://heavyai.mycompany.com:6273.

3. When prompted, paste your license key in the text box and click Apply.

4. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

The $HEAVYAI_BASE directory must be dedicated to HEAVYAI; do not set it to a directory shared by other packages.

Final Checks

To verify that everything is working, load some sample data, perform a heavysql query, and generate a Pointmap using Heavy Immerse. ¹

Load Sample Data and Run a Simple Query

HEAVY.AI ships with two sample datasets of airline flight information collected in 2008, and a census of New York City trees. To install sample data, run the following command.

cd $HEAVYAI_PATH
sudo ./insert_sample_data --data /var/lib/heavyai/storage

#     Enter dataset number to download, or 'q' to quit:
Dataset           Rows    Table Name          File Name
1)    Flights (2008)    7M      flights_2008_7M     flights_2008_7M.tar.gz
2)    Flights (2008)    10k     flights_2008_10k    flights_2008_10k.tar.gz
3)    NYC Tree Census (2015)    683k    nyc_trees_2015_683k    nyc_trees_2015_683k.tar.gz

Connect to HeavyDB by entering the following command in a terminal on the host machine (default password is HyperInteractive):

$HEAVYAI_PATH/bin/heavysql -p HyperInteractive

anEnter a SQL query such as the following:

SELECT origin_city AS "Origin", 
dest_city AS "Destination", 
AVG(airtime) AS "Average Airtime" 
FROM flights_2008_10k WHERE distance < 175 
GROUP BY origin_city, dest_city;

The results should be similar to the results below.

Origin|Destination|Average Airtime
Austin|Houston|33.055556
Norfolk|Baltimore|36.071429
Ft. Myers|Orlando|28.666667
Orlando|Ft. Myers|32.583333
Houston|Austin|29.611111
Baltimore|Norfolk|31.714286

Create a Dashboard Using Heavy Immerse ᵉᵉ⁻ᶠʳᵉᵉ ᵒⁿˡʸ ¹

After installing Enterprise or Free Edition, check if Heavy Immerse is running as intended.

1. Connect to Heavy Immerse using a web browser connected to your host machine on port 6273. For example, http://heavyai.mycompany.com:6273.

2. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

¹ In the OS Edition, Heavy Immerse is unavailable.

² The OS Edition does not require a license key.

Install Prerequisites

Install the Extra Packages for Enterprise Linux (EPEL) repository and other packages before installing NVIDIA drivers.

sudo dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm

RHEL-based distributions require Dynamic Kernel Module Support (DKMS) to build the GPU driver kernel modules. For more information, see https://fedoraproject.org/wiki/EPEL. Upgrade the kernel and restart the machine.

sudo dnf -y upgrade kernel
sudo reboot now

Install Kernel Headers

Install kernel headers and development packages:

sudo dnf -y install kernel-devel-$(uname -r) kernel-headers-$(uname -r)

sudo dnf -y install \
kernel-devel-4.18.0-553.el8_10.x86_64 \
kernel-headers-4.18.0-553.el8_10.x86_64

Install the dependencies and extra packages:

Sudo dnf install -y kernel-devel kernel-headers pciutils dkms

Install NVIDIA Drivers and Vulkan

CUDA is a parallel computing platform and application programming interface (API) model. It uses a CUDA-enabled graphics processing unit (GPU) for general-purpose processing. The CUDA platform provides direct access to the GPU virtual instruction set and parallel computation elements. For more information on CUDA unrelated to installing HEAVY.AI, see https://developer.nvidia.com/cuda-zone. You can install drivers in multiple ways. This section provides installation information using the NVIDIA website or using dnf.

Install NVIDIA Drivers Using the NVIDIA Website

Install the CUDA package for your platform and operating system according to the instructions on the NVIDIA website (https://developer.nvidia.com/cuda-downloads).

If you do not know the GPU model installed on your system, run this command:

lspci -v | egrep "3D|VGA*.NVIDIA" | awk -F '\[|\]' ' { print $2 } '

The output shows the product type, series, and model. In this example, the product type is Tesla, the series is T (as Turing), and the model is T4.

Tesla T4

1. Select the product type shown after running the command above.

2. Select the correct product series and model for your installation.

3. In the Operating System dropdown list, select Linux 64-bit.

4. In the CUDA Toolkit dropdown list, click a supported version (11.4 or higher).

5. Click Search.

6. On the resulting page, verify the download information and click Download.

Move the downloaded file to the server, change the permissions, and run the installation.

chmod +x NVIDIA-Linux-x86_64-*.run
sudo ./NVIDIA-Linux--x86_64-*.runYou might get the following error during installation:

Install NVIDIA Drivers Using DNF

Install a specific version of the driver for your GPU by installing the NVIDIA repository and using the DNF package manager.

Add the NVIDIA network repository to your system.

sudo dnf config-manager --add-repo \
http://developer.download.nvidia.com/compute/cuda/repos/rhel8/$(uname -i)/cuda-rhel8.repo

Install the driver version needed with dnf. For 8.0, the minimum version is 535.

sudo dnf -y module install nvidia-driver:535-dkms

To load the installed driver, you can run sudo modprobe nvidia or nvidia-smi commands, or , in case of driver upgrade, you can reboot your system to ensure that the new version of the driver is loaded using the command sudo reboot

Check NVIDIA Driver Installation

Run the specified command to verify that your drivers are installed correctly and recognize the GPUs in your environment. Depending on your environment, you should see output confirming the presence of your NVIDIA GPUs and drivers. This verification step ensures that your system can identify and utilize the GPUs as intended.

Install Vulkan

The back-end renderer requires a Vulkan-enabled driver and the Vulkan library to work correctly. Without these components, the database cannot start without disabling the back-end renderer.

To ensure the Vulkan library and its dependencies are installed, use the DNF.

sudo dnf -y install vulkan

For more information about troubleshooting Vulkan, see the Vulkan Renderer section.

Install CUDA Toolkit ᴼᴾᵀᴵᴼᴺᴬᴸ

You must install the CUDA Toolkit if you use advanced features like C++ User-Defined Functions or User-Defined Table Functions to extend the database capabilities.

1. Add the NVIDIA network repository to your system:

sudo dnf config-manager --add-repo \
http://developer.download.nvidia.com/compute/cuda/repos/rhel8/$(uname -i)/cuda-rhel8.repo

2. List the available CUDA Toolkit versions using the DNF list command

dnf list cuda-toolkit-* | egrep -v config

Available Packages
cuda-toolkit-10-1.x86_64                     10.1.243-1        cuda-rhel8-x86_64
cuda-toolkit-10-2.x86_64                     10.2.89-1         cuda-rhel8-x86_64
cuda-toolkit-11-0.x86_64                     11.0.3-1          cuda-rhel8-x86_64
cuda-toolkit-11-1.x86_64                     11.1.1-1          cuda-rhel8-x86_64
cuda-toolkit-11-2.x86_64                     11.2.2-1          cuda-rhel8-x86_64
cuda-toolkit-11-3.x86_64                     11.3.1-1          cuda-rhel8-x86_64
cuda-toolkit-11-4.x86_64                     11.4.4-1          cuda-rhel8-x86_64
cuda-toolkit-11-5.x86_64                     11.5.2-1          cuda-rhel8-x86_64
cuda-toolkit-11-6.x86_64                     11.6.2-1          cuda-rhel8-x86_64
cuda-toolkit-11-7.x86_64                     11.7.1-1          cuda-rhel8-x86_64
cuda-toolkit-11-8.x86_64                     11.8.0-1          cuda-rhel8-x86_64
cuda-toolkit-12.x86_64                       12.5.0-1          cuda-rhel8-x86_64
cuda-toolkit-12-0.x86_64                     12.0.1-1          cuda-rhel8-x86_64
cuda-toolkit-12-1.x86_64                     12.1.1-1          cuda-rhel8-x86_64
cuda-toolkit-12-2.x86_64                     12.2.2-1          cuda-rhel8-x86_64
cuda-toolkit-12-3.x86_64                     12.3.2-1          cuda-rhel8-x86_64
cuda-toolkit-12-4.x86_64                     12.4.1-1          cuda-rhel8-x86_64
cuda-toolkit-12-5.x86_64                     12.5.0-1          cuda-rhel8-x86_64

3. Install the CUDA Toolkit version using DNF.

sudo dnf -y install cuda-toolkit-<version>.x86_64

4. Check that everything is working correctly:

nvcc --version

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2020 NVIDIA Corporation
Built on Mon_Nov_30_19:08:53_PST_2020
Cuda compilation tools, release 11.2, V11.2.67
Build cuda_11.2.r11.2/compiler.29373293_0

HEAVY.AI is an analytics platform designed to handle very large datasets. It leverages the processing power of GPUs alongside traditional CPUs to achieve very high performance. HEAVY.AI combines an open-source SQL engine (HeavyDB), server-side rendering (HeavyRender), and web-based data visualization (Heavy Immerse) to provide a comprehensive platform for data analysis.

HeavyDB

The foundation of the platform is HeavyDB, an open-source, GPU-accelerated database. HeavyDB harnesses GPU processing power and returns SQL query results in milliseconds, even on tables with billions of rows. HeavyDB delivers high performance with rapid query compilation, query vectorization, and advanced memory management.

Native SQL

With native SQL support, HeavyDB returns query results hundreds of times faster than CPU-only analytical database platforms. Use your existing SQL knowledge to query data. You can use the standalone SQL engine with the command line, or the SQL editor that is part of the Heavy Immerse visual analytics interface. Your SQL query results can output to Heavy Immerse or to third-party software such as Birst, Power BI, Qlik, or Tableau.

Geospatial Data

HeavyDB can store and query data using native Open Geospatial Consortium (OGC) types, including POINT, LINESTRING, POLYGON, and MULTIPOLYGON. With geo type support, you can query geo data at scale using special geospatial functions. Using the power of GPU processing, you can quickly and interactively calculate distances between two points and intersections between objects.

Open Source

HeavyDB is open source and encourages contribution and innovation from a global community of users. It is available on Github under the Apache 2.0 license, along with components like a Python interface (heavyai) and JavaScript infrastructure (mapd-connector, mapd-charting), making HEAVY.AI the leader in open-source analytics.

HeavyRender

HeavyRender works on the server side, using GPU buffer caching, graphics APIs, and a Vega-based interface to generate custom pointmaps, heatmaps, choropleths, scatterplots, and other visualizations. HEAVY.AI enables data exploration by creating and sending lightweight PNG images to the web browser, avoiding high-volume data transfers. Fast SQL queries make metadata in the visualizations appear as if the data exists on the browser side.

Network bandwidth is a bottleneck for complex chart data, so HEAVY.AI uses in-situ rendering of on-GPU query results to accelerate visual rendering. This differentiates HEAVY.AI from systems that execute queries quickly but then transfer the results to the client for rendering, which slows performance.

Geospatial Analysis

Efficient geospatial analysis requires fast data-rendering of complex shapes on a map. HEAVY.AI can import and display millions of lines or polygons on a geo chart with minimal lag time. Server-side rendering technology prevents slowdowns associated with transferring data over the network to the client. You can select location shapes down to a local level, like census tracts or building footprints, and cross-filter interactively.

Visualize with Vega

Complex server-side visualizations are specified using an adaptation of the Vega Visualization Grammar. Heavy Immerse generates Vega rendering specifications behind the scenes; however, you can also generate custom visualizations using the same API. This customizable visualization system combines the agility of a lightweight frontend with the power of a GPU engine.

Heavy Immerse

Heavy Immerse is a web-based data visualization interface that uses HeavyDB and HeavyRender for visual interaction. Intuitive and easy to use, Heavy Immerse provides standard visualizations, such as line, bar, and pie charts, as well as complex data visualizations, such as geo point maps, geo heat maps, choropleths, and scatter plots. Heavy Immerse provides quick insights and makes them easy to recognize.

Dashboards

Use dashboards to create and organize your charts. Dashboards automatically cross-filter when interacting with data, and refresh with zero latency. You can create dashboards and interact with conventional charts and data tables, as well as scatterplots and geo charts created by HeavyRender. You can also create your own queries in the SQL editor.

Charts

Heavy Immerse lets you create a variety of different chart types. You can display pointmaps, heatmaps, and choropleths alongside non-geographic charts, graphs, and tables. When you zoom into any map, visualizations refresh immediately to show data filtered by that geographic context. Multiple sources of geographic data can be rendered as different layers on the same map, making it easy to find the spatial relationships between them.

Create geo charts with multiple layers of data to visualize the relationship between factors within a geographic area. Each layer represents a distinct metric overlaid on the same map. Those different metrics can come from the same or a different underlying dataset. You can manipulate the layers in various ways, including reorder, show or hide, adjust opacity, or add or remove legends.

Use Multiple Sources

Heavy Immerse can visually display dozens of datasets in the same dashboard, allowing you to find multi-factor relationships that you might not otherwise consider. Each chart (or groups of charts) in a dashboard can point to a different table, and filters are applied at the dataset level. Multisource dashboards make it easier to quickly compare across datasets, without merging the underlying tables.

Streaming Data

Heavy Immerse is ideal for high-velocity data that is constantly streaming; for example, sensor, clickstream, telematics, or network data. You can see the latest data to spot anomalies and trend variances rapidly. Immerse auto-refresh automatically updates dashboards at flexible intervals that you can tailor to your use case.

Ready to Get Started?

This is an end-to-end recipe for installing HEAVY.AI on a Ubuntu 18.04/20.04 machine using CPU and GPU devices.

Assumptions

These instructions assume the following:

• You are installing on a “clean” Ubuntu 18.04/20.04 host machine with only the operating system installed.

• Your HEAVY.AI host only runs the daemons and services required to support HEAVY.AI.

• Your HEAVY.AI host is connected to the Internet.

Preparation

Prepare your Ubuntu machine by updating your system, creating the HEAVY.AI user (named heavyai), installing kernel headers, installing CUDA drivers, and optionally enabling the firewall.

Update and Reboot

1. Update the entire system:

2. Install the utilities needed to create Heavy.ai repositories and download archives:

3. Install the headless JDK and the utility apt-transport-https:

4. Reboot to activate the latest kernel:

Create the HEAVY.AI User

Create a group called heavyai and a user named heavyai, who will be the owner of the HEAVY.AI software and data on the filesystem.

1. Create the group, user, and home directory using the useradd command with the --user-group and --create-home switches.

2. Set a password for the user:

3. Log in with the newly created user:

Installation

Install the HEAVY.AI using APT and a tarball.

Install Nvidia Drivers ᴳᴾᵁ ᴼᴾᵀᴵᴼᴺ

Installing with APT

Download and add a GPG key to APT.

Add a source apt depending on the edition (Enterprise, Free, or Open Source) and execution device (GPU or CPU) you are going to use.

Use apt to install the latest version of HEAVY.AI.

Installing with a Tarball

First create the installation directory.

Download the archive and install the software. A different archive is downloaded depending on the Edition (Enterprise, Free, or Open Source) and the device used for runtime (GPU or CPU).

Configuration

Follow these steps to prepare your HEAVY.AI environment.

Set Environment Variables

For convenience, you can update .bashrc with these environment variables

Initialization

Run the systemd installer to create heavyai services, a minimal config file, and initialize the data storage.

Accept the default values provided or make changes as needed.

The script creates a data directory in $HEAVYAI_BASE/storage (default /var/lib/heavyai/storage) with the directories catalogs, data, export and log.The import directory is created when you insert data the first time. If you are HEAVY.AI administrator, the log directory is of particular interest.

Activation

Heavy Immerse is available in OS Edition, so the systemctl command using the heavy_web_server has no effect.

Enable the automatic startup of the service at reboot and start the HEAVY.AI services.

Configure Firewall ᴼᴾᵀᴵᴼᴺᴬᴸ

If a firewall is not already installed and you want to harden your system, install theufw.

To use Heavy Immerse or other third-party tools, you must prepare your host machine to accept incoming HTTP(S) connections. Configure your firewall for external access.

Licensing HEAVY.AI ᵉᵉ⁻ᶠʳᵉᵉ ᵒⁿˡʸ

If you are using Enterprise or Free Edition, you need to validate your HEAVY.AI instance with your license key.

1. Copy your license key of Enterprise or Free Edition from the registration email message. If you do not have a license and you want to evaluate HEAVI.AI in an unlimited
2. Connect to Heavy Immerse using a web browser connected to your host machine on port 6273. For example, http://heavyai.mycompany.com:6273.

3. When prompted, paste your license key in the text box and click Apply.

4. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

   .

Final Checks

Load Sample Data and Run a Simple Query

HEAVY.AI ships with two sample datasets of airline flight information collected in 2008, and a census of New York City trees. To install sample data, run the following command.

Connect to HeavyDB by entering the following command in a terminal on the host machine (default password is HyperInteractive):

Enter a SQL query such as the following

The results should be similar to the results below.

After installing Enterprise or Free Edition, check if Heavy Immerse is running as intended.

1. Connect to Heavy Immerse using a web browser connected to your host machine on port 6273. For example, http://heavyai.mycompany.com:6273.

2. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

¹ In the OS Edition, Heavy Immerse is unavailable.

² The OS Edition does not require a license key.

The amount of data you can process with the HEAVY.AI database depends primarily on the amount of GPU RAM and CPU RAM available across HEAVY.AI cluster servers. For zero-latency queries, the system caches compressed versions of the row- and column-queried fields into GPU RAM. This is called hot data (see ). Semi-hot data utilizes CPU RAM for certain parts of the data.

show example configurations to help you configure your system.

Optimal GPUs on which to run the HEAVY.AI platform include:

• NVIDIA Tesla A100

• NVIDIA Tesla V100 v2

• NVIDIA Tesla V100 v1

• NVIDIA Tesla P100

• NVIDIA Tesla P40

• NVIDIA Testa T4

The following configurations are valid for systems using any of these GPUs as the building blocks of your system. For production systems, use Tesla enterprise-grade cards. Avoid mixing card types in the same system; use a consistent card model across your environment.

Primary factors to consider when choosing GPU cards are:

• The amount of GPU RAM available on each card

• The number of GPU cores

• Memory bandwidth

Newer cards like the Tesla V100 have higher double-precision compute performance, which is important in geospatial analytics. The Tesla V100 models support the NVLink interconnect, which can provide a significant speed increase for some query workloads.

For advice on optimal GPU hardware for your particular use case, ask your HEAVY.AI sales representative.

HeavyDB Architecture

Before considering hardware details, this topic describes the HeavyDB architecture.

HeavyDB is a hybrid compute architecture that utilizes GPU, CPU, and storage. GPU and CPU are the Compute Layer, and SSD storage is the Storage Layer.

When determining the optimal hardware, make sure to consider the storage and compute layers separately.

Loading raw data into HeavyDB ingests data onto disk, so you can load as much data as you have disk space available, allowing some overhead.

When queries are executed, HeavyDB optimizer utilizes GPU RAM first if it is available. You can view GPU RAM as an L1 cache conceptually similar to modern CPU architectures. HeavyDB attempts to cache the hot data. If GPU RAM is unavailable or filled, HeavyDB optimizer utilizes CPU RAM (L2). If both L1 and L2 are filled, query records overflow to disk (L3). To minimize latency, use SSDs for the Storage Layer.

You can run a query on a record set that spans both GPU RAM and CPU RAM as shown in the diagram above, which also shows the relative performance improvement you can expect based on whether the records all fit into L1, a mix of L1 and L2, only L2, or some combination of L1, L2, and L3.

Hot Records and Columns

Projection-only Columns

CPU RAM

The amount of CPU RAM should equal four to eight times the amount of total available GPU memory. Each NVIDIA Tesla P40 has 24 GB of onboard RAM available, so if you determine that your application requires four NVIDIA P40 cards, you need between 4 x 24 GB x 4 (384 GB) and 4 x 24 GB x 8 (768 GB) of CPU RAM. This correlation between GPU RAM and CPU RAM exists because the HeavyDB uses CPU RAM in certain operations for columns that are not filtered or aggregated.

SSD Storage

A HEAVY.AI deployment should be provisioned with enough SSD storage to reliably store the required data on disk, both in compressed format and in HEAVY.AI itself. HEAVY.AI requires 30% overhead beyond compressed data volumes. HEAVY.AI recommends drives such as the Intel® SSD DC S3610 Series, or similar, in any size that meets your requirements.

Hardware Sizing Schedule

If you already have your data in a database, you can look at the largest fact table, get a count of those records, and compare that with this schedule.

If you have a .csv file, you need to get a count of the number of lines and compare it with this schedule.

CPU Cores

HEAVY.AI uses the CPU in addition to the GPU for some database operations. GPUs are the primary performance driver; CPUs are utilized secondarily. More cores provide better performance but increase the cost. Intel CPUs with 10 cores offer good performance for the price. For example, so you could configure your system with a single NVIDIA P40 GPU and two 10-core CPUs. Similarly, you can configure a server with eight P40s and two 10-core CPUs.

Suggested CPUs:

• Intel® Xeon® E5-2650 v3 2.3GHz, 10 cores

• Intel® Xeon® E5-2660 v3 2.6GHz, 10 cores

• Intel® Xeon® E5-2687 v3 3.1GHz, 10 cores

• Intel® Xeon® E5-2667 v3 3.2GHz, 8 cores

PCI Express (PCIe)

GPUs are typically connected to the motherboard using PCIe slots. The PCIe connection is based on the concept of a lane, which is a single-bit, full-duplex, high-speed serial communication channel. The most common numbers of lanes are x4, x8, and x16. The current PCIe 3.0 version with an x16 connection has a bandwidth of 16 GB/s. PCIe 2.0 bandwidth is half the PCIe 3.0 bandwidth, and PCIe 1.0 is half the PCIe 2.0 bandwidth. Use a motherboard that supports the highest bandwidth, preferably, PCIe 3.0. To achieve maximum performance, the GPU and the PCIe controller should have the same version number.

The PCIe specification permits slots with different physical sizes, depending on the number of lanes connected to the slot. For example, a slot with an x1 connection uses a smaller slot, saving space on the motherboard. However, bigger slots can actually have fewer lanes than their physical designation. For example, motherboards can have x16 slots connected to x8, x4, or even x1 lanes. With bigger slots, check to see if their physical sizes correspond to the number of lanes. Additionally, some slots downgrade speeds when lanes are shared. This occurs most commonly on motherboards with two or more x16 slots. Some motherboards have only 16 lanes connecting the first two x16 slots to the PCIe controller. This means that when you install a single GPU, it has the full x16 bandwidth available, but two installed GPUs each have x8 bandwidth.

HEAVY.AI does not recommend adding GPUs to a system that is not certified to support the cards. For example, to run eight GPU cards in a machine, the BIOS register the additional address space required for the number of cards. Other considerations include power routing, power supply rating, and air movement through the chassis and cards for temperature control.

NVLink

NVLink is a bus technology developed by NVIDIA. Compared to PCIe, NVLink offers higher bandwidth between host CPU and GPU and between the GPU processors. NVLink-enabled servers, such as the IBM S822LC Minsky server, can provide up to 160 GB/sec bidirectional bandwidth to the GPUs, a significant increase over PCIe. Because Intel does not currently support NVLink, the technology is available only on IBM Power servers. Servers like the NVIDIA-manufactured DGX-1 offer NVLink between the GPUs but not between the host and the GPUs.

System Examples

A variety of hardware manufacturers make suitable GPU systems. For more information, follow these links to their product specifications.

Installation Prerequisites

Upgrade the system and the kernel, then the machine if needed.

Install Kernel Headers

Install kernel headers and development packages.

Install the extra packages.

Installing Vulkan Library

The rendering engine of HEAVY.AI (present in Enterprise Editions) requires a Vulkan-enabled driver and the Vulkan library. Without these components, the database itself may not be able to start.

Install the Vulkan library and its dependencies using apt.

For more information about troubleshooting Vulkan, see the section.

Installing NVIDIA Drivers

Installing NVIDIA drivers with support for the CUDA platform is required to run GPU-enabled versions of HEAVY.AI.

You can install NVIDIA drivers in multiple ways, we've outlined three available options below. If you would prefer not to decide, we recommend Option 1.

What is CUDA? What is the CUDA toolkit?

The CUDA Toolkit from NVIDIA provides everything you need to develop GPU-accelerated applications. The CUDA Toolkit includes GPU-accelerated libraries, a compiler, development tools and the CUDA runtime. The CUDA Toolkit is not required to run HEAVY.AI, but you must install the CUDA toolkit if you use advanced features like C++ User-Defined Functions and or User-Defined Table Functions to extend the database capabilities.

Option 1: Install NVIDIA Drivers with CUDA Toolkit from NVIDIA Website

In the "Target Platform" section, follow these steps:

1. For "Operating System" select Linux

2. For Architecture" select x86_64

3. For "Distribution" select Ubuntu

4. For "Version" select the version of your operating system (18.04 or 20.04)

5. For "Installer Type" choose deb (network) **

6. One by one, run the presented commands in the Installer Instructions section on your server.

Option 2: Install NVIDIA Drivers via .run file using the NVIDIA Website

If you don't know the exact GPU model in your system run this command

You'll get an output in the format Product Type, Series and Model

In this example, the Product type is Tesla the Series is T (as Turing), and the model is T4.

1. Select the Product Type as the one you got with the command.

2. Select the correct Product Series and Product Type for your installation.

3. In the Operating System dropdown list, select Linux 64-bit.

4. In the CUDA Toolkit dropdown list, click a supported version (11.4 or higher).

5. Click Search.

6. On the resulting page, verify the download information and click Download

7. On the subsequent page, if you agree to the terms, right click on "Agree and Download" and select "Copy Link Address". You may also manually download and transfer to your server, skipping the next step.

8. On your server, type wget and paste the URL you copied in the previous step. Press enter to download.

Install the tools needed for installation.

Change the permissions of the downloaded .run file to allow execution, and run the installation.

Option 3: Install NVIDIA drivers using APT

Install a specific version of the driver for your GPU by installing the NVIDIA repository and using the apt package manager.

Run the command to get a list of the available driver's version

Install the driver version needed with apt

NVIDIA Driver Post-Installation steps

Reboot your system to ensure the new version of the driver is loaded

Verify Successful NVIDIA driver installation

Run nvidia-smi to verify that your drivers are installed correctly and recognize the GPUs in your environment. Depending on your environment, you should see something like this to confirm that your NVIDIA GPUs and drivers are present.

Install Vulkan library

The rendering engine of HEAVY.AI requires a Vulkan-enabled driver and the Vulkan library. Without these components, the database itself can't even start without disabling the back-end renderer.

Install the Vulkan library and its dependencies using apt.

Advanced Installation

You must install the CUDA toolkit and Clang if you use advanced features like C++ User-Defined Functions and or User-Defined Table Functions to extend the database capabilities.

Install CUDA Toolkit ᴼᴾᵀᴵᴼᴺᴬᴸ

Install the NVIDIA public repository GPG key.

Add the repository.

List the available Cuda toolkit versions.

Install the CUDA toolkit using apt.

Verification

Check that everything is working and the toolkit has been installed.

Install Clang ᴼᴾᵀᴵᴼᴺᴬᴸ

You must install Clang if you use advanced features like C++ User-Defined Functions and or User-Defined Table Functions to extend the database capabilities. Install Clang and LLVM dependencies using apt.

Verification

Check that the software is installed and in the execution path.

Follow these steps to install HEAVY.AI as a Docker container on a machine running with on CPU or with supported NVIDIA GPU cards using Ubuntu as the host OS.

Preparation

Prepare your host by installing Docker and if needed for your configuration NVIDIA drivers and NVIDIA runtime.

Install Docker

Remove any existing Docker Installs and if on GPU the legacy NVIDIA docker runtime.

Use curl to add the docker's GPG key.

Add Docker to your Apt repository.

Update your repository.

Install Docker, the command line interface, and the container runtime.

Run the following usermod command so that docker command execution does not require sudo privilege. Log out and log back in for the changes to take effect. (reccomended)

Verify your Docker installation.

Install NVIDIA Drivers and NVIDIA Container ᴳᴾᵁ ᴼᴾᵀᴵᴼᴺ

Install NVIDIA Docker Runtime

Use curl to add Nvidia's Gpg key:

Update your sources list:

Update apt-get and install nvidia-container-runtime:

Edit /etc/docker/daemon.json to add the following, and save the changes:

Restart the Docker daemon:

Check Nvidia Drivers

Verify that docker and NVIDIA runtime work together.

If everything is working you should get the output of nvidia-smi command showing the installed GPUs in the system.

HEAVY.AI Installation

Create a directory to store data and configuration files

Then a minimal configuration file for the docker installation

Download HEAVY.AI from DockerHub and Start HEAVY.AI in Docker. Select the tab depending on the Edition (Enterprise, Free, or Open Source) and execution Device (GPU or CPU) you are going to use.

Check that the docker is up and running a docker ps commnd:

You should see an output similar to the following.

Configure Firewall ᴼᴾᵀᴵᴼᴺᴬᴸ

If a firewall is not already installed and you want to harden your system, install theufw.

To use Heavy Immerse or other third-party tools, you must prepare your host machine to accept incoming HTTP(S) connections. Configure your firewall for external access.

Licensing HEAVY.AI ᵉᵉ⁻ᶠʳᵉᵉ ᵒⁿˡʸ

2. Connect to Heavy Immerse using a web browser to your host on port 6273. For example, http://heavyai.mycompany.com:6273.

3. When prompted, paste your license key in the text box and click Apply.

4. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

Command-Line Access

You can access the command line in the Docker image to perform configuration and run HEAVY.AI utilities.

You need to know the container-id to access the command line. Use the command below to list the running containers.

You see output similar to the following.

Once you have your container ID, in the example 9e01e520c30c, you can access the command line using the Docker exec command. For example, here is the command to start a Bash session in the Docker instance listed above. The -it switch makes the session interactive.

You can end the Bash session with the exit command.

Final Checks

Load Sample Data and Run a Simple Query

HEAVY.AI ships with two sample datasets of airline flight information collected in 2008, and a census of New York City trees. To install sample data, run the following command.

Where <container-id> is the container in which HEAVY.AI is running.

When prompted, choose whether to insert dataset 1 (7,000,000 rows), dataset 2 (10,000 rows), or dataset 3 (683,000 rows). The examples below use dataset 2.

Connect to HeavyDB by entering the following command (a password willò be asked; the default password is HyperInteractive):

Enter a SQL query such as the following:

The results should be similar to the results below.

Installing Enterprise or Free Edition, check if Heavy Immerse is running as intended.

1. Connect to Heavy Immerse using a web browser connected to your host machine on port 6273. For example, http://heavyai.mycompany.com:6273.

2. Log into Heavy Immerse by entering the default username (admin) and password (HyperInteractive), and then click Connect.

¹ In the OS Edition, Heavy Immerse Service is unavailable.

² The OS Edition does not require a license key.