public FlexibleGmresWithGmresPreconditioner(
ILogger logger,
INativeMemoryProvider memoryProvider,
GmresParams fgmresParams,
int innerBufferLength)
{
var innerParams = new GmresParams(fgmresParams.LocalDimensionSize, innerBufferLength)
{
Tolerance = fgmresParams.Tolerance,
MaxRepeatNumber = 1,
ResidualAtRestart = fgmresParams.ResidualAtRestart,
GramSchmidtType = fgmresParams.GramSchmidtType,
InitialGuess = InitialGuess.UserSupplied,
Preconditioning = Preconditioning.None,
BackwardErrorChecking = BackwardErrorChecking.CheckArnoldiOnly
};
_classicGmres = new ClassicGmresSolver(logger, memoryProvider, innerParams);
_flexibleGmres = new FlexibleGmresSolver(logger, memoryProvider, fgmresParams);
_classicGmres.DotProductRequest += (s, a) => OnDotProductRequest(a);
_flexibleGmres.DotProductRequest += (s, a) => OnDotProductRequest(a);
_classicGmres.MatrixVectorMultRequest += (s, a) => OnMatrixVectorMultRequest(a);
_flexibleGmres.MatrixVectorMultRequest += (s, a) => OnMatrixVectorMultRequest(a);
_classicGmres.IterationComplete += (s, a) => OnInnerIterationComplete(a);
_flexibleGmres.IterationComplete += (s, a) => OnIterationComplete(a);
_flexibleGmres.RightPreconditionerRequest += (s, a) => _classicGmres.Solve(a.Src, a.Src, a.Dst);
}
protected GmresSolver(ILogger logger, INativeMemoryProvider memoryProvider, GmresParams parameters)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (memoryProvider == null)
{
throw new ArgumentNullException(nameof(memoryProvider));
}
Logger = logger;
Parameters = parameters;
_nloc = Parameters.LocalDimensionSize;
_m = Parameters.BufferSize;
_dotProducts = Parameters.GramSchmidtType == GramSchmidtType.IterativeClassical ?
new NativeVector(memoryProvider, _m) :
new NativeVector(memoryProvider, 1);
var krylovSize = Parameters.ResidualAtRestart == ResidualAtRestart.ComputeTheTrue ? _m : _m + 1;
_krylovBasis = new FortranMatrix(memoryProvider, _nloc, krylovSize);
_hessenberg = new FortranMatrix(memoryProvider, _m + 1, _m + 1);
_w = new NativeVector(memoryProvider, _nloc);
_r0 = new NativeVector(memoryProvider, _nloc);
_xCurrent = new NativeVector(memoryProvider, _nloc);
_yCurrent = new NativeVector(memoryProvider, _m);
_givensRotSin = new Complex[_m];
_givensRotCos = new double[_m];
}
public static ScalarSegments AllocateAndConvert(INativeMemoryProvider memoryProvider, ScalarPlan plan, GreenScalars scalars)
{
var segments = AllocateScalarSegments(memoryProvider, plan, scalars);
ConvertScalarsToSegments(scalars, segments);
return(segments);
}
private static List <IntPtr> AllocateGiem2gDataBuffers(INativeMemoryProvider memoryProvider, ref giem2g_data giem2g_ie_op, int nz)
{
var giem2g_ptrs = new List <IntPtr> ();
// var tmp1=(memoryProvider.AllocateBytes(giem2g_ie_op.tensor_size));
// giem2g_ie_op.giem2g_tensor=tmp1;
var tmp1 = giem2g_ie_op.giem2g_tensor;
giem2g_ptrs.Add(tmp1);
var tmp2 = (memoryProvider.AllocateComplex(giem2g_ie_op.ie_kernel_buffer_length));
giem2g_ptrs.Add(new IntPtr(tmp2));
giem2g_ie_op.kernel_buffer = tmp2;
var dz = (memoryProvider.AllocateDouble(nz));
giem2g_ie_op.dz = dz;
giem2g_ptrs.Add(new IntPtr(dz));
var sqsigb = (memoryProvider.AllocateDouble(nz));
giem2g_ie_op.sqsigb = sqsigb;
giem2g_ptrs.Add(new IntPtr(sqsigb));
var csigb = (memoryProvider.AllocateComplex(nz));
giem2g_ie_op.csigb = csigb;
giem2g_ptrs.Add(new IntPtr(csigb));
return(giem2g_ptrs);
}
public AtoAGreenTensorCalculator(
ILogger logger,
OmegaModel model,
INativeMemoryProvider memoryProvider) :
base(logger, model, memoryProvider)
{
}
private ScalarSegments(INativeMemoryProvider memoryProvider, Complex *ptr, double[] radii, SingleScalarSegment[] segment)
{
_memoryProvider = memoryProvider;
Ptr = ptr;
Radii = radii;
SingleSegment = segment;
}
public FortranMatrix(INativeMemoryProvider memoryProvider, int nx, int ny)
{
_ptr = memoryProvider.AllocateComplex(((long)nx) * ny);
Nx = nx;
Ny = ny;
_memoryProvider = memoryProvider;
}
public static void PrintMemoryReport(string message, ILogger logger, INativeMemoryProvider memoryProvider)
{
var linux = LinuxMemoryFileReader.GetTotalMemoryInMiB();
var native = (memoryProvider as MemoryProvider).GetAllocatedMemorySizeInBytes() / (1024 * 1024M);
var managed = GC.GetTotalMemory(false) / (1024 * 1024M);
// logger.WriteStatus($"[{message.PadRight(15)}]: linux:{linux:0.000}, native:{native:0.000}, managed:{managed:0.000}, n+m:{native + managed:0.000}");
}
public FftBuffer(INativeMemoryProvider memoryProvider, IProfiler profiler = null)
{
if (memoryProvider == null)
{
throw new ArgumentNullException(nameof(memoryProvider));
}
_memoryProvider = memoryProvider;
_profiler = profiler;
}
public static GreenTensor CreateGiem2gTensor(INativeMemoryProvider memoryProvider, int nx, int ny, int nTr, int nRc, List <IntPtr> giem2g_ptrs)
{
var gt = new GreenTensor(memoryProvider, nx, ny, nTr, nRc);
var dict = new Dictionary <string, Component>();
dict.Add("giem2g", new Component(gt, (Complex *)giem2g_ptrs[0]));
gt._components = dict;
gt._basePtrs.AddRange(giem2g_ptrs);
return(gt);
}
private GreenTensor(INativeMemoryProvider memoryProvider, int nx, int ny, int nTr, int nRc)
{
if (memoryProvider == null)
{
throw new ArgumentNullException(nameof(memoryProvider));
}
_memoryProvider = memoryProvider;
Nx = nx;
Ny = ny;
NTr = nTr;
NRc = nRc;
}
public static void ExportMemoryUsage(string resultPath, Mpi mpi, INativeMemoryProvider memoryProvider, double frequency)
{
Complex localNativeMemory = (memoryProvider as MemoryProvider)?.GetAllocatedMemorySizeInBytes() / (1024 * 1024.0) ?? 0;
var nativeMemory = new Complex[mpi?.Size ?? 1];
Complex localManagedMemory = GC.GetTotalMemory(false) / (1024 * 1024.0);
var managedMemory = new Complex[mpi?.Size ?? 1];
Complex localLinuxMemory = (double)LinuxMemoryFileReader.GetTotalMemoryInMiB();
var linuxMemory = new Complex[mpi?.Size ?? 1];
mpi?.Gather(nativeMemory, localNativeMemory);
mpi?.Gather(managedMemory, localManagedMemory);
mpi?.Gather(linuxMemory, localLinuxMemory);
if (mpi?.IsMaster ?? true)
{
string path = Path.Combine(resultPath, $"mem_info_mpi{mpi?.Size:0000}_freq{frequency}.dat");
Func <Complex, string> pr = v => $"{v.Real / 1024:######0.0000} GiB".PadLeft(16);
using (var sw = new StreamWriter(path))
{
sw.WriteLine($"MPI_proc\t\tNATIVE\t\tMANAGED\t\tSUMM\t\tLINUX");
sw.Write($"Total".PadRight(16));
sw.Write(pr(nativeMemory.Sum(c => c.Real)));
sw.Write(pr(managedMemory.Sum(c => c.Real)));
sw.Write(pr(nativeMemory.Sum(c => c.Real) + managedMemory.Sum(c => c.Real)));
sw.Write(pr(linuxMemory.Sum(c => c.Real)));
sw.WriteLine();
for (int i = 0; i < nativeMemory.Length; i++)
{
sw.Write($"{i}".PadRight(16));
sw.Write(pr(nativeMemory[i]));
sw.Write(pr(managedMemory[i]));
sw.Write(pr(nativeMemory[i] + managedMemory[i]));
sw.Write(pr(linuxMemory[i]));
sw.WriteLine();
}
}
}
}
protected ForwardSolver(ILogger logger, INativeMemoryProvider memoryProvider, ForwardSettings settings, bool store = false)
: base(logger, memoryProvider)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
Settings = settings;
StoreAtoA = store;
if (Settings.NumberOfHankels <= 0)
{
Engine = ForwardSolverEngine.Giem2g;
SetGiem2gLogger();
StoreAtoA = true;
}
}
public static ScalarSegments AllocateScalarSegments(INativeMemoryProvider memoryProvider, ScalarPlan plan, GreenScalars scalars, int length)
{
var radii = scalars.Radii;
int nRho = radii.Length - 1;
var segments = new SingleScalarSegment[nRho];
int nComp = scalars.GetNumberOfAvailableIs(plan);
var ptr = memoryProvider.AllocateComplex(length * nComp * 2L * nRho);
long oneSegmentSize = length * nComp * 2L;
for (int i = 0; i < segments.Length; i++)
{
var startPtr = ptr + oneSegmentSize * i;
segments[i] = new SingleScalarSegment(plan, startPtr, length, nComp);
}
return(new ScalarSegments(memoryProvider, ptr, radii, segments));
}
public ExtremeMtSolverRunner(ForwardProject project, INativeMemoryProvider memoryProvider, Mpi mpi = null)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (memoryProvider == null)
{
throw new ArgumentNullException(nameof(memoryProvider));
}
_project = project;
_memoryProvider = memoryProvider;
_mpi = mpi;
_logger = (_mpi == null || !_mpi.IsParallel) ?
(ILogger) new ConsoleLogger() :
new ParallelConsoleLogger(_mpi);
_solver = new Mt3DForwardSolver(_logger, memoryProvider, _project.ForwardSettings);
_solver.SetProfiler(_profiler);
}
protected GreenTensorCalculator(
ILogger logger,
OmegaModel model,
INativeMemoryProvider memoryProvider)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (memoryProvider == null)
{
throw new ArgumentNullException(nameof(memoryProvider));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Logger = logger;
MemoryProvider = memoryProvider;
Model = model;
}
private static void PrepareBuffersForModel(ModelSize ms, INativeMemoryProvider memoryProvider, Mpi mpi, IProfiler profiler)
{
if (Buffers.ContainsKey(ms))
{
throw new InvalidOperationException("Buffer for such model size is already created");
}
using (profiler?.StartAuto(ProfilerEvent.FftwPlanCalculation))
{
var buffer = new FftBuffer(memoryProvider, profiler);
if (IsParallel(mpi))
{
buffer.AllocateBuffersAndCreatePlansParallel(ms.Nx, ms.Ny, ms.Nz, mpi);
}
else
{
buffer.AllocateBuffersAndCreatePlansLocal(ms.Nx, ms.Ny, ms.Nz);
}
Buffers.Add(ms, buffer);
}
}
public static GreenTensor AllocateNew(INativeMemoryProvider memoryProvider,
int nx, int ny, int nTr, int nRc, long compSize, params string[] components)
{
var gt = new GreenTensor(memoryProvider, nx, ny, nTr, nRc);
var fullSize = compSize * components.Length;
var ptr = memoryProvider.AllocateComplex(fullSize);
UNM.ClearBuffer(ptr, fullSize);
var dict = new Dictionary <string, Component>();
for (int i = 0; i < components.Length; i++)
{
var nextPtr = ptr + i * compSize;
dict.Add(components[i], new Component(gt, nextPtr));
}
gt._basePtrs.Add(new IntPtr(ptr));
gt._components = dict;
return(gt);
}
public FlexibleGmresSolver(ILogger logger, INativeMemoryProvider memoryProvider, GmresParams parameters) :
base(logger, memoryProvider, parameters)
{
_precondKrylovBasis = new FortranMatrix(memoryProvider, Parameters.LocalDimensionSize, Parameters.BufferSize);
}
public static unsafe double *AllocateDouble(this INativeMemoryProvider memoryProvider, long numberOfElements)
{
var ptr = (double *)memoryProvider.AllocateBytes(numberOfElements * sizeof(double)).ToPointer();
return(ptr);
}
public static unsafe void Release(this INativeMemoryProvider memoryProvider, void *data)
{
memoryProvider.ReleaseMemory(new IntPtr(data));
}
public NativeVector(INativeMemoryProvider memoryProvider, int length)
{
_memoryProvider = memoryProvider;
_ptr = memoryProvider.AllocateComplex(length);
Length = length;
}
public static unsafe Complex *AllocateComplex(this INativeMemoryProvider memoryProvider, long numberOfElements)
{
var ptr = (Complex *)memoryProvider.AllocateComplexIntPtr(numberOfElements).ToPointer();
return(ptr);
}
protected ForwardSolverGenerics(ILogger logger, INativeMemoryProvider memoryProvider)
{
MemoryProvider = memoryProvider;
Logger = logger;
}
private static ScalarSegments AllocateScalarSegments(INativeMemoryProvider memoryProvider, ScalarPlan plan, GreenScalars scalars) => AllocateScalarSegments(memoryProvider, plan, scalars, scalars.SingleScalars.Length);
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 Mt3DForwardSolver(ILogger logger, INativeMemoryProvider memoryProvider, ForwardSettings settings, bool store = false)
: base(logger, memoryProvider, settings, store)
{
_eFields = new List <MtFieldsAtLevelCalculatedEventArgs>();
_hFields = new List <MtFieldsAtLevelCalculatedEventArgs>();
}
public ClassicGmresSolver(ILogger logger, INativeMemoryProvider memoryProvider, GmresParams parameters) :
base(logger, memoryProvider, parameters)
{
}
private static unsafe IntPtr AllocateComplexIntPtr(this INativeMemoryProvider memoryProvider, long numberOfElements)
{
var ptr = memoryProvider.AllocateBytes(numberOfElements * sizeof(Complex));
return(ptr);
}