daoas/fulddaekning/Lookup.java

package dk.daoas.fulddaekning;

import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.logging.Level;
import java.util.logging.Logger;

import dk.daoas.fulddaekning.BoundingBox.BoundingBoxException;

public class Lookup {

        
        final static Logger logger = Logger.getLogger( Lookup.class.toString() );
        
        short postnr;
        Database db;
                
        Adresse daekkedeAdresser[];
        Adresse udvidetDaekkedeAdresser[];
        Queue<Adresse> queue;
        
        Map<Integer, LookupWorker> workers = new ConcurrentHashMap<Integer, LookupWorker>();

        ThreadPoolExecutor threadPool;  
        
        CyclicBarrier barrier;

                
        public Lookup(short postnr, Database db, ThreadPoolExecutor threadPool) {
                this.postnr = postnr;
                this.db = db;
                this.threadPool = threadPool;
        }
        

        public void doLookup() throws BoundingBoxException {
                logger.info("Starting for postnr=" + postnr);
                
                Statistik stat = new Statistik();
                
                Constants consts = Constants.getInstance();
                                
                long start1 = System.currentTimeMillis();               
                long start2 = 0;
                
                barrier = new CyclicBarrier(LookupMain.max_workers + 1);
                
                try {
                        
                        logger.info("Henter _ikke_ daekkede adresser i " + postnr);
                        queue = db.hentIkkedaekkedeAdresserCache(postnr);
                        if (queue.size() == 0) {
                                logger.info("Fandt ikke nogen _ikke_ daekkede adresser i " + postnr);
                                return;
                        }
                        
                        BoundingBox bbox = db.getBoundingbox(postnr);
                        bbox.validateBbox();
                        
                        BoundingBox udvidetBbox = db.getBoundingbox(postnr);
                        udvidetBbox.adjustToMargin( consts.getMaxDistance() );
                        
                        logger.info("Henter udvidet daekkede adresser i " + postnr);
                        udvidetDaekkedeAdresser = db.hentDaekkedeAdresserCache(udvidetBbox);

                        
                        logger.info("Bbox=" + bbox);
                        bbox.adjustToMargin( consts.getKmMargin() );
                        logger.info("Bbox Adjusted=" + bbox);
                        
                        logger.info("Henter daekkede adresser i " + postnr);
                        daekkedeAdresser = db.hentDaekkedeAdresserCache(bbox,udvidetDaekkedeAdresser);
                        
                                                
                        stat.postnr = postnr;
                        stat.antalDaekkede = daekkedeAdresser.length;
                        stat.antalIkkeDaekkede = queue.size();
                        stat.totalDataset = stat.antalDaekkede * stat.antalIkkeDaekkede;
                                                                        
                        
                        logger.info("Starter beregning for " + postnr);
                        start2 = System.currentTimeMillis();
                                                                                                                
                        for (int i =0; i < LookupMain.max_workers; i++) {
                                LookupWorker worker = new LookupWorker(i, this, barrier);
                                threadPool.submit(worker);
                        }
                        
                        barrier.await();
                        
                        db.saveBatch();//Save any unsaved rows
                        
                        
                } catch(Exception e) {
                        logger.log(Level.WARNING, "Exception during lookup", e);
                        
                        if (e instanceof BoundingBoxException) {
                                logger.severe( e.getMessage() );
                                System.exit(1);
                        }
                        
                }
                long now = System.currentTimeMillis();
                
                stat.forbrugtTid = (now-start1);
                LookupMain.saveStatistics(stat);

                logger.info( stat.toString() );
                logger.info("Done! elapsed=" + (now-start1) + "/" +  (now-start2) + "  postnr=" + postnr);
        }
        
        
        // Getters and setters
                
        ///////////////////////////
        public Database getDb() {
                return db;
        }


