/// <summary>
/// unloads the library
/// </summary>
public void Dispose()
{
if (m_LibHandle.val != IntPtr.Zero)
{
DynamicLibraries.UnloadDynLib(m_LibHandle);
m_LibHandle.val = IntPtr.Zero;
}
}
/// <summary>
///
/// </summary>
/// <param name="LibNames">
/// a list of library names
/// </param>
/// <param name="OsFilter">
/// Operating system filter
/// </param>
/// <param name="NameMangling">
///
/// name mangling, suggestions are: <see cref="LeadingUnderscore_SmallLetters"/>, <see cref="SmallLetters_TrailingUnderscore"/>
/// or <see cref="CAPITAL_LETTERS"/>
/// </param>
protected DynLibLoader(string[] LibNames, PlatformID[] OsFilter, GetNameMangling[] NameMangling)
{
if (LibNames.Length != OsFilter.Length || OsFilter.Length != NameMangling.Length)
{
throw new ApplicationException("all arrays must have the same length.");
}
PlatformID CurrentSys = System.Environment.OSVersion.Platform;
for (int i = 0; i < LibNames.Length; i++)
{
if (CurrentSys != OsFilter[i])
{
continue;
}
m_LibHandle = DynamicLibraries.LoadDynLib(LibNames[i]);
if (m_LibHandle.val == IntPtr.Zero)
{
continue;
}
Type myType = this.GetType();
FieldInfo[] fields = myType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
// loop over all delegates ....
foreach (FieldInfo fld in fields)
{
if (IsDelegate(fld.FieldType))
{
// get function name in DLL
string UnmanagedName = NameMangling[i](fld.Name);
// get function pointer
IntPtr FuncPtr = DynamicLibraries.LoadSymbol(m_LibHandle, UnmanagedName);
if (FuncPtr == IntPtr.Zero)
{
//throw new ApplicationException("Library '" + LibNames[i] + "' not working - missing function '" + UnmanagedName + "';");
DynamicLibraries.UnloadDynLib(m_LibHandle);
}
// create delegate
fld.SetValue(this, Marshal.GetDelegateForFunctionPointer(FuncPtr, fld.FieldType));
}
}
// successfully loaded all library functions
return;
}
// error
throw new ApplicationException("unable to find/load dynamic library - none supported on actual system.");
}
static void Main(string[] args)
{
using (var env = DynamicLibraries.LoadIpp())
{
Console.WriteLine("IPP available");
Console.Write("How many paths? [e.g. 10000]: ");
var nPaths = int.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
// working memory
var nVariables = 102; //100 normal draws and mu and sigma
var valueMem = Marshal.AllocHGlobal(sizeof(double) * nPaths * (2 + nVariables));
var gradientMem = valueMem + sizeof(double) * nPaths;
var variablesMem = gradientMem + sizeof(double) * nPaths;
var variables = Enumerable.Range(0, nVariables)
.Select(i => (i == 0 ? "mu" : i == 1 ? "sigma" : $"x{i - 2}",
(ptr: variablesMem + sizeof(double) * nPaths * i, seed: i == 0 ? 1.0 : 0.0))).ToDictionary(t => t.Item1, t => t.Item2);
var xValues = new double[nPaths * nVariables];
var rng = new Random();
for (int i = 0; i < nPaths; i++)
{
xValues[i] = 0.1; // mu
xValues[nPaths + i] = 0.5; // sigma
xValues[2 * nPaths + i] = 0.0; // x0
}
for (int i = nPaths * 3; i < nVariables * nPaths; i += 2)
{
var normal = Statistics.BoxMuller(rng.NextDouble(), rng.NextDouble());
xValues[i] = normal.x;
if (i + 1 < nPaths * nVariables)
{
xValues[i + 1] = normal.y;
}
}
Marshal.Copy(xValues, 0, variablesMem, nPaths * nVariables);
Expr node = new Var("x0");
Expr mu = new Var("mu");
Expr s = new Var("sigma");
double timeGrid = 0.01;
Expr dt = new Const(timeGrid);
Expr brownianScale = new Const(Math.Sqrt(timeGrid));
for (int i = 0; i < nVariables - 2; i++)
{
var brownianIncrement = new Mul(new[] { new Var($"x{i}"), brownianScale });
node = new Add(new[] { new Mul(new[] { mu, dt }), new Mul(new[] { s, brownianIncrement }), node });
}
var final = new Exp(node);
var state = final.Visit(new ForwardAdVisitor(), new CodeGenerator(valueMem, variables, gradientMem, (ulong)nPaths, LlvmBindings.BuildFunctions));
var executor = new LlvmExecutor(state);
executor.Run(env.FunctionPointers);
Console.WriteLine("Back in main, fetching result.");
var result = new double[nPaths];
Marshal.Copy(valueMem, result, 0, nPaths);
var gradResult = new double[nPaths];
Marshal.Copy(gradientMem, gradResult, 0, nPaths);
Console.WriteLine("E[X(100)] = {0}, expected 1.25", result.Average());
Console.WriteLine("dE[X(100)]/dmu = {0}, expected 1.25", gradResult.Average());
Marshal.FreeHGlobal(valueMem);
}
}
