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

        ThreadPoolExecutor threadPool;  
        
        CyclicBarrier barrier;

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