Changeset 1692


Ignore:
Timestamp:
Jun 23, 2010, 10:29:57 AM (11 years ago)
Author:
Sven Rech
Message:

quadratic sieve terminology change:
"yield" is called "relation package" now.

Location:
trunk
Files:
2 added
2 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/QuadraticSieve/PeerToPeer.cs

    r1691 r1692  
    5959        private BigInteger factor;
    6060        private int head;
    61         private Queue storequeue;   //yields to store in the DHT
    62         private Queue loadqueue;    //yields that have been loaded from the DHT
     61        private Queue storequeue;   //relation packages to store in the DHT
     62        private Queue loadqueue;    //relation packages that have been loaded from the DHT
    6363        private Thread loadStoreThread;
    6464        private bool stopLoadStoreThread;
    6565        private QuadraticSievePresentation quadraticSieveQuickWatchPresentation;
    66         private AutoResetEvent yieldEvent;
     66        private AutoResetEvent newRelationPackageEvent;
    6767        private int ourID;           //Our ID
    6868        private Dictionary<int, string> nameCache;  //associates the ids with the names
     
    8181        public event P2PWarningHandler P2PWarning;       
    8282
    83         public PeerToPeer(QuadraticSievePresentation presentation, AutoResetEvent yieldEvent)
     83        public PeerToPeer(QuadraticSievePresentation presentation, AutoResetEvent newRelationPackageEvent)
    8484        {
    8585            quadraticSieveQuickWatchPresentation = presentation;
    86             this.yieldEvent = yieldEvent;
     86            this.newRelationPackageEvent = newRelationPackageEvent;
    8787            SetOurID();
    8888        }
     
    9797
    9898            ourID = BitConverter.ToInt32(idBytes, 3);
    99             quadraticSieveQuickWatchPresentation.ProgressYields.setOurID(ourID);
     99            quadraticSieveQuickWatchPresentation.ProgressRelationPackages.setOurID(ourID);
    100100
    101101            ourName = System.Net.Dns.GetHostName();
     
    103103
    104104        /// <summary>
    105         /// Reads yield at position "index" from DHT and returns the ownerID and the decompressed packet itself.
    106         /// </summary>
    107         private byte[] ReadYield(int index, out int ownerID)
     105        /// Reads relation package at position "index" from DHT and returns the ownerID and the decompressed packet itself.
     106        /// </summary>
     107        private byte[] ReadRelationPackage(int index, out int ownerID)
    108108        {
    109109            ownerID = 0;
    110             byte[] yield = P2PManager.Retrieve(YieldIdentifier(index)).Data;
    111             if (yield == null)
     110            byte[] relationPackage = P2PManager.Retrieve(RelationPackageIdentifier(index)).Data;
     111            if (relationPackage == null)
    112112                return null;
    113             downloaded += (uint)yield.Length;
    114 
    115             byte[] decompressedYield = DecompressYield(yield);
     113            downloaded += (uint)relationPackage.Length;
     114
     115            byte[] decompressedRelationPackage = DecompressRelationPackage(relationPackage);
    116116
    117117            byte[] idbytes = new byte[4];
    118             Array.Copy(decompressedYield, idbytes, 4);
     118            Array.Copy(decompressedRelationPackage, idbytes, 4);
    119119            ownerID = BitConverter.ToInt32(idbytes, 0);
    120             byte[] y = new byte[decompressedYield.Length - 4];
    121             Array.Copy(decompressedYield, 4, y, 0, y.Length);
     120            byte[] y = new byte[decompressedRelationPackage.Length - 4];
     121            Array.Copy(decompressedRelationPackage, 4, y, 0, y.Length);
    122122           
    123123            return y;
    124124        }
    125125
    126         private static byte[] DecompressYield(byte[] yield)
     126        private static byte[] DecompressRelationPackage(byte[] relationPackage)
    127127        {
    128128            MemoryStream memStream = new MemoryStream();
    129129            DeflateStream defStream = new DeflateStream(memStream, CompressionMode.Decompress);
    130             memStream.Write(yield, 0, yield.Length);
     130            memStream.Write(relationPackage, 0, relationPackage.Length);
    131131            memStream.Position = 0;
    132132            MemoryStream memStream2 = new MemoryStream();
    133133            defStream.CopyTo(memStream2);
    134134            defStream.Close();
    135             byte[] decompressedYield = memStream2.ToArray();
    136             return decompressedYield;
    137         }
    138 
    139         private bool ReadAndEnqueueYield(int loadIndex, bool checkAlive)
     135            byte[] decompressedRelationPackage = memStream2.ToArray();
     136            return decompressedRelationPackage;
     137        }
     138
     139        private bool ReadAndEnqueueRelationPackage(int loadIndex, bool checkAlive)
    140140        {
    141141            int ownerID;
    142             byte[] yield = ReadYield(loadIndex, out ownerID);
    143             if (yield != null)
     142            byte[] relationPackage = ReadRelationPackage(loadIndex, out ownerID);
     143            if (relationPackage != null)
    144144            {
    145145                ShowTransfered(downloaded, uploaded);
    146                 loadqueue.Enqueue(yield);
     146                loadqueue.Enqueue(relationPackage);
    147147
    148148                string name = null;
     
    150150                if (ownerID != ourID)
    151151                {
    152                     //Progress Yield:
     152                    //Progress relation package:
    153153                    if (!nameCache.ContainsKey(ownerID))
    154154                    {
     
    176176
    177177                //Set progress info:
    178                 SetProgressYield(loadIndex, ownerID, name);
    179 
    180                 yieldEvent.Set();
     178                SetProgressRelationPackage(loadIndex, ownerID, name);
     179
     180                newRelationPackageEvent.Set();
    181181                return true;
    182182            }
     
    185185
    186186        /// <summary>
    187         /// Tries to read and enqueue yield on position "loadIndex".
     187        /// Tries to read and enqueue relation package on position "loadIndex".
    188188        /// If it fails, it stores the index in lostIndices queue.
    189189        /// </summary>
    190         private void TryReadAndEnqueueYield(int index, bool checkAlive, Queue<KeyValuePair<int, DateTime>> lostIndices)
    191         {
    192             bool succ = ReadAndEnqueueYield(index, checkAlive);
     190        private void TryReadAndEnqueueRelationPackage(int index, bool checkAlive, Queue<KeyValuePair<int, DateTime>> lostIndices)
     191        {
     192            bool succ = ReadAndEnqueueRelationPackage(index, checkAlive);
    193193            if (!succ)               
    194194            {
    195195                var e = new KeyValuePair<int, DateTime>(index, DateTime.Now);
    196196                lostIndices.Enqueue(e);
    197                 SetProgressYield(index, -1, null);
     197                SetProgressRelationPackage(index, -1, null);
    198198            }
    199199        }
     
    258258                    if (storequeue.Count != 0)  //store our packages
    259259                    {
    260                         byte[] yield = (byte[])storequeue.Dequeue();
    261                         bool success = P2PManager.Store(YieldIdentifier(head), yield).IsSuccessful();
     260                        byte[] relationPackage = (byte[])storequeue.Dequeue();
     261                        bool success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
    262262                        while (!success)
    263263                        {
    264264                            SynchronizeHead();
    265                             success = P2PManager.Store(YieldIdentifier(head), yield).IsSuccessful();
     265                            success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
    266266                        }
    267                         SetProgressYield(head, ourID, null);
     267                        SetProgressRelationPackage(head, ourID, null);
    268268                        ourIndices.Add(head);
    269269                       
    270270                        head++;
    271271
    272                         //show informations about the uploaded yield:
    273                         uploaded += (uint)yield.Length;
     272                        //show informations about the uploaded relation package:
     273                        uploaded += (uint)relationPackage.Length;
    274274                        ShowTransfered(downloaded, uploaded);
    275275                        UpdateStoreLoadQueueInformation();
     
    277277                    }
    278278
    279                     //load the other yields:
     279                    //load the other relation packages:
    280280
    281281                    //skip all indices which are uploaded by us:
     
    286286                    {
    287287                        bool checkAlive = loadIndex >= startHead;       //we don't check the peer alive informations of the packages that existed before we joined
    288                         TryReadAndEnqueueYield(loadIndex, checkAlive, lostIndices);
     288                        TryReadAndEnqueueRelationPackage(loadIndex, checkAlive, lostIndices);
    289289                        loadIndex++;
    290290                        UpdateStoreLoadQueueInformation();
     
    299299                        {
    300300                            var e = lostIndices.Dequeue();
    301                             TryReadAndEnqueueYield(loadIndex, true, lostIndices);
     301                            TryReadAndEnqueueRelationPackage(loadIndex, true, lostIndices);
    302302                            UpdateStoreLoadQueueInformation();                           
    303303                        }
     
    355355                    head = dhthead;
    356356                    if (head != 0)
    357                         SetProgressYield(head - 1, 0, null);
     357                        SetProgressRelationPackage(head - 1, 0, null);
    358358                }
    359359            }
     
    378378        }
    379379
    380         private void SetProgressYield(int index, int id, string name)
     380        private void SetProgressRelationPackage(int index, int id, string name)
    381381        {
    382382            quadraticSieveQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    383383            {
    384                 quadraticSieveQuickWatchPresentation.ProgressYields.Set(index, id, name);
     384                quadraticSieveQuickWatchPresentation.ProgressRelationPackages.Set(index, id, name);
    385385            }, null);
    386386        }
    387387
    388         private void ClearProgressYields()
     388        private void ClearProgressRelationPackages()
    389389        {
    390390            quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    391391            {
    392                 quadraticSieveQuickWatchPresentation.ProgressYields.Clear();
     392                quadraticSieveQuickWatchPresentation.ProgressRelationPackages.Clear();
    393393            }, null);
    394394        }
     
    404404        }
    405405
    406         private string YieldIdentifier(int index)
     406        private string RelationPackageIdentifier(int index)
    407407        {
    408408            return channel + "#" + number + "-" + factor + "!" + index;
     
    463463        }
    464464
    465         public Queue GetLoadedYieldsQueue()
     465        public Queue GetLoadedRelationPackagesQueue()
    466466        {
    467467            return loadqueue;
     
    469469
    470470        /// <summary>
    471         /// Compresses the yield and puts it in the DHT.
    472         /// </summary>
    473         public void Put(byte[] serializedYield)
     471        /// Compresses the relation package and puts it in the DHT.
     472        /// </summary>
     473        public void Put(byte[] serializedRelationPackage)
    474474        {
    475475            //Add our ID:
    476476            byte[] idbytes = BitConverter.GetBytes(ourID);
    477477            Debug.Assert(idbytes.Length == 4);
    478             serializedYield = concat(idbytes, serializedYield); ;
     478            serializedRelationPackage = concat(idbytes, serializedRelationPackage); ;
    479479
    480480            //Compress:
    481481            MemoryStream memStream = new MemoryStream();
    482482            DeflateStream defStream = new DeflateStream(memStream, CompressionMode.Compress);
    483             defStream.Write(serializedYield, 0, serializedYield.Length);
     483            defStream.Write(serializedRelationPackage, 0, serializedRelationPackage.Length);
    484484            defStream.Close();
    485             byte[] compressedYield = memStream.ToArray();
     485            byte[] compressedRelationPackage = memStream.ToArray();
    486486
    487487            //Debug stuff:
    488             byte[] decompr = DecompressYield(compressedYield);
    489             Debug.Assert(decompr.Length == serializedYield.Length);
     488            byte[] decompr = DecompressRelationPackage(compressedRelationPackage);
     489            Debug.Assert(decompr.Length == serializedRelationPackage.Length);
    490490
    491491            //store in queue, so the LoadStoreThread can store it in the DHT later:
    492             storequeue.Enqueue(compressedYield);
     492            storequeue.Enqueue(compressedRelationPackage);
    493493
    494494            UpdateStoreLoadQueueInformation();
     
    519519            Debug.Assert(this.number % this.factor == 0);
    520520
    521             ClearProgressYields();
     521            ClearProgressRelationPackages();
    522522            nameCache = new Dictionary<int, string>();
    523523            peerPerformances = new Queue<PeerPerformanceInformations>();
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1690 r1692  
    5454        private BigInteger[] outputFactors;
    5555        private bool running;
    56         private Queue yieldqueue;
    57         private AutoResetEvent yieldEvent = new AutoResetEvent(false);
     56        private Queue relationPackageQueue;
     57        private AutoResetEvent newRelationPackageEvent = new AutoResetEvent(false);
    5858        private IntPtr obj = IntPtr.Zero;
    5959        private volatile int threadcount = 0;
     
    102102            QuickWatchPresentation = new QuadraticSievePresentation();
    103103
    104             peerToPeer = new PeerToPeer(quadraticSieveQuickWatchPresentation, yieldEvent);
     104            peerToPeer = new PeerToPeer(quadraticSieveQuickWatchPresentation, newRelationPackageEvent);
    105105            peerToPeer.P2PWarning += new PeerToPeer.P2PWarningHandler(peerToPeer_P2PWarning);
    106106           
     
    204204                    quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    205205                    {
    206                         quadraticSieveQuickWatchPresentation.ProgressYields.Clear();
     206                        quadraticSieveQuickWatchPresentation.ProgressRelationPackages.Clear();
    207207                        quadraticSieveQuickWatchPresentation.logging.Text = logging_message;
    208208                        quadraticSieveQuickWatchPresentation.endTime.Text = endtime_message;
     
    458458            MethodInfo getObjFromConf = msieve.GetMethod("getObjFromConf");
    459459            this.obj = (IntPtr)getObjFromConf.Invoke(null, new object[] { conf });           
    460             yieldqueue = Queue.Synchronized(new Queue());
     460            relationPackageQueue = Queue.Synchronized(new Queue());
    461461            conf_list = new ArrayList();
    462462
     
    482482                conf_list.Add(clone);
    483483                WaitCallback worker = new WaitCallback(MSieveJob);
    484                 ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, yieldqueue, i });
    485             }
    486 
    487             //manage the yields of the other threads:
    488             manageYields(conf, max_relations);  //this method returns as soon as there are enough relations found
     484                ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, relationPackageQueue, i });
     485            }
     486
     487            //manage the relation packages of the other threads:
     488            manageRelationPackages(conf, max_relations);  //this method returns as soon as there are enough relations found
    489489            if (userStopped)
    490490                return;
     
    501501           
    502502            stopThreads();
    503             if (yieldqueue != null)
    504                 yieldqueue.Clear();
    505         }
    506 
    507         /// <summary>
    508         /// Manages the whole yields that are created during the sieving process by the other threads (and other peers).
     503            if (relationPackageQueue != null)
     504                relationPackageQueue.Clear();
     505        }
     506
     507        /// <summary>
     508        /// Manages the whole relation packages that are created during the sieving process by the other threads (and other peers).
    509509        /// Returns true, if enough relations have been found.
    510510        /// </summary>
    511         private void manageYields(IntPtr conf, int max_relations)
    512         {
    513             MethodInfo serializeYield = msieve.GetMethod("serializeYield");
    514             MethodInfo deserializeYield = msieve.GetMethod("deserializeYield");
     511        private void manageRelationPackages(IntPtr conf, int max_relations)
     512        {
     513            MethodInfo serializeRelationPackage = msieve.GetMethod("serializeRelationPackage");
     514            MethodInfo deserializeRelationPackage = msieve.GetMethod("deserializeRelationPackage");
    515515            MethodInfo getNumRelations = msieve.GetMethod("getNumRelations");
    516516            int num_relations = (int)getNumRelations.Invoke(null, new object[] { conf });
    517517            int start_relations = num_relations;
    518518            DateTime start_sieving_time = DateTime.Now;
    519             MethodInfo saveYield = msieve.GetMethod("saveYield");
     519            MethodInfo saveRelationPackage = msieve.GetMethod("saveRelationPackage");
    520520
    521521            while (num_relations < max_relations)
     
    523523                ProgressChanged((double)num_relations / max_relations * 0.8 + 0.1, 1.0);
    524524               
    525                 yieldEvent.WaitOne();               //wait until queue is not empty
     525                newRelationPackageEvent.WaitOne();               //wait until there is a new relation package in the queue
    526526                if (userStopped)
    527527                    return;
    528528
    529                 while (yieldqueue.Count != 0)       //get all the results from the helper threads, and store them
    530                 {
    531                     IntPtr yield = (IntPtr)yieldqueue.Dequeue();                   
     529                while (relationPackageQueue.Count != 0)       //get all the results from the helper threads, and store them
     530                {
     531                    IntPtr relationPackage = (IntPtr)relationPackageQueue.Dequeue();                   
    532532
    533533                    if (usePeer2Peer)
    534534                    {
    535                         byte[] serializedYield = (byte[])serializeYield.Invoke(null, new object[] { yield });
    536                         peerToPeer.Put(serializedYield);
    537                     }
    538 
    539                     saveYield.Invoke(null, new object[] { conf, yield });
     535                        byte[] serializedRelationPackage = (byte[])serializeRelationPackage.Invoke(null, new object[] { relationPackage });
     536                        peerToPeer.Put(serializedRelationPackage);
     537                    }
     538
     539                    saveRelationPackage.Invoke(null, new object[] { conf, relationPackage });
    540540                }
    541541
    542542                if (usePeer2Peer)
    543543                {
    544                     Queue dhtqueue = peerToPeer.GetLoadedYieldsQueue();
     544                    Queue dhtqueue = peerToPeer.GetLoadedRelationPackagesQueue();
    545545                    while (dhtqueue.Count != 0)       //get all the loaded results from the DHT, and store them
    546546                    {
    547                         byte[] yield = (byte[])dhtqueue.Dequeue();
    548                         IntPtr deserializedYield = (IntPtr)deserializeYield.Invoke(null, new object[] { yield });
    549                         saveYield.Invoke(null, new object[] { conf, deserializedYield });
     547                        byte[] relationPackage = (byte[])dhtqueue.Dequeue();
     548                        IntPtr deserializedRelationPackage = (IntPtr)deserializeRelationPackage.Invoke(null, new object[] { relationPackage });
     549                        saveRelationPackage.Invoke(null, new object[] { conf, deserializedRelationPackage });
    550550                    }
    551551                }
     
    629629        /// The method then factors all the factors that are still composite by using the quadratic sieve.
    630630        /// </summary>
    631         private void getTrivialFactorlist(IntPtr list, IntPtr obj)
     631        private void putTrivialFactorlist(IntPtr list, IntPtr obj)
    632632        {
    633633            //add the trivial factors to the factor list:
     
    691691            int update = (int)parameters[1];
    692692            IntPtr core_sieve_fcn = (IntPtr)parameters[2];
    693             Queue yieldqueue = (Queue)parameters[3];
     693            Queue relationPackageQueue = (Queue)parameters[3];
    694694            int threadNR = (int)parameters[4];
    695695
     
    697697            {
    698698                MethodInfo collectRelations = msieve.GetMethod("collectRelations");
    699                 MethodInfo getYield = msieve.GetMethod("getYield");
    700                 MethodInfo getAmountOfRelationsInYield = msieve.GetMethod("getAmountOfRelationsInYield");
     699                MethodInfo getRelationPackage = msieve.GetMethod("getRelationPackage");
     700                MethodInfo getAmountOfRelationsInRelationPackage = msieve.GetMethod("getAmountOfRelationsInRelationPackage");
    701701
    702702                Thread.CurrentThread.Priority = ThreadPriority.BelowNormal;
     
    709709                        DateTime beginning = DateTime.Now;
    710710                        collectRelations.Invoke(null, new object[] { clone, update, core_sieve_fcn });
    711                         IntPtr yield = (IntPtr)getYield.Invoke(null, new object[] { clone });
    712 
    713                         int amountOfFullRelations = (int)getAmountOfRelationsInYield.Invoke(null, new object[] { yield });
     711                        IntPtr relationPackage = (IntPtr)getRelationPackage.Invoke(null, new object[] { clone });
     712
     713                        int amountOfFullRelations = (int)getAmountOfRelationsInRelationPackage.Invoke(null, new object[] { relationPackage });
    714714                        relationsPerMS[threadNR] = amountOfFullRelations / (DateTime.Now - beginning).TotalMilliseconds;
    715715
     
    717717                            peerToPeer.SetOurPerformance(relationsPerMS);
    718718
    719                         yieldqueue.Enqueue(yield);
    720                         yieldEvent.Set();
     719                        relationPackageQueue.Enqueue(relationPackage);
     720                        newRelationPackageEvent.Set();
    721721                    }
    722722                    catch (Exception ex)
     
    838838            Object callback_struct = Activator.CreateInstance(msieveDLL.GetType("Msieve.callback_struct"));           
    839839            FieldInfo prepareSievingField = msieveDLL.GetType("Msieve.callback_struct").GetField("prepareSieving");
    840             FieldInfo getTrivialFactorlistField = msieveDLL.GetType("Msieve.callback_struct").GetField("getTrivialFactorlist");           
     840            FieldInfo putTrivialFactorlistField = msieveDLL.GetType("Msieve.callback_struct").GetField("putTrivialFactorlist");           
    841841            Delegate prepareSievingDel = MulticastDelegate.CreateDelegate(msieveDLL.GetType("Msieve.prepareSievingDelegate"), this, "prepareSieving");
    842             Delegate getTrivialFactorlistDel = MulticastDelegate.CreateDelegate(msieveDLL.GetType("Msieve.getTrivialFactorlistDelegate"), this, "getTrivialFactorlist");           
     842            Delegate putTrivialFactorlistDel = MulticastDelegate.CreateDelegate(msieveDLL.GetType("Msieve.putTrivialFactorlistDelegate"), this, "putTrivialFactorlist");           
    843843            prepareSievingField.SetValue(callback_struct, prepareSievingDel);
    844             getTrivialFactorlistField.SetValue(callback_struct, getTrivialFactorlistDel);
     844            putTrivialFactorlistField.SetValue(callback_struct, putTrivialFactorlistDel);
    845845            initMsieve.Invoke(null, new object[1] { callback_struct });
    846846        }
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.csproj

    r1668 r1692  
    110110    <Compile Include="FactorManager.cs" />
    111111    <Compile Include="PeerToPeer.cs" />
    112     <Compile Include="ProgressYields.xaml.cs">
    113       <DependentUpon>ProgressYields.xaml</DependentUpon>
     112    <Compile Include="ProgressRelationPackages.xaml.cs">
     113      <DependentUpon>ProgressRelationPackages.xaml</DependentUpon>
    114114    </Compile>
    115115    <Compile Include="Properties\AssemblyInfo.cs" />
     
    142142      <SubType>Designer</SubType>
    143143    </Resource>
    144     <Page Include="ProgressYields.xaml">
     144    <Page Include="ProgressRelationPackages.xaml">
    145145      <SubType>Designer</SubType>
    146146      <Generator>MSBuild:Compile</Generator>
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSievePresentation.xaml

    r1653 r1692  
    2727            <TextBox Name="endTime" Grid.Row="1" Grid.Column="1" TextAlignment="Center" IsReadOnly="True" TextWrapping="WrapWithOverflow" BorderThickness="1" Margin="1" BorderBrush="AliceBlue" />
    2828            <ListBox Grid.Row="2" Grid.ColumnSpan="2" Name="factorList" Canvas.Left="1" Canvas.Top="50" Height="150" Width="233" />
    29             <Label Grid.Row="3" Grid.ColumnSpan="2" Content="" HorizontalAlignment="Left" Name="factorInfo" VerticalAlignment="Top" />
     29            <Label Grid.Row="3" Grid.ColumnSpan="2" Content="" HorizontalAlignment="Stretch" Name="factorInfo" VerticalAlignment="Top" />
    3030
    3131            <UserControl Name="peer2peer" Grid.Row="4" Grid.ColumnSpan="2">
    3232                <Grid>
    3333                <Grid.RowDefinitions>
     34                    <RowDefinition />
    3435                    <RowDefinition />
    3536                    <RowDefinition />
     
    4243                <Label Grid.Row="1" Content="" HorizontalAlignment="Stretch" Name="relationsInfo" VerticalAlignment="Bottom" />
    4344                <Label Grid.Row="2" Content="" HorizontalAlignment="Stretch" Name="amountOfPeers" VerticalAlignment="Bottom" />
     45                <Label Grid.Row="3" Content="" HorizontalAlignment="Stretch" Name="queueInformation" VerticalAlignment="Bottom" />
    4446                </Grid>
    4547            </UserControl>
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSievePresentation.xaml.cs

    r1678 r1692  
    2020    public partial class QuadraticSievePresentation : UserControl
    2121    {
    22         private ProgressYields progressYields;
    23         public ProgressYields ProgressYields
     22        private ProgressRelationPackages progressRelationPackages;
     23        public ProgressRelationPackages ProgressRelationPackages
    2424        {
    25             get { return progressYields; }
     25            get { return progressRelationPackages; }
    2626        }
    2727
     
    3535            sviewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
    3636            sviewer.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
    37             progressYields = new ProgressYields(sviewer);
    38             sviewer.Content = progressYields;
     37            progressRelationPackages = new ProgressRelationPackages(sviewer);
     38            sviewer.Content = progressRelationPackages;
    3939            Grid grid = ((Grid)peer2peer.Content);
    4040            Grid.SetRow(sviewer, 0);
     
    4242            sviewer.MinHeight = 100;
    4343            sviewer.MaxHeight = 100;
    44             progressYields.MaxWidth = factorList.Width - 10;
     44            progressRelationPackages.MaxWidth = factorList.Width - 10;
    4545        }
    4646
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/WrapperTester/Program.cs

    r1468 r1692  
    1111    class Program
    1212    {
    13         private static Queue yieldqueue;
     13        private static Queue relationpackagequeue;
    1414        private static bool running;
    1515
     
    1818            Console.WriteLine("Update: " + update);
    1919
    20             yieldqueue = Queue.Synchronized(new Queue());
     20            relationpackagequeue = Queue.Synchronized(new Queue());
    2121           
    2222            //Create a thread:
     
    2424            WaitCallback worker = new WaitCallback(MSieveJob);
    2525            running = true;
    26             ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, yieldqueue });
     26            ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, relationpackagequeue });
    2727        }
    2828
     
    3434            int update = (int)parameters[1];
    3535            IntPtr core_sieve_fcn = (IntPtr)parameters[2];
    36             Queue yieldqueue = (Queue)parameters[3];
     36            Queue relationpackagequeue = (Queue)parameters[3];
    3737
    3838            while (running)
    3939            {
    4040                    Msieve.msieve.collectRelations(clone, update, core_sieve_fcn);
    41                     IntPtr yield = Msieve.msieve.getYield(clone);
    42                     yield = Msieve.msieve.deserializeYield(Msieve.msieve.serializeYield(yield));
    43                     yieldqueue.Enqueue(yield);
     41                    IntPtr relationPackage = Msieve.msieve.getRelationPackage(clone);
     42                    relationPackage = Msieve.msieve.deserializeRelationPackage(Msieve.msieve.serializeRelationPackage(relationPackage));
     43                    relationpackagequeue.Enqueue(relationPackage);
    4444            }
    4545        }
     
    4949            Msieve.callback_struct callbacks = new Msieve.callback_struct();
    5050            callbacks.prepareSieving = prepareSieving;
    51             callbacks.getTrivialFactorlist = delegate(IntPtr list, IntPtr obj)
     51            callbacks.putTrivialFactorlist = delegate(IntPtr list, IntPtr obj)
    5252            {
    5353                foreach (Object o in Msieve.msieve.getPrimeFactors(list))
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp

    r1628 r1692  
    9797{
    9898        public delegate void prepareSievingDelegate(IntPtr conf, int update, IntPtr core_sieve_fcn, int max_relations);
    99         public delegate void getTrivialFactorlistDelegate(IntPtr list, IntPtr obj);
     99        public delegate void putTrivialFactorlistDelegate(IntPtr list, IntPtr obj);
    100100
    101101        public ref struct callback_struct
     
    103103        public:
    104104                prepareSievingDelegate^ prepareSieving;
    105                 getTrivialFactorlistDelegate^ getTrivialFactorlist;
     105                putTrivialFactorlistDelegate^ putTrivialFactorlist;
    106106        };
    107107
     
    187187                        free(c->buckets);
    188188                        free(c->modsqrt_array);
    189                         if (c->yield != 0)
    190                         {
    191                                 for (int j = 0; j < c->yield->yield_count; j++)                 
    192                                         if (c->yield->yield_array[j].type == 0)
    193                                                 free(c->yield->yield_array->rel.fb_offsets);
    194                                 free(c->yield->yield_array);
    195                                 free(c->yield);
     189                        if (c->relationPackage != 0)
     190                        {
     191                                for (int j = 0; j < c->relationPackage->package_count; j++)                     
     192                                        if (c->relationPackage->package_array[j].type == 0)
     193                                                free(c->relationPackage->package_array->rel.fb_offsets);
     194                                free(c->relationPackage->package_array);
     195                                free(c->relationPackage);
    196196                        }
    197197                        free(c);
     
    203203                }
    204204               
    205                 //get the yield in the thread of "conf" (shoudn't be the main thread):
    206                 static IntPtr getYield(IntPtr conf)
     205                //get the relation package in the thread of "conf" (shoudn't be the main thread):
     206                static IntPtr getRelationPackage(IntPtr conf)
    207207                {
    208208                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
    209209                        if (!c->slave)
    210210                                return IntPtr::Zero;
    211                         relationYield* yield = c->yield;
    212                         c->yield = 0;
    213                         return IntPtr((void*)yield);
    214                 }
    215 
    216                 //stores the yield in the thread of "conf" (should be the main thread), and destroys the yield:
    217                 static void saveYield(IntPtr conf, IntPtr yield)
     211                        RelationPackage* relationPackage = c->relationPackage;
     212                        c->relationPackage = 0;
     213                        return IntPtr((void*)relationPackage);
     214                }
     215
     216                //stores the relation package in the thread of "conf" (should be the main thread), and destroys the relation package:
     217                static void saveRelationPackage(IntPtr conf, IntPtr relationPackage)
    218218                {
    219219                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
    220220                        if (c->slave)
    221221                                return;                 
    222                         relationYield* y = (relationYield*)yield.ToPointer();
    223 
    224                         for (int j = 0; j < y->yield_count; j++)
    225                         {
    226                                 if (y->yield_array[j].type == 1)
    227                                         savefile_write_line(&c->obj->savefile, y->yield_array[j].polybuf);
     222                        RelationPackage* y = (RelationPackage*)relationPackage.ToPointer();
     223
     224                        for (int j = 0; j < y->package_count; j++)
     225                        {
     226                                if (y->package_array[j].type == 1)
     227                                        savefile_write_line(&c->obj->savefile, y->package_array[j].polybuf);
    228228                                else
    229229                                {
    230                                         relation* rel = &y->yield_array[j].rel;
     230                                        relation* rel = &y->package_array[j].rel;
    231231                                        save_relation(c, rel->sieve_offset, rel->fb_offsets, rel->num_factors, rel->poly_index, rel->large_prime1, rel->large_prime2);
    232232                                        free(rel->fb_offsets);
     
    234234                        }
    235235
    236                         free(y->yield_array);
     236                        free(y->package_array);
    237237                        free(y);
    238238                }
     
    278278                }
    279279
    280                 //serialize the yield, so that you can send it over the net:
    281                 static array<unsigned char>^ serializeYield(IntPtr yield)
    282                 {
    283                         relationYield* y = (relationYield*)yield.ToPointer();
     280                //serialize the relation package, so that you can send it over the net:
     281                static array<unsigned char>^ serializeRelationPackage(IntPtr relationPackage)
     282                {
     283                        RelationPackage* y = (RelationPackage*)relationPackage.ToPointer();
    284284
    285285                        //calculate needed size:
    286286                        int size = 0;
    287                         for (int c = 0; c < y->yield_count; c++)
     287                        for (int c = 0; c < y->package_count; c++)
    288288                        {
    289289                                size++; //type information
    290                                 if (y->yield_array[c].type == 1)        //poly  (256 bytes)
     290                                if (y->package_array[c].type == 1)      //poly  (256 bytes)
    291291                                        size += 256;
    292292                                else                                                            //relation      ((5+num_factors)*4 bytes)
    293                                         size += (5 + y->yield_array[c].rel.num_factors)*4;
     293                                        size += (5 + y->package_array[c].rel.num_factors)*4;
    294294                        }
    295295
    296296                        //serialize:                   
    297297                        array<unsigned char>^ out = gcnew array<unsigned char>(size + 4);
    298                         copyIntToArray(out, 0, y->yield_count);
     298                        copyIntToArray(out, 0, y->package_count);
    299299                        int pos = 4;
    300300
    301                         for (int c = 0; c < y->yield_count; c++)
    302                         {
    303                                 out[pos++] = (char)(y->yield_array[c].type);
    304                                 if (y->yield_array[c].type == 1)        //poly  (256 bytes)
     301                        for (int c = 0; c < y->package_count; c++)
     302                        {
     303                                out[pos++] = (char)(y->package_array[c].type);
     304                                if (y->package_array[c].type == 1)      //poly  (256 bytes)
    305305                                {
    306306                                        for (int i = 0; i < 256; i++)
    307                                                 out[pos++] = y->yield_array[c].polybuf[i];
     307                                                out[pos++] = y->package_array[c].polybuf[i];
    308308                                }
    309309                                else                                                            //relation      ((5+num_factors)*4 bytes)
    310310                                {
    311                                         copyIntToArray(out, pos, y->yield_array[c].rel.sieve_offset);
    312                                         copyIntToArray(out, pos + 4, y->yield_array[c].rel.num_factors);
    313                                         copyIntToArray(out, pos + 8, y->yield_array[c].rel.poly_index);
    314                                         copyIntToArray(out, pos + 12, y->yield_array[c].rel.large_prime1);
    315                                         copyIntToArray(out, pos + 16, y->yield_array[c].rel.large_prime2);
     311                                        copyIntToArray(out, pos, y->package_array[c].rel.sieve_offset);
     312                                        copyIntToArray(out, pos + 4, y->package_array[c].rel.num_factors);
     313                                        copyIntToArray(out, pos + 8, y->package_array[c].rel.poly_index);
     314                                        copyIntToArray(out, pos + 12, y->package_array[c].rel.large_prime1);
     315                                        copyIntToArray(out, pos + 16, y->package_array[c].rel.large_prime2);
    316316                                        pos += 20;
    317                                         for (int i = 0; i < y->yield_array[c].rel.num_factors; i++)
     317                                        for (int i = 0; i < y->package_array[c].rel.num_factors; i++)
    318318                                        {
    319                                                 copyIntToArray(out, pos, y->yield_array[c].rel.fb_offsets[i]);
     319                                                copyIntToArray(out, pos, y->package_array[c].rel.fb_offsets[i]);
    320320                                                pos += 4;
    321321                                        }
     
    326326                }
    327327
    328                 static IntPtr deserializeYield(array<unsigned char>^ yield)
    329                 {
    330                         relationYield* y = (relationYield*)malloc(sizeof(relationYield));
    331                         y->yield_count = getIntFromArray(yield, 0);
    332                         y->yield_array = (yield_element*)malloc(sizeof(yield_element)*y->yield_count);
     328                static IntPtr deserializeRelationPackage(array<unsigned char>^ relationPackage)
     329                {
     330                        RelationPackage* y = (RelationPackage*)malloc(sizeof(relationPackage));
     331                        y->package_count = getIntFromArray(relationPackage, 0);
     332                        y->package_array = (package_element*)malloc(sizeof(package_element)*y->package_count);
    333333                        int pos = 4;
    334334                       
    335                         for (int c = 0; c < y->yield_count; c++)
    336                         {
    337                                 y->yield_array[c].type = yield[pos++];
    338                                 if (y->yield_array[c].type == 1)        //poly  (256 bytes)
     335                        for (int c = 0; c < y->package_count; c++)
     336                        {
     337                                y->package_array[c].type = relationPackage[pos++];
     338                                if (y->package_array[c].type == 1)      //poly  (256 bytes)
    339339                                {
    340340                                        for (int i = 0; i < 256; i++)
    341                                                 y->yield_array[c].polybuf[i] = yield[pos++];
     341                                                y->package_array[c].polybuf[i] = relationPackage[pos++];
    342342                                }
    343343                                else                                                            //relation      ((5+num_factors)*4 bytes)
    344344                                {
    345                                         y->yield_array[c].rel.sieve_offset = getIntFromArray(yield, pos);
    346                                         y->yield_array[c].rel.num_factors = getIntFromArray(yield, pos + 4);
    347                                         y->yield_array[c].rel.poly_index = getIntFromArray(yield, pos + 8);
    348                                         y->yield_array[c].rel.large_prime1 = getIntFromArray(yield, pos + 12);
    349                                         y->yield_array[c].rel.large_prime2 = getIntFromArray(yield, pos + 16);
     345                                        y->package_array[c].rel.sieve_offset = getIntFromArray(relationPackage, pos);
     346                                        y->package_array[c].rel.num_factors = getIntFromArray(relationPackage, pos + 4);
     347                                        y->package_array[c].rel.poly_index = getIntFromArray(relationPackage, pos + 8);
     348                                        y->package_array[c].rel.large_prime1 = getIntFromArray(relationPackage, pos + 12);
     349                                        y->package_array[c].rel.large_prime2 = getIntFromArray(relationPackage, pos + 16);
    350350                                        pos += 20;
    351                                         y->yield_array[c].rel.fb_offsets = (uint32*)malloc(sizeof(uint32) * y->yield_array[c].rel.num_factors);
    352                                         for (int i = 0; i < y->yield_array[c].rel.num_factors; i++)
     351                                        y->package_array[c].rel.fb_offsets = (uint32*)malloc(sizeof(uint32) * y->package_array[c].rel.num_factors);
     352                                        for (int i = 0; i < y->package_array[c].rel.num_factors; i++)
    353353                                        {
    354                                                 y->yield_array[c].rel.fb_offsets[i] = getIntFromArray(yield, pos);
     354                                                y->package_array[c].rel.fb_offsets[i] = getIntFromArray(relationPackage, pos);
    355355                                                pos += 4;
    356356                                        }
     
    361361                }
    362362
    363                 static int getAmountOfRelationsInYield(IntPtr yield)
    364                 {
    365                         relationYield* y = (relationYield*)yield.ToPointer();
     363                static int getAmountOfRelationsInRelationPackage(IntPtr relationPackage)
     364                {
     365                        RelationPackage* y = (RelationPackage*)relationPackage.ToPointer();
    366366                        return y->num_relations;
    367367                }
     
    400400}
    401401
    402 extern "C" void get_trivial_factorlist(factor_list_t * factor_list, msieve_obj *obj)
     402extern "C" void put_trivial_factorlist(factor_list_t * factor_list, msieve_obj *obj)
    403403{
    404         Msieve::msieve::callbacks->getTrivialFactorlist(IntPtr(factor_list), IntPtr(obj));
    405 }
     404        Msieve::msieve::callbacks->putTrivialFactorlist(IntPtr(factor_list), IntPtr(obj));
     405}
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.h

    r1628 r1692  
    1515};
    1616
    17 struct yield_element
     17struct package_element
    1818{
    1919        int type;       // 0 = relation; 1 = poly
     
    2424typedef struct
    2525{
    26         int yield_count;
    27         int yield_capacity;
    28         struct yield_element *yield_array;
     26        int package_count;
     27        int package_capacity;
     28        struct package_element *package_array;
    2929        int num_relations;
    30 } relationYield;
     30} RelationPackage;
  • trunk/CrypPlugins/QuadraticSieve/msieve/common/driver.c

    r1463 r1692  
    208208
    209209        //callback to inform Cryptool about the already found trivial factors:
    210         get_trivial_factorlist(&factor_list, obj);
     210        put_trivial_factorlist(&factor_list, obj);
    211211
    212212
  • trunk/CrypPlugins/QuadraticSieve/msieve/mpqs/mpqs.h

    r622 r1692  
    230230        //added field:
    231231        int slave;
    232         relationYield *yield;
     232        RelationPackage *relationPackage;
    233233        uint32 num_derived_poly;
    234234} sieve_conf_t;
  • trunk/CrypPlugins/QuadraticSieve/msieve/mpqs/poly.c

    r648 r1692  
    533533
    534534        if (conf->slave) {
    535                 if (++(conf->yield->yield_count) > conf->yield->yield_capacity)
     535                if (++(conf->relationPackage->package_count) > conf->relationPackage->package_capacity)
    536536                {
    537                         conf->yield->yield_capacity *= 2;                       
    538                         conf->yield->yield_array = xrealloc(conf->yield->yield_array, sizeof(struct yield_element) * conf->yield->yield_capacity);                     
    539                 }
    540 
    541                 conf->yield->yield_array[conf->yield->yield_count - 1].type = 1;
     537                        conf->relationPackage->package_capacity *= 2;                   
     538                        conf->relationPackage->package_array = xrealloc(conf->relationPackage->package_array, sizeof(struct package_element) * conf->relationPackage->package_capacity);                       
     539                }
     540
     541                conf->relationPackage->package_array[conf->relationPackage->package_count - 1].type = 1;
    542542                for (i = 0; i < 256; i++)
    543                         conf->yield->yield_array[conf->yield->yield_count - 1].polybuf[i] = buf[i];
     543                        conf->relationPackage->package_array[conf->relationPackage->package_count - 1].polybuf[i] = buf[i];
    544544        }
    545545        else
  • trunk/CrypPlugins/QuadraticSieve/msieve/mpqs/relation.c

    r633 r1692  
    123123        if (conf->slave)
    124124        {
    125                 if (++(conf->yield->yield_count) > conf->yield->yield_capacity)
     125                if (++(conf->relationPackage->package_count) > conf->relationPackage->package_capacity)
    126126                {
    127                         conf->yield->yield_capacity *= 2;                       
    128                         conf->yield->yield_array = xrealloc(conf->yield->yield_array, sizeof(struct yield_element) * conf->yield->yield_capacity);                     
    129                 }
    130 
    131                 conf->yield->yield_array[conf->yield->yield_count - 1].type = 0;
    132                 rel = &conf->yield->yield_array[conf->yield->yield_count - 1].rel;
     127                        conf->relationPackage->package_capacity *= 2;                   
     128                        conf->relationPackage->package_array = xrealloc(conf->relationPackage->package_array, sizeof(struct package_element) * conf->relationPackage->package_capacity);                       
     129                }
     130
     131                conf->relationPackage->package_array[conf->relationPackage->package_count - 1].type = 0;
     132                rel = &conf->relationPackage->package_array[conf->relationPackage->package_count - 1].rel;
    133133               
    134134                fb_offsets_copy = (uint32*)malloc(len*sizeof(uint32));
  • trunk/CrypPlugins/QuadraticSieve/msieve/mpqs/sieve.c

    r1628 r1692  
    714714        if (conf->slave)
    715715        {
    716                 conf->yield = malloc(sizeof(relationYield));
    717                 conf->yield->yield_count = 0;
    718                 conf->yield->yield_capacity = target_relations*10;
    719                 conf->yield->yield_array = malloc(sizeof(struct yield_element) * conf->yield->yield_capacity);
     716                conf->relationPackage = malloc(sizeof(RelationPackage));
     717                conf->relationPackage->package_count = 0;
     718                conf->relationPackage->package_capacity = target_relations*10;
     719                conf->relationPackage->package_array = malloc(sizeof(struct package_element) * conf->relationPackage->package_capacity);
    720720        }       
    721721
     
    764764
    765765        if (conf->slave)
    766                 conf->yield->num_relations = relations_found;
     766                conf->relationPackage->num_relations = relations_found;
    767767}
    768768
Note: See TracChangeset for help on using the changeset viewer.