Beispiel #1
0
        /// <summary>
        /// Test if the matrix is symmetric positive definite
        /// </summary>
        /// <returns>bool array res=[symmetry, positive definit]</returns>
        public bool[] Symmetry()
        {
            bool[] res = new bool[2];

            //extract submatrix for selected dependent variables
            int[]    DepVars        = this.VarGroup;
            double[] DepVars_subvec = this.m_map.GetSubvectorIndices(true, DepVars).Select(i => i + 1.0).ToArray();

            //MsrMatrix OpMtxMSR = m_OpMtx.ToMsrMatrix();

            int[] SubMatrixIdx_Row  = m_map.GetSubvectorIndices(false, DepVars);
            int[] SubMatrixIdx_Cols = m_map.GetSubvectorIndices(false, DepVars);
            int   L = SubMatrixIdx_Row.Length;

            MsrMatrix SubOpMtx = new MsrMatrix(L, L, 1, 1);

            m_OpMtx.WriteSubMatrixTo(SubOpMtx, SubMatrixIdx_Row, default(int[]), SubMatrixIdx_Cols, default(int[]));


            // symmetry test by calculation of symmetry deviation
            bool   sym     = false;
            double SymmDev = m_OpMtx.SymmetryDeviation();

            if (SymmDev < 1e-5)
            {
                sym = true;
            }

            res[0] = sym;


            // positive definite test by Cholesky decomposition
            var FullyPopulatedMatrix = m_OpMtx.ToFullMatrixOnProc0();

            bool posDef = true;

            // only proc 0 gets info so the following is executed exclusively on rank 0
            if (ilPSP.Environment.MPIEnv.MPI_Rank == 0)
            {
                try
                {
                    FullyPopulatedMatrix.Cholesky();
                }
                catch (ArithmeticException)
                {
                    posDef = false;
                }
            }
            res[1] = MPIEnviroment.Broadcast <bool>(posDef, 0, ilPSP.Environment.MPIEnv.Mpi_comm);

            Debug.Assert(res[0].MPIEquals(), "value does not match on procs");
            Debug.Assert(res[1].MPIEquals(), "value does not match on procs");
            return(res);
        }
Beispiel #2
0
        /// <summary>
        /// Creates OpenCL environment on this process
        /// </summary>
        /// <param name="_MpiEnv">MPI environment of this process</param>
        public clEnvironment(MPIEnviroment _MpiEnv)
        {
            MpiEnv = _MpiEnv;

            cl_platform_id[]        platforms = cl.GetPlatformIDs();
            cl_platform_info_return pinfo     = cl.GetPlatformInfo(platforms[0]);
            string vnd = pinfo.vendor;

            switch (vnd)
            {
            case "NVIDIA Corporation":
                _vendor = Vendor.NVIDIA;
                break;

            case "Advanced Micro Devices, Inc.":
                _vendor = Vendor.AMD;
                break;

            default:
                _vendor = Vendor.Other;
                break;
            }

            Console.WriteLine(vnd + " : " + _vendor.ToString());
            Console.WriteLine(pinfo.version);

            if (_vendor == Vendor.AMD)
            {
                clVectorSource.source[0] = clVectorSource.source[0].Replace("cl_khr_fp64", "cl_amd_fp64");
                clMatrixSource.source[0] = clMatrixSource.source[0].Replace("cl_khr_fp64", "cl_amd_fp64");
                Console.WriteLine("Adjusted AMD fp64 extenstion");
            }

            cl_device_id[] devices    = cl.GetDeviceIDs(platforms[0], cl_device_type.CL_DEVICE_TYPE_GPU);
            int            numDevices = devices.Length;

            if (numDevices < _MpiEnv.ProcessesOnMySMP)
            {
                throw new ApplicationException("not enougth OpenCL devices; There must be at least one OpenCL device for each MPI process;");
            }

            device  = devices[0];
            context = cl.CreateContext(platforms[0], devices);

            //cl_device_info_return dinfo = cl.GetDeviceInfo(device);
            //Console.WriteLine("Max work group size: " + dinfo.max_work_group_size);
            //Console.WriteLine("Process " + _MpiEnv.ProcessRankOnSMP + " running on device " + dinfo.name + ", " + dinfo.version);
            //Console.WriteLine(dinfo.extensions);
        }