        public Adresse[] getDaekkedeAdresser() {
                return daekkedeAdresser;
        }
        public Adresse[] getUdvidetDaekkedeAdresser() {
                return udvidetDaekkedeAdresser;
        }
        
        
        public Queue<Adresse> getQueue() {
                return queue;
        }


}
1	torben	2145	package dk.daoas.fulddaekning;
2
3			import java.util.Map;
4	torben	2150	import java.util.Queue;
5	torben	2263	import java.util.concurrent.ConcurrentHashMap;
6			import java.util.concurrent.CyclicBarrier;
7			import java.util.concurrent.ThreadPoolExecutor;
8	torben	2145	import java.util.logging.Level;
9			import java.util.logging.Logger;
10
11			import dk.daoas.fulddaekning.BoundingBox.BoundingBoxException;
12
13			public class Lookup {
14	torben	2158
15	torben	2145
16	torben	2195
17	torben	2241	final static Logger logger = Logger.getLogger( Lookup.class.toString() );
18	torben	2145
19	torben	2575	short postnr;
20	torben	2145	Database db;
21	torben	2150
22	torben	2207	Adresse daekkedeAdresser[];
23	torben	2422	Adresse udvidetDaekkedeAdresser[];
24	torben	2150	Queue<Adresse> queue;
25	torben	2145
26			Map<Integer, LookupWorker> workers = new ConcurrentHashMap<Integer, LookupWorker>();
27
28	torben	2259	ThreadPoolExecutor threadPool;
29	torben	2263
30			CyclicBarrier barrier;
31	torben	2227
32	torben	2154
33
34	torben	2575	public Lookup(short postnr, Database db, ThreadPoolExecutor threadPool) {
35	torben	2150	this.postnr = postnr;
36	torben	2145	this.db = db;
37	torben	2259	this.threadPool = threadPool;
38	torben	2145	}
39
40	torben	2241
41	torben	2145
42			public void doLookup() throws BoundingBoxException {
43	torben	2150	logger.info("Starting for postnr=" + postnr);
44	torben	2145
45	torben	2154	Statistik stat = new Statistik();
46	torben	2330
47			Constants consts = Constants.getInstance();
48	torben	2154
49	torben	2145	long start1 = System.currentTimeMillis();
50			long start2 = 0;
51
52	torben	2263	barrier = new CyclicBarrier(LookupMain.max_workers + 1);
53
54	torben	2145	try {
55	torben	2232
56			logger.info("Henter _ikke_ daekkede adresser i " + postnr);
57	torben	2328	queue = db.hentIkkedaekkedeAdresserCache(postnr);
58	torben	2232	if (queue.size() == 0) {
59			logger.info("Fandt ikke nogen _ikke_ daekkede adresser i " + postnr);
60	torben	2233	return;
61	torben	2232	}
62
63	torben	2150	BoundingBox bbox = db.getBoundingbox(postnr);
64			bbox.validateBbox();
65
66	torben	2424	BoundingBox udvidetBbox = db.getBoundingbox(postnr);
67			udvidetBbox.adjustToMargin( consts.getMaxDistance() );
68
69			logger.info("Henter udvidet daekkede adresser i " + postnr);
70			udvidetDaekkedeAdresser = db.hentDaekkedeAdresserCache(udvidetBbox);
71
72
73	torben	2150	logger.info("Bbox=" + bbox);
74	torben	2330	bbox.adjustToMargin( consts.getKmMargin() );
75	torben	2150	logger.info("Bbox Adjusted=" + bbox);
76
77			logger.info("Henter daekkede adresser i " + postnr);
78	torben	2424	daekkedeAdresser = db.hentDaekkedeAdresserCache(bbox,udvidetDaekkedeAdresser);
79	torben	2150
80	torben	2424
81	torben	2263
82	torben	2422
83	torben	2154	stat.postnr = postnr;
84	torben	2207	stat.antalDaekkede = daekkedeAdresser.length;
85	torben	2154	stat.antalIkkeDaekkede = queue.size();
86	torben	2227	stat.totalDataset = stat.antalDaekkede * stat.antalIkkeDaekkede;
87
88	torben	2150
89			logger.info("Starter beregning for " + postnr);
90	torben	2145	start2 = System.currentTimeMillis();
91
92	torben	2241	for (int i =0; i < LookupMain.max_workers; i++) {
93	torben	2263	LookupWorker worker = new LookupWorker(i, this, barrier);
94	torben	2260	threadPool.submit(worker);
95	torben	2145	}
96
97	torben	2263	barrier.await();
98	torben	2145
99	torben	2219	db.saveBatch();//Save any unsaved rows
100	torben	2145
101	torben	2219
102	torben	2145	} catch(Exception e) {
103			logger.log(Level.WARNING, "Exception during lookup", e);
104
105			if (e instanceof BoundingBoxException) {
106			logger.severe( e.getMessage() );
107			System.exit(1);
108			}
109
110			}
111			long now = System.currentTimeMillis();
112
113	torben	2227	stat.forbrugtTid = (now-start1);
114	torben	2241	LookupMain.saveStatistics(stat);
115	torben	2154
116			logger.info( stat.toString() );
117	torben	2153	logger.info("Done! elapsed=" + (now-start1) + "/" + (now-start2) + " postnr=" + postnr);
118	torben	2145	}
119
120
121			// Getters and setters
122
123			///////////////////////////
124			public Database getDb() {
125			return db;
126			}
127	torben	2150
128
129
130	torben	2207	public Adresse[] getDaekkedeAdresser() {
131	torben	2150	return daekkedeAdresser;
132	torben	2145	}
133	torben	2422	public Adresse[] getUdvidetDaekkedeAdresser() {
134			return udvidetDaekkedeAdresser;
135			}
136
137
138	torben	2145
139	torben	2150	public Queue<Adresse> getQueue() {
140			return queue;
141			}
142
143
144	torben	2145	}