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() );
        
        int postnr;
        Database db;
                
        Adresse daekkedeAdresser[];
        Adresse udvidetDaekkedeAdresser[];
        Queue<Adresse> queue;
        
        Map<Integer, LookupWorker> workers = new ConcurrentHashMap<Integer, LookupWorker>();

        ThreadPoolExecutor threadPool;  
        
        CyclicBarrier barrier;

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