public void MeasurePool()
{
Info("Measuring memory pool performance");
Info("---------------------------------");
ILArray <int> Lengths = ILMath.toint32(ILMath.vector(1000000, 1000, 1000000));
ILArray <int> PoolSizes = ILMath.toint32(ILMath.vector(00, 10, 250));
ILArray <double> result = ILMath.zeros(Lengths.Length, PoolSizes.Length);
ILArray <double> dataA = ILMath.ones(1000, 1000);
ILArray <double> dataB = ILMath.ones(1000, 1000);
int counter = 1, countAll = Lengths.Length * PoolSizes.Length;
for (int p = 0; p < PoolSizes.Length; p++)
{
for (int s = 0; s < Lengths.Length; s++)
{
result[s, p] = MeasurePoolParameter((int)Lengths[s], (int)PoolSizes[p], 100, dataA, dataB);
Console.Out.Write(String.Format("\r... step {0} of {1} completed", counter++, countAll));
}
}
result.Name = "results";
ILMatFile mf = new ILMatFile();
mf["results"] = result;
mf["lengths"] = Lengths;
mf["poolSizes"] = PoolSizes;
mf.Write(new FileStream("memoryPoolTestPerf.mat", FileMode.Create));
}
protected void StoreIgnoreIds(string outDir)
{
// store ignore ids
ILMatFile ignoreIDs = new ILMatFile();
ILArray <int> ids = new ILArray <int>(m_manualIgnoreIds.ToArray(), m_manualIgnoreIds.Count, 1);
ignoreIDs["ignored"] = ids;
using (Stream outStream = new FileStream(outDir + Path.DirectorySeparatorChar + "ignored.mat", FileMode.Create, FileAccess.ReadWrite)) {
ignoreIDs.Write(outStream);
}
}
static void Main(string[] args)
{
using (ILScope.Enter()) {
ILCell data = Helper.DBQuery();
// data is:
//Cell [2,2]
//[0]: <String> header 1 <Double> [100,200]
//[1]: <String> header 2 <Single> [2,3000]
// store into mat file
ILMatFile mat = new ILMatFile();
var key1 = (string)data.GetArray <string>(0, 0);
mat.AddArray(data.GetArray <double>(0, 1), key1); // stores rand(100,200) as key: "header1"
// proceed with other columns...
// write mat file
mat.Write("filename");
}
}
/// <summary>
/// generate single test case
/// </summary>
/// <param name="arrProv">test data provider (ILCell, specific type)</param>
/// <param name="definition">case definition</param>
/// <returns>localPostfixedTestCaseName</returns>
public string AutoCreateTestCase(ILTestArrayProvider arrProv, ILTestCaseDefinition definition)
{
StringBuilder ocs = new StringBuilder("clear output*;");
string matInputFileName = INPUT_PARAMETER_PREFIX + ".mat";
string matOutputFileName = OUTPUT_PARAMETER_PREFIX + ".mat";
string resultOverridesFileName = OVERRIDES_PARAMETER_PREFIX + ".mat";
ILCell inputVars = arrProv.GenerateTestArrays();
ILMatFile matFile = new ILMatFile();
List <string> inTag = new List <string>();
List <string> outTag = new List <string>();
string outTagJoined;
string inTagJoined;
ocs.Append("\n" + String.Format("parameter = load('{0}');", matInputFileName));
for (int i = 0; i < inputVars.Dimensions[0]; i++)
{
inTag.Clear(); outTag.Clear();
// handle input parameters
for (int c = 0; c < definition.InputParameterCount; c++)
{
string ident = "_" + i.ToString() + "_" + c.ToString();
matFile[INPUT_PARAMETER_PREFIX + ident] = inputVars.GetValue(i, c);
inTag.Add("parameter." + INPUT_PARAMETER_PREFIX + ident);
}
// handle output parameters
for (int c = 0; c < definition.OutputParameterCount; c++)
{
string ident = "_" + i.ToString() + "_" + c.ToString();
outTag.Add(OUTPUT_PARAMETER_PREFIX + ident);
}
//outTagJoined = String.Join(",", outTag.ToArray());
//inTagJoined = String.Join(",", inTag.ToArray());
List <object> allTags = new List <object>();
foreach (string s in inTag)
{
allTags.Add(s);
}
foreach (string s in outTag)
{
allTags.Add(s);
}
string octaveFuncCall = String.Format(definition.OctaveFunctionDef, allTags.ToArray());
ocs.Append(String.Format("\ntry {0} catch {1} = 'Exception'; end",
octaveFuncCall, outTag[0]));
}
// the name for the case directory will be postfixed with the arrayprovider types ('double',...)
string localPostfixedTestCaseName = definition.TestCaseName + "_" + arrProv.GetIdentifierPostfix();
string TestCaseOutputPath = Path.Combine(m_baseDirectory, RelativeTestCasePath);
TestCaseOutputPath = Path.Combine(TestCaseOutputPath, localPostfixedTestCaseName)
+ Path.DirectorySeparatorChar;
if (Directory.Exists(TestCaseOutputPath))
{
Directory.Delete(TestCaseOutputPath, true);
}
Directory.CreateDirectory(TestCaseOutputPath);
// save matfile
using (Stream outStream = new FileStream(TestCaseOutputPath + matInputFileName, FileMode.Create)) {
matFile.Write(outStream);
}
// finish + save creation script
ocs.Append(String.Format("\n\nsave ('{0}','{1}*','-v6');", matOutputFileName, OUTPUT_PARAMETER_PREFIX));
File.WriteAllText(TestCaseOutputPath + OCTAVE_CREATION_SCRIPT_NAME, ocs.ToString());
#region create test class file
inTag.Clear(); outTag.Clear();
List <string> inTagR = new List <string>();
StringBuilder testRunFunc = new StringBuilder();
// handles input parameter
for (int i = 0; i < definition.InputParameterCount; i++)
{
testRunFunc.Append(String.Format(@"{1} {2}{0} = ({1})m_inputMatfile[""{2}_""+id.ToString()+""_{0}""];
{2}{0}.Detach();"
, i.ToString(), arrProv.GetCSharpTypeDefinition(), INPUT_PARAMETER_PREFIX));
inTag.Add(INPUT_PARAMETER_PREFIX + i.ToString());
inTagR.Add(INPUT_PARAMETER_PREFIX + i.ToString() + ".R");
}
// handles output parameter
StringBuilder errorCheckString = new StringBuilder();
for (int i = 0; i < definition.OutputParameterCount; i++)
{
testRunFunc.Append(Environment.NewLine + "\t\t\t\t"
+ String.Format(@"ILBaseArray parameter{0} = null;", i));
outTag.Add("parameter" + i.ToString());
// error checking
errorCheckString.Append(String.Format(@"
if (!(parameter{0}.IsEmpty & m_outputMatfile[""output_""+id.ToString()+""_{0}""].IsEmpty) &&
(!TestHelper.TestEqualSloppy(parameter{0},m_outputMatfile[""{1}_""+id.ToString()+""_{0}""]))) {{
Error(""result{0} does not match expected value! parameterset: #""+id.ToString()+"",input #0: "" + input0.Dimensions.ToString());
return ProcessParameterErrorInfo(id, parameter{0}, {2}, {3}, {0}, m_inputMatfile, m_outputMatfile,{4});
}}", i.ToString(), OUTPUT_PARAMETER_PREFIX, definition.InputParameterCount, definition.OutputParameterCount, escape(definition.TargetFunctionDef)));
}
outTagJoined = String.Join(",", outTag.ToArray());
inTagJoined = String.Join(",", inTag.ToArray());
string inTagRJoined = String.Join(",", inTagR.ToArray());
inTag.AddRange(outTag);
inTagR.AddRange(outTag);
string targetFunction = String.Format(definition.TargetFunctionDef, inTag.ToArray());
// create dense test
testRunFunc.Append(Environment.NewLine + "\t\t\t\t" + targetFunction);
testRunFunc.Append(errorCheckString.ToString());
// create reference test
targetFunction = String.Format(definition.TargetFunctionDef, inTagR.ToArray());
testRunFunc.Append(Environment.NewLine + "\t\t\t\t" + targetFunction);
testRunFunc.Append(errorCheckString.ToString());
// finish
string runtimeRelPath2matFiles = Path.Combine(m_baseDirectoryRelative2EXE, RelativeTestCasePath) + Path.DirectorySeparatorChar
+ localPostfixedTestCaseName
+ Path.DirectorySeparatorChar;
string testClass = String.Format(HEADER, localPostfixedTestCaseName, // 0
runtimeRelPath2matFiles + matInputFileName,
runtimeRelPath2matFiles + matOutputFileName, // 1,2
inputVars.Dimensions[0].ToString(),
testRunFunc.ToString(),
arrProv.GetCSharpTypeDefinition(),
runtimeRelPath2matFiles + resultOverridesFileName);
File.WriteAllText(TestCaseOutputPath + localPostfixedTestCaseName + ".cs", testClass);
#endregion
if (DeleteResultsOnRecreate)
{
if (File.Exists(TestCaseOutputPath + matOutputFileName))
{
File.Delete(TestCaseOutputPath + matOutputFileName);
}
}
#region write ResultOverrides
if (definition.ResultOverrides != null)
{
ILMatFile overridesMatFile = new ILMatFile();
bool mustWriteOverrides = false;
foreach (ILResultOverride overr in definition.ResultOverrides)
{
if (overr.TestArrayProvider == arrProv)
{
// foreach override find matching parameters in current provider
for (int o = 0; o < overr.Inputs.Dimensions[0]; o++)
{
for (int i = 0; i < inputVars.Dimensions[0]; i++)
{
if (ILMath.isequalwithequalnans(
overr.Inputs[o, null], inputVars[i, null]))
{
// matching override found
System.Diagnostics.Debug.Assert(overr.Outputs.Dimensions[1] == inputVars.Dimensions[1]);
for (int c = 0; c < inputVars.Dimensions[1]; c++)
{
string ident = "_" + i.ToString() + "_" + c.ToString();
overridesMatFile[OUTPUT_PARAMETER_PREFIX + ident] = overr.Outputs[o, c];
}
mustWriteOverrides = true;
}
}
}
}
}
if (mustWriteOverrides)
{
using (FileStream overridesStream = new FileStream(TestCaseOutputPath + OVERRIDES_PARAMETER_PREFIX + ".mat", FileMode.Create)) {
overridesMatFile.Write(overridesStream);
}
}
else if (File.Exists(TestCaseOutputPath + OVERRIDES_PARAMETER_PREFIX + ".mat"))
{
File.Delete(TestCaseOutputPath + OVERRIDES_PARAMETER_PREFIX + ".mat");
}
}
#endregion
return(localPostfixedTestCaseName);
}