Changeset 1651


Ignore:
Timestamp:
Jun 15, 2010, 10:16:40 PM (11 years ago)
Author:
Paul Lelgemann
Message:

o Work on the distributed KeySearcher

Location:
trunk/CrypPlugins/KeySearcher/P2P
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/P2P/KeyPoolTree.cs

    r1647 r1651  
    1 using System;
    2 using System.Collections.Generic;
     1using System.Collections.Generic;
    32using System.Numerics;
    43using KeySearcher.Helper;
     
    3433            AdvanceToFirstLeaf();
    3534
    36             if (_rootNode is Node)
    37             {
    38                 _calculationFinishedOnStart = ((Node) _rootNode).IsCalculated;
    39             } else
    40             {
    41                 _calculationFinishedOnStart = _rootNode.Result.Count > 0;
    42             }
     35            _calculationFinishedOnStart = _rootNode.IsCalculated();
    4336        }
    4437
     
    5043        public bool LocateNextPattern()
    5144        {
     45            _useReservedNodes = false;
     46            _skippedReservedNodes = false;
    5247            var patternLocated = LocateNextPattern(false);
    5348
     
    6863            if (_rootNode is Leaf)
    6964            {
    70                 // Root node finished?
    71                 if (_rootNode.Result.Count > 0)
    72                 {
    73                     return false;
    74                 }
    75 
    7665                _currentLeaf = (Leaf) _rootNode;
    77                 return true;
     66                return _rootNode.IsCalculated();
    7867            }
    7968
     
    8170            while (nextNode != null)
    8271            {
    83                 // TODO update required?
    8472                _p2PHelper.UpdateFromDht(nextNode);
    85                 if (nextNode.IsCalculated)
     73                if (nextNode.IsCalculated())
    8674                {
    8775                    nextNode = nextNode.ParentNode;
  • trunk/CrypPlugins/KeySearcher/P2P/Nodes/Leaf.cs

    r1647 r1651  
    3131        }
    3232
     33        public override bool IsCalculated()
     34        {
     35            return Result.Count > 0;
     36        }
     37
    3338        public bool ReserveLeaf()
    3439        {
     
    4348            return isReserverd;
    4449        }
     50
     51        public override string ToString()
     52        {
     53            return base.ToString() + ", last reservation date " + LastReservationDate;
     54        }
    4555    }
    4656}
  • trunk/CrypPlugins/KeySearcher/P2P/Nodes/Node.cs

    r1645 r1651  
    1515            : base(p2PHelper, keyQualityHelper, parentNode, @from, to, distributedJobIdentifier)
    1616        {
    17             if (!LeftChildFinished || !RightChildFinished)
    18             {
    19                 FindChildNodes();
    20             }
    2117        }
    2218
    23         private void FindChildNodes()
     19        private void LoadOrUpdateChildNodes(bool ignoreReservation = false)
    2420        {
    2521            var middle = (From + To)/2;
    26             if (_leftChild == null)
     22
     23            if (!LeftChildFinished)
    2724            {
    28                 _leftChild = NodeFactory.CreateNode(P2PHelper, KeyQualityHelper, this, From, middle, DistributedJobIdentifier);
    29             }
    30             else
    31             {
    32                 if (!LeftChildFinished)
     25                if (_leftChild == null)
     26                {
     27                    _leftChild = NodeFactory.CreateNode(P2PHelper, KeyQualityHelper, this, From, middle,
     28                                                        DistributedJobIdentifier);
     29                }
     30                else
     31                {
    3332                    P2PHelper.UpdateFromDht(_leftChild);
     33                }
    3434            }
    3535
    3636            // Only load right node, if the left one is finished or reserved
    37             if (LeftChildFinished || _leftChild.IsReserverd())
     37            var leftChildsReservationExistingAndNotIgnored = !LeftChildFinished && _leftChild.IsReserverd() && !ignoreReservation;
     38            if ((LeftChildFinished || !leftChildsReservationExistingAndNotIgnored) && !RightChildFinished)
    3839            {
    3940                if (_rightChild == null)
    4041                {
    41                     _rightChild = NodeFactory.CreateNode(P2PHelper, KeyQualityHelper, this, middle + 1, To, DistributedJobIdentifier);
     42                    _rightChild = NodeFactory.CreateNode(P2PHelper, KeyQualityHelper, this, middle + 1, To,
     43                                                         DistributedJobIdentifier);
    4244                }
    4345                else
    4446                {
    45                     if (!RightChildFinished)
    46                         P2PHelper.UpdateFromDht(_rightChild);
     47                    P2PHelper.UpdateFromDht(_rightChild);
    4748                }
    4849            }
    4950        }
    5051
    51         public bool IsCalculated
     52        public override bool IsCalculated()
    5253        {
    53             get
    54             {
    55                 return LeftChildFinished && RightChildFinished;
    56             }
     54            return LeftChildFinished && RightChildFinished;
    5755        }
    5856
    5957        public override NodeBase CalculatableNode(bool useReservedNodes)
    6058        {
    61             if (LeftChildFinished && RightChildFinished)
     59            if (IsCalculated())
    6260            {
    6361                return null;
    6462            }
    6563
    66             if (LeftChildFinished || (_leftChild.IsReserverd() && !useReservedNodes))
     64            LoadOrUpdateChildNodes(true);
     65
     66            if ((LeftChildFinished || (_leftChild.IsReserverd() && !useReservedNodes)) && !RightChildFinished)
    6767            {
    68                 if (_rightChild == null)
    69                 {
    70                     FindChildNodes();
    71                 }
    72 
    7368                return _rightChild.CalculatableNode(useReservedNodes);
    7469            }
     
    7671            return _leftChild.CalculatableNode(useReservedNodes);
    7772        }
    78 
    79        
    8073
    8174        public void ChildFinished(NodeBase childNode)
     
    9992        public override bool IsReserverd()
    10093        {
    101             if (LeftChildFinished || _leftChild.IsReserverd())
     94            LoadOrUpdateChildNodes(true);
     95
     96            var leftChildFinishedOrReserved = LeftChildFinished || _leftChild.IsReserverd();
     97
     98            if (leftChildFinishedOrReserved && !RightChildFinished)
    10299            {
    103                 if (_rightChild == null)
    104                 {
    105                     FindChildNodes();
    106                 }
    107 
    108100                return _rightChild.IsReserverd();
    109101            }
    110102
    111             return false;
     103            return !LeftChildFinished && _leftChild.IsReserverd();
     104        }
     105
     106        public override string ToString()
     107        {
     108            return base.ToString() + ", LeftChildFinished " + LeftChildFinished + ",  RightChildFinished " +
     109                   RightChildFinished;
    112110        }
    113111    }
  • trunk/CrypPlugins/KeySearcher/P2P/Nodes/NodeBase.cs

    r1643 r1651  
    1717        protected internal DateTime LastUpdate;
    1818
    19         private readonly KeySearcher _keySearcher;
    2019        public readonly Node ParentNode;
    2120        public LinkedList<KeySearcher.ValueKey> Result;
     
    8180            P2PManager.Remove(P2PHelper.KeyInDht(this));
    8281
    83             if (ParentNode.IsCalculated)
     82            if (ParentNode.IsCalculated())
    8483            {
    8584                ParentNode.UpdateDht();
     
    9695
    9796        public abstract NodeBase CalculatableNode(bool useReservedNodes);
     97
     98        public abstract bool IsCalculated();
     99
     100        public override string ToString()
     101        {
     102            return "NodeBase " + GetType() + ", from " + From + " to " + To;
     103        }
    98104    }
    99105}
  • trunk/CrypPlugins/KeySearcher/P2P/Nodes/NodeFactory.cs

    r1634 r1651  
    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Numerics;
    5 using System.Text;
     1using System.Numerics;
    62using KeySearcher.Helper;
    73
    84namespace KeySearcher.P2P.Nodes
    95{
    10     class NodeFactory
     6    static class NodeFactory
    117    {
    128        public static NodeBase CreateNode(P2PHelper p2PHelper, KeyQualityHelper keyQualityHelper, Node parentNode, BigInteger from, BigInteger to, string distributedJobIdentifier)
  • trunk/CrypPlugins/KeySearcher/P2P/Nodes/P2PHelper.cs

    r1647 r1651  
    5959            }
    6060
     61            nodeToUpdate.LastUpdate = DateTime.Now;
     62
    6163            var nodeBytes = P2PManager.Retrieve(KeyInDht(nodeToUpdate));
    6264
     
    6567                return;
    6668            }
    67 
    68             nodeToUpdate.LastUpdate = DateTime.Now;
    6969
    7070            var binaryReader = new BinaryReader(new MemoryStream(nodeBytes));
  • trunk/CrypPlugins/KeySearcher/P2P/P2PBruteForce.cs

    r1647 r1651  
    11using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    42using System.Numerics;
    5 using System.Text;
    63using Cryptool.PluginBase;
    74using KeySearcher.Helper;
Note: See TracChangeset for help on using the changeset viewer.