Updated docs

Author: deepakkumar1984

doc-gen/_site/manifest.json

@@ -0,0 +1,98 @@
+# Alternate methods to execute kernels
+
+In the "Run your first kernel" guide, you have used the executer instance to run the compiler in a simple fashion. Here are more ways to execute and you can choose the way you like
+
+## Using Array For Loop
+
+Let's try to implement some simple neural network activation kernel as below
+
+```csharp
+class ForLoopKernels : OpenCLFunctions
+{
+    [OpenCLKernel]
+    void Sigmoid([Global]float[] x)
+    {
+        int i = get_global_id(0);
+        x[i] = exp(x[i]) / (exp(x[i]) + 1);
+    }
+
+    [OpenCLKernel]
+    void Threshold([Global] float[] x, float value)
+    {
+        int i = get_global_id(0);
+        x[i] = x[i] > value ? 1 : 0;
+    }
+}
+```
+
+And if we need to invoke using AmplifyFor loop which is an extension method for an array, here is the below code:
+
+```csharp
+public void Execute()
+{
+    //Create instance of OpenCL compiler and use device
+    var compiler1 = new OpenCLCompiler();
+    compiler1.UseDevice(0);
+
+    var compiler2 = new OpenCLCompiler();
+    compiler1.UseDevice(1);
+
+    compiler1.CompileKernel(typeof(ForLoopKernels));
+    compiler2.CompileKernel(typeof(ForLoopKernels));
+
+    float[] x = new float[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+    x.AmplifyFor(compiler1, "Sigmoid");
+    PrintArray(x);
+
+    Console.WriteLine();
+
+    x.AmplifyFor(compiler2, "Threshold", 0.85f);
+    PrintArray(x);
+}
+
+private void PrintArray(float[] data)
+{
+    for(int i=0;i<data.Length;i++)
+    {
+        Console.Write(data[i] + " ");
+    }
+}
+```
+
+## Using compiler execute function
+
+The compiler execute function is the base for all the other kernel invoke. Below is the sample implementation for the same example we have above:
+
+```csharp
+public void Execute()
+{
+    //Create instance of OpenCL compiler and use device
+    var compiler1 = new OpenCLCompiler();
+    compiler1.UseDevice(0);
+
+    var compiler2 = new OpenCLCompiler();
+    compiler1.UseDevice(1);
+
+    compiler1.CompileKernel(typeof(ForLoopKernels));
+    compiler2.CompileKernel(typeof(ForLoopKernels));
+
+    float[] x = new float[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+    compiler1.Execute<float>("Sigmoid", x);
+    PrintArray(x);
+
+    Console.WriteLine();
+
+    compiler2.Execute<float>("Threshold", x, 0.85f);
+    PrintArray(x);
+}
+
+private void PrintArray(float[] data)
+{
+    for(int i=0;i<data.Length;i++)
+    {
+        Console.Write(data[i] + " ");
+    }
+}
+```

doc-gen/articles/Execute Kernel Alternatives.md

@@ -0,0 +1,53 @@
+# Saving and loading the compiler
+
+Saving the compiler after compiling the kernel and reusing it is an efficient way of working. This save a lot of compilation time and the saved bin file can be reused in other project.
+
+Below is how you can save a compiler after compiling with kernel class. Simply invoke Save function passing the file name:
+
+```csharp
+private void SaveCompiler()
+{
+    //Create instance of OpenCL compiler
+    var compiler = new OpenCLCompiler();
+
+    //Select a default device
+    compiler.UseDevice(0);
+
+    //Compile the sample kernel
+    compiler.CompileKernel(typeof(SimpleKernels));
+    compiler.Save("amp_cl.bin");
+}
+```
+
+Create another project file, and you can copy the amp_cl.bin file to the new project directory. Below is the code to load and execute, note that you don't have to compile anything here.
+
+```csharp
+//Once saved you can reuse the same bin instead of compiling from scratch. Save compilation time. Also the bin file is portable
+var compiler = new OpenCLCompiler();
+compiler.Load("amp_cl.bin");
+
+foreach (var item in compiler.Kernels)
+{
+    Console.WriteLine(item);
+}
+
+//Create variable a, b and r
+Array x = new float[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+Array y = new float[9];
+
+//Get the execution engine
+var exec = compiler.GetExec<float>();
+
+//Execute fill kernel method
+exec.Fill(y, 0.5f);
+
+//Execuete SAXPY kernel method
+exec.SAXPY(x, y, 2f);
+
+//Print the result
+Console.WriteLine("\nResult----");
+for (int i = 0; i < y.Length; i++)
+{
+    Console.Write(y.GetValue(i) + " ");
+}
+```

doc-gen/articles/Save and load.md

@@ -11,3 +11,7 @@ Following are the list of useful functions to build and run the kernel
    2. args: List of arguments array or scalar values.
 
 6. **GetExecuter**: Get the executer for the compiler which can seemlesly invoke the kernel methods. Internally it calls the compiler Execute function.
+
+7. **Save**: Save the compiler in form of binary for reusablibity.
+
+8. **Load**: Load the saved bin compiler file. Avoids recompilation of kernel.

doc-gen/articles/Useful functions.md

@@ -6,3 +6,7 @@
   href: Create a simple kernel.md
 - name: Run your first kernel
   href: Run your first kernel.md
+- name: Alternate methods to execute kernels
+  href: Execute Kernel Alternatives.md
+- name: Saving and loading compiler
+  href: Save and load.md