public void Run(CartesianModel model)
{
FftBuffersPool.PrepareBuffersForModel(model, _memoryProvider, _mpi, _profiler);
LogSettingsInfo();
_solver.SetProfiler(_profiler);
_solver
.WithMpi(_mpi)
.With(_project.ObservationLevels);
int freqCounter = 0;
foreach (var frequency in _project.Frequencies)
{
ForwardLoggerHelper.WriteStatus(_logger, $"\t\t\tFrequecy {frequency}, {++freqCounter} of {_project.Frequencies.Count}");
var omegaModel = OmegaModelBuilder.BuildOmegaModel(model, frequency);
_profiler.ClearAllRecords();
using (var rc = _solver.Solve(omegaModel))
{
if (!_solver.IsParallel || _mpi.IsMaster)
{
ExportProfiling(model, frequency);
Export(rc, frequency);
}
ForwardLoggerHelper.WriteStatus(_logger, "Finish");
ParallelMemoryUtils.ExportMemoryUsage(_project.ResultsPath, _mpi, _memoryProvider, frequency);
}
}
}
private void ExportProfiling(CartesianModel model, double frequency)
{
ForwardLoggerHelper.WriteStatus(_logger, "Exporting profiling results");
var dir = _project.ResultsPath;
var freqStr = $"_freq{frequency:####0.0000}";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
//ProfilerResultsTextExporter.SaveRawProfilingResults(Path.Combine(dir, $"rawprofile{freqStr}.xml"), model, _profiler);
var records = _profiler.GetAllRecords();
var analizer = new ProfilerStatisticsAnalyzer(records);
var analisisResult = analizer.PerformAnalysis();
int numberOfMpi = _mpi?.Size ?? 1;
int numberOfThreads = MultiThreadUtils.MaxDegreeOfParallelism;
var file = Path.Combine(dir, $"profiling_mpi{numberOfMpi:0000}_threads{numberOfThreads}{freqStr}.txt");
ProfilerResultsTextExporter.SaveProfilingResultsTo(file, model, analisisResult, numberOfMpi, numberOfThreads);
var file2 = Path.Combine(dir, "..", "common.dat");
ProfilerResultsTextExporter.SaveProfilingResultsToCommon(file2, model, analisisResult, numberOfMpi, numberOfThreads, _project.ForwardSettings.NumberOfHankels);
}
public static void SaveWithModel(string path, CartesianModel model, ProfilerRecord[] profilerRecord)
{
var xdoc = new XDocument();
xdoc.Add(new XElement("ProfilingResults",
ModelWriter.ToXElement(model),
new XElement("Records",
profilerRecord.Select(ToXElement))));
xdoc.Save(path);
}
public CartesianModel CreateModel(MeshParameters mesh, decimal xCellSize, decimal yCellSize)
{
var lateral = new LateralDimensions(mesh.Nx, mesh.Ny, xCellSize, yCellSize);
var section1D = CreateSection1D();
var anomaly = CreateAnomaly(mesh, lateral);
var model = new CartesianModel(lateral, section1D, anomaly);
return(model);
}
public static void SaveProfilingResultsToCommon(string fileName, CartesianModel model, ProfilerStatistics[] analisisResult, int numberOfMpi, int numberOfThreads, int nhank)
{
if (analisisResult == null)
{
throw new ArgumentNullException();
}
try
{
Func <string, int, string> padStr = (str, p) => str.PadRight(p);
Func <string, string> pad = (str) => padStr(str, 15);
Func <TimeSpan, string> toStr = (ts) => padStr(ts.TotalSeconds.ToString("0.00000"), 15);
if (!File.Exists(fileName))
{
File.AppendAllText(fileName, $"{pad("Date")}{padStr("Time", 12)}" +
$"{padStr("nx", 6)}{padStr("ny", 6)}{padStr("nz", 6)}" +
$"{padStr("nhank", 6)}" +
$"{padStr("mpi_size", 9)}{padStr("nthreads", 9)}" +
$"{pad("AtoA_Green")}{pad("polX")}{pad("polY")}" +
$"{pad("AtoO_Green")}{pad("AtoO_calc_X")}{pad("AtoO_calc_Y")}\n");
}
var atoa = GetTimeSpan(analisisResult, ProfilerEvent.GreenAtoATotal, 0);
var polX = GetTimeSpan(analisisResult, ProfilerEvent.SolveCie, 0);
var polY = GetTimeSpan(analisisResult, ProfilerEvent.SolveCie, 1);
var atoo = GetTotalTime(analisisResult, ProfilerEvent.AtoOGreenCalc);
var atoc1 = GetTimeSpan(analisisResult, ProfilerEvent.AtoOFields, 0);
var atoc2 = GetTimeSpan(analisisResult, ProfilerEvent.AtoOFields, 1);
var now = DateTime.Now;
var line = $"{pad(now.ToShortDateString())}{padStr(now.ToShortTimeString(), 12)}" +
$"{padStr(model.Nx.ToString(), 6)}{padStr(model.Ny.ToString(), 6)}{padStr(model.Nz.ToString(), 6)}" +
$"{padStr(nhank.ToString(), 6)}" +
$"{padStr(numberOfMpi.ToString(), 9)}{padStr(numberOfThreads.ToString(), 9)}" +
$"{toStr(atoa)}{toStr(polX)}{toStr(polY)}" +
$"{toStr(atoo)}{toStr(atoc1)}{toStr(atoc2)}\n";
File.AppendAllText(fileName, line);
}
catch (Exception ex)
{
Console.WriteLine($"Scalability profiling export {ex.Message} {ex.StackTrace}");
// throw;
}
}
public static void SaveProfilingResultsTo(string path, CartesianModel model, ProfilerStatistics[] analisisResult, int nMpi, int nThreads)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (analisisResult == null)
{
throw new ArgumentNullException(nameof(analisisResult));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
new ProfilerResultsTextExporter(analisisResult, model)
.SaveProfilingResultsTo(path, nMpi, nThreads);
}
public static void PrepareBuffersForModel(CartesianModel model, INativeMemoryProvider memoryProvider, Mpi mpi = null, IProfiler profiler = null)
{
var modelSize = new ModelSize(model.Nx, model.Ny, model.Nz);
PrepareBuffersForModel(modelSize, memoryProvider, mpi, profiler);
}
public static void SaveRawProfilingResults(string path, CartesianModel cartesianModel, Profiler profiler)
{
profiler.GetAllRecords().SaveWithModel(path, cartesianModel);
}
private ProfilerResultsTextExporter(ProfilerStatistics[] analisisResult, CartesianModel model)
{
_analisisResult = analisisResult;
_model = model;
}
public static void SaveWithModel(this ProfilerRecord[] profilerRecord, string path, CartesianModel model)
{
SaveWithModel(path, model, profilerRecord);
}
