[SYSTEMML-1325] Support for GPU in JMLC and Harmonize Script Execution Pipelines

[thomas9t]

This PR adds support for compilation and execution of GPU enabled scripts in JMLC and harmonizes the pipeline used to compile and execute DML programs across the JMLC, MLContext and DMLScript (command line) APIs. Specifically, the following changes were made:

1. All three APIs now call ScriptExecutorUtils.compileRuntimeProgram to compile DML scripts. The original logic in MLContext and JMLC for pinning inputs and persisting outputs has been preserved.
2. All three APIs now use ScriptExecutorUtils.executeRuntimeProgram to execute the compiled program. Previously, JMLC called the Script.execute method directly.
3. jmlc.Connection.prepareScript now supports compiling a script to use GPU. Compiling a GPU enabled program requires modifying static flags in DMLScript. Because of this, it is necessary to synchronize compilation when using GPU to ensure only a single program is being compiled at any one time. Otherwise, a script being compiled to use CPU only may incorrectly use GPU enabled opertors. To avoid unnecessary synchronization in the more common case that multiple JMLC scripts are being compiled to use CPU only, we perform a static check at startup to see if the user has included the JCuda dependency in the pipeline. If so, we assume they may want to use GPU and compilation is synchronized. Otherwise, compilation remains unsynchronized.
4. A PreparedScript is now statically assigned a GPU context when it is compiled and instatiated. This has potential performance implications because it means that a PreparedScript must be executed on a specific GPU. However, it reduces overhead from creating a GPU context each time a script is executed and unsures that a user cannot compile a script to use GPU and then forget to assign a GPU context when the script is run.

@niketanpansare, @bertholdreinwald, @mboehm7 and @deroneriksson can you please take a look over these changes and let me know if you have comments/questions.

[mboehm7]

Overall, this is a great start. Let's also flag this with SYSTEMML-1325 during the merge, because we want to consolidate the replicated compilation chain for a while now.

There is just one scenario where the current approach wouldn't work. JMLC allows for dynamic recompilation. If there are multiple JMLC streams with different GPU configurations (which are also used for recompilation during runtime), the approach of static variables and synchronized compilation is not sufficient. Maybe we could promote these flags to thread-local compiler configurations similar to the recompilation configuration?