/[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 544 by william, Wed Jun 5 22:00:27 2013 UTC revision 545 by william, Wed Jun 5 22:08:38 2013 UTC
# Line 1491  namespace RomCheater.Docking Line 1491  namespace RomCheater.Docking
1491                      else                      else
1492                      {                      {
1493                          Guid new_SearchGuid = SearchGuid;                          Guid new_SearchGuid = SearchGuid;
1494                          int Last_Whole_Percent_Done = 0;                          //int Last_Whole_Percent_Done = 0;
1495                          // need to get the address list                          // need to get the address list
1496                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, true)) // delete the file on dispose                          using (SearchResultReader reader = new SearchResultReader(SearchGuid, true)) // delete the file on dispose
1497                          {                          {
# Line 1500  namespace RomCheater.Docking Line 1500  namespace RomCheater.Docking
1500                              {                              {
1501                                  //int index = 0;                                  //int index = 0;
1502    
1503                                  const int ChunkCount = 0x100;                                  provider.OpenProvider();
1504                                  for (int ResultIndex = 0; ResultIndex < reader.ResultCount; ResultIndex += ChunkCount)                                  //int count = (int)((MemoryRangeSize - MemoryRangeStart) / STEP_SIZE);
1505                                    //SearchResultWriter writer = new SearchResultWriter((int)(count), SearchGuid);
1506                                    int Last_Whole_Percent_Done = 0;
1507                                    uint size = STEP_SIZE * 4096;
1508                                    for (uint i = MemoryRangeStart; i < MemoryRangeSize; i += size)
1509                                  {                                  {
                                     StructResultType<ulong>[] ChunkResults = new StructResultType<ulong>[ChunkCount];  
                                     for (int ChunkIndex = 0; ChunkIndex < ChunkCount; ChunkIndex++)  
                                     {  
                                         int ResultChunkIndex = (ResultIndex + ChunkIndex);  
                                         StructResultType<ulong> result = StructResultType<ulong>.Empty;  
                                         reader.GetResultAtIndex(ResultChunkIndex, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), out result, new Func<bool>(ShouldCancelAnySearchOperation));  
                                         ChunkResults[ChunkIndex] = result;  
                                         if (SearchWorkerThread.CancellationPending)  
                                         {  
                                             provider_st.Stop();  
                                             st.Stop();  
                                             writer.CancelRequest();  
                                             writer.Dispose();  
                                             e.Result = true;  
                                             break;  
                                         }  
                                     }  
                                     // Get update value(s) for each chunk result  
                                     ISerializedResult sr = (reader as ISerializedResult);  
                                     if(sr == null)  
                                     {  
                                         throw new ArgumentNullException("sr",string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name,typeof(ISerializedResult).Name));  
                                     }  
   
                                     Stopwatch st_memory_results_updater = new Stopwatch();  
                                     st_memory_results_updater.Start();  
                                     sr.UpdateResultValuesFromMemory(ref ChunkResults, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation), (IAcceptsProcessAndConfig)this);  
                                     if (SearchWorkerThread.CancellationPending) // catch a cancelled operation from UpdateResultValuesFromMemory  
                                     {  
                                         provider_st.Stop();  
                                         st.Stop();  
                                         writer.CancelRequest();  
                                         writer.Dispose();  
                                         e.Result = true;  
                                         break;  
                                     }  
   
                                     st_memory_results_updater.Stop();  
                                     logger.Profiler.WriteLine("sr.UpdateResultValuesFromMemory [ResultIndex=0x{0} ChunkCount=0x{1}] took a total of {2} seconds to complete", ResultIndex.ToString("X"), ChunkCount.ToString("X"), st_memory_results_updater.Elapsed.TotalSeconds.ToString());  
   
                                     // ChunkResults should have had thier values updated from memory  
1510    
1511                                        int bytesRead = 0;
1512                                      string message = string.Format(" -> Updateing Values [ResultIndex=0x{0} of Total=0x{1}]", ResultIndex.ToString("X"), reader.ResultCount.ToString("X"));                                      byte[] data = new byte[size];
1513                                      double double_percent_done = 100.0 * (double)((double)ResultIndex / (double)reader.ResultCount);                                      provider.ReadProcessMemoryAtOnce(i, size, out bytesRead, out data);
1514                                        string message = string.Format(" -> Reading Address: 0x{0:x8}", (i + MemoryRangeStart));
1515                                        double double_percent_done = 100.0 * (double)((double)i / (double)MemoryRangeSize);
1516                                      int int_percent_done = (int)double_percent_done;                                      int int_percent_done = (int)double_percent_done;
1517                                      //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)                                      if ((int_percent_done != Last_Whole_Percent_Done) && (i % 10000) == 0)
                                     //{  
                                     //    UpdateProgress((int)double_percent_done, message);  
                                     //    Last_Whole_Percent_Done = int_percent_done;  
                                     //}  
                                     if (((double)ResultIndex % ((double)reader.ResultCount) * 0.25) == 0)  
                                     //if ((ResultIndex % 10000) == 0)  
1518                                      {                                      {
1519                                          UpdateProgress((int)double_percent_done, message);                                          UpdateProgress((int)double_percent_done, message);
1520                                          Last_Whole_Percent_Done = int_percent_done;                                          Last_Whole_Percent_Done = int_percent_done;
1521                                      }                                      }
1522    
1523                                        uint address_index = i;
1524                                        #region comparison and serialization
1525                                        switch (sdt)
1526                                        {
1527                                            case SearchDataTypes._8bits:
1528                                                if (unsigned)
1529                                                {
1530                                                    #region 8bits - unsigned
1531                                                    var t_data = data;
1532                                                    foreach (var Value in t_data)
1533                                                    {
1534                                                        if (SearchWorkerThread.CancellationPending) { break; }
1535                                                        using (_8bit_unsigned_comparer_ comparer = new _8bit_unsigned_comparer_(SearchArgs, address_index))
1536                                                        {
1537                                                            byte value = 0;
1538                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1539                                                            {
1540                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1541                                                                {
1542                                                                    try
1543                                                                    {
1544                                                                        gmp.OpenProvider();
1545                                                                        gmp.ReadMemory(address_index, out value);
1546                                                                        gmp.CloseProvider();
1547                                                                    }
1548                                                                    catch (Exception ex)
1549                                                                    {
1550                                                                        logger.VerboseError.WriteLine(ex.ToString());
1551                                                                    }
1552                                                                }
1553                                                                comparer.Value = value;
1554                                                            }
1555                                                            else
1556                                                            {
1557                                                                value = Convert.ToByte(SearchArgs.CompareStartValue);
1558                                                                comparer.Value = value;
1559                                                            }
1560                                                            if (comparer.Compare(Convert.ToByte(Value), value))
1561                                                            {
1562                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1563                                                                {
1564                                                                    writer.WriteResult<byte>(comparer.Address, comparer.Value);
1565                                                                }                                                            
1566                                                            }
1567                                                        }
1568                                                        address_index += STEP_SIZE;
1569                                                    }
1570                                                    #endregion
1571                                                }
1572                                                else
1573                                                {
1574                                                    #region 8bits - signed
1575                                                    var t_data = data;
1576                                                    foreach (var Value in t_data)
1577                                                    {
1578                                                        if (SearchWorkerThread.CancellationPending) { break; }
1579                                                        using (_8bit_signed_comparer_ comparer = new _8bit_signed_comparer_(SearchArgs, address_index))
1580                                                        {
1581                                                            sbyte value = 0;
1582                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1583                                                            {
1584                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1585                                                                {
1586                                                                    try
1587                                                                    {
1588                                                                        gmp.OpenProvider();
1589                                                                        gmp.ReadMemory(address_index, out value);
1590                                                                        gmp.CloseProvider();
1591                                                                    }
1592                                                                    catch (Exception ex)
1593                                                                    {
1594                                                                        logger.VerboseError.WriteLine(ex.ToString());
1595                                                                    }
1596                                                                }
1597                                                                comparer.Value = value;
1598                                                            }
1599                                                            else
1600                                                            {
1601                                                                value = Convert.ToSByte(SearchArgs.CompareStartValue);
1602                                                                comparer.Value = value;
1603                                                            }
1604                                                            if (comparer.Compare(Convert.ToSByte(Value), value))
1605                                                            {
1606                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1607                                                                {
1608                                                                    writer.WriteResult<sbyte>(comparer.Address, comparer.Value);
1609                                                                }
1610                                                            }
1611                                                        }
1612                                                        address_index += STEP_SIZE;
1613                                                    }
1614                                                    #endregion
1615                                                } break;
1616                                            case SearchDataTypes._16bits:
1617                                                if (unsigned)
1618                                                {
1619                                                    #region 16bits - unsigned
1620                                                    var t_data = BitTools.ConvertByteArray<ushort>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1621                                                    foreach (var Value in t_data)
1622                                                    {
1623                                                        if (SearchWorkerThread.CancellationPending) { break; }
1624                                                        using (_16bit_unsigned_comparer_ comparer = new _16bit_unsigned_comparer_(SearchArgs, address_index))
1625                                                        {
1626                                                            ushort value = 0;
1627                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1628                                                            {
1629                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1630                                                                {
1631                                                                    try
1632                                                                    {
1633                                                                        gmp.OpenProvider();
1634                                                                        gmp.ReadMemory(address_index, out value);
1635                                                                        gmp.CloseProvider();
1636                                                                    }
1637                                                                    catch (Exception ex)
1638                                                                    {
1639                                                                        logger.VerboseError.WriteLine(ex.ToString());
1640                                                                    }
1641                                                                }
1642                                                                comparer.Value = value;
1643                                                            }
1644                                                            else
1645                                                            {
1646                                                                value = Convert.ToUInt16(SearchArgs.CompareStartValue);
1647                                                                comparer.Value = value;
1648                                                            }
1649                                                            if (comparer.Compare(Convert.ToUInt16(Value), value))
1650                                                            {
1651                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1652                                                                {
1653                                                                    writer.WriteResult<ushort>(comparer.Address, comparer.Value);
1654                                                                }
1655                                                            }
1656                                                        }
1657                                                        address_index += STEP_SIZE;
1658                                                    }
1659                                                    #endregion
1660                                                }
1661                                                else
1662                                                {
1663                                                    #region 16bits - signed
1664                                                    var t_data = BitTools.ConvertByteArray<short>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1665                                                    foreach (var Value in t_data)
1666                                                    {
1667                                                        if (SearchWorkerThread.CancellationPending) { break; }
1668                                                        using (_16bit_signed_comparer_ comparer = new _16bit_signed_comparer_(SearchArgs, address_index))
1669                                                        {
1670                                                            short value = 0;
1671                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1672                                                            {
1673                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1674                                                                {
1675                                                                    try
1676                                                                    {
1677                                                                        gmp.OpenProvider();
1678                                                                        gmp.ReadMemory(address_index, out value);
1679                                                                        gmp.CloseProvider();
1680                                                                    }
1681                                                                    catch (Exception ex)
1682                                                                    {
1683                                                                        logger.VerboseError.WriteLine(ex.ToString());
1684                                                                    }
1685                                                                }
1686                                                                comparer.Value = value;
1687                                                            }
1688                                                            else
1689                                                            {
1690                                                                value = Convert.ToInt16(SearchArgs.CompareStartValue);
1691                                                                comparer.Value = value;
1692                                                            }
1693                                                            if (comparer.Compare(Convert.ToSByte(Value), value))
1694                                                            {
1695                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1696                                                                {
1697                                                                    writer.WriteResult<short>(comparer.Address, comparer.Value);
1698                                                                }
1699                                                            }
1700                                                        }
1701                                                        address_index += STEP_SIZE;
1702                                                    }
1703                                                    #endregion
1704                                                } break;
1705                                            case SearchDataTypes._32bits:
1706                                                if (unsigned)
1707                                                {
1708                                                    #region 32bits - unsigned
1709                                                    var t_data = BitTools.ConvertByteArray<uint>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1710                                                    foreach (var Value in t_data)
1711                                                    {
1712                                                        if (SearchWorkerThread.CancellationPending) { break; }
1713                                                        using (_32bit_unsigned_comparer_ comparer = new _32bit_unsigned_comparer_(SearchArgs, address_index))
1714                                                        {
1715                                                            uint value = 0;
1716                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1717                                                            {
1718                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1719                                                                {
1720                                                                    try
1721                                                                    {
1722                                                                        gmp.OpenProvider();
1723                                                                        gmp.ReadMemory(address_index, out value);
1724                                                                        gmp.CloseProvider();
1725                                                                    }
1726                                                                    catch (Exception ex)
1727                                                                    {
1728                                                                        logger.VerboseError.WriteLine(ex.ToString());
1729                                                                    }
1730                                                                }
1731                                                                comparer.Value = value;
1732                                                            }
1733                                                            else
1734                                                            {
1735                                                                value = Convert.ToUInt32(SearchArgs.CompareStartValue);
1736                                                                comparer.Value = value;
1737                                                            }
1738                                                            if (comparer.Compare(Convert.ToUInt32(Value), value))
1739                                                            {
1740                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1741                                                                {
1742                                                                    writer.WriteResult<uint>(comparer.Address, comparer.Value);
1743                                                                }
1744                                                            }
1745                                                        }
1746                                                        address_index += STEP_SIZE;
1747                                                    }
1748                                                    #endregion
1749                                                }
1750                                                else
1751                                                {
1752                                                    #region 32bits - signed
1753                                                    var t_data = BitTools.ConvertByteArray<int>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1754                                                    foreach (var Value in t_data)
1755                                                    {
1756                                                        if (SearchWorkerThread.CancellationPending) { break; }
1757                                                        using (_32bit_signed_comparer_ comparer = new _32bit_signed_comparer_(SearchArgs, address_index))
1758                                                        {
1759                                                            int value = 0;
1760                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1761                                                            {
1762                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1763                                                                {
1764                                                                    try
1765                                                                    {
1766                                                                        gmp.OpenProvider();
1767                                                                        gmp.ReadMemory(address_index, out value);
1768                                                                        gmp.CloseProvider();
1769                                                                    }
1770                                                                    catch (Exception ex)
1771                                                                    {
1772                                                                        logger.VerboseError.WriteLine(ex.ToString());
1773                                                                    }
1774                                                                }
1775                                                                comparer.Value = value;
1776                                                            }
1777                                                            else
1778                                                            {
1779                                                                value = Convert.ToInt32(SearchArgs.CompareStartValue);
1780                                                                comparer.Value = value;
1781                                                            }
1782                                                            if (comparer.Compare(Convert.ToInt32(Value), value))
1783                                                            {
1784                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1785                                                                {
1786                                                                    writer.WriteResult<int>(comparer.Address, comparer.Value);
1787                                                                }
1788                                                            }
1789                                                        }
1790                                                        address_index += STEP_SIZE;
1791                                                    }
1792                                                    #endregion
1793                                                } break;
1794                                            case SearchDataTypes._64bits:
1795                                                if (unsigned)
1796                                                {
1797                                                    #region 64bits - unsigned
1798                                                    var t_data = BitTools.ConvertByteArray<ulong>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1799                                                    foreach (var Value in t_data)
1800                                                    {
1801                                                        if (SearchWorkerThread.CancellationPending) { break; }
1802                                                        using (_64bit_unsigned_comparer_ comparer = new _64bit_unsigned_comparer_(SearchArgs, address_index))
1803                                                        {
1804                                                            ulong value = 0;
1805                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1806                                                            {
1807                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1808                                                                {
1809                                                                    try
1810                                                                    {
1811                                                                        gmp.OpenProvider();
1812                                                                        gmp.ReadMemory(address_index, out value);
1813                                                                        gmp.CloseProvider();
1814                                                                    }
1815                                                                    catch (Exception ex)
1816                                                                    {
1817                                                                        logger.VerboseError.WriteLine(ex.ToString());
1818                                                                    }
1819                                                                }
1820                                                                comparer.Value = value;
1821                                                            }
1822                                                            else
1823                                                            {
1824                                                                value = Convert.ToUInt64(SearchArgs.CompareStartValue);
1825                                                                comparer.Value = value;
1826                                                            }
1827                                                            if (comparer.Compare(Convert.ToUInt64(Value), value))
1828                                                            {
1829                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1830                                                                {
1831                                                                    writer.WriteResult<ulong>(comparer.Address, comparer.Value);
1832                                                                }
1833                                                            }
1834                                                        }
1835                                                        address_index += STEP_SIZE;
1836                                                    }
1837                                                    #endregion
1838                                                }
1839                                                else
1840                                                {
1841                                                    #region 64bits - signed
1842                                                    var t_data = BitTools.ConvertByteArray<long>(data, new Func<bool>(ShouldCancelAnySearchOperation));
1843                                                    foreach (var Value in t_data)
1844                                                    {
1845                                                        if (SearchWorkerThread.CancellationPending) { break; }
1846                                                        using (_64bit_signed_comparer_ comparer = new _64bit_signed_comparer_(SearchArgs, address_index))
1847                                                        {
1848                                                            long value = 0;
1849                                                            if (SearchArgs.CompareValueType == CompareValueTypes.OldValue)
1850                                                            {
1851                                                                using (GenericMemoryProvider gmp = new GenericMemoryProvider((IAcceptsProcessAndConfig)this))
1852                                                                {
1853                                                                    try
1854                                                                    {
1855                                                                        gmp.OpenProvider();
1856                                                                        gmp.ReadMemory(address_index, out value);
1857                                                                        gmp.CloseProvider();
1858                                                                    }
1859                                                                    catch (Exception ex)
1860                                                                    {
1861                                                                        logger.VerboseError.WriteLine(ex.ToString());
1862                                                                    }
1863                                                                }
1864                                                                comparer.Value = value;
1865                                                            }
1866                                                            else
1867                                                            {
1868                                                                value = Convert.ToInt64(SearchArgs.CompareStartValue);
1869                                                                comparer.Value = value;
1870                                                            }
1871                                                            if (comparer.Compare(Convert.ToInt64(Value), value))
1872                                                            {
1873                                                                if (reader.ContainsAddress(address_index, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1874                                                                {
1875                                                                    writer.WriteResult<long>(comparer.Address, comparer.Value);
1876                                                                }
1877                                                            }
1878                                                        }
1879                                                        address_index += STEP_SIZE;
1880                                                    }
1881                                                    #endregion
1882                                                } break;
1883    
1884                                        }
1885                                        #endregion
1886    
1887                                      if (SearchWorkerThread.CancellationPending)                                      if (SearchWorkerThread.CancellationPending)
1888                                      {                                      {
1889                                          provider_st.Stop();                                          provider_st.Stop();
# Line 1567  namespace RomCheater.Docking Line 1891  namespace RomCheater.Docking
1891                                          writer.CancelRequest();                                          writer.CancelRequest();
1892                                          writer.Dispose();                                          writer.Dispose();
1893                                          e.Result = true;                                          e.Result = true;
1894                                          break;                                          provider.CloseProvider();
1895                                            return;
1896                                      }                                      }
1897                                  }                                  }
1898                                    #region old-code2
1899                                    //const int ChunkCount = 0x100;
1900                                    //for (int ResultIndex = 0; ResultIndex < reader.ResultCount; ResultIndex += ChunkCount)
1901                                    //{
1902                                    //    StructResultType<ulong>[] ChunkResults = new StructResultType<ulong>[ChunkCount];
1903                                    //    for (int ChunkIndex = 0; ChunkIndex < ChunkCount; ChunkIndex++)
1904                                    //    {
1905                                    //        int ResultChunkIndex = (ResultIndex + ChunkIndex);
1906                                    //        StructResultType<ulong> result = StructResultType<ulong>.Empty;
1907                                    //        reader.GetResultAtIndex(ResultChunkIndex, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), out result, new Func<bool>(ShouldCancelAnySearchOperation));
1908                                    //        ChunkResults[ChunkIndex] = result;
1909                                    //        if (SearchWorkerThread.CancellationPending)
1910                                    //        {
1911                                    //            provider_st.Stop();
1912                                    //            st.Stop();
1913                                    //            writer.CancelRequest();
1914                                    //            writer.Dispose();
1915                                    //            e.Result = true;
1916                                    //            break;
1917                                    //        }
1918                                    //    }
1919                                    //    // Get update value(s) for each chunk result
1920                                    //    ISerializedResult sr = (reader as ISerializedResult);
1921                                    //    if(sr == null)
1922                                    //    {
1923                                    //        throw new ArgumentNullException("sr",string.Format("Unable to cast: '{0}' to '{1}'", reader.GetType().Name,typeof(ISerializedResult).Name));
1924                                    //    }
1925                                    //    Stopwatch st_memory_results_updater = new Stopwatch();
1926                                    //    st_memory_results_updater.Start();
1927                                    //    sr.UpdateResultValuesFromMemory(ref ChunkResults, SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation), (IAcceptsProcessAndConfig)this);
1928                                    //    if (SearchWorkerThread.CancellationPending) // catch a cancelled operation from UpdateResultValuesFromMemory
1929                                    //    {
1930                                    //        provider_st.Stop();
1931                                    //        st.Stop();
1932                                    //        writer.CancelRequest();
1933                                    //        writer.Dispose();
1934                                    //        e.Result = true;
1935                                    //        break;
1936                                    //    }
1937                                    //    st_memory_results_updater.Stop();
1938                                    //    logger.Profiler.WriteLine("sr.UpdateResultValuesFromMemory [ResultIndex=0x{0} ChunkCount=0x{1}] took a total of {2} seconds to complete", ResultIndex.ToString("X"), ChunkCount.ToString("X"), st_memory_results_updater.Elapsed.TotalSeconds.ToString());
1939                                    //    // ChunkResults should have had thier values updated from memory
1940                                    //    string message = string.Format(" -> Updateing Values [ResultIndex=0x{0} of Total=0x{1}]", ResultIndex.ToString("X"), reader.ResultCount.ToString("X"));
1941                                    //    double double_percent_done = 100.0 * (double)((double)ResultIndex / (double)reader.ResultCount);
1942                                    //    int int_percent_done = (int)double_percent_done;
1943                                    //    //if ((int_percent_done != Last_Whole_Percent_Done) && (index % 1000) == 0)
1944                                    //    //{
1945                                    //    //    UpdateProgress((int)double_percent_done, message);
1946                                    //    //    Last_Whole_Percent_Done = int_percent_done;
1947                                    //    //}
1948                                    //    if (((double)ResultIndex % ((double)reader.ResultCount) * 0.25) == 0)
1949                                    //    //if ((ResultIndex % 10000) == 0)
1950                                    //    {
1951                                    //        UpdateProgress((int)double_percent_done, message);
1952                                    //        Last_Whole_Percent_Done = int_percent_done;
1953                                    //    }
1954                                    //    if (SearchWorkerThread.CancellationPending)
1955                                    //    {
1956                                    //        provider_st.Stop();
1957                                    //        st.Stop();
1958                                    //        writer.CancelRequest();
1959                                    //        writer.Dispose();
1960                                    //        e.Result = true;
1961                                    //        break;
1962                                    //    }
1963                                    //}
1964                                    #endregion
1965    
1966                                  #region old-code                                  #region old-code1
1967                                  //foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))                                  //foreach (var k in reader.GetResults(SearchArgs.IsUnsignedDataType, SearchArgs.DataType, new Action<int, string>(UpdateProgress), new Func<bool>(ShouldCancelAnySearchOperation)))
1968                                  //{                                  //{
1969                                  //    if (SearchWorkerThread.CancellationPending)                                  //    if (SearchWorkerThread.CancellationPending)
# Line 1953  namespace RomCheater.Docking Line 2345  namespace RomCheater.Docking
2345                                  //}                                  //}
2346                                  #endregion                                  #endregion
2347    
2348                                    #region reference-code (can be deleted - later)
2349                                  //ISerializedResult sr = (reader as ISerializedResult);                                  //ISerializedResult sr = (reader as ISerializedResult);
2350                                  //if (sr == null)                                  //if (sr == null)
2351                                  //{                                  //{
# Line 1971  namespace RomCheater.Docking Line 2364  namespace RomCheater.Docking
2364                                  //        }                                  //        }
2365                                  //    }                                  //    }
2366                                  //}                                  //}
2367                                    #endregion
2368                              }                              }
2369    
2370                          }                          }

Legend:
Removed from v.544  
changed lines
  Added in v.545

  ViewVC Help
Powered by ViewVC 1.1.22