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