The CPU (no GPUs) install does not support backend rendering. For example, Pointmap and Scatterplot charts are not available. The GPU install supports all chart types.

The Open Source options do not require a license, and do not include Heavy Immerse.

• Operating Systems

  • CentOS/RHEL 7.0 or later

  • Ubuntu 20.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 520 and Cuda 11.8 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

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

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

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

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

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

Heavy Immerse

Dashboards

Charts

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?

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.

What Will I Learn?

For Analysts

For Administrators

For Developers and Data Scientists

Release Highlights

Release 7.0

Overview

We are also pleased to announce the general availability of our new backend Executor Resource Manager with CPU / GPU parallelism and query policy controls such as executor type, memory and time limits. We can also now support CPU queries larger than available CPU memory.

This release also features the debut of a user interface for joins in Immerse (beta), supporting inner and left joins which are named and persisted in dashboards. This provides analytic and visualization access to joined columns, complementing the prior table linking function supporting cross-filtering.

Powerful machine learning (beta) and statistical methods (beta) are now available in the database, supporting high performance predictive analytics workflows. For example you can now perform clustering or run linear regression or random forest models on large datasets with interactive inferencing.

Immerse also gains a large set of dashboard refinements, including an optional ‘minimalist’ style with hidden chart titles, and an optional new text chart with full HTML and font controls.

There are several major external dependency updates in this release. With Ubuntu 18 reaching its end of life we now require Ubuntu 20.04. For similar reasons, we now support NVIDIA CUDA version 11.8, which deprecates support for Kepler GPUs. Last but not least, we are formally retiring polygon ‘render groups’ within the database, a change which is not backwards compatible. So full database backups are required as part of this upgrade.

Heavy Immerse

New Features and Improvements

• BETA: Joins in Immerse

• BETA: Enhanced text chart. The flag `ui/enable_new_text_chart` adds a “text2” chart type, with additional features:

  • font family (e.g. arial)

  • font sizes, line height

  • colors populated from dashboard palette

  • html table

  • undo/redo

  • separator line with styles

  • full html support

• Added a new “minimal” style mode in which chart titles are hidden by default but appear on rollover. Controlled by feature flag `ui/minimize_chart_size` which defaults to off

• Within map chart editor geo layers are now renamable

• Role-based access to control panel UX previously requiring admin access.

HeavyML (BETA)

7.0 marks the beta release of HeavyML, a new set of capabilities to execute accelerated machine learning workflows directly from SQL.

General Capabilities and Methods

• Named model creation is supported via a new CREATE MODEL statement (see the release notes and documentation for more details)

• Row-wise inference (GPU-accelerated for GPU queries) can be performed via a new ML_PREDICT row-wise operator. This can be used as an Immerse custom measure and persisted into dashboards, allowing end-users to consume models without needing to know how to create or administer them.

• An EVALUATE model function is provided to test models against metrics (such as r2).

• Table functions are provided to access linear regression coefficients for linear regression models and variable importance scores for random forest models.

• A new “SHOW MODELS” SQL command allows end users to determine which models are available.

• More-detailed model metadata can be accessed by admins with SHOW MODEL DETAILS and in a new ml_models system table in the information_schema database.

Regression Algorithms

• Four regression algorithms are supported initially: linear regression, random forest regression, decision trees, and Gradient Boosted Trees (GBT).

• Both categorical text and continuous numeric regressors/predictors are supported. Categorical inputs are automatically one-hot-encoded.

• Support for continuous variable prediction is initially supported, categorical classification is planned for a later release.

Clustering Algorithms

• Two clustering algorithms are supported in this initial release: KMeans and DBScan.

• Clustering algorithms can be called via associated table functions (more detail can be found in the relevant documentation), and currently support continuous numeric inputs only.

Performance and Administration

• A new Executor Resource Manager (ERM) framework is provided

• The ERM allows for CPU queries to run fully in parallel, and one or more CPU queries to run in parallel while a GPU query is executing (parallel GPU query kernel execution is not supported yet).

• It also allows execution of CPU queries where the input datasets do not fit into the CPU buffer pool by executing on a fragment-by-fragment basis, paging from storage.

• The Executor Resource Manager takes into account the resources needed for each query to schedule them in the most efficient manner.

• It is defaulted on, however it can be turned off using the following flag: --enable-executor-resource-mgr=0, which will lead query kernel execution to follow the same serial, pre-7.0 path.

HeavyRF

