Hybridizer Essentials For Linux – Beta

With version 1.1.6151.9352 comes a beta version of Hybridizer Essentials for Linux.

You can download the package from our github.

Prerequisites:

  • Tested on Ubuntu 16.04 – should work on other debian-based systems
  • Install a version of CUDA (starting at 8.0 – 9.0, 9.1 and 9.2 supported)
  • Install Mono (version 5.8.0.108 or later)

Installation:

  • Intall deb package #> sudo dpkg -i hybridizer-essentials-amd64-.deb
  • Package will install in /opt/altimesh/hybridizer-essentials

Request a license:

  • Run /opt/altimesh/hybridizer-essentials/bin/RequestLicense.exe and follow the instructions.
  • The license key for your machine will be sent to you by email to the address you are invited to provide.
  • Edit a .hybridizerrc configuration in your home directory and paste the license after the hostname and column. Here is an example:
    MyMachineHostName: yTfgNaoGHDZYpP7t0+ECTLeaUuNr<...>lPg==

Automatic Null Checks : mitigate null pointers exceptions

As every modern language, C# exposes the null reference billion dollar mistake. On the other hand, native languages such as CUDA or C/C++ expose null pointers. To mitigate that, latest versions of compilers tend to introduce some form of automatic null checks.
For example, Typescript recently added a --strictNullChecks option, and C#, following a proposal, will expose similar features.

When it comes to CUDA, null pointers can pop out virtually anywhere. You can explicitely return nullptr in some cases, and forget to check against it at some point in your code. You can also allocate local memory by using malloc which returns null when no more memory is available.

A example

For example, have a look at this simple toy code:

unsafe class Program
    {
        struct MyStruct
        {
            public fixed double large[1000001]; // 8 extra bytes
        }

        [IntrinsicFunction("malloc")]
        static void* malloc(int s)
        {
            return (void*)Marshal.AllocHGlobal(s);
        }

        [IntrinsicFunction("free")]
        static void free(void* ptr)
        {
            Marshal.FreeHGlobal(new IntPtr(ptr));
        }

        [EntryPoint]
        public static void Run(double[] output, double[] input)
        {
            MyStruct* ptr = (MyStruct*) malloc(sizeof(MyStruct));
            for (int k = 0; k < 1000001; ++k) {
                ptr->large[k] = input[k];
            }

            free(ptr);
        }

        static void Main(string[] args)
        {
            cudaDeviceProp prop;
            cuda.GetDeviceProperties(out prop, 0);
            HybRunner runner = HybRunner.Cuda("NullChecks_CUDA.dll").SetDistrib(1, 1);
            dynamic wrapped = runner.Wrap(new Program());

            int threadCount = 1;
            double[] output = new double[threadCount];
            double[] input = new double[1000001];
            wrapped.Run(output, input);
        }
    }

Since we allocate 8000008 bytes per thread, we exceed the cudaLimitMallocHeapSize limit of 8MB, and malloc will return NULL.

Running the above code in Release mode yields the following output:


System.ApplicationException: CUDA error occured before deserialization (most probably during kernel call): an illegal memory access was encountered
at Hybridizer.Runtime.CUDAImports.CudaSerializationState.CUDADeserializer.InitialVisit(Object param)
at Hybridizer.Runtime.CUDAImports.NativeSerializerState.UpdateManagedData(Object param)

Leverage automatic null checks

As of version 1.0.5923.8928, Hybridizer proposes automatic null checks with various behaviors:

Print

The good old printf debugging! Just add -DHYBRIDIZER_NULL_CHECKS_PRINT to Hybridizer Jitter Options, recompile, and you’ll get:

null pointer at directory\Program.cs:31
System.ApplicationException: CUDA error occured before deserialization (most probably during kernel call): an illegal memory access was encountered

handy isn’t it?

Break

Add -DHYBRIDIZER_NULL_CHECKS_BREAK to Hybridizer Jitter Options. Then recompile and start CUDA debugging, and debugger will stop just before the illegal memory access:
automatic null checks