Beispiel #3
0
        /// <summary>
        /// ctor
        /// </summary>
        public CudaEnviroment(MPIEnviroment _MpiEnv)
        {
            m_MpiEnv = _MpiEnv;
            if (!CudaAvailable)
            {
                throw new ApplicationException("No CUDA driver on this machine.");
            }

            int NoOfDev;

            cu.DeviceGetCount(out NoOfDev);

            if (NoOfDev < _MpiEnv.ProcessesOnMySMP)
            {
                throw new ApplicationException("not enough CUDA devices; There must be at least one CUDA device for each MPI process;");
            }

            //cu.DeviceGet(out m_CUDAdev, 0); // provisorisch
            //Console.WriteLine("Cuda: prowisoischä dev-allok.");
            cu.DeviceGet(out m_CUDAdev, _MpiEnv.ProcessRankOnSMP); // korrekt

            int major, minor;

            cu.DeviceComputeCapability(out major, out minor, m_CUDAdev);
            if ((major < 1) || (major <= 1 && minor <= 2))
            {
                throw new ApplicationException("requiring at least compute capability 1.3 - got " + major + "." + minor + " for device #" + _MpiEnv.ProcessRankOnSMP + " on host '" + MpiEnv.Hostname + "';");
            }

            cu.CtxCreate(out m_context, CUDAdev, CUctx_flags_enum.CU_CTX_MAP_HOST);
            disposed = false;
            String name;

            cu.DeviceGetName(out name, CUDAdev);

            //uint membytes;
            //cu.DeviceTotalMem(out membytes, m_Env.CUDAdev);
            //membytes /= 1024 * 1024;

            Logger.Info("Process " + MpiEnv.MPI_Rank + " on " + MpiEnv.Hostname + " using " + name + ".");
        }
