/[RomCheater]/trunk/RomCheater/Docking/FloatingMemorySearcher.cs
ViewVC logotype

Diff of /trunk/RomCheater/Docking/FloatingMemorySearcher.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 520 by william, Wed Jun 5 04:50:44 2013 UTC revision 521 by william, Wed Jun 5 07:06:53 2013 UTC
# Line 1443  namespace RomCheater.Docking Line 1443  namespace RomCheater.Docking
1443                          {                          {
1444                              try                              try
1445                              {                              {
1446                                  if (e.ReportProgress)                                  //if (e.ReportProgress)
1447                                  {                                  //{
1448                                      double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);                                  //    double double_percent_done = 100.0 * (double)((double)CurrentIndex / (double)e.TotalCount);
1449                                      int int_percent_done = (int)double_percent_done;                                  //    int int_percent_done = (int)double_percent_done;
1450                                                                        //    int align_base = 100;
1451                                      double align_base = 100000;                                  //    int align_power = 1;
1452                                      double align_power = 1;                                  //    int align = align_base * align_power;
1453                                      double align = align_base * align_power;                                  //    if (int_percent_done != Last_Whole_Percent_Done && (CurrentIndex % align) == 0)
1454                                      if ((int_percent_done != Last_Whole_Percent_Done) && (CurrentIndex % align) == 0)                                  //    {
1455                                      //if ((CurrentIndex % align) == 0)                                  //        string message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));
1456                                      {                                  //        UpdateProgress((int)double_percent_done, message);
1457                                          if (int_percent_done <= 100)                                  //        //new Action<int, string>(UpdateProgress).Invoke(int_percent_done, message);
1458                                          {                                  //        Last_Whole_Percent_Done = int_percent_done;
1459                                              string message = string.Format(" -> Reading Address: 0x{0:x8}", (CurrentIndex + MemoryRangeStart));                                  //        if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }
1460                                              UpdateProgress(int_percent_done, message);                                  //    }
1461                                              //new Action<int, string>(UpdateProgress).Invoke(int_percent_done, message);                                  //}
                                             Last_Whole_Percent_Done = int_percent_done;  
                                         }  
                                         if (SearchWorkerThread.CancellationPending) { e.Canceled = true; return; }  
                                     }  
                                 }  
1462    
1463                                  switch (sdt)                                  switch (sdt)
1464                                  {                                  {
# Line 1807  namespace RomCheater.Docking Line 1802  namespace RomCheater.Docking
1802                          provider.OpenProvider();                          provider.OpenProvider();
1803                          int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);                          int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1804                          SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);                          SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1805                          provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);                          //provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(search_provider_OnBytesRead);
1806                          provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);                          //provider.ReadProcessMemoryAtOnce(MemoryRangeStart, (MemoryRangeSize - MemoryRangeStart), writer);
1807    
1808    
1809                            Stopwatch st_profiler = new Stopwatch();
1810                            st_profiler.Start();
1811                            //int Last_Whole_Percent_Done = 0;
1812                            uint size = STEP_SIZE * 4096;
1813                            for (uint i = MemoryRangeStart; i < MemoryRangeSize; i+=size)
1814                            {
1815                              
1816                                int bytesRead=0;
1817                                byte[] data = new byte[size];
1818                                //provider.ReadProcessMemory(i, size, out bytesRead, out data);
1819    
1820                                provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1821    
1822                                //OnBytesReadEventArgs t_args = new OnBytesReadEventArgs(this, writer, data, i, MemoryRangeSize, true);
1823                                //search_provider_OnBytesRead(t_args);
1824                                //t_args = null;
1825    
1826                                string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1827                                double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1828                                //int int_percent_done = (int)double_percent_done;
1829                                if ((i % 10000) == 0)
1830                                {
1831                                    UpdateProgress((int)double_percent_done, message);
1832                                    logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation has taken {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
1833                                    //Last_Whole_Percent_Done = int_percent_done;
1834                                }
1835    
1836                                //int len = data.Length / BitTools.SizeOf<int>(sdt);
1837                                //switch (sdt)
1838                                //{
1839                                //    case SearchDataTypes._8bits:
1840                                //        // use the data array as is
1841                                //        break;
1842                                //    case SearchDataTypes._16bits:
1843                                //        // create a short or ushort arrray from data
1844                                //        break;
1845                                //    case SearchDataTypes._32bits:
1846                                //        // create a int or uing arrray from data
1847                                //        break;
1848                                //    case SearchDataTypes._64bits:
1849                                //        // create a long or ulong arrray from data
1850                                //        break;
1851                                //}
1852    
1853                                // testing byte array conversion
1854                                
1855    
1856    
1857                                #region comparison and serialization
1858                                switch (sdt)
1859                                {
1860                                    case SearchDataTypes._8bits:
1861                                        if (unsigned)
1862                                        {
1863                                            #region 8bits - unsigned
1864                                            var t_data = BitTools.ConvertByteArray<byte>(data);
1865                                            foreach (var Value in t_data)
1866                                            {
1867                                                if (SearchWorkerThread.CancellationPending) { break; }
1868                                                using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, i))
1869                                                {
1870                                                    byte value = 0;
1871                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1872                                                    {
1873                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1874                                                        {
1875                                                            try
1876                                                            {
1877                                                                gmp.OpenProvider();
1878                                                                gmp.ReadMemory(i, out value);
1879                                                                gmp.CloseProvider();
1880                                                            }
1881                                                            catch (Exception ex)
1882                                                            {
1883                                                                logger.VerboseError.WriteLine(ex.ToString());
1884                                                            }
1885                                                        }
1886                                                        comparer.Value = value;
1887                                                    }
1888                                                    else
1889                                                    {
1890                                                        value = Convert.ToByte(SearchArgs.CompareStartValue);
1891                                                        comparer.Value = value;
1892                                                    }
1893                                                    if (comparer.Compare(Convert.ToByte(Value), value))
1894                                                    {
1895                                                        writer.WriteResult<byte>(comparer.Address, comparer.Value);
1896                                                    }
1897                                                }
1898                                            }
1899                                            #endregion
1900                                        }
1901                                        else
1902                                        {
1903                                            #region 8bits - signed
1904                                            var t_data = BitTools.ConvertByteArray<sbyte>(data);
1905                                            foreach (var Value in t_data)
1906                                            {
1907                                                if (SearchWorkerThread.CancellationPending) { break; }
1908                                                using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, i))
1909                                                {
1910                                                    sbyte value = 0;
1911                                                    if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1912                                                    {
1913                                                        using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1914                                                        {
1915                                                            try
1916                                                            {
1917                                                                gmp.OpenProvider();
1918                                                                gmp.ReadMemory(i, out value);
1919                                                                gmp.CloseProvider();
1920                                                            }
1921                                                            catch (Exception ex)
1922                                                            {
1923                                                                logger.VerboseError.WriteLine(ex.ToString());
1924                                                            }
1925                                                        }
1926                                                        comparer.Value = value;
1927                                                    }
1928                                                    else
1929                                                    {
1930                                                        value = Convert.ToSByte(SearchArgs.CompareStartValue);
1931                                                        comparer.Value = value;
1932                                                    }
1933                                                    if (comparer.Compare(Convert.ToSByte(Value), value))
1934                                                    {
1935                                                        writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1936                                                    }
1937                                                }
1938                                            }
1939                                            #endregion
1940                                        } break;
1941                                    case SearchDataTypes._16bits:
1942                                        if (unsigned)
1943                                        {
1944                                            #region 16bits - unsigned
1945                                              var t_data = BitTools.ConvertByteArray<ushort>(data);
1946                                              foreach (var Value in t_data)
1947                                              {
1948                                                  if (SearchWorkerThread.CancellationPending) { break; }
1949                                                  using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, i))
1950                                                  {
1951                                                      ushort value = 0;
1952                                                      if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1953                                                      {
1954                                                          using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1955                                                          {
1956                                                              try
1957                                                              {
1958                                                                  gmp.OpenProvider();
1959                                                                  gmp.ReadMemory(i, out value);
1960                                                                  gmp.CloseProvider();
1961                                                              }
1962                                                              catch (Exception ex)
1963                                                              {
1964                                                                  logger.VerboseError.WriteLine(ex.ToString());
1965                                                              }
1966                                                          }
1967                                                          comparer.Value = value;
1968                                                      }
1969                                                      else
1970                                                      {
1971                                                          value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1972                                                          comparer.Value = value;
1973                                                      }
1974                                                      if (comparer.Compare(Convert.ToUInt16(Value), value))
1975                                                      {
1976                                                          writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1977                                                      }
1978                                                  }
1979                                              }
1980                                            #endregion
1981                                        }
1982                                        else
1983                                        {
1984                                            #region 16bits - signed
1985                                             var t_data = BitTools.ConvertByteArray<short>(data);
1986                                             foreach (var Value in t_data)
1987                                             {
1988                                                 if (SearchWorkerThread.CancellationPending) { break; }
1989                                                 using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, i))
1990                                                 {
1991                                                     short value = 0;
1992                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1993                                                     {
1994                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1995                                                         {
1996                                                             try
1997                                                             {
1998                                                                 gmp.OpenProvider();
1999                                                                 gmp.ReadMemory(i, out value);
2000                                                                 gmp.CloseProvider();
2001                                                             }
2002                                                             catch (Exception ex)
2003                                                             {
2004                                                                 logger.VerboseError.WriteLine(ex.ToString());
2005                                                             }
2006                                                         }
2007                                                         comparer.Value = value;
2008                                                     }
2009                                                     else
2010                                                     {
2011                                                         value = Convert.ToInt16(SearchArgs.CompareStartValue);
2012                                                         comparer.Value = value;
2013                                                     }
2014                                                     if (comparer.Compare(Convert.ToSByte(Value), value))
2015                                                     {
2016                                                         writer.WriteResult<short>(comparer.Address, comparer.Value);
2017                                                     }
2018                                                 }
2019                                             }
2020                                            #endregion
2021                                        } break;
2022                                    case SearchDataTypes._32bits:
2023                                        if (unsigned)
2024                                        {
2025                                            #region 32bits - unsigned
2026                                             var t_data = BitTools.ConvertByteArray<uint>(data);
2027                                             foreach (var Value in t_data)
2028                                             {
2029                                                 if (SearchWorkerThread.CancellationPending) { break; }
2030                                                 using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, i))
2031                                                 {
2032                                                     uint value = 0;
2033                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2034                                                     {
2035                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2036                                                         {
2037                                                             try
2038                                                             {
2039                                                                 gmp.OpenProvider();
2040                                                                 gmp.ReadMemory(i, out value);
2041                                                                 gmp.CloseProvider();
2042                                                             }
2043                                                             catch (Exception ex)
2044                                                             {
2045                                                                 logger.VerboseError.WriteLine(ex.ToString());
2046                                                             }
2047                                                         }
2048                                                         comparer.Value = value;
2049                                                     }
2050                                                     else
2051                                                     {
2052                                                         value = Convert.ToUInt32(SearchArgs.CompareStartValue);
2053                                                         comparer.Value = value;
2054                                                     }
2055                                                     if (comparer.Compare(Convert.ToUInt32(Value), value))
2056                                                     {
2057                                                         writer.WriteResult<uint>(comparer.Address, comparer.Value);
2058                                                     }
2059                                                 }
2060                                             }
2061                                            #endregion
2062                                        }
2063                                        else
2064                                        {
2065                                            #region 32bits - signed
2066                                             var t_data = BitTools.ConvertByteArray<int>(data);
2067                                             foreach (var Value in t_data)
2068                                             {
2069                                                 if (SearchWorkerThread.CancellationPending) { break; }
2070                                                 using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, i))
2071                                                 {
2072                                                     int value = 0;
2073                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2074                                                     {
2075                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2076                                                         {
2077                                                             try
2078                                                             {
2079                                                                 gmp.OpenProvider();
2080                                                                 gmp.ReadMemory(i, out value);
2081                                                                 gmp.CloseProvider();
2082                                                             }
2083                                                             catch (Exception ex)
2084                                                             {
2085                                                                 logger.VerboseError.WriteLine(ex.ToString());
2086                                                             }
2087                                                         }
2088                                                         comparer.Value = value;
2089                                                     }
2090                                                     else
2091                                                     {
2092                                                         value = Convert.ToInt32(SearchArgs.CompareStartValue);
2093                                                         comparer.Value = value;
2094                                                     }
2095                                                     if (comparer.Compare(Convert.ToInt32(Value), value))
2096                                                     {
2097                                                         writer.WriteResult<int>(comparer.Address, comparer.Value);
2098                                                     }
2099                                                 }
2100                                             }
2101                                            #endregion
2102                                        } break;
2103                                    case SearchDataTypes._64bits:
2104                                        if (unsigned)
2105                                        {
2106                                            #region 64bits - unsigned
2107                                             var t_data = BitTools.ConvertByteArray<ulong>(data);
2108                                             foreach (var Value in t_data)
2109                                             {
2110                                                 if (SearchWorkerThread.CancellationPending) { break; }
2111                                                 using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, i))
2112                                                 {
2113                                                     ulong value = 0;
2114                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2115                                                     {
2116                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2117                                                         {
2118                                                             try
2119                                                             {
2120                                                                 gmp.OpenProvider();
2121                                                                 gmp.ReadMemory(i, out value);
2122                                                                 gmp.CloseProvider();
2123                                                             }
2124                                                             catch (Exception ex)
2125                                                             {
2126                                                                 logger.VerboseError.WriteLine(ex.ToString());
2127                                                             }
2128                                                         }
2129                                                         comparer.Value = value;
2130                                                     }
2131                                                     else
2132                                                     {
2133                                                         value = Convert.ToUInt64(SearchArgs.CompareStartValue);
2134                                                         comparer.Value = value;
2135                                                     }
2136                                                     if (comparer.Compare(Convert.ToUInt64(Value), value))
2137                                                     {
2138                                                         writer.WriteResult<ulong>(comparer.Address, comparer.Value);
2139                                                     }
2140                                                 }
2141                                             }
2142                                            #endregion
2143                                        }
2144                                        else
2145                                        {
2146                                            #region 64bits - signed
2147                                             var t_data = BitTools.ConvertByteArray<long>(data);
2148                                             foreach (var Value in t_data)
2149                                             {
2150                                                 if (SearchWorkerThread.CancellationPending) { break; }
2151                                                 using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, i))
2152                                                 {
2153                                                     long value = 0;
2154                                                     if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
2155                                                     {
2156                                                         using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
2157                                                         {
2158                                                             try
2159                                                             {
2160                                                                 gmp.OpenProvider();
2161                                                                 gmp.ReadMemory(i, out value);
2162                                                                 gmp.CloseProvider();
2163                                                             }
2164                                                             catch (Exception ex)
2165                                                             {
2166                                                                 logger.VerboseError.WriteLine(ex.ToString());
2167                                                             }
2168                                                         }
2169                                                         comparer.Value = value;
2170                                                     }
2171                                                     else
2172                                                     {
2173                                                         value = Convert.ToInt64(SearchArgs.CompareStartValue);
2174                                                         comparer.Value = value;
2175                                                     }
2176                                                     if (comparer.Compare(Convert.ToInt64(Value), value))
2177                                                     {
2178                                                         writer.WriteResult<long>(comparer.Address, comparer.Value);
2179                                                     }
2180                                                 }
2181                                             }
2182                                            #endregion
2183                                        } break;
2184                                }
2185                                
2186                                //using (MemoryStream ms = new MemoryStream(data))
2187                                //{
2188                                //    using (BinaryReader br = new BinaryReader(ms))
2189                                //    {
2190                                //        while (br.BaseStream.Position < br.BaseStream.Length)
2191                                //        {
2192                                //            if (SearchWorkerThread.CancellationPending)
2193                                //            {
2194                                //                break;
2195                                //            }                                      
2196                                //        }
2197                                //    }
2198                                //}
2199                                #endregion
2200    
2201    
2202                                if (SearchWorkerThread.CancellationPending)
2203                                {
2204                                    st_profiler.Stop();
2205                                    provider_st.Stop();
2206                                    st.Stop();
2207                                    writer.CancelRequest();
2208                                    writer.Dispose();
2209                                    writer = null;
2210                                    e.Result = true;
2211                                    provider.CloseProvider();
2212                                    logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2213                                    return;
2214                                }
2215                            }
2216    
2217                            st_profiler.Stop();
2218    
2219                            logger.Profiler.WriteLine("Memory Search Operation Profiler: search operation took {0} seconds", st_profiler.Elapsed.TotalSeconds.ToString());
2220    
2221                          if (SearchWorkerThread.CancellationPending)                          if (SearchWorkerThread.CancellationPending)
2222                          {                          {
2223                              provider_st.Stop();                              provider_st.Stop();

Legend:
Removed from v.520  
changed lines
  Added in v.521

  ViewVC Help
Powered by ViewVC 1.1.22