New Features and Improvements

A new “cell editor” is provided. This supports multi-band antennas mounted within various sites within a cell. Various antenna attributes such as horizontal and vertical falloff can be easily applied based on an extensible library of antenna types.

Vegetation and building envelope attenuation can now be directly or indirectly specified. For example, typical values can be provided as scalar constants, or clutter object-specific attributes can be derived from normal SQL cursor queries. Vegetation attenuation can be tied to measurements of canopy moisture content from remote sensing based on seasonal statistics, or for individual dates to match drive test data. Building attenuation can be driven by various known or inferred characteristics, such as from parcels databases.

The right-hand information panel has been extended to better support targeting of large numbers of buildings. This can be done directly by searching and filtering on building attributes in the HeavyRF application, such as building type or size. But it can also be combined with analyses in Immerse extending to multiple arbitrary tags. For example, a set of locations with high customer value and high potential for churn can be identified in Immerse and tagged with attributes searchable in HeavyRF.

Last but not least, the HeavyRF platform will soon be available on NVIDIA’s LaunchPad. This facilitates initial evaluation of the software by making it immediately available together with appropriate supporting GPU hardware.

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.

• 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.

• 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.

• 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.

• New filter sets can be created through duplicating existing 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.
• 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 is an end-to-end recipe for installing HEAVY.AI on a CentOS/RHEL 7 machine using CPU and GPU devices.

Assumptions

These instructions assume the following:

• You are installing on a “clean” CentOS/RHEL 7 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 Centos/RHEL 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.

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

JDK

1. Open a terminal on the host machine.

2. Install the headless JDK using the following command:

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:

Set a password for the user:

Log in with the newly created user:

Installation

Install HEAVY.AI using yum or a tarball.

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

If your system includes NVIDIA GPUs, but the drivers are not installed, install them now.

Installing with Yum

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

Add the GPG-key to the newly added repository.

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

Installing with a Tarball

First create the installation directory.

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

Configuration

Follow these steps to prepare your HEAVY.AI environment.

Set Environment Variables

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

Initialization

Run the systemd installer to initialize the HEAVY.AI services and the database storage.

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, data, export and log. The directory import is created when you insert data the first time. If you are a HeavyDB administrator, the log directory is of particular interest.

Activation

Note that Heavy Immerse is not available in the OS SEdition, so if running the OSS Edition 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 the Firewall ᴼᴾᵀᴵᴼᴺᴬᴸ

If a firewall is not already installed and you want to harden your system, install and start 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:

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

1. Open a terminal window.

2. Enter cd ~/ to go to your home directory.

3. Open .bashrc in a text editor. For example, vi .bashrc.

4. Edit the .bashrc file. Add the following export commands under “User specific aliases and functions.”

5. Save the .bashrc file. For example, in vi enter[esc]:x!

6. Open a new terminal window to use your changes.

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

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

10. 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

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.

HEAVY.AI Free is a full-featured version of the HEAVY.AI platform available at no cost for non-hosted commercial use.

To get started with HEAVY.AI Free:

2. On the Get HEAVY.AI Free page, enter your email address and click I Agree.

3. Open the HEAVY.AI Free Edition Activation Link email that you receive from HEAVY.AI, and click Click Here to view and download the free edition license. You will need this license to run HEAVY.AI after you install it. A copy of the license is also sent to your email.

Add Users

You can create additional HEAVY.AI users to collaborate with.

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

Install Prerequisites

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

For CentOS, use yum to install the epel-release package.

Use the following install command for RHEL.

Install Kernel Headers

Install kernel headers and development packages:

Install the dependencies and extra packages:

Install NVIDIA Drivers and Vulkan

Install NVIDIA Drivers Using the NVIDIA Website

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

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.

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.

Install NVIDIA Drivers Using Yum

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

Add the NVIDIA network repository to your system.

Run the available drivers for the download.

Install the driver version needed with yum.

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

Check 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

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

Install the Vulkan library and its dependencies using yum both CentOS and RHEL.

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:

2. List the available CUDA Toolkit versions:

3. Install the CUDA Toolkit using yum:

4. Check that everything is working correctly:

In this section you will find the recipes to install HEAVY.AI platform using Dcoker.

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.

sudo docker volume ls -q -f driver=nvidia-docker \
| xargs -r -I{} -n1 docker ps -q -a -f volume={} | xargs -r docker rm -f
sudo apt-get purge nvidia-docker
sudo apt-get remove docker docker-engine docker.io containerd runc

Use curl to add the docker's GPG key.

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo apt-key add -

Add Docker to your Apt repository.

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Update your repository.

sudo apt update

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

sudo apt install docker-ce docker-ce-cli containerd.io

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)

sudo usermod  --append --groups docker $USER

Verify your Docker installation.

sudo docker run hello-world

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

Install NVIDIA Docker Runtime

Use curl to add Nvidia's Gpg key:

curl --silent --location https://nvidia.github.io/nvidia-container-runtime/gpgkey | \
sudo apt-key add -

Update your sources list:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl --silent --location https://nvidia.github.io/nvidia-container-runtime/$distribution/nvidia-container-runtime.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-runtime.list

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

sudo apt-get update
sudo apt-get install -y nvidia-container-runtime

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

{
  "default-runtime": "nvidia",
  "runtimes": {
     "nvidia": {
         "path": "/usr/bin/nvidia-container-runtime",
         "runtimeArgs": []
     }
 }
}

Restart the Docker daemon:

sudo pkill -SIGHUP dockerd

Check Nvidia Drivers

Verify that docker and NVIDIA runtime work together.

sudo docker run --gpus=all \
--rm nvidia/cuda:11.0-runtime-ubuntu20.04 nvidia-smi

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

sudo mkdir -p /var/lib/heavyai && sudo chown $USER /var/lib/heavyai

Then a minimal configuration file for the docker installation

echo "port = 6274
http-port = 6278
calcite-port = 6279
data = \"/var/lib/heavyai\"
null-div-by-zero = true

[web]
port = 6273
frontend = \"/opt/heavyai/frontend\"" \
>/var/lib/heavyai/heavy.conf

if test -d /var/lib/heavyai; then echo "There is $(df -kh /var/lib/heavyai --output="avail" | sed 1d) avaibale space in you storage dir"; else echo "There was a problem with the creation of storage dir";  fi;

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.

sudo docker run -d --gpus=all \
-v /var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/heavyai-ee-cuda:latest

sudo docker run -d \
-v /var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/heavyai-ee-cpu:latest

sudo docker run -d --gpus=all \
-v /var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/core-os-cuda:latest

sudo docker run -d \
-v /var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/core-os-cpu:latest

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

sudo docker container ps --format "{{.Image}} {{.Status}}" \
-f status=running | grep heavyai\/

You should see an output similar to the following.

heavyai/heavyai-ee-cuda Up 48 seconds ago 

Configure Firewall ᴼᴾᵀᴵᴼᴺᴬᴸ

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

sudo apt install ufw
sudo ufw allow ssh

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 ufw disable
sudo ufw allow 6273:6278/tcp
sudo ufw enable

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.

sudo docker container ps

You see output similar to the following.

CONTAINER ID        IMAGE                     COMMAND                     CREATED             STATUS              PORTS                                            NAMES
9e01e520c30c        heavyai/heavyai-ee-gpu    "/bin/sh -c '/heavyai..."   50 seconds ago      Up 48 seconds ago   0.0.0.0:6273-6280->6273-6280/tcp                 confident_neumann

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.

sudo docker exec -it 9e01e520c30c bash

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.

sudo docker exec -it <container-id> \
./insert_sample_data --data /var/lib/heavyai/storage

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.

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 (a password willò be asked; the default password is HyperInteractive):

sudo docker exec -it <container-id> bin/heavysql 

Enter a SQL query such as the following:

SELECT origin_city AS "Origin", 
dest_city AS "Destination", 
ROUND(AVG(airtime),1) 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
West Palm Beach|Tampa|33.8
Norfolk|Baltimore|36.1
Ft. Myers|Orlando|28.7
Indianapolis|Chicago|39.5
Tampa|West Palm Beach|33.3
Orlando|Ft. Myers|32.6
Austin|Houston|33.1
Chicago|Indianapolis|32.7
Baltimore|Norfolk|31.7
Houston|Austin|29.6

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.

Installation Prerequisites

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

sudo apt update

sudo apt upgrade -y
sudo reboot

Install Kernel Headers

Install kernel headers and development packages.

sudo apt install linux-headers-$(uname -r)

Install the extra packages.

sudo apt install pciutils

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.

sudo apt install libvulkan1

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 (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

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

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

Tesla T4

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.

sudo apt install build-essential

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

chmod +x NVIDIA-Linux-x86_64-*.run
sudo ./NVIDIA-Linux--x86_64-*.run

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

apt list nvidia-driver-*
Listing... Done

nvidia-driver-450/bionic-updates,bionic-security 460.91.03-0ubuntu0.18.04.1 amd64
nvidia-driver-450-server/bionic-updates,bionic-security 450.172.01-0ubuntu0.18.04.1 amd64
nvidia-driver-455/bionic-updates,bionic-security 460.91.03-0ubuntu0.18.04.1 amd64
nvidia-driver-460/bionic-updates,bionic-security 470.103.01-0ubuntu0.18.04.1 amd64
nvidia-driver-465/bionic-updates,bionic-security 470.103.01-0ubuntu0.18.04.1 amd64
nvidia-driver-470/bionic-updates,bionic-security 470.103.01-0ubuntu0.18.04.1 amd64
nvidia-driver-470-server/bionic-updates,bionic-security 470.103.01-0ubuntu0.18.04.1 amd64
nvidia-driver-495/bionic-updates,bionic-security 510.60.02-0ubuntu0.18.04.1 amd64
nvidia-driver-510/bionic-updates,bionic-security 510.60.02-0ubuntu0.18.04.1 amd64
nvidia-driver-510-server/bionic-updates,bionic-security 510.47.03-0ubuntu0.18.04.1 amd64

Install the driver version needed with apt

sudo apt install nvidia-driver-<version>

NVIDIA Driver Post-Installation steps

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

sudo reboot

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.

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. 
Make sure that the latest NVIDIA driver is installed and running.

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.

sudo apt install libvulkan1

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.

distribution=$(. /etc/os-release;echo $ID$VERSION_ID | sed -e 's/\.//g')
sudo apt-key adv --fetch-keys \
https://developer.download.nvidia.com/compute/cuda/repos/$distribution/x86_64/3bf863cc.pub

Add the repository.

echo "deb http://developer.download.nvidia.com/compute/cuda/repos/$distribution/x86_64 /" \
| sudo tee /etc/apt/sources.list.d/cuda.list
apt update

List the available Cuda toolkit versions.

apt list cuda-toolkit-* | grep -v config

Listing...
cuda-toolkit-10-0/unknown 10.0.130-1 amd64
cuda-toolkit-10-1/unknown 10.1.243-1 amd64
cuda-toolkit-10-2/unknown 10.2.89-1 amd64
cuda-toolkit-11-0/unknown 11.0.3-1 amd64
cuda-toolkit-11-1/unknown 11.1.1-1 amd64
cuda-toolkit-11-2/unknown 11.2.2-1 amd64
cuda-toolkit-11-3/unknown 11.3.1-1 amd64
cuda-toolkit-11-4/unknown 11.4.4-1 amd64
cuda-toolkit-11-5/unknown 11.5.2-1 amd64
cuda-toolkit-11-6/unknown 11.6.2-1 amd64
cuda-toolkit-11-7/unknown 11.7.0-1 amd64

Install the CUDA toolkit using apt.

sudo apt install cuda-toolkit-<version>

Verification

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

/usr/local/cuda/bin/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

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.

sudo apt install clang

Verification

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

clang --version
clang version 10.0.0-4ubuntu1 
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin

This documentation outlines how to use HEAVY.AI’s Helm Chart within a Kubernetes environment. It assumes the user is a network administrator within your organization and is an experienced Kubernetes administrator. This is not a beginner guide and does not instruct on Kubernetes installation or administration. It is quite possible you will require additional manifest files for your environment.

Overview

The HEAVY.AI Helm Chart is a template of how to configure deployment of the HEAVY.AI platform. The following files need to be updated/created to reflect the customer's deployment environment.

• values.yml

• <customer_created>-pv.yml

• <customer_created>-pvc.yml

Once the files are updated/created, follow the installation instructions below to install the Helm Chart into your Kubernetes environment.

Where to get the Helm Chart?

What’s included?

How to install?

1. Before installing, create a PV/PVC that the deployment will use. Save these files in the regular PVC/PV location used in the customer’s environment. Reference the README.pdf file found in the Helm Chart under templates and the example PV/PVC manifests in the misc folder in the helm chart. The PVC name is then provided to the helm install command.

2. In your current directory; copy the values.yml file from the HEAVY.AI Helm Chart and customize for your needs.

3. Run the helm install command with the desired deployment name and Helm Chart.

   1. When using a values.yml file:

      $ helm install heavyai --values values.yml heavyaihelmchart-1.0.0.tgz

   2. When not using a values.yml file:

      If you only need to change a value or two from the default values.yml file you can use --set instead of a custom values.yml file.

      For example:

      $ helm install heavyai --set pvcName=MyPVCName heavyaihelmchart-1.0.0.tgz

How to uninstall?

To uninstall the helm installed HEAVY.AI instance:

$ helm uninstall heavyai

Example: values.yml

Example: example-heavyai-pvc.yml

Example: example-heavyai-pv.yml

Follow these instructions to get started with HEAVY.AI on Microsoft Azure.

Prerequisites

Configure Your HEAVY.AI Instance

To launch HEAVY.AI on Microsoft Azure, you configure a GPU-enabled instance.

1) Log in to you Microsoft Azure portal.

2) On the left side menu, create a Resource group, or use one that your organization has created.

3) On the left side menu, click Virtual machines, and then click Add.

4) Create your virtual machine:

• On the Basics tab:

  • In Project Details, specify the Resource group.

  • Specify the Instance Details:

    • Virtual machine name

    • Region

    • Image (Ubuntu 16.04 or higher, or CentOS/RHEL 7.0 or higher)

    • Size. Click Change size and use the Family filter to filter on GPU, based on your use case and requirements. Not all GPU VM variants are available in all regions.

  • For Username, add any user name other than admin.

  • In Inbound Port Rules, click Allow selected ports and select one or more of the following:

    • HTTP (80)

    • HTTPS (443)

    • SSH (22)

• On the Disks tab, select Premium or Standard SSD, depending on your needs.

• For the rest of the tabs and sections, use the default values.

5) Click Review + create. Azure reviews your entries, creates the required services, deploys them, and starts the VM.

6) Once the VM is running, select the VM you just created and click the Networking tab.

7) Click the Add inbound button and configure security rules to allow any source, any destination, and destination port 6273 so you can access Heavy Immerse from a browser on that port. Consider renaming the rule to 6273-Immerse or something similar so that the default name makes sense.

8) Click Add and verify that your new rule appears.

You can use the HEAVY.AI AWS AMI (Amazon Web Services Amazon Machine Image) to try HeavyDB and Heavy Immerse in the cloud. Perform visual analytics with the included New York Taxi database, or import and explore your own data.

Many options are available when deploying an AWS AMI. These instructions skip to the specific tasks you must perform to deploy a sample environment.

Prerequisite

You need a security key pair when you launch your HEAVY.AI instance. If you do not have one, create one before you continue.

1. Go to the EC2 Dashboard.

2. Select Key Pairs under Network & Security.

3. Click Create Key Pair.

4. Enter a name for your key pair. For example, MyKey.

5. Click Create. The key pair PEM file downloads to your local machine. For example, you would find MyKey.pem in your Downloads directory.

Launching Your Instance

2. Click Continue to Subscribe to subscribe.

3. Read the Terms and Conditions, and then click Continue to Configuration.

4. Select the Fulfillment Option, Software Version, and Region.

5. Click Continue to Launch.

6. On the Launch this software page, select Launch through EC2, and then click Launch.

7. From the Choose and Instance Type page, select an available EC2 instance type, and click Review and Launch.

8. Review the instance launch details, and click Launch.

9. Select a key pair, or click Create a key pair to create a new key pair and download it, and then click Launch Instances.

10. On the Launch Status page, click the instance name to see it on your EC2 Dashboard Instances page.

Using HEAVY.AI Immerse on Your AWS Instance

To connect to Heavy Immerse, you need your Public IP address and Instance ID for the instance you created. You can find these values on the Description tab for your instance.

To connect to Heavy Immerse:

1. Point your Internet browser to the public IP address for your instance, on port 6273. For example, for public IP 54.83.211.182, you would use the URL https://54.83.211.182:6273.

2. 1. Enter the USERNAME (admin), PASSWORD ( {Instance ID} ), and DATABASE (heavyai). If you are using the BYOL version, enter you license key in the key field and click Apply.

3. Click Connect.

4. On the Dashboards page, click NYC Taxi Rides. Explore and filter the chart information on the NYC Taxis Dashboard.

Importing Your Own Data

Working with your own familiar dataset makes it easier to see the advantages of HEAVY.AI processing speed and data visualization.

To import your own data to Heavy Immerse:

1. Export your data from your current datastore as a comma-separated value (CSV) or tab-separated value (TSV) file. HEAVY.AI supports Latin-1 ASCII format and UTF-8. If you want to load data with another encoding (for example, UTF-16), convert the data to UTF-8 before loading it to HEAVY.AI.

2. Point your Internet browser to the public IP address for your instance, on port 6273. For example, for public IP 54.83.211.182, you would use the URL https://54.83.211.182:6273.

3. Enter the USERNAME (admin) and PASSWORD ( {instance ID} ). If you are using the BYOL version, enter you license key in the key field and click Apply.

4. Click Connect.

5. Click Data Manager, and then click Import Data.

6. Drag your data file onto the table importer page, or use the directory selector.

7. Click Import Files.

8. Verify the column names and datatypes. Edit them if needed.

9. Enter a Name for your table.

10. Click Save Table.

11. Click Connect to Table.

12. On the New Dashboard page, click Add Chart.

13. Choose a chart type.

14. Add dimensions and measures as required.

15. Click Apply.

16. Enter a Name for your dashboard.

17. Click Save.

Accessing Your HEAVY.AI Instance Using SSH

1. Open a terminal window.

2. Locate your private key file (for example, MyKey.pem). The wizard automatically detects the key you used to launch the instance.

3. Your key must not be publicly viewable for SSH to work. Use this command to change permissions, if needed:

4. Connect to your instance using its Public DNS. The default user name is centos or ubuntu, depending on the version you are using. For example:
5. Use the following command to run the heavysql SQL command-line utility on HeavyDB. The default user is admin and the default password is { Instance ID }:

In this section, you will find recipes to upgrade from the OmniSci to the HEAVY.AI platform and upgrade between versions of the HEAVY.AI platform.

Supported Upgrade Path

The following table shows the steps needed to move from one version to a later one.

Example: if you are running an OmniSci version older than 5.5, you must first upgrade to 5.5, then upgrade to 6.0 and after that upgrade to 7.0. If you are running 6.0 - 6.4, you can upgrade directly to 7.0 in a single step.

This section is giving a recipe to upgrade between fully compatible products version.

Upgrading from Omnisci

If you need to upgrade from Omnisci to HEAVY.AI 6.0 or later, please refer to the specific recipe.

Upgrading Using Docker

To upgrade HEAVY.AI in place in Docker

In a terminal window, get the Docker container ID.

sudo docker container ps --format "{{.Id}} {{.Image}}" \
-f status=running | grep omnisci\/

You should see output similar to the following. The first entry is the container ID. In this example, it is 9e01e520c30c:

9e01e520c30c omnisci/omnisci-ee-gpu

Stop the HEAVY.AI Docker container. For example:

docker container stop 9e01e520c30c

Optionally, remove the HEAVY.AI Docker container. This removes unused Docker containers on your system and saves disk space.

docker container rm 9e01e520c30c

Backup the Omnisci data directory (typically /var/lib/omnisci)

tar zcvf /backup_dir/omnisci_storage_backup.tar.gz /var/lib/omnisci

Download the latest version of the HEAVY.AI Docker image according to the Edition and device you are actually coming from Select the tab depending on the Edition (Enterprise, Free, or Open Source) and execution Device (GPU or CPU) you are upgrading.

sudo docker run -d --gpus=all \
  -v /var/lib/heavyai:/var/lib/heavyai \
  -p 6273-6278:6273-6278 \
  heavyai/heavyai-ee-cuda:latest

sudo docker run -d -v \
/var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/heavyai-ee-cpu:latest

sudo docker run -d --gpu=all \
  -v /var/lib/heavyai:/var/lib/heavyai \
  -p 6273-6278:6273-6278 \
  heavyai/core-os-cuda:latest

sudo docker run -d -v \
/var/lib/heavyai:/var/lib/heavyai \
-p 6273-6278:6273-6278 \
heavyai/core-os-cpu:latest

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

sudo docker container ps --format "{{.Image}} {{.Status}}" \
-f status=running | grep heavyai\/

You should see an output similar to the following.

heavyai/heavyai-ee-cuda Up 48 seconds ago 

This runs both the HEAVY.AI database and Immerse in the same container.

Upgrading HEAVY.AI Using Package Managers and Tarball

To upgrade an existing system installed with package managers or tarball. The commands upgrade HEAVY.AI in place without disturbing your configuration or stored data

Stop the HEAVY.AI services.

sudo systemctl stop heavydb heavy_web_server

Back up your $HEAVYAI_STORAGE directory (the default location is /var/lib/heavyai).

Run the appropriate set of commands depending on the method used to install the previous version of the software.

sudo yum update heavyai.x86_64

sudo apt update
sudo apt upgrade heavyai

sudo mv /opt/heavyai /opt/heavyai_backup

When the upgrade is complete, start the HEAVY.AI services.

sudo systemctl start heavydb heavy_web_server

This section is giving a recipe to upgrade from Omnisci platform 5.5+ to HEAVY.AI 6.0.

Considerations when Upgrading from Omnisci to HEAVY.AI Platform

If you are upgrading from Omnisci to HEAVY.AI, there are a lot of additional steps compared to a simple sub-version upgrade.

Before Upgrading to Release 6.0

The omnisci the database will not be automatically renamed to the new default name heavyai.This will be done manually and it's documented in the upgrade steps.

Essential Changes for release 6.0 of HEAVY.AI compared to Omnisci

The following table describes the changes to environment variables, storage locations, and filenames in Release 6.0 compared to Release 5.x. Except where noted, revised storage subfolders, symlinks for old folder names, and filenames are created automatically on server start.

Change descriptions in bold require user intervention.

Upgrade Instructions

Assumptions

This upgrade procedure is assuming that you are using the default storage location for both Omnisci and HEAVY.AI.

Upgrading Using Docker

Stop all containers running Omnisci services.

In a terminal window, get the Docker container IDs:

You should see an output similar to the following. The first entry is the container ID. In this example, it is 9e01e520c30c:

Stop the HEAVY.AI Docker container. For example:

Backup the Omnisci data directory (typically /var/lib/omnisci).

Rename the Omnisci data directory to reflect the HEAVY.AI naming scheme.

Create a new configuration file for heavydb changing the data parameter to point to the renamed data directory.

Rename the Omnisci license file (EE and FREE only).

Download and run the 6.0 version of the HEAVY.AI Docker image.

Select the tab depending on the Edition (Enterprise, Free, or Open Source) and execution Device (GPU or CPU) you are upgrading.

Check that Docker is up and running using a docker ps command:

You should see output similar to the following:

Using the new container ID rename the default omnisci database to heavyai:

Check that everything is running as expected.

Upgrading to HEAVY.AI Using Package Managers or Tarball

To upgrade an existing system installed with package managers or tarball. The commands upgrade HEAVY.AI in place without disturbing your configuration or stored data.

Back up the Omnisci Database

Stop the Omnisci services.

Backup the Omnisci data directory (typically /var/lib/omnisci).

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

Set a password for the user. It'll need when sudo-ing.

Login with the newly created user

Rename the Omnisci data directory to reflect the HEAVY.AI naming scheme and change the ownership to heavyai user.

Create the "semaphore" catalog directory; we'll have to remove it later "

Check that everything is in order and that the "semaphore" directory is created,

All the directories must belong to the heavyai user, and the directory catalogs would be present

Rename the license file. (EE and FREE only)

Install the HEAVY.AI Software

Update the configuration file and rename the default database

Log in with the heavyai user and ensure the heavyai services are stopped.

Create a new configuration file for heavydb, changing the data parameter to point to the /var/lib/heavyai/storage directory and the frontend to the new install directory.

All the settings of the upgraded database will be moved to the new configuration file.

Now we have to complete the database migration.

Remove the "semaphore" directory we previously created. (this is a fundamental step needed for the omnsci to heavydb upgrade)

To complete the upgrade, start the HEAVY.AI servers.

Check if the database migrated, running this command and checking for the Rebrand migration complete message.

Rename the default omnisci database to heavyai. Run the command using an administrative user (typically admin) with his password (default HyperInteractive)

Restart the database service and check that everything is running as expected.

Remove Omnisci Software from the System

After all the checks confirmed that the upgraded system is stable, clean up the system to remove the Omnisci install and relative system configuration. Remove permanently the configuration of the services.

Remove the installed software.

Delete the YUM or APT repositories.

Installing the Drivers

Use the following commands to install the CUDA 11 compatibility drivers on Ubuntu:

After the last nvidia-smi, ensure that CUDA shows the correct version.

Updating systemd Files

After installing the drivers, update the systemd files in /lib/systemd/system/heavydb.service.

In the service section, add or update the environment property

The file should look like that

Then force the reload of the systemd configuration