source: trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp @ 648

Last change on this file since 648 was 648, checked in by Sven Rech, 12 years ago

QuadraticSieve works much better now

File size: 7.2 KB
Line 
1/**
2* This .Net msieve wrapper was written by Sven Rech (rech@cryptool.org)
3**/
4
5#include <msieve.h>
6extern "C" {
7#include "wrapper.h"
8#include "../../mpqs/mpqs.h"
9}
10
11using namespace System;
12using namespace System::Collections;
13
14//From demo.c:
15extern "C" msieve_factor* factor(char *number, char *savefile_name);
16extern "C" char* getNextFactor(msieve_factor** factor);
17extern "C" void stop_msieve(msieve_obj *obj);
18extern "C" void get_random_seeds(uint32 *seed1, uint32 *seed2);
19//From sieve.c:
20extern "C" void collect_relations(sieve_conf_t *conf, uint32 target_relations, qs_core_sieve_fcn core_sieve_fcn);
21//From relation.c:
22extern "C" void save_relation(sieve_conf_t *conf, uint32 sieve_offset,
23                uint32 *fb_offsets, uint32 num_factors, 
24                uint32 poly_index, uint32 large_prime1, uint32 large_prime2);
25
26
27//Copy a sieve configuration that can be used in a different thread:
28sieve_conf_t *copy_sieve_conf(sieve_conf_t *conf) {
29        sieve_conf_t *copy = (sieve_conf_t*)malloc(sizeof(sieve_conf_t));
30        msieve_obj *objcopy = (msieve_obj*)malloc(sizeof(msieve_obj));
31
32        *copy = *conf;
33        *objcopy = *(conf->obj);
34        copy->obj = objcopy;
35        copy->slave = 1;        //we are a slave
36
37        //threads shouldn't be allowed to access files or the factor list:
38        objcopy->logfile_name = 0;
39        objcopy->savefile.file_handle = 0;
40        objcopy->factors = 0;
41       
42        //threads shouldn't be allowed to access these fields:
43        copy->poly_a_list = 0;
44        copy->poly_list = 0;   
45        copy->relation_list = 0;
46        copy->num_relations = 0;
47        copy->cycle_list = 0;
48        copy->num_cycles = 0;
49        copy->cycle_table = 0;
50        copy->cycle_hashtable = 0;
51        copy->cycle_table_size = 0;
52        copy->cycle_table_alloc = 0;
53        copy->components = 0;
54        copy->vertices = 0;
55
56        //deep copies:
57        copy->sieve_array = (uint8 *)aligned_malloc(
58                                (size_t)copy->sieve_block_size, 64);
59        for (uint32 i = 0; i < copy->sieve_block_size; i++)
60                copy->sieve_array[i] = conf->sieve_array[i];
61
62        copy->factor_base = (fb_t *)xmalloc(objcopy->fb_size * sizeof(fb_t));
63        for (uint32 i = 0; i < objcopy->fb_size; i++)
64                copy->factor_base[i] = conf->factor_base[i];
65
66        copy->packed_fb = (packed_fb_t *)xmalloc(conf->tf_large_cutoff * sizeof(packed_fb_t));
67        for (uint32 i = 0; i < conf->tf_large_cutoff; i++)
68                copy->packed_fb[i] = conf->packed_fb[i];
69
70        copy->buckets = (bucket_t *)xcalloc((size_t)(copy->poly_block *
71                                                copy->num_sieve_blocks), 
72                                                sizeof(bucket_t));
73        for (uint32 i = 0; i < copy->poly_block * copy->num_sieve_blocks; i++) {
74                copy->buckets[i].num_alloc = 1000;
75                copy->buckets[i].list = (bucket_entry_t *)
76                                xmalloc(1000 * sizeof(bucket_entry_t));
77        }
78
79        copy->modsqrt_array = (uint32 *)xmalloc(objcopy->fb_size * sizeof(uint32));
80        for (uint32 i = 0; i < objcopy->fb_size; i++)
81                copy->modsqrt_array[i] = conf->modsqrt_array[i];
82
83        //we need new seeds:
84        uint32 seed1, seed2;
85        get_random_seeds(&seed1, &seed2);
86        copy->obj->seed1 = seed1;
87        copy->obj->seed2 = seed2;
88
89        poly_init(copy, copy->num_sieve_blocks * copy->sieve_block_size / 2);
90
91        return copy;
92}
93
94namespace Msieve
95{
96        public delegate void showProgressDelegate(IntPtr conf, int num_relations, int max_relations);
97        public delegate void prepareSievingDelegate(IntPtr conf, int update, IntPtr core_sieve_fcn);
98
99        public ref struct callback_struct
100        {
101        public:
102                showProgressDelegate^ showProgress;
103                prepareSievingDelegate^ prepareSieving;
104        };
105
106        public ref class msieve 
107        {
108        private:
109                static char* stringToCharA(String^ str)
110                {
111                        if (!str)
112                                return 0;
113                        char* ch = (char*)malloc(str->Length + 1);
114                        for (int i = 0; i < str->Length; i++)
115                                ch[i] = (char)str[i];
116                        ch[str->Length] = 0;
117                        return ch;
118                }
119
120        public:
121                static callback_struct^ callbacks;
122
123                //initialize msieve with callback functions:
124                static void initMsieve(callback_struct^ cb)
125                {
126                        callbacks = cb;
127                }
128
129                //factorize the number:
130                static ArrayList^ factorize(String^ number, String^ savefile)
131                {
132                        ArrayList^ factor_list = gcnew ArrayList;
133                        char* num = stringToCharA(number);     
134                        char* save = stringToCharA(savefile);
135                        msieve_factor* factors = factor(num, save);
136
137                        while (factors != 0)
138                        {
139                                char* f = getNextFactor(&factors);
140                                String^ fa = gcnew String(f);
141                                free(f);
142                                factor_list->Add(fa);
143                        }
144
145                        free(num);
146                        return factor_list;
147                }
148
149                //stop msieve:
150                static void stop(IntPtr obj)
151                {
152                        stop_msieve((msieve_obj*)obj.ToPointer());
153                }
154
155                //clone this conf (the clone can be used to run the sieving in a different thread):
156                static IntPtr cloneSieveConf(IntPtr conf)
157                {
158                        return IntPtr(copy_sieve_conf((sieve_conf_t*)conf.ToPointer()));
159                }
160
161                //free this conf (shouldn't be the conf file that belongs to the main thread):
162                static void freeSieveConf(IntPtr conf)
163                {
164                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
165                        if (!c->slave)
166                                return;
167                        free(c->obj);
168                        free(c->next_poly_action);
169                        free(c->curr_b);
170                        free(c->poly_b_small[0]);
171                        free(c->poly_b_array);
172                        aligned_free(c->sieve_array);
173                        free(c->factor_base);
174                        free(c->packed_fb);
175                        for (uint32 i = 0; i < c->poly_block * c->num_sieve_blocks; i++)
176                                free(c->buckets[i].list);
177                        free(c->buckets);
178                        free(c->modsqrt_array);
179                        if (c->yield != 0)
180                        {
181                                for (int j = 0; j < c->yield->yield_count; j++)                 
182                                        if (c->yield->yield_array[j].type == 0)
183                                                free(c->yield->yield_array->rel.fb_offsets);
184                                free(c->yield->yield_array);
185                                free(c->yield);
186                        }
187                        free(c);
188                }
189
190                static void collectRelations(IntPtr conf, int target_relations, IntPtr core_sieve_fcn)
191                {
192                        collect_relations((sieve_conf_t*)conf.ToPointer(), target_relations, (qs_core_sieve_fcn)core_sieve_fcn.ToPointer());
193                }
194               
195                //get the yield in the thread of "conf" (shoudn't be the main thread):
196                static IntPtr getYield(IntPtr conf)
197                {
198                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
199                        if (!c->slave)
200                                return IntPtr::Zero;
201                        relationYield* yield = c->yield;
202                        c->yield = 0;
203                        return IntPtr((void*)yield);
204                }
205
206                //stores the yield in the thread of "conf" (should be the main thread), and destroys the yield:
207                static void saveYield(IntPtr conf, IntPtr yield)
208                {
209                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
210                        if (c->slave)
211                                return;                 
212                        relationYield* y = (relationYield*)yield.ToPointer();
213
214                        for (int j = 0; j < y->yield_count; j++)
215                        {
216                                if (y->yield_array[j].type == 1)
217                                        savefile_write_line(&c->obj->savefile, y->yield_array[j].polybuf);
218                                else
219                                {
220                                        relation* rel = &y->yield_array[j].rel;
221                                        save_relation(c, rel->sieve_offset, rel->fb_offsets, rel->num_factors, rel->poly_index, rel->large_prime1, rel->large_prime2);
222                                        free(rel->fb_offsets);
223                                }
224                        }
225
226                        free(y->yield_array);
227                        free(y);
228                }
229
230                static IntPtr getObjFromConf(IntPtr conf)
231                {
232                        sieve_conf_t* c = (sieve_conf_t*)conf.ToPointer();
233                        return IntPtr(c->obj);
234                }
235        };
236
237}
238
239extern "C" void showProgress(void* conf, int num_relations, int max_relations)
240{       
241        Msieve::msieve::callbacks->showProgress(IntPtr(conf), num_relations, max_relations);
242}
243
244extern "C" void prepare_sieving(void* conf, int update, void* core_sieve_fcn)
245{
246        Msieve::msieve::callbacks->prepareSieving(IntPtr(conf), update, IntPtr(core_sieve_fcn));
247}
248
249extern "C" void throwException(char* message)
250{
251        throw gcnew Exception(gcnew String(message));
252}
Note: See TracBrowser for help on using the repository browser.