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();
                        
                        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	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	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	logger.info("Bbox=" + bbox);
74	bbox.adjustToMargin( consts.getKmMargin() );
75	logger.info("Bbox Adjusted=" + bbox);
76
77	logger.info("Henter daekkede adresser i " + postnr);
78	daekkedeAdresser = db.hentDaekkedeAdresserCache(bbox,udvidetDaekkedeAdresser);
79
80
81
82
83	stat.postnr = postnr;
84	stat.antalDaekkede = daekkedeAdresser.length;
85	stat.antalIkkeDaekkede = queue.size();
86	stat.totalDataset = stat.antalDaekkede * stat.antalIkkeDaekkede;
87
88
89	logger.info("Starter beregning for " + postnr);
90	start2 = System.currentTimeMillis();
91
92	for (int i =0; i < LookupMain.max_workers; i++) {
93	LookupWorker worker = new LookupWorker(i, this, barrier);
94	threadPool.submit(worker);
95	}
96
97	barrier.await();
98
99	db.saveBatch();//Save any unsaved rows
100
101
102	} 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	stat.forbrugtTid = (now-start1);
114	LookupMain.saveStatistics(stat);
115
116	logger.info( stat.toString() );
117	logger.info("Done! elapsed=" + (now-start1) + "/" + (now-start2) + " postnr=" + postnr);
118	}
119
120
121	// Getters and setters
122
123	///////////////////////////
124	public Database getDb() {
125	return db;
126	}
127
128
129
130	public Adresse[] getDaekkedeAdresser() {
131	return daekkedeAdresser;
132	}
133	public Adresse[] getUdvidetDaekkedeAdresser() {
134	return udvidetDaekkedeAdresser;
135	}
136
137
138
139	public Queue<Adresse> getQueue() {
140	return queue;
141	}
142
143
144	}