Beispiel #4
0
        /// <summary>
        /// creates a new instance of the MATLAB connector.
        /// </summary>
        /// <param name="Flav">
        /// octave or MATLAB
        /// </param>
        /// <param name="ExecutablePath">
        /// Where to find the executable on the current system.
        /// If NULL, the standard installation path is assumed.
        /// In the case of Cygwin/octave, the path to the Cygwin bash.exe;
        /// </param>
        /// <param name="WorkingPath">
        /// working directory of the MATLAB instance;
        /// if NULL, a temporary directory is created.
        /// </param>
        public BatchmodeConnector(string WorkingPath = null)
        {
            ilPSP.MPICollectiveWatchDog.Watch(csMPI.Raw._COMM.WORLD);
            csMPI.Raw.Comm_Rank(csMPI.Raw._COMM.WORLD, out Rank);
            this.m_Flav = Flav;

            // create/check working path
            // =========================

            if (Rank == 0)
            {
                if (WorkingPath == null)
                {
                    var  rnd    = new Random();
                    bool Exists = false;
                    do
                    {
                        var tempPath = Path.GetTempPath();
                        var tempDir  = rnd.Next().ToString();
                        WorkingDirectory = new DirectoryInfo(Path.Combine(tempPath, tempDir));
                        Exists           = WorkingDirectory.Exists;
                        if (!Exists)
                        {
                            WorkingDirectory.Create();
                            DelWorkingDir = true;
                        }
                    } while (Exists == true);
                }
                else
                {
                    WorkingDirectory = new DirectoryInfo(WorkingPath);
                    if (!WorkingDirectory.Exists)
                    {
                        throw new ArgumentException("Given working directory is inexistent.");
                    }
                }
            }

            MPIEnviroment.Broadcast(this.WorkingDirectory, 0, csMPI.Raw._COMM.WORLD);

            // more checks
            // ===========
            if (MatlabExecuteable != null)
            {
                if (!File.Exists(MatlabExecuteable))
                {
                    throw new ArgumentException("Unable to find file '" + MatlabExecuteable + "' on this system.");
                }
            }


            // setup MATLAB process
            // ====================

            if (Rank == 0)
            {
                psi = new ProcessStartInfo();
                psi.WorkingDirectory = WorkingDirectory.FullName;
                psi.UseShellExecute  = false;
                //psi.RedirectStandardOutput = true;
                //psi.RedirectStandardError = true;
                //psi.RedirectStandardInput = true;


                PlatformID CurrentSys = System.Environment.OSVersion.Platform;
                switch (CurrentSys)
                {
                case PlatformID.Win32NT:
                case PlatformID.Win32S:
                case PlatformID.Win32Windows: {
                    if (m_Flav == Flavor.Matlab)
                    {
                        if (MatlabExecuteable == null)
                        {
                            MatlabExecuteable = get_program_path("matlab.exe");
                            if (MatlabExecuteable == null)
                            {
                                throw new ApplicationException("Unable to find 'matlab.exe' in your PATH environment; please provide path to 'matlab.exe'.");
                            }
                        }

                        psi.FileName  = MatlabExecuteable;
                        psi.Arguments = "-nosplash -nodesktop -minimize -wait -r " + CMDFILE + " -logfile " + LOGFILE;
                    }
                    else if (m_Flav == Flavor.Octave)
                    {
                        this.Cygwin = true;         // octave and windows must be cygwin!

                        if (MatlabExecuteable == null)
                        {
                            if (File.Exists("c:\\cygwin64\\bin\\octave"))
                            {
                                psi.FileName = "c:\\cygwin64\\bin\\bash.exe";
                            }
                            else if (File.Exists("c:\\cygwin\\bin\\octave"))
                            {
                                psi.FileName = "c:\\cygwin\\bin\\bash.exe";
                            }
                            else
                            {
                                throw new NotSupportedException("Cygwin/Octave are expected to be in the default path: C:\\cygwin or c:\\cygwin64");
                            }
                        }
                        else
                        {
                            //throw new NotSupportedException("Cygwin/Octave are expected to be in the default path: C:\\cygwin or c:\\cygwin64");
                            if (!MatlabExecuteable.EndsWith("bash.exe"))
                            {
                                throw new NotSupportedException("For Cygwin/Octave, the 'MatlabExecuteable' is expected to point to 'bash.exe'.");
                            }

                            psi.FileName = MatlabExecuteable;
                        }
                        psi.Arguments = "--login -c \"cd " + TranslatePath(WorkingDirectory.FullName) + " "
                                        + "&& octave --no-gui " + CMDFILE + ".m" + " > " + LOGFILE + "  \"";
                        //+ "pwd && ls - l && pwd";
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }

                    break;
                }



                case PlatformID.Unix:
                case PlatformID.MacOSX: {
                    throw new NotImplementedException("will implement on request");
                }

                default:
                    throw new NotSupportedException("unable to use MATLAB on " + CurrentSys.ToString());
                }


                CreatedFiles.Add(Path.Combine(WorkingDirectory.FullName, LOGFILE));


                var ScriptsToWrite = new List <Tuple <string, string> >();
                ScriptsToWrite.Add(new Tuple <string, string>("ReadMsr.m", Resource1.ReadMsr));
                ScriptsToWrite.Add(new Tuple <string, string>("SaveVoronoi.m", Resource1.SaveVoronoi));

                foreach (var t in ScriptsToWrite)
                {
                    string name   = t.Item1;
                    string script = t.Item2;
                    var    rmPath = Path.Combine(WorkingDirectory.FullName, name);
                    CreatedFiles.Add(rmPath);
                    File.WriteAllText(rmPath, script);
                }
            }

            // create command file
            // ===================
            if (Rank == 0)
            {
                var p = Path.Combine(WorkingDirectory.FullName, CMDFILE + ".m");
                CommandFile = new StreamWriter(p, false);
                CreatedFiles.Add(p);
            }
        }