private static void AddErrorCases(Random random)
{
{
// error case
Vector2I outerDimensions = (704, 2256);
uint[] data = GC.AllocateUninitializedArray <uint>(outerDimensions.Area);
random.NextBytes(data.AsSpan().AsBytes());
Bounds innerBounds = new((703, 1912), (1, 264));
ReadOnlySpan <byte> dataBytes = data.AsSpan().AsBytes();
var format = SurfaceFormat.Color;
var actualWidth = format.SizeBytes(innerBounds.Extent.X);
var rawStride = format.SizeBytes(outerDimensions.Width);
var rawOffset = (rawStride * innerBounds.Top) + format.SizeBytes(innerBounds.Left);
SpriteDataSet set = new(
false,
new(
array : dataBytes.ToArray(),
offset : rawOffset,
width : actualWidth,
height : innerBounds.Extent.Y,
pitch : rawStride - actualWidth
)
);
DataSets.Add(set);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ToolDialog"/> class.
/// </summary>
/// <param name="tool">The ITool to create the dialog box for</param>
/// <param name="modelElements">A list of all model elements</param>
public ToolDialog(ITool tool, IEnumerable <ModelElement> modelElements)
{
// Required by the designer
InitializeComponent();
// We store all the element names here and extract the datasets
foreach (ModelElement me in modelElements)
{
DataElement de = me as DataElement;
if (de != null)
{
bool addData = true;
foreach (Parameter par in tool.OutputParameters)
{
if (par.ModelName == de.Parameter.ModelName)
{
addData = false;
}
break;
}
if (addData)
{
DataSets.Add(new DataSetArray(me.Name, de.Parameter.Value as IDataSet));
}
}
}
Initialize(tool);
}
static Dictionary()
{
string[] words;
var dictionary = Program.CurrentOptions?.Dictionary ?? Options.Default.Dictionary;
try {
{
using FileStream file = File.OpenRead(dictionary);
if (Path.GetExtension(dictionary).EqualsInvariantInsensitive(".zip"))
{
using ZipArchive zip = new(file, ZipArchiveMode.Read, leaveOpen : false);
using StreamReader reader = new(zip.Entries[0].Open());
words = reader.ReadToEnd().Replace('\r', '\n').Split('\n', StringSplitOptions.RemoveEmptyEntries);
}
else
{
using StreamReader reader = new(file);
words = reader.ReadToEnd().Replace('\r', '\n').Split('\n', StringSplitOptions.RemoveEmptyEntries);
}
}
}
catch (Exception ex) {
throw new Exception($"Failed to open dictionary file '{dictionary}'");
}
void AddSet(in DataSet <string[]> dataSet)
{
DataSets.Add(dataSet);
}
AddSet(new(words));
}
/// <summary>
/// add's data to the chart. At least one set of data is needed to create the chart, when supplying multiple sets of data a multi-bar column charts is created.
/// Number of columns and the columns label's are determined from the first set of data only.
/// </summary>
public void AddDataSet(DataSet data)
{
//add dataset
DataSets.Add(data);
//keep track of items
NumberOfColumns = DataSets.First().Data.Count;
BarsPerColumn = DataSets.Count;
}
public ManageDataSetViewModel(IDataSetManager dataSetManager, DialogHandler dialogHandler)
{
_dataSetManager = dataSetManager;
_dialogHandler = dialogHandler;
AddCommand = new RelayCommand(async() => await Add());
CloneDatasetCommand = new RelayCommand(async() => await Add(SelectedDataSet));
ImportDocumentCommand = new RelayCommand(ImportJson <object>);
ImportTagCommand = new RelayCommand(ImportJson <Tag>);
ImportDocumentCsvCommand = new RelayCommand(ImportCsv <object>);
ImportTagCsvCommand = new RelayCommand(ImportCsv <Tag>);
DoubleClickCommand = new RelayCommand(() =>
{
if (SelectedDataSet != null)
{
Messenger.Default.Send(new UpdateMessage(UpdateType.OpenNewTab,
new HeaderedItemViewModel(SelectedDataSet.Name + " -Data",
new ManageData {
DataContext = new ManageDataViewModel(SelectedDataSet, _dialogHandler)
}, true)));
}
});
DeleteCommand = new RelayCommand(Delete);
RenameCommand = new RelayCommand(Rename);
LoadedCommand = new RelayCommand(async() =>
{
try
{
Mouse.SetCursor(Cursors.Arrow);
if (_loadedFirst)
{
_loadedFirst = false;
await _dialogHandler.ShowProgress(null, async() =>
{
DispatcherHelper.CheckBeginInvokeOnUI(() => DataSets.Clear());
var response = await _dataSetManager.GetDataSetsAsync();
if (ResponseValidator.Validate(response))
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
response.ResponseObject.ToList().ForEach(ds => DataSets.Add(ds));
});
}
});
}
}
catch (Exception exception)
{
Messenger.Default.Send(exception);
}
});
}
public STM()
{
this.Name = "STM";
this.Description = "VSIS 2.13 STM definitions";
DataSets.Add(IP_STM_1);
DataSets.Add(IP_STM_15);
DataSets.Add(IP_STM_32);
DataSets.Add(IP_STM_35);
DataSets.Add(IP_STM_38);
DataSets.Add(IP_STM_39);
DataSets.Add(IP_STM_43);
DataSets.Add(IP_STM_46);
DataSets.Add(IP_STM_30);
DataSets.Add(IP_STM_34);
DataSets.Add(IP_STM_40);
}
private void UserControl_Initialized(object sender, EventArgs e)
{
Random rnd = new Random();
for (int n = 0; n < 1; n++)
{
Polyline p = new Polyline();
p.Stroke = new SolidColorBrush(Color.FromRgb((byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255)));
p.StrokeThickness = 1;
for (int i = 0; i < 500; i++)
{
p.Points.Add(new Point(i, rnd.Next(-25, 25)));
}
DataSets.Add(p);
}
}
private void RecordDataSet(Core.Dom.Action action)
{
foreach (var item in action.outputData)
{
var options = item.allData.ToList();
if (options.Count > 0)
{
// Don't use the instance name here, we only pick the data set
// once per state, not each time the state is re-entered.
var rec = new DataSetTracker(item.modelName, options);
if (!_dataSets.Contains(item.modelName))
{
_dataSets.Add(rec);
}
}
}
}
public DataAgeDistributionViewModel(
List <IDataAgeDistribution> distributions,
Dictionary <string, string> ageCategoryColors,
Dictionary <string, string> dataSetToLayer)
{
InitColors(ageCategoryColors);
distributions.ForEach(d => {
DataSets.Add($"{d.DataSetName} ({d.ObjectCount} objekter)", dataSetToLayer[d.DataSetName]);
BarLabels += "'',";
_sums.Add(GetSum(d));
});
IEnumerable <AgeCategory> enums = Enum.GetValues(typeof(AgeCategory)).Cast <AgeCategory>();
foreach (AgeCategory enumValue in enums)
{
Categories.Add(GetCategory(enumValue, distributions));
}
}
static Strings()
{
var random = new Random(RandSeed);
void AddSet(in DataSet <string> dataSet)
{
DataSets.Add(dataSet);
}
long min = MinSize;
if (min == 0 && min != MaxSize)
{
AddSet(new(new StringBuilder().ToString()));
min = 1;
}
for (long i = min; i <= MaxSize; i *= 2)
{
var sb = new StringBuilder();
for (int j = 0; j < i; ++j)
{
sb.Append(RandomChar(random));
}
AddSet(new(sb.ToString()));
}
if (DataSets.Last().Data.Length != MaxSize)
{
var sb = new StringBuilder();
for (int j = 0; j < MaxSize; ++j)
{
sb.Append(RandomChar(random));
}
AddSet(new(sb.ToString()));
}
}
public void AddDataSet(string dataSetName)
{
DataSets.Add(dataSetName, CreateDataTable());
DataSetNames.Add(dataSetName);
}
private void AddDataSet(ChromDataSet chromDataSet)
{
Assume.IsTrue(DataSets.Count == 0 || DataSets[0].FirstKey.OptionalMaxTime == chromDataSet.FirstKey.OptionalMaxTime);
DataSets.Add(chromDataSet);
}
private async Task Add(DataSet selectedDataSet = null)
{
Log.Info(LogMessages.ManageDataSetAddCommand);
var newDataSet = selectedDataSet == null ? new DataSet
{
NGramCount = 3,
IdField = "id",
TagField = "tag",
InterpretedFields = new List <string> {
"title", "desc"
},
SampleDocument = JsonConvert.SerializeObject(new
{
id = 10,
title = "thisisthetitle",
desc = "thisisthedesc",
tag = "tag1"
}, Formatting.Indented),
Schema = JsonConvert.SerializeObject(new
{
type = "object",
properties = new
{
id = new { type = "integer" },
title = new { type = "string" },
desc = new { type = "string" },
tag = new { type = "string" }
}
}, Formatting.Indented)
} : new DataSet
{
NGramCount = SelectedDataSet.NGramCount,
IdField = SelectedDataSet.IdField,
TagField = SelectedDataSet.TagField,
InterpretedFields = SelectedDataSet.InterpretedFields,
SampleDocument = SelectedDataSet.SampleDocument ?? JsonConvert.SerializeObject(new
{
id = 10,
title = "thisisthetitle",
desc = "thisisthedesc",
tag = "tag1"
}, Formatting.Indented),
Schema = selectedDataSet.Schema ?? JsonConvert.SerializeObject(new
{
type = "object",
properties = new
{
id = new { type = "integer" },
title = new { type = "string" },
desc = new { type = "string" },
tag = new { type = "string" }
}
}, Formatting.Indented)
};
var context = new CommonDialogViewModel
{
Header = "Add Dataset",
Buttons = ButtonsEnum.OkCancel,
Content = new NewDataSetWrapper {
DataSet = newDataSet, SampleDocumentChecked = true
}
};
var view = new CommonDialog {
DataContext = context
};
var canClose = false;
var result = await _dialogHandler.Show(view, "RootDialog",
async (object sender, DialogClosingEventArgs args) =>
{
if (!canClose && (CommonDialogResult)args.Parameter == CommonDialogResult.Ok)
{
args.Cancel();
args.Session.UpdateContent(new ProgressDialog());
var isSuccessful = false;
var errorMessage = "";
try
{
var wrapper = (NewDataSetWrapper)(context.Content);
newDataSet = wrapper.DataSet;
if (wrapper.SampleDocumentChecked)
{
newDataSet.Schema = null;
newDataSet.SampleDocument = JsonConvert.DeserializeObject(newDataSet.SampleDocument.ToString());
}
else
{
newDataSet.SampleDocument = null;
newDataSet.Schema = JsonConvert.DeserializeObject((newDataSet.Schema).ToString());
}
newDataSet.InterpretedFields = newDataSet.InterpretedFields.Where(f => !string.IsNullOrEmpty(f.Trim())).ToList();
var response = wrapper.SampleDocumentChecked ? await _dataSetManager.CreateDataSetAsync(newDataSet) : await _dataSetManager.CreateDataSetSchemaAsync(newDataSet);
isSuccessful = response.IsSuccessful;
ResponseValidator.Validate(response, false);
}
catch (Exception exception)
{
isSuccessful = false;
errorMessage = exception.Message;
}
finally
{
if (!isSuccessful)
{
context.ErrorMessage = errorMessage;
context.ShowError = true;
args.Session.UpdateContent(view);
}
else
{
canClose = true;
args.Session.Close((CommonDialogResult)args.Parameter);
}
}
}
});
if ((CommonDialogResult)result == CommonDialogResult.Ok)
{
DataSets.Add(newDataSet);
}
}
static Sprites()
{
var random = new Random(RandSeed);
//AddErrorCases(random);
var testSizes = CommonSizes.SortF(new SizeComparer());
foreach (var size in testSizes)
{
//DataSets.Add(MakeAlignedSprite(random, size));
}
Vector2I outerSize = (1024, 1024);
foreach (var size in testSizes)
{
var tempOuterSize = outerSize;
if (size.X >= tempOuterSize.X)
{
tempOuterSize.X = NextPower2(size.X + 1);
}
if (size.Y >= tempOuterSize.Y)
{
tempOuterSize.Y = NextPower2(size.Y + 1);
}
DataSets.Add(MakeUnalignedSprite(random, tempOuterSize, size));
}
if (Program.CurrentOptions.DoValidate)
{
bool error = false;
Console.WriteLine("Performing Validation...");
var referenceInstance = new Sprites();
foreach (var dataSet in DataSets)
{
try {
ulong baseline = referenceInstance.Baseline(dataSet);
foreach (var hasher in new TestFunction[] {
referenceInstance.Copy,
referenceInstance.SegmentedSpan,
referenceInstance.SegmentedSpanExperimental
})
{
ulong hash = hasher(dataSet);
if (baseline != hash)
{
Console.Error.WriteLine($"{hasher.Method.Name} mismatch [{dataSet}]: {hash} != {baseline}");
error = true;
}
}
}
catch (Exception ex) {
Console.Error.WriteLine($"Exception validating {dataSet}: {ex.GetType().Name} {ex.Message}");
error = true;
}
}
if (error)
{
throw new Exception("Benchmark validation failed");
}
}
}
internal DataFile Construct(string FilePath)
{
this.Name = Path.GetFileName(FilePath);
this.DataSets = new HashSet <DataSet>();
var RawLines = File.ReadAllLines(FilePath);
var LockThis = new object();
this.IsALog = false;
if (FilePath.EndsWith("HandleServer.dll.log", StringComparison.InvariantCultureIgnoreCase))
{
this.IsALog = true;
var DataSetNames = new string[10] {
"GetObjectsToDelete", "GetCivData", "GetCivCacheData", "CountEnemyInArea", "CountPlayerInArea", "AddObjectToDelete", "AddObjectsData", "DeleteObjects", "AddCivWayPos", "AssignCivNames"
};
Parallel.ForEach(DataSetNames, new ParallelOptions {
MaxDegreeOfParallelism = DataSetNames.Length
}, CurDataSetName =>
{
var CurDataSet = new DataSet(CurDataSetName);
lock (LockThis)
{
DataSets.Add(CurDataSet);
}
double CurValue;
for (int i2 = 0; i2 < RawLines.Length; i2++)
{
CurValue = GetValue(RawLines[i2], CurDataSetName, ": ", "ms", 0);
if (CurValue > -1)
{
CurDataSet.DataValues.Add(CurValue);
}
}
if (CurDataSet.DataValues.Count > 0)
{
CurDataSet.AVGValue = Math.Round(CurDataSet.DataValues.Average(), 3, MidpointRounding.AwayFromZero);
CurDataSet.MaxValue = CurDataSet.DataValues.Max();
}
if (CurDataSet.MaxValue == 0)
{
DataSets.Remove(CurDataSet);
}
});
}
else if (FilePath.EndsWith("HandleServer_Standalone.Perf.log", StringComparison.InvariantCultureIgnoreCase))
{
var DataSetNames = new HashSet <DataSetName>();
DataSetNames.Add(new DataSetName("Durchschnittlich gecached", "(", "%)", 2));
DataSetNames.Add(new DataSetName("Durchschnittlich nicht gecached", "(", "%)", 3));
DataSetNames.Add(new DataSetName("Empfangene Datenmenge", " ", "MB", 2));
DataSetNames.Add(new DataSetName("Gesendete Datenmenge", " ", "MB", 3));
DataSetNames.Add(new DataSetName("Bandbreite", "AVG Bandwidth: ", "Kbit/s", 0));
Parallel.ForEach(DataSetNames, new ParallelOptions {
MaxDegreeOfParallelism = DataSetNames.Count
}, CurDataSetName =>
{
var CurDataSet = new DataSet(CurDataSetName.Name);
lock (LockThis)
{
DataSets.Add(CurDataSet);
}
double CurValue;
for (int i2 = 0; i2 < RawLines.Length; i2++)
{
CurValue = GetValue(RawLines[i2], CurDataSetName.SecondCut, CurDataSetName.FirstCut, CurDataSetName.SecondCut, CurDataSetName.CutType);
if (CurValue > -1)
{
CurDataSet.DataValues.Add(CurValue);
}
}
if (CurDataSet.DataValues.Count > 0)
{
CurDataSet.AVGValue = Math.Round(CurDataSet.DataValues.Average(), 3, MidpointRounding.AwayFromZero);
CurDataSet.MaxValue = CurDataSet.DataValues.Max();
}
if (CurDataSet.MaxValue == 0)
{
DataSets.Remove(CurDataSet);
}
});
}
else if (FilePath.EndsWith(".rpt", StringComparison.InvariantCultureIgnoreCase))
{
var DataSetNames = new HashSet <DataSetName>();
DataSetNames.Add(new DataSetName("Einheiten", "Einheiten: ", " DavonLokalOhne", 0));
DataSetNames.Add(new DataSetName("Lokale Einheiten (Keine Zivilisten)", " DavonLokalOhneZivs: ", " Spieler: ", 0));
DataSetNames.Add(new DataSetName("Lokale Einheiten", " DavonLokal: ", " Spieler: ", 0));
DataSetNames.Add(new DataSetName("Spieler", " Spieler: ", " Objekte: ", 0));
DataSetNames.Add(new DataSetName("Objekte", " Objekte: ", " FPS: ", 0));
DataSetNames.Add(new DataSetName("FPS", " FPS: ", " Schleifen: ", 0));
DataSetNames.Add(new DataSetName("Schleifen", " Schleifen: ", " Skripte: ", 0));
DataSetNames.Add(new DataSetName("Skriptthreads", " Skripte: [", "]", 1));
Parallel.ForEach(DataSetNames, new ParallelOptions {
MaxDegreeOfParallelism = DataSetNames.Count
}, CurDataSetName =>
{
var CurDataSet = new DataSet(CurDataSetName.Name);
lock (LockThis)
{
DataSets.Add(CurDataSet);
}
double CurValue;
for (int i2 = 0; i2 < RawLines.Length; i2++)
{
CurValue = GetValue(RawLines[i2], CurDataSetName.FirstCut, CurDataSetName.FirstCut, CurDataSetName.SecondCut, CurDataSetName.CutType);
if (CurValue > -1)
{
CurDataSet.DataValues.Add(CurValue);
}
}
if (CurDataSet.DataValues.Count > 0)
{
CurDataSet.AVGValue = Math.Round(CurDataSet.DataValues.Average(), 3, MidpointRounding.AwayFromZero);
CurDataSet.MaxValue = CurDataSet.DataValues.Max();
}
if (CurDataSet.MaxValue == 0)
{
DataSets.Remove(CurDataSet);
}
});
if ((DataSets.Any(i => i.Name.Equals("Skriptthreads"))) && (DataSets.Any(i => i.Name.Equals("FPS"))))
{
var CurCustomDataSet = new DataSet("Rechenzeit(ms) pro Skriptthread & Sekunde");
DataSets.Add(CurCustomDataSet);
var FPSSet = DataSets.First(i => i.Name.Equals("FPS"));
var ThreadsSet = DataSets.First(i => i.Name.Equals("Skriptthreads"));
Parallel.For(0, FPSSet.DataValues.Count, new ParallelOptions {
MaxDegreeOfParallelism = FPSSet.DataValues.Count
}, i =>
{
if ((ThreadsSet.DataValues.Count > i) && (FPSSet.DataValues[i] > 0) && (ThreadsSet.DataValues[i] > 0))
{
lock (LockThis)
{
CurCustomDataSet.DataValues.Add(Math.Round((FPSSet.DataValues[i] * 3) / ThreadsSet.DataValues[i], 1, MidpointRounding.AwayFromZero));
}
}
});
CurCustomDataSet.AVGValue = Math.Round(CurCustomDataSet.DataValues.Average(), 3, MidpointRounding.AwayFromZero);
CurCustomDataSet.MaxValue = CurCustomDataSet.DataValues.Max();
if (CurCustomDataSet.MaxValue == 0)
{
DataSets.Remove(CurCustomDataSet);
}
}
}
return(this);
}
