Changeset 1372


Ignore:
Timestamp:
Apr 30, 2010, 2:50:41 PM (12 years ago)
Author:
Sven Rech
Message:

some modifications for msieve

Location:
trunk/CrypPlugins/QuadraticSieve/msieve
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp

    r648 r1372  
    9696        public delegate void showProgressDelegate(IntPtr conf, int num_relations, int max_relations);
    9797        public delegate void prepareSievingDelegate(IntPtr conf, int update, IntPtr core_sieve_fcn);
     98        public delegate void factorListChangedDelegate(IntPtr list);
    9899
    99100        public ref struct callback_struct
     
    102103                showProgressDelegate^ showProgress;
    103104                prepareSievingDelegate^ prepareSieving;
     105                factorListChangedDelegate^ factorListChanged;
    104106        };
    105107
     
    116118                        ch[str->Length] = 0;
    117119                        return ch;
     120                }
     121
     122                static void copyIntToArray(array<unsigned char>^ arr, int pos, int theInt)
     123                {
     124                        //We always use 4 bytes
     125                        arr[pos] = theInt & 255;
     126                        arr[pos+1] = (theInt >> 8) & 255;
     127                        arr[pos+2] = (theInt >> 16) & 255;
     128                        arr[pos+3] = (theInt >> 24) & 255;
     129                }
     130
     131                static int getIntFromArray(array<unsigned char>^ arr, int pos)
     132                {
     133                        //We always use 4 bytes
     134                        int res = arr[pos];
     135                        res |= arr[pos+1]<<8;
     136                        res |= arr[pos+2]<<16;
     137                        res |= arr[pos+3]<<24;
     138                       
     139                        return res;
    118140                }
    119141
     
    233255                        return IntPtr(c->obj);
    234256                }
     257
     258                static ArrayList^ getPrimeFactors(IntPtr factorList)
     259                {
     260                        char buf[929];
     261                        ArrayList^ factors = gcnew ArrayList;
     262                        factor_list_t * factor_list = (factor_list_t *)factorList.ToPointer();
     263                        for (int c = 0; c < factor_list->num_factors; c++)
     264                        {
     265                                if (factor_list->final_factors[c]->type != MSIEVE_COMPOSITE)
     266                                {
     267                                        char* factor = mp_sprintf(&factor_list->final_factors[c]->factor, 10, buf);
     268                                        factors->Add(gcnew String(factor));
     269                                }
     270                        }
     271
     272                        return factors;
     273                }
     274
     275                static ArrayList^ getCompositeFactors(IntPtr factorList)
     276                {
     277                        char buf[929];
     278                        ArrayList^ factors = gcnew ArrayList;
     279                        factor_list_t * factor_list = (factor_list_t *)factorList.ToPointer();
     280                        for (int c = 0; c < factor_list->num_factors; c++)
     281                        {
     282                                if (factor_list->final_factors[c]->type == MSIEVE_COMPOSITE)
     283                                {
     284                                        char* factor = mp_sprintf(&factor_list->final_factors[c]->factor, 10, buf);
     285                                        factors->Add(gcnew String(factor));
     286                                }
     287                        }
     288
     289                        return factors;
     290                }
     291
     292                //get's the current factor on which we are sieving:
     293                static String^ getCurrentFactor(IntPtr conf)
     294                {
     295                        char buf[929];
     296                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
     297                        mp_t mult;
     298                        *((uint32*)(&mult.val[0])) = c->multiplier;
     299                        mult.nwords = 4;
     300                        mp_t n;
     301                        mp_div(c->n, &mult, &n);
     302                        char* nchar = mp_sprintf(&n, 10, buf);
     303                        return gcnew String(nchar);
     304                }
     305
     306                //serialize the yield, so that you can send it over the net:
     307                static array<unsigned char>^ serializeYield(IntPtr yield)
     308                {
     309                        relationYield* y = (relationYield*)yield.ToPointer();
     310                        array<unsigned char>^ out = gcnew array<unsigned char>((y->yield_count)*257 + 4);
     311                        copyIntToArray(out, 0, y->yield_count);
     312
     313                        for (int c = 0; c < y->yield_count; c++)
     314                        {
     315                                out[4 + c*257] = (char)(y->yield_array[c].type);
     316                                if (y->yield_array[c].type == 1)        //poly
     317                                {
     318                                        for (int i = 0; i < 256; i++)
     319                                                out[4 + c*257 + 1 + i] = y->yield_array[c].polybuf[i];
     320                                }
     321                                else                                                            //relation
     322                                {
     323                                        copyIntToArray(out, 4+c*257 + 1, y->yield_array[c].rel.sieve_offset);
     324                                        copyIntToArray(out, 4+c*257 + 1 + 4, y->yield_array[c].rel.num_factors);
     325                                        copyIntToArray(out, 4+c*257 + 1 + 8, y->yield_array[c].rel.poly_index);
     326                                        copyIntToArray(out, 4+c*257 + 1 + 12, y->yield_array[c].rel.large_prime1);
     327                                        copyIntToArray(out, 4+c*257 + 1 + 16, y->yield_array[c].rel.large_prime2);
     328                                        for (int i = 0; i < 232; i++)
     329                                                copyIntToArray(out, 4+c*257 + 1 + 20 + i*4, y->yield_array[c].rel.fb_offsets[i]);
     330                                }
     331                        }
     332
     333                        return out;
     334                }
     335
     336                static IntPtr deserializeYield(array<unsigned char>^ yield)
     337                {
     338                        relationYield* y = (relationYield*)malloc(sizeof(relationYield));
     339                        y->yield_count = getIntFromArray(yield, 0);
     340                        y->yield_array = (yield_element*)malloc(sizeof(yield_element)*y->yield_count);
     341                       
     342                        for (int c = 0; c < y->yield_count; c++)
     343                        {
     344                                y->yield_array[c].type = yield[4+c*257];
     345                                if (y->yield_array[c].type == 1)        //poly
     346                                {
     347                                        for (int i = 0; i < 256; i++)
     348                                                y->yield_array[c].polybuf[i] = yield[4 + c*257 + 1 + i];
     349                                }
     350                                else                                                            //relation
     351                                {
     352                                        y->yield_array[c].rel.sieve_offset = getIntFromArray(yield, 4+c*257 + 1);
     353                                        y->yield_array[c].rel.num_factors = getIntFromArray(yield, 4+c*257 + 1 + 4);
     354                                        y->yield_array[c].rel.poly_index = getIntFromArray(yield, 4+c*257 + 1 + 8);
     355                                        y->yield_array[c].rel.large_prime1 = getIntFromArray(yield, 4+c*257 + 1 + 12);
     356                                        y->yield_array[c].rel.large_prime2 = getIntFromArray(yield, 4+c*257 + 1 + 16);
     357                                        for (int i = 0; i < 232; i++)
     358                                                y->yield_array[c].rel.fb_offsets[i] = getIntFromArray(yield, 4+c*257 + 1 + 20 + i*4);
     359                                }
     360                        }
     361                       
     362                        return IntPtr((void*)y);
     363                }
    235364        };
    236365
     
    251380        throw gcnew Exception(gcnew String(message));
    252381}
     382
     383extern "C" void factor_list_changed(factor_list_t * factor_list)
     384{
     385        Msieve::msieve::callbacks->factorListChanged(IntPtr(factor_list));
     386}
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.h

    r648 r1372  
    11#pragma once
     2
     3//#include <common.h>
     4
    25void showProgress(void* conf, int num_relations, int max_relations);
    36void prepare_sieving(void* conf, int update, void* core_sieve_fcn);
    47void throwException(char* message);
     8//void factor_list_changed(factor_list_t * factor_list);
    59
    610struct relation
  • trunk/CrypPlugins/QuadraticSieve/msieve/common/driver.c

    r648 r1372  
    529529                factor_list_add_core(obj, list, new_factor);
    530530
     531
     532        factor_list_changed(list);
    531533        return factor_list_max_composite(list);
    532534}
Note: See TracChangeset for help on using the changeset viewer.