Combine C-Sharp With CUDA and OpenCL On Linux, iOS, Android and Windows

Google Protobufs (via protobuf-net) in combination with the click-together framework taught in my CUDA and OpenCL tutorials allows C# and .NET programmers to include Linux and Windows GPU and Intel Xeon Phi codes in their workflows.

Mono

The freely available opensource mono-project creates C# executables that can run unchanged on both Linux and Windows – just copy the binary and dlls. Mono projects can also be built with Visual Studio. Further, mono supports both Android and IOS.  Thanks to mono-project, click-together tools, and Google protobufs, developers have an extraordinary ability to create workflows that utilize most current devices and operating systems.

Mono An open source, cross-platform, implementation of C# and the CLR that is binary compatible with Microsoft.NET DownloadLearn More

Xamarin.iOS (MonoTouch) Build apps for iPhone and iPad using C#, Visual Studio or MonoDevelop, and the Mono Framework Learn More

Xamarin.Android Build apps for Android devices using C#, Visual Studio or MonoDevelop, and the Mono Framework Learn More

 Click-together Tools

The “click-together” tools framework was originally developed by Rob Farber while a scientist in the theoretical division at Los Alamos and external faculty at the Santa Fe Institute. It has been in use since the 1980s and was designed to allow the creation of very efficient, scalable workflows. In this context, scalable means the ability to scale according to people (from one to many collaborators) and technology (from one workstations, to clusters and leadership class supercomputers).

Very simply, the click-together framework passes serialized packets of data from stdin to stdout or via other streaming connections like sockets and FIFOs. Applications can be written in the collaborators choice of language. As I wrote in my OpenCL tutorial:

For many applications, preprocessing the data can be as complicated and time consuming as the actual computation that generates the desired results. “Click together tools” is a common design pattern that enables flexible and efficient data workflows by creating a pipeline of applications to process information. Each element in the pipeline reads data from an input (usually stdin), performs some filtering or transformation operation, and writes the result to the output (usually stdout). Information flows through these pipelines as packets of information comprised of streams of bytes. All elements in a “click-together” pipeline have the ability to read a message (sometimes called a packet of information) and write it to an output. Based on the type of the packet of information, elements in the pipeline can decide to operate on the data or just pass it along to other elements in the pipeline.

A “click together” framework naturally exploits the parallelism of multi-core processors because each element in the pipeline is a separate application. The operating system scheduler ensures that any applications that have the data necessary to perform work will run – generally on separate processor cores. Buffering between applications allows very large data sets to be processed on the fly. Similarly, the parallelism of multiple machines can be exploited by piping data across machines with ssh, socat, or equivalent socket-based applications or libraries.

Data can be persistent, and in fact I use data sets created in the 1980s for validation and regression testing.

Dynamic compile load/link is used to create generic tools that allow the use of C, C++, CUDA, and OpenCL as scripting languages.

More about click-together tools can be found in my CUDA and OpenCL tutorials and a number of Supercomputing and NVIDIA GTC presentations such as  “Clicking GPUs into a Portable, Persistent and Scalable Massive Data” [video][FLV][PDF].

Why use click-together tools?

Flexibility:

• Use any machine or collection of machines (Local, LAN, WAN, Cloud)
• Use your own code – in your own language
• GPU acceleration!
• CUDA/OpenCL/OpenACC as a dynamically compiled RAD (Rapid Application Development) language

Application robustness

1. Most workflows use “known working” code (Most project require adding or changing just a few different modules)
2. Stream integrity voids network errors and “bitrot” in persistent data stores.

Protobuf-net

protobuf-net is a .NET implementation of Google Protobufs  that allows developers to serialize .NET objects efficiently and easily. It is compatible with most of the .NET family, including .NET 2.0/3.0/3.5, .NET CF 2.0/3.5, Mono 2.x, Silverlight 2, etc.

protocol buffers is the name of the binary serialization format used by Google for much of their data communications. It is designed to be:

• small in size – efficient data storage (far smaller than xml)
• cheap to process – both at the client and server
• platform independent – portable between different programming architectures
• extensible – to add new data to old messages

Programming Language support for Protobufs

These are projects Google reports that implement Protocol Buffers for other programming languages:

• Action Script: http://code.google.com/p/protobuf-actionscript3/
• Action Script: https://code.google.com/p/protoc-gen-as3/
• Action Script: https://github.com/matrix3d/JProtoc
• C: http://code.google.com/p/protobuf-c/
• C: http://koti.kapsi.fi/jpa/nanopb/
• C++: http://protobuf.googlecode.com/ (Google-official implementation)
• C/C++: http://spbc.sf.net/
• C#: http://code.google.com/p/protobuf-csharp-port
• C#: http://code.google.com/p/protosharp/
• C#: https://silentorbit.com/protobuf/
• C#/.NET/WCF/VB: http://code.google.com/p/protobuf-net/
• Clojure: http://github.com/ninjudd/clojure-protobuf
• Common Lisp: http://www.prism.gatech.edu/~ndantam3/docs/s-protobuf/
• Common Lisp: http://github.com/brown/protobuf
• D: http://256.makerslocal.org/wiki/index.php/ProtocolBuffer
• Dart: https://github.com/dart-lang/dart-protobuf (runtime) https://github.com/dart-lang/dart-protoc-plugin (code generator)
• Elixir: https://github.com/jeremyong/exprotoc
• Erlang: http://github.com/ngerakines/erlang_protobuffs/tree/master
• Erlang: http://piqi.org/
• Go: http://code.google.com/p/goprotobuf/
• Haskell: http://hackage.haskell.org/package/hprotoc
• Haxe: https://github.com/Atry/protoc-gen-haxe
• Java: http://protobuf.googlecode.com/ (Google-official implementation)
• Java/Android: https://github.com/square/wire
• Java ME: http://code.google.com/p/protobuf-javame/
• Java ME: http://swingme.sourceforge.net/encode.shtml
• Java ME: http://github.com/ponderingpanda/protobuf-j2me
• Java ME: http://code.google.com/p/protobuf-j2me/
• Javascript: http://code.google.com/p/protobuf-js/
• Javascript: http://github.com/sirikata/protojs
• Javascript: https://github.com/dcodeIO/ProtoBuf.js
• Julia: https://github.com/tanmaykm/ProtoBuf.jl
• Lua: http://code.google.com/p/protoc-gen-lua/
• Lua: http://github.com/indygreg/lua-protobuf
• Matlab: http://code.google.com/p/protobuf-matlab/
• Mercury: http://code.google.com/p/protobuf-mercury/
• Objective C: http://code.google.com/p/protobuf-objc/
• OCaml: http://piqi.org/
• Perl: http://groups.google.com/group/protobuf-perl
• Perl: http://search.cpan.org/perldoc?Google::ProtocolBuffers
• Perl/XS: http://code.google.com/p/protobuf-perlxs/
• PHP: http://code.google.com/p/pb4php/
• PHP: https://github.com/allegro/php-protobuf/
• PHP: https://github.com/chobie/php-protocolbuffers
• Python: http://protobuf.googlecode.com/ (Google-official implementation)
• R: http://cran.r-project.org/package=RProtoBuf
• Ruby: http://code.google.com/p/ruby-protobuf/
• Ruby: http://github.com/mozy/ruby-protocol-buffers
• Ruby: https://github.com/bmizerany/beefcake/tree/master/lib/beefcake
• Scala: http://github.com/jeffplaisance/scala-protobuf
• Scala: http://code.google.com/p/protobuf-scala
• Vala: https://launchpad.net/protobuf-vala
• Visual Basic: http://code.google.com/p/protobuf-net/

There are many RPC implementations and Utilities (e.g. NetBeans, etc) listed for Protobufs.

A simple C# example code to interface with the CUDA and OpenCL tutorials

Following is a simple C# console code to read and write a float and double-precision vector to the tutorial codes. This code corresponds to the testRead.cc and testWrite.cc codes in the CUDA and OpenCL tutorials. Note the namespace tutorial code was autogenerated by protobuf-net from the tutorial protobuf file.

Users can build this code in Visual Studio or mono. Don’t forget to include the protobuf-net .dll file in the references!