High Performance GPU computing with Ruby, Rubykaigi 2018

High Performance GPU
Computing with Ruby
Prasun Anand

About me
● Modak Analytics
● Genenetwork project
● SciRuby Contributor
● Google Summer of Code 2016, 2017
● Ruby Grant 2017
● Fukuoka Ruby Award 2018
● Projects:
○ JRuby port of NMatrix
○ ArrayFire gem
○ RbCUDA

Highlights
Modak Analytics is helping implement one of the largest Life Sciences
Platform in the world.
Platform Details
2100
Structured
data sources
500k
Tables
1350
Unstructured
sources
1.3
Billion
Files
1200
Data Nodes
6
Petabytes
Usable
information
• 1000+ clinical trials being standardized to
CDISC (SDTM) model for cross-study analysis,
placebo baseline etc.
• Single integrated data platform comprising of
compound, activity results, assay protocol and
project information
• “Like Minded” data has been grounded into
Data Domains by business areas. E.g. Clinical,
Assay, Gene, Regulatory etc
• Around 17+ solutions have been developed
and deployed for business
Awarded at the prestigious ‘Strata
Data Conference 2017’ for building
this platform in record time

Governed Data Lake approach
AUTOMATED
DATA DISCOVERY
• Modak is
providing
end-to-end
service for the
platform
including
Automated
Ingestion,
Curation, and
innovative
Solutions
• Modak is also
providing 24*7
support for the
massive platform
AUTOMATED
DATA INGESTION
Data Spider
Postgres
SQL serverOracle
MySQL
Structured Data
SAS Data Sets
Unstructured Data
File shares
SharePointDocumentum
BOTS
FOUNDATION
LAYER
Ingested
Raw Data
Data Tagging
Data Masking
Data
cleansing
Data lineage
Data profiling
Augmented Data
Mapping/
Standardization
Data
Fingerprinting
A replica of the
Data is
ingested into
the Integration
Layer
INTEGRATION
LAYER
SOLUTIONS
LAYER
Data Analytics
SEMANTICLAYER
Visulaisation
Dashboards
and Reports
MetaData
Catalog
(KOSH)
Flow
controller
Streamsets
Pipelines are
generated
automatically
Data Governance
Data Security
System / Application Management
SOURCE DATA
Originators of data and serve
as “authoring” systems to
support business processes
Optimized for computing and
distribution of data Optimized for strategic BI
product development
Optimized for
Business Users
Optimized for
Analysts, Data
scientists
GWAS

Genome Wide Association
Studies(GWAS)

Af_Array
[1] pry(main)> a = ArrayFire::Af_Array.new 2, [2,2],[1,2,3,4]
No Name Array
[2 2 1 1]
Offsets: [0 0 0 0]
Strides: [1 2 4 4]
1.0000 3.0000
2.0000 4.0000
=> #<ArrayFire::Af_Array:0x000000020aeab8>

[2] pry(main)> b = a + a
No Name Array
[2 2 1 1]
Offsets: [0 0 0 0]
Strides: [1 2 4 4]
2.0000 6.0000
4.0000 8.0000
=> #<ArrayFire::Af_Array:0x000000020625c8>

[1] pry(main)> left = ArrayFire::Af_Array.new 2 , [3,3] , [1, 4, 6, 4, 11 , 2 ,-5, 8, 10]
No Name Array
[3 3 1 1]
1.0000 4.0000 -5.0000
4.0000 11.0000 8.0000
6.0000 2.0000 10.0000
=> #<ArrayFire::Af_Array:0x000000014e56c8>
[2] pry(main)> right = ArrayFire::Af_Array.new 2 , [3,2] , [1, 0, 8, 10, -11, 8]
No Name Array
[3 2 1 1]
1.0000 10.0000
0.0000 -11.0000
8.0000 8.0000
=> #<ArrayFire::Af_Array:0x00000001591db0>

[3] pry(main)> result = ArrayFire::BLAS.matmul(left, right, :AF_MAT_NONE, :AF_MAT_NONE)
No Name Array
[3 2 1 1]
-39.0000 -74.0000
68.0000 -17.0000
86.0000 118.0000
=> #<ArrayFire::Af_Array:0x000000016136f8>

VALUE arf_init(int argc, VALUE* argv, VALUE self)
{
afstruct* afarray;
Data_Get_Struct(self, afstruct, afarray);
dim_t ndims = (dim_t)NUM2LONG(argv[0]);
dim_t* dimensions = (dim_t*)malloc(ndims * sizeof(dim_t));
dim_t count = 1;
for (size_t index = 0; index < ndims; index++) {
dimensions[index] = (dim_t)NUM2LONG(RARRAY_AREF(argv[1], index));
count *= dimensions[index];
}
double* host_array = (double*)malloc(count * sizeof(double));
for (size_t index = 0; index < count; index++) {
host_array[index] = (double)NUM2DBL(RARRAY_AREF(argv[2], index));
}
af_create_array(&afarray->carray, host_array, ndims, dimensions, f64);
return self;
}

static VALUE arf_matmul(VALUE self, VALUE left_val, VALUE right_val, VALUE left_prop_val, VALUE
right_prop_val){
afstruct* left;
afstruct* right;
afstruct* result = ALLOC(afstruct);
Data_Get_Struct(left_val, afstruct, left);
Data_Get_Struct(right_val, afstruct, right);
af_mat_prop left_mat_prop = arf_mat_type_from_rbsymbol(left_prop_val);
af_mat_prop right_mat_prop = arf_mat_type_from_rbsymbol(right_prop_val);
af_matmul(&result->carray, left->carray, right->carray, left_mat_prop, right_mat_prop);
return Data_Wrap_Struct(CLASS_OF(left_val), NULL, arf_free, result);
}

BLAS functionalities
● Matmult
● Transpose
LAPACK functionalities
● Det
● Inverse
● Norm
● Qr
● Cholesky
● Svd
● lu

Statistics
● Mean
● Median
● Variance

Benchmarks
● AMD FX 8350 octacore processor
● Nvidia GTX 750Ti GPU
● Double dtype

10 X
Faster than NMatrix-Ruby-Lapack

10,000 X
Faster than NMatrix-Ruby

100,000 X
Faster than NMatrix-Ruby-BLAS

GPU Array
● Generic pointer used to handle an array of elements on the GPU.
● Memory copying from CPU to GPU and vice-versa.
● Interfaced with NMatrix and NArray

vadd_kernel_src = <<-EOS
extern "C" {
__global__ void matSum(int *a, int *b, int *c)
{
int tid = blockIdx.x;
if (tid < 100)
c[tid] = a[tid] + b[tid];
}
}
EOS
f = compile(vadd_kernel_src)
RbCUDA::Driver.run_kernel(f.path)

● CuBLAS
● CuSolver
● CuRand

1,000,000 X
Faster than NMatrix-Ruby-BLAS

Fastest Matrix Multiplication
Library in Ruby!

Future Work
● Image Processing APIs and Indexers
● Multiple dtypes
● RbCUDA is under development.

● https://github.com/arrayfire/arrayfire-rb
● https://github.com/prasunanand/rbcuda
Contributions are Welcome!

Acknowledgements
1. Pjotr Prins
2. Pradeep Garigipati
3. Kenta Murata
4. Ruby Science Foundation
5. Ruby Association
6. Modak Analytics

Thanks!
Github: prasunanand
Twitter: @prasun_anand
Blog: prasunanand.com

High Performance GPU computing with Ruby, Rubykaigi 2018

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a High Performance GPU computing with Ruby, Rubykaigi 2018

Semelhante a High Performance GPU computing with Ruby, Rubykaigi 2018 (20)

Último

Último (20)

High Performance GPU computing with Ruby, Rubykaigi 2018