001/*
002 * $Id: GroebnerBaseDistHybridTest.java 4010 2012-07-21 20:39:56Z kredel $
003 */
004
005package edu.jas.gb;
006
007
008//import edu.jas.poly.GroebnerBase;
009
010import java.io.IOException;
011import java.io.Reader;
012import java.io.StringReader;
013import java.util.ArrayList;
014import java.util.List;
015
016import junit.framework.Test;
017import junit.framework.TestCase;
018import junit.framework.TestSuite;
019
020import org.apache.log4j.BasicConfigurator; //import org.apache.log4j.Logger;
021
022import edu.jas.kern.ComputerThreads;
023import edu.jas.arith.BigRational;
024
025import edu.jas.poly.GenPolynomial;
026import edu.jas.poly.GenPolynomialRing;
027import edu.jas.poly.GenPolynomialTokenizer;
028import edu.jas.poly.PolynomialList;
029
030import edu.jas.structure.RingElem;
031
032
033/**
034 * Distributed hybrid architecture GroebnerBase tests with JUnit.
035 * @author Heinz Kredel
036 */
037
038public class GroebnerBaseDistHybridTest extends TestCase {
039
040
041    //private static final Logger logger = Logger.getLogger(GroebnerBaseDistHybridTest.class);
042
043    /**
044     * main
045     */
046    public static void main(String[] args) {
047        BasicConfigurator.configure();
048        junit.textui.TestRunner.run(suite());
049        //ComputerThreads.terminate();
050    }
051
052
053    /**
054     * Constructs a <CODE>GroebnerBaseDistHybridTest</CODE> object.
055     * @param name String.
056     */
057    public GroebnerBaseDistHybridTest(String name) {
058        super(name);
059    }
060
061
062    /**
063     * suite.
064     */
065    public static Test suite() {
066        TestSuite suite = new TestSuite(GroebnerBaseDistHybridTest.class);
067        return suite;
068    }
069
070
071    int port = 4711;
072
073
074    String host = "localhost";
075
076
077    GenPolynomialRing<BigRational> fac;
078
079
080    List<GenPolynomial<BigRational>> L;
081
082
083    PolynomialList<BigRational> F;
084
085
086    List<GenPolynomial<BigRational>> G;
087
088
089    GroebnerBase<BigRational> bbseq;
090
091
092    GroebnerBaseDistributedHybrid<BigRational> bbdisthybs;
093
094
095    GroebnerBaseDistributedHybrid<BigRational> bbdisthyb;
096
097
098    GenPolynomial<BigRational> a;
099
100
101    GenPolynomial<BigRational> b;
102
103
104    GenPolynomial<BigRational> c;
105
106
107    GenPolynomial<BigRational> d;
108
109
110    GenPolynomial<BigRational> e;
111
112
113    int rl = 3; //4; //3; 
114
115
116    int kl = 4;
117
118
119    int ll = 7;
120
121
122    int el = 3;
123
124
125    float q = 0.2f; //0.4f
126
127
128    int threads = 2;
129
130
131    int threadsPerNode = 2;
132
133
134    @Override
135    protected void setUp() {
136        BigRational coeff = new BigRational(9);
137        fac = new GenPolynomialRing<BigRational>(coeff, rl);
138        a = b = c = d = e = null;
139        bbseq = new GroebnerBaseSeq<BigRational>();
140        bbdisthybs = null; //new GroebnerBaseDistributed<BigRational>(threads, port);
141        bbdisthyb = null; //new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
142    }
143
144
145    @Override
146    protected void tearDown() {
147        a = b = c = d = e = null;
148        fac = null;
149        bbseq = null;
150        bbdisthybs.terminate();
151        bbdisthybs = null;
152        bbdisthyb.terminate();
153        bbdisthyb = null;
154        ComputerThreads.terminate();
155    }
156
157
158    /**
159     * Helper method to start threads with distributed clients.
160     * 
161     */
162    Thread[] startThreads() {
163        Thread[] clients = new Thread[threads];
164        for (int t = 0; t < threads; t++) {
165            clients[t] = new Thread(new JunitClientHybrid(threadsPerNode, host, port));
166            clients[t].start();
167        }
168        return clients;
169    }
170
171
172    /**
173     * Helper method to stop threads with distributed clients.
174     * 
175     */
176    void stopThreads(Thread[] clients) {
177        for (int t = 0; t < threads; t++) {
178            try {
179                while ( clients[t].isAlive() ) {
180                        clients[t].interrupt(); 
181                        clients[t].join(100);
182                }
183            } catch (InterruptedException e) {
184            }
185        }
186    }
187
188
189    /**
190     * Test distributed hybrid GBase.
191     * 
192     */
193    public void testDistributedHybridGBase() {
194
195        bbdisthybs = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
196        bbdisthyb = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, new OrderedSyzPairlist<BigRational>(), port);
197
198        Thread[] clients;
199
200        L = new ArrayList<GenPolynomial<BigRational>>();
201
202        a = fac.random(kl, ll, el, q);
203        b = fac.random(kl, ll, el, q);
204        c = fac.random(kl, ll, el, q);
205        d = fac.random(kl, ll, el, q);
206        e = d; //fac.random(kl, ll, el, q );
207
208        assertTrue("not isZERO( a )", !a.isZERO());
209        L.add(a);
210
211        clients = startThreads();
212        L = bbdisthyb.GB(L);
213        stopThreads(clients);
214        assertTrue("isGB( { a } )", bbseq.isGB(L));
215        //System.out.println("L = " + L.size() );
216
217        assertTrue("not isZERO( b )", !b.isZERO());
218        L.add(b);
219        //System.out.println("L = " + L.size() );
220
221        clients = startThreads();
222        L = bbdisthyb.GB(L);
223        stopThreads(clients);
224        assertTrue("isGB( { a, b } )", bbseq.isGB(L));
225        //System.out.println("L = " + L.size() );
226
227        assertTrue("not isZERO( c )", !c.isZERO());
228        L.add(c);
229
230        clients = startThreads();
231        L = bbdisthyb.GB(L);
232        stopThreads(clients);
233        assertTrue("isGB( { a, b, c } )", bbseq.isGB(L));
234        //System.out.println("L = " + L.size() );
235
236        assertTrue("not isZERO( d )", !d.isZERO());
237        L.add(d);
238
239        clients = startThreads();
240        L = bbdisthyb.GB(L);
241        stopThreads(clients);
242        assertTrue("isGB( { a, b, c, d } )", bbseq.isGB(L));
243        //System.out.println("L = " + L.size() );
244
245        assertTrue("not isZERO( e )", !e.isZERO());
246        L.add(e);
247
248        clients = startThreads();
249        L = bbdisthyb.GB(L);
250        stopThreads(clients);
251        assertTrue("isGB( { a, b, c, d, e } )", bbseq.isGB(L));
252        //System.out.println("L = " + L.size() );
253    }
254
255
256    /**
257     * Test Trinks7 GBase.
258     * 
259     */
260    @SuppressWarnings("unchecked")
261    public void testTrinks7GBase() {
262        bbdisthybs = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
263        bbdisthyb = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, new OrderedSyzPairlist<BigRational>(), port);
264        Thread[] clients;
265        String exam = "(B,S,T,Z,P,W) L " + "( " + "( 45 P + 35 S - 165 B - 36 ), "
266                + "( 35 P + 40 Z + 25 T - 27 S ), " + "( 15 W + 25 S P + 30 Z - 18 T - 165 B**2 ), "
267                + "( - 9 W + 15 T P + 20 S Z ), " + "( P W + 2 T Z - 11 B**3 ), "
268                + "( 99 W - 11 B S + 3 B**2 ), " + "( B**2 + 33/50 B + 2673/10000 ) " + ") ";
269        Reader source = new StringReader(exam);
270        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
271        try {
272            F = (PolynomialList<BigRational>) parser.nextPolynomialSet();
273        } catch (IOException e) {
274            fail("" + e);
275        }
276        //System.out.println("F = " + F);
277
278        clients = startThreads();
279        G = bbdisthyb.GB(F.list);
280        stopThreads(clients);
281
282        assertTrue("isGB( GB(Trinks7) )", bbseq.isGB(G));
283        assertEquals("#GB(Trinks7) == 6", 6, G.size());
284        //PolynomialList<BigRational> trinks = new PolynomialList<BigRational>(F.ring, G);
285        //System.out.println("G = " + trinks);
286
287    }
288
289
290    /**
291     * Test Trinks7 GBase.
292     * 
293     */
294    @SuppressWarnings("unchecked")
295    public void testTrinks7GBase_t1_p4() {
296
297        //bbdisthyb.terminate();
298        threads = 1;
299        threadsPerNode = 4;
300        bbdisthybs = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
301        bbdisthyb = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, new OrderedSyzPairlist<BigRational>(), port);
302
303        Thread[] clients;
304        String exam = "(B,S,T,Z,P,W) L " + "( " + "( 45 P + 35 S - 165 B - 36 ), "
305                + "( 35 P + 40 Z + 25 T - 27 S ), " + "( 15 W + 25 S P + 30 Z - 18 T - 165 B**2 ), "
306                + "( - 9 W + 15 T P + 20 S Z ), " + "( P W + 2 T Z - 11 B**3 ), "
307                + "( 99 W - 11 B S + 3 B**2 ), " + "( B**2 + 33/50 B + 2673/10000 ) " + ") ";
308        Reader source = new StringReader(exam);
309        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
310        try {
311            F = (PolynomialList<BigRational>) parser.nextPolynomialSet();
312        } catch (IOException e) {
313            fail("" + e);
314        }
315        //System.out.println("F = " + F);
316
317        clients = startThreads();
318        G = bbdisthyb.GB(F.list);
319        stopThreads(clients);
320
321        assertTrue("isGB( GB(Trinks7) )", bbseq.isGB(G));
322        assertEquals("#GB(Trinks7) == 6", 6, G.size());
323        //PolynomialList<BigRational> trinks = new PolynomialList<BigRational>(F.ring, G);
324        //System.out.println("G = " + trinks);
325    }
326
327
328    /**
329     * Test Trinks7 GBase.
330     * 
331     */
332    @SuppressWarnings("unchecked")
333    public void testTrinks7GBase_t4_p1() {
334
335        //bbdisthyb.terminate();
336        threads = 4;
337        threadsPerNode = 1;
338        bbdisthybs = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
339        bbdisthyb = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, new OrderedSyzPairlist<BigRational>(), port);
340
341        Thread[] clients;
342        String exam = "(B,S,T,Z,P,W) L " + "( " + "( 45 P + 35 S - 165 B - 36 ), "
343                + "( 35 P + 40 Z + 25 T - 27 S ), " + "( 15 W + 25 S P + 30 Z - 18 T - 165 B**2 ), "
344                + "( - 9 W + 15 T P + 20 S Z ), " + "( P W + 2 T Z - 11 B**3 ), "
345                + "( 99 W - 11 B S + 3 B**2 ), " + "( B**2 + 33/50 B + 2673/10000 ) " + ") ";
346        Reader source = new StringReader(exam);
347        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
348        try {
349            F = (PolynomialList<BigRational>) parser.nextPolynomialSet();
350        } catch (IOException e) {
351            fail("" + e);
352        }
353        //System.out.println("F = " + F);
354
355        clients = startThreads();
356        G = bbdisthyb.GB(F.list);
357        stopThreads(clients);
358
359        assertTrue("isGB( GB(Trinks7) )", bbseq.isGB(G));
360        assertEquals("#GB(Trinks7) == 6", 6, G.size());
361        //PolynomialList<BigRational> trinks = new PolynomialList<BigRational>(F.ring, G);
362        //System.out.println("G = " + trinks);
363    }
364
365
366    /**
367     * Test Trinks7 GBase.
368     * 
369     */
370    @SuppressWarnings("unchecked")
371    public void testTrinks7GBase_t2_p2() {
372
373        //bbdisthyb.terminate();
374        threads = 2;
375        threadsPerNode = 4;
376        bbdisthybs = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, port);
377        bbdisthyb = new GroebnerBaseDistributedHybrid<BigRational>(threads, threadsPerNode, new OrderedSyzPairlist<BigRational>(), port);
378
379        Thread[] clients;
380        String exam = "(B,S,T,Z,P,W) L " + "( " + "( 45 P + 35 S - 165 B - 36 ), "
381                + "( 35 P + 40 Z + 25 T - 27 S ), " + "( 15 W + 25 S P + 30 Z - 18 T - 165 B**2 ), "
382                + "( - 9 W + 15 T P + 20 S Z ), " + "( P W + 2 T Z - 11 B**3 ), "
383                + "( 99 W - 11 B S + 3 B**2 ), " + ") ";
384        //      + "( 99 W - 11 B S + 3 B**2 ), " + "( B**2 + 33/50 B + 2673/10000 ) " + ") ";
385        Reader source = new StringReader(exam);
386        GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source);
387        try {
388            F = (PolynomialList<BigRational>) parser.nextPolynomialSet();
389        } catch (IOException e) {
390            fail("" + e);
391        }
392        //System.out.println("F = " + F);
393
394        clients = startThreads();
395        G = bbdisthyb.GB(F.list);
396        stopThreads(clients);
397
398        assertTrue("isGB( GB(Trinks7) )", bbseq.isGB(G));
399        assertEquals("#GB(Trinks7) == 6", 6, G.size());
400        //PolynomialList<BigRational> trinks = new PolynomialList<BigRational>(F.ring, G);
401        //System.out.println("G = " + trinks);
402    }
403
404}
405
406
407/**
408 * Unit Test client to be executed by test threads.
409 */
410
411class JunitClientHybrid<C extends RingElem<C>> implements Runnable {
412
413
414    private final int threadsPerNode;
415
416
417    private final String host;
418
419
420    private final int port;
421
422
423    JunitClientHybrid(int threadsPerNode, String host, int port) {
424        this.threadsPerNode = threadsPerNode;
425        this.host = host;
426        this.port = port;
427    }
428
429
430    public void run() {
431        GroebnerBaseDistributedHybrid<C> bbd;
432        bbd = new GroebnerBaseDistributedHybrid<C>(1, threadsPerNode, null, null, port);
433        try {
434            bbd.clientPart(host);
435        } catch (IOException ignored) {
436        }
437        bbd.terminate();
438    }
439}