root / trunk / libraries / libRaster / src / org / gvsig / raster / buffer / cache / Cache.java @ 11074
History | View | Annotate | Download (25 KB)
1 | 11074 | nacho | |
---|---|---|---|
2 | /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
|
||
3 | *
|
||
4 | * Copyright (C) 2006 IVER T.I. and Generalitat Valenciana.
|
||
5 | *
|
||
6 | * This program is free software; you can redistribute it and/or
|
||
7 | * modify it under the terms of the GNU General Public License
|
||
8 | * as published by the Free Software Foundation; either version 2
|
||
9 | * of the License, or (at your option) any later version.
|
||
10 | *
|
||
11 | * This program is distributed in the hope that it will be useful,
|
||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 | * GNU General Public License for more details.
|
||
15 | *
|
||
16 | * You should have received a copy of the GNU General Public License
|
||
17 | * along with this program; if not, write to the Free Software
|
||
18 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA.
|
||
19 | */
|
||
20 | package org.gvsig.raster.buffer.cache; |
||
21 | |||
22 | import java.io.File; |
||
23 | import java.io.FileNotFoundException; |
||
24 | import java.io.IOException; |
||
25 | |||
26 | import org.gvsig.raster.dataset.NotSupportedExtensionException; |
||
27 | import org.gvsig.raster.dataset.RasterDataset; |
||
28 | import org.gvsig.raster.dataset.RasterDriverException; |
||
29 | import org.gvsig.raster.shared.Extent; |
||
30 | |||
31 | /**
|
||
32 | * <P>
|
||
33 | * Esta clase representa a la cache raster. Consta de una ser?e de p?ginas (CachePages)
|
||
34 | * que son buffers con los bloques de datos cacheados en un instante dado. Esta cache tiene
|
||
35 | * una estructura en forma de array donde cada elemento es una p?gina de cach?. Las p?ginas
|
||
36 | * se agrupan en bloques de N p?ginas denominados grupos. La variable nelemsGroup contiene
|
||
37 | * el n?mero de p?ginas de cada grupo.
|
||
38 | * </P>
|
||
39 | * <P>
|
||
40 | * La politica de reemplazo es que una p?gina siempre va a un conjunto determinado por el calculo
|
||
41 | * cto = pag % nelemsGroup. Si hay hueco vac?o en el grupo se a?adir? en el siguiente hueco pero
|
||
42 | * si hay que reeplazar se reeplazar? la p?gina que m?s tiempo haga su ?ltimo acceso.
|
||
43 | * </P>
|
||
44 | * <P>
|
||
45 | * Esta cach? lleva el control de que p?ginas est?n cargadas a trav?s de un array de de booleanos
|
||
46 | * donde cada elemento representa a una p?gina de datos del raster. Si el elemento en la posici?n
|
||
47 | * N de dicho array es true significa que la p?gina est? cacheada. Si es false no lo estar?.
|
||
48 | * </P>
|
||
49 | * <P>
|
||
50 | * La p?gina de datos actualmente accedida debe estar cacheada por lo que est? clase debe llevar
|
||
51 | * el control de que p?gina se est? accediendo o a sido accedida por ?ltima vez. La variable que
|
||
52 | * nos dice que p?gina est? siendo accedida es loadPage y pageBuffer ser? la variable que apunta
|
||
53 | * al buffer de esta p?gina. Cuando se cambia de p?gina en un acceso estas dos variables deben
|
||
54 | * cambiar a sus nuevos valores.
|
||
55 | * </P>
|
||
56 | * <P>
|
||
57 | * Otro par?metro que controla esta clase es que p?gina de cada grupo ha sido accedido con mayor
|
||
58 | * frecuencia. Esto es ?til porque siempre se reemplaza la p?gina de un grupo que haga m?s tiempo
|
||
59 | * que haya sido accedida bajo la premisa de que "las p?ginas con accesos recientes tienen mayor
|
||
60 | * probabilidad de volver a ser usadas". Esto es controlado por la variable lastAccess que es
|
||
61 | * usada para implementar el algoritmo LRU. Cada vez que una p?gina de un grupo es accedida su
|
||
62 | * contador de lastAccess se pone a 0. El resto de contadores de las p?ginas del grupo se incrementa
|
||
63 | * en uno. Siempre se sustituye la p?gina del grupo con valor m?s grande en el contador.
|
||
64 | * </P>
|
||
65 | *
|
||
66 | * @author Nacho Brodin (nachobrodin@gmail.com)
|
||
67 | *
|
||
68 | */
|
||
69 | public class Cache{ |
||
70 | /**
|
||
71 | * Cada elemento es una p?gina del raster y dice si est? cacheada o no.
|
||
72 | */
|
||
73 | private boolean[] cacheada = null; |
||
74 | /**
|
||
75 | * N?mero de p?gina cargada en accessPage.
|
||
76 | */
|
||
77 | private int numberInAccessPage = -1; |
||
78 | /**
|
||
79 | * Buffer de datos de la p?gina actualmente accedida.
|
||
80 | */
|
||
81 | private PageBuffer accessPage = null; |
||
82 | /**
|
||
83 | * P?ginas de cach?
|
||
84 | */
|
||
85 | private PageBuffer[] page = null; |
||
86 | /**
|
||
87 | * Cada elemento del array es una p?gina de cach? y contiene el n?mero de p?gina cargada en
|
||
88 | * esa posici?n.
|
||
89 | */
|
||
90 | private int[] pageNumberInCache = null; |
||
91 | /**
|
||
92 | * P?ginas de la cach?.
|
||
93 | */
|
||
94 | private CacheStruct cacheStruct = null; |
||
95 | /**
|
||
96 | * ?ltimo acceso a las p?ginas de cada grupo.
|
||
97 | */
|
||
98 | private int[][] lastAccess = null; |
||
99 | /**
|
||
100 | * Cada elemento representa una p?gina de cach? y dice si esta ha sido modificada desde que
|
||
101 | * fu? cargada en cach? o no.
|
||
102 | */
|
||
103 | private boolean[] modified = null; |
||
104 | /**
|
||
105 | * P?ginas de disco
|
||
106 | */
|
||
107 | private HddPage[] hddPage = null; |
||
108 | |||
109 | /**
|
||
110 | * Inicializamos la variables. Para ello creamos el objeto Cache que contendr? todos los
|
||
111 | * par?metros necesarios para crear el array que controla los accesos m?s recientes y el
|
||
112 | * array que dice si una p?gina est? en memoria o no.
|
||
113 | * @param nBands N?mero de bandas
|
||
114 | * @param dataType Tipo de dato de la p?gina
|
||
115 | * @param dataSourceWidth ancho de la fuente de datos
|
||
116 | * @param driverParam par?metro para el driver
|
||
117 | */
|
||
118 | public Cache(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight, Object driverParam) throws FileNotFoundException, NotSupportedExtensionException, RasterDriverException { |
||
119 | if(driverParam instanceof String) { |
||
120 | File file = new File(((String)driverParam)); |
||
121 | if(!file.exists())
|
||
122 | throw new FileNotFoundException("I can't make read only cache structure."); |
||
123 | } |
||
124 | |||
125 | init(nBands, dataType, dataSourceWidth, dataSourceHeight); |
||
126 | |||
127 | //Creamos las estructuras de las p?ginas de disco
|
||
128 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
129 | |||
130 | RasterDataset dataset = RasterDataset.open(null, driverParam);
|
||
131 | Extent[] extentList = calcExtentPages(dataset, hddPage.length);
|
||
132 | |||
133 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
134 | hddPage[iPage] = new HddPage(iPage, dataset, extentList[iPage]);
|
||
135 | |||
136 | //Creamos las p?ginas de memoria
|
||
137 | for(int i = 0; i < cacheStruct.getNPags(); i++) { |
||
138 | page[i] = new PageBuffer(dataType, dataSourceWidth, cacheStruct.getHPag(), nBands, true, i); |
||
139 | page[i].setHddPages(hddPage); |
||
140 | } |
||
141 | } |
||
142 | |||
143 | /**
|
||
144 | * Calcula la extensi?n de las p?ginas en coordenadas del mundo real
|
||
145 | * @param dataset Dataset
|
||
146 | * @param nPages N?mero de p?ginas en que se divide el raster
|
||
147 | * @return Extensi?n de cada p?gina
|
||
148 | */
|
||
149 | private Extent[] calcExtentPages(RasterDataset dataset, int nPages) { |
||
150 | Extent datasetExtent = dataset.getExtent(); |
||
151 | double h = cacheStruct.getHPag() * (dataset.getExtent().height() / dataset.getHeight());
|
||
152 | Extent[] ext = new Extent[nPages]; |
||
153 | |||
154 | double minX = datasetExtent.getMin().getX();
|
||
155 | double maxX = datasetExtent.getMax().getX();
|
||
156 | double maxY = datasetExtent.getMax().getY();
|
||
157 | double minY = maxY - h;
|
||
158 | for (int i = 0; i < ext.length; i++) { |
||
159 | ext[0] = new Extent(minX, maxY, maxX, minY); |
||
160 | maxY = minY; |
||
161 | minY -= h; |
||
162 | } |
||
163 | return ext;
|
||
164 | } |
||
165 | |||
166 | /**
|
||
167 | * Inicializamos la variables. Para ello creamos el objeto Cache que contendr? todos los
|
||
168 | * par?metros necesarios para crear el array que controla los accesos m?s recientes y el
|
||
169 | * array que dice si una p?gina est? en memoria o no.
|
||
170 | * @param nBands N?mero de bandas
|
||
171 | * @param dataType Tipo de dato de la p?gina
|
||
172 | * @param dataSourceWidth ancho de la fuente de datos
|
||
173 | */
|
||
174 | public Cache(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight) { |
||
175 | init(nBands, dataType, dataSourceWidth, dataSourceHeight); |
||
176 | |||
177 | //Creamos las estructuras de las p?ginas de disco
|
||
178 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
179 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
180 | hddPage[iPage] = new HddPage(iPage, getNBands());
|
||
181 | |||
182 | //Creamos las p?ginas de memoria
|
||
183 | for(int i = 0; i < cacheStruct.getNPags(); i++) { |
||
184 | page[i] = new PageBuffer(dataType, dataSourceWidth, cacheStruct.getHPag(), nBands, true, i); |
||
185 | page[i].setHddPages(hddPage); |
||
186 | } |
||
187 | } |
||
188 | |||
189 | /**
|
||
190 | * Contructor
|
||
191 | * @param cacheStruct
|
||
192 | */
|
||
193 | public Cache(CacheStruct cacheStruct, int dataSourceWidth) { |
||
194 | this.cacheStruct = cacheStruct;
|
||
195 | |||
196 | //Inicializamos la antig?edad de acceso
|
||
197 | lastAccess = new int[cacheStruct.getNGroups()][cacheStruct.getPagsPerGroup()]; |
||
198 | |||
199 | //Creamos el buffer de la cach?
|
||
200 | page = new PageBuffer[cacheStruct.getNPags()];
|
||
201 | pageNumberInCache = new int[cacheStruct.getNPags()]; |
||
202 | modified = new boolean[cacheStruct.getNPags()]; |
||
203 | cacheada = new boolean[cacheStruct.getNTotalPags()]; |
||
204 | |||
205 | //Creamos las estructuras de las p?ginas de disco
|
||
206 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
207 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
208 | hddPage[iPage] = new HddPage(iPage, getNBands());
|
||
209 | |||
210 | //Creamos las p?ginas de memoria
|
||
211 | for(int i = 0; i < cacheStruct.getNPags(); i++) { |
||
212 | page[i] = new PageBuffer(cacheStruct.getDataType(), dataSourceWidth, cacheStruct.getHPag(), cacheStruct.getNBands(), true, i); |
||
213 | page[i].setHddPages(hddPage); |
||
214 | } |
||
215 | |||
216 | initStructs(); |
||
217 | } |
||
218 | |||
219 | /**
|
||
220 | *
|
||
221 | * @param nBands
|
||
222 | * @param dataType
|
||
223 | * @param dataSourceWidth
|
||
224 | * @param dataSourceHeight
|
||
225 | */
|
||
226 | private void init(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight) { |
||
227 | //Creamos la estructura de la cach?
|
||
228 | cacheStruct = new CacheStruct(nBands, dataType, dataSourceWidth, dataSourceHeight);
|
||
229 | |||
230 | //Inicializamos la antig?edad de acceso
|
||
231 | lastAccess = new int[cacheStruct.getNGroups()][cacheStruct.getPagsPerGroup()]; |
||
232 | |||
233 | //Creamos el buffer de la cach?
|
||
234 | page = new PageBuffer[cacheStruct.getNPags()];
|
||
235 | pageNumberInCache = new int[cacheStruct.getNPags()]; |
||
236 | modified = new boolean[cacheStruct.getNPags()]; |
||
237 | cacheada = new boolean[cacheStruct.getNTotalPags()]; |
||
238 | |||
239 | this.initStructs();
|
||
240 | } |
||
241 | |||
242 | /**
|
||
243 | * Inicializa las estructuras de mantenimiento de cach?. Estas son array de paginas
|
||
244 | * accedidas por ?ltima vez, numeros de p?gina cargadas en cada posici?n de cach?,
|
||
245 | * array con la informaci?n de p?gina modificada y array que dice si una p?gina de disco
|
||
246 | * est? cacheada o no.
|
||
247 | */
|
||
248 | private void initStructs() { |
||
249 | for(int i = 0; i < cacheStruct.getNGroups(); i ++) |
||
250 | for(int j = 0; j < cacheStruct.getPagsPerGroup(); j ++) |
||
251 | lastAccess[i][j] = -1;
|
||
252 | |||
253 | for(int i = 0; i < cacheada.length; i++) |
||
254 | cacheada[i] = false;
|
||
255 | |||
256 | for(int i = 0; i < cacheStruct.getNPags(); i++){ |
||
257 | pageNumberInCache[i] = -1;
|
||
258 | modified[i] = false;
|
||
259 | } |
||
260 | } |
||
261 | |||
262 | /**
|
||
263 | * Obtiene el n?mero de bits por p?gina para poder calcular el desplazamiento binario
|
||
264 | * de la direcci?n de acceso de la petici?n. Es decir si se solicita un dato en la l?nea
|
||
265 | * 36 (en decimal) del raster 100100(en binario) y el desplazamiento es 4 bits el n?mero de
|
||
266 | * p?gina resultante ser? 10(en binario) 2 (en decimal)
|
||
267 | * @return
|
||
268 | */
|
||
269 | public int getBitsPag() { |
||
270 | return cacheStruct.getBitsPag();
|
||
271 | } |
||
272 | |||
273 | /**
|
||
274 | * Obtiene la altura de la p?gina de cache en l?neas.
|
||
275 | * @return N?mero de l?neas de altura de p?gina.
|
||
276 | */
|
||
277 | public int getHPag() { |
||
278 | return cacheStruct.getHPag();
|
||
279 | } |
||
280 | |||
281 | /**
|
||
282 | * Array de booleanos donde cada elemento es una p?gina del raster y dice si la p?gina
|
||
283 | * est? cacheada o no.
|
||
284 | * @return true si la p?gina est? en cach? y false si no lo est?
|
||
285 | */
|
||
286 | public boolean isInCache(int nPag) { |
||
287 | if(nPag < 0 || nPag >= cacheada.length) |
||
288 | return false; |
||
289 | return cacheada[nPag];
|
||
290 | } |
||
291 | |||
292 | /**
|
||
293 | * Marca una p?gina como cargada en cach?.
|
||
294 | * @param nPag N?mero de p?gina a marcar.
|
||
295 | */
|
||
296 | public void setPageAsLoadInCache(int nPag) { |
||
297 | if(nPag < 0 || nPag >= cacheada.length) |
||
298 | return;
|
||
299 | cacheada[nPag] = true;
|
||
300 | } |
||
301 | |||
302 | /**
|
||
303 | * Desmarca una p?gina como cargada en cach?.
|
||
304 | * @param nPag N?mero de p?gina a desmarcar.
|
||
305 | */
|
||
306 | public void setPageAsNotLoadInCache(int nPag) { |
||
307 | if(nPag < 0 || nPag >= cacheada.length) |
||
308 | return;
|
||
309 | cacheada[nPag] = false;
|
||
310 | } |
||
311 | |||
312 | /**
|
||
313 | * Obtiene el n?mero de p?gina del raster cargada en una p?gina de cach? especificada
|
||
314 | * en el par?metro.
|
||
315 | * @param nCachePage N?mero de p?gina de cach? de la que se quiere saber que p?gina del
|
||
316 | * raster hay cargada.
|
||
317 | * @return N?mero de p?gina del raster
|
||
318 | */
|
||
319 | public int getRasterPageNumberInPosition(int nCachePage) { |
||
320 | return pageNumberInCache[nCachePage];
|
||
321 | } |
||
322 | |||
323 | /**
|
||
324 | * Obtiene el n?mero de p?gina del raster cargada en una p?gina de cach? especificada
|
||
325 | * en el par?metro.
|
||
326 | * @param group Grupo en el que se encuentra la p?gina
|
||
327 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
328 | * @return N?mero de p?gina del raster
|
||
329 | */
|
||
330 | public int getRasterPageNumberInPosition(int group, int posInGroup) { |
||
331 | return pageNumberInCache[group * getPagsPerGroup() + posInGroup];
|
||
332 | } |
||
333 | |||
334 | /**
|
||
335 | * Asigna el n?mero de p?gina del raster cargada en una p?gina de cach? especificada.
|
||
336 | * @param nCachePage N?mero de p?gina de cach?
|
||
337 | * @param nRasterPage N?mero de p?gina de raster a asignar
|
||
338 | */
|
||
339 | public void setRasterPageNumberInPosition(int nCachePage, int nRasterPage) { |
||
340 | pageNumberInCache[nCachePage] = nRasterPage; |
||
341 | } |
||
342 | |||
343 | /**
|
||
344 | * Asigna el n?mero de p?gina del raster cargada en una p?gina de cach? especificada.
|
||
345 | * @param nCachePage N?mero de p?gina de cach?
|
||
346 | * @param nRasterPage N?mero de p?gina de raster a asignar
|
||
347 | */
|
||
348 | public void setRasterPageNumberInPosition(int group, int posInGroup, int nRasterPage) { |
||
349 | pageNumberInCache[group * getPagsPerGroup() + posInGroup] = nRasterPage; |
||
350 | } |
||
351 | |||
352 | /**
|
||
353 | * Obtiene el n?mero de p?gina de cach? donde est? cargada la p?gina del raster
|
||
354 | * que se ha pasado por par?metro.
|
||
355 | * @param pag P?gina del raster
|
||
356 | * @return N?mero de p?gina del raster
|
||
357 | */
|
||
358 | public int getNumberCachePageFromNumberRasterPage(int pag) { |
||
359 | int group = pag % getNGroups();
|
||
360 | for(int i = 0; i < getPagsPerGroup(); i++) |
||
361 | if(pageNumberInCache[group + i] == pag)
|
||
362 | return (group * getPagsPerGroup() + i);
|
||
363 | return -1; |
||
364 | } |
||
365 | |||
366 | /**
|
||
367 | * Obtiene el n?mero de p?gina de cach? (en formato grupo/p?gina dentro del grupo)
|
||
368 | * donde est? cargada la p?gina del raster que se ha pasado por par?metro.
|
||
369 | * @param pag P?gina del raster
|
||
370 | * @return N?mero de p?gina del raster
|
||
371 | */
|
||
372 | public int[] getNumberGroupFromNumberRasterPage(int pag) { |
||
373 | int group = pag % getNGroups();
|
||
374 | for(int i = 0; i < getPagsPerGroup(); i++) |
||
375 | if(pageNumberInCache[(group * getPagsPerGroup()) + i] == pag)
|
||
376 | return new int[]{group, i}; |
||
377 | return null; |
||
378 | } |
||
379 | |||
380 | /**
|
||
381 | * Obtiene el array que contiene los valores de la antig?edad del acceso dentro del
|
||
382 | * grupo. La primera dimensi?n del array corresponde al n?mero de grupo y la segunda
|
||
383 | * a los elementos del grupo. El elemento del grupo con un acceso m?s reciente tendr?
|
||
384 | * un n?mero menor y el de mayor valor ser? el candidato para la sustituci?n en el pr?ximo
|
||
385 | * remplazamiento.
|
||
386 | * @return Array bidimensional con los valores de antig?edad.
|
||
387 | */
|
||
388 | public int[][] getLastAccess() { |
||
389 | return lastAccess;
|
||
390 | } |
||
391 | |||
392 | /**
|
||
393 | * Asigna un cero en la posici?n del array que contiene la antig?edad de acceso dentro
|
||
394 | * del grupo. Esta operaci?n se realiza cada vez que se accede a un dato del la p?gina
|
||
395 | * cacheada y significa que es la p?gina m?s recientemente accedida.
|
||
396 | * @param group N?mero de grupo
|
||
397 | * @param posInGroup Posici?n de la p?gina dentro del grupo.
|
||
398 | */
|
||
399 | public void setZeroInLastAccess(int group, int posInGroup) { |
||
400 | lastAccess[group][posInGroup] = 0;
|
||
401 | } |
||
402 | |||
403 | /**
|
||
404 | * Obtiene el n?mero de p?gina cargada en el buffer
|
||
405 | * @return Entero con el n?mero de p?gina
|
||
406 | */
|
||
407 | public int getNumberInAccessPage() { |
||
408 | return numberInAccessPage;
|
||
409 | } |
||
410 | |||
411 | /**
|
||
412 | * Obtiene el n?mero de p?ginas que tiene cada grupo
|
||
413 | * @return Entero con el n?mero de p?ginas por grupo
|
||
414 | */
|
||
415 | public int getPagsPerGroup() { |
||
416 | return cacheStruct.getPagsPerGroup();
|
||
417 | } |
||
418 | |||
419 | /**
|
||
420 | * Obtiene la p?gina de datos de la posici?n pag
|
||
421 | * @param pag N?mero de p?gina de cach? a recuperar
|
||
422 | * @return PageBuffer correspondiente a la p?gina recuperada
|
||
423 | */
|
||
424 | public PageBuffer getPageBufferFromNumberCachePage(int pag) { |
||
425 | return page[pag];
|
||
426 | } |
||
427 | |||
428 | /**
|
||
429 | * Obtiene la p?gina de datos a partir del n?mero de p?gina de raster
|
||
430 | * @param pag N?mero de p?gina raster a recuperar
|
||
431 | * @return PageBuffer correspondiente a la p?gina recuperada o null si no est? en cach?
|
||
432 | */
|
||
433 | public PageBuffer getPageBufferFromNumberRasterPage(int pag) { |
||
434 | int group = pag % getNGroups();
|
||
435 | for(int i = 0; i < getPagsPerGroup(); i++) |
||
436 | if(pageNumberInCache[group * getPagsPerGroup() + i] == pag)
|
||
437 | return page[group * getPagsPerGroup() + i];
|
||
438 | return null; |
||
439 | } |
||
440 | |||
441 | /**
|
||
442 | * Obtiene la p?gina de datos del grupo definido en el par?metro group y de la
|
||
443 | * posici?n pag dentro de ese grupo.
|
||
444 | * @param group Grupo de la p?gina requerida
|
||
445 | * @param pag N?mero de p?gina dentro del grupo
|
||
446 | * @return PageBuffer correspondiente a la p?gina recuperada
|
||
447 | */
|
||
448 | public PageBuffer getPageBuffer(int group, int posInGroup) { |
||
449 | return page[group * getPagsPerGroup() + posInGroup];
|
||
450 | } |
||
451 | |||
452 | /**
|
||
453 | * Obtiene la p?gina de datos actualmente accedida
|
||
454 | * @return PageBuffer correspondiente a la p?gina que se est? accediendo
|
||
455 | */
|
||
456 | public PageBuffer getAccessPage() {
|
||
457 | return accessPage;
|
||
458 | } |
||
459 | |||
460 | /**
|
||
461 | * Asigna el buffer de la p?gina accedida por referencia
|
||
462 | * @param pb
|
||
463 | */
|
||
464 | public void setAccessPage(PageBuffer pb, int pagNumber) { |
||
465 | accessPage = pb; |
||
466 | numberInAccessPage = pagNumber; |
||
467 | } |
||
468 | |||
469 | /**
|
||
470 | * Consulta si una p?gina de cach? ha sido modificada desde que se carg? en cach? o no.
|
||
471 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
472 | * @return true si ha sido modificada y false si no lo ha sido.
|
||
473 | */
|
||
474 | public boolean isModified(int nCachePag) { |
||
475 | return modified[nCachePag];
|
||
476 | } |
||
477 | |||
478 | /**
|
||
479 | * Consulta si una p?gina de cach? ha sido modificada desde que se carg? en cach? o no.
|
||
480 | * @param group Grupo en el que se encuentra la p?gina
|
||
481 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
482 | * @return true si ha sido modificada y false si no lo ha sido.
|
||
483 | */
|
||
484 | public boolean isModified(int group, int posInGroup) { |
||
485 | return modified[group * getPagsPerGroup() + posInGroup];
|
||
486 | } |
||
487 | |||
488 | /**
|
||
489 | * Pone como modificada una p?gina de cach?
|
||
490 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
491 | */
|
||
492 | public void setModify(int nCachePag) { |
||
493 | modified[nCachePag] = true;
|
||
494 | } |
||
495 | |||
496 | /**
|
||
497 | * Pone como modificada una p?gina de cach?
|
||
498 | * @param group Grupo en el que se encuentra la p?gina
|
||
499 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
500 | */
|
||
501 | public void setModify(int group, int posInGroup) { |
||
502 | modified[group * getPagsPerGroup() + posInGroup] = true;
|
||
503 | } |
||
504 | |||
505 | /**
|
||
506 | * Pone como no modificada una p?gina de cach?
|
||
507 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
508 | */
|
||
509 | public void unsetModify(int nCachePag) { |
||
510 | modified[nCachePag] = false;
|
||
511 | } |
||
512 | |||
513 | /**
|
||
514 | * Pone como no modificada una p?gina de cach?
|
||
515 | * @param group Grupo en el que se encuentra la p?gina
|
||
516 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
517 | */
|
||
518 | public void unsetModify(int group, int posInGroup) { |
||
519 | modified[group * getPagsPerGroup() + posInGroup] = false;
|
||
520 | } |
||
521 | |||
522 | /**
|
||
523 | * Obtiene el n?mero de p?ginas de la cach?
|
||
524 | * @return N?mero total de p?ginas de la cach?
|
||
525 | */
|
||
526 | public int getNPags() { |
||
527 | return cacheStruct.getNPags();
|
||
528 | } |
||
529 | |||
530 | /**
|
||
531 | * Obtiene el n?mero de bandas
|
||
532 | * @return N?mero de bandas
|
||
533 | */
|
||
534 | public int getNBands() { |
||
535 | return cacheStruct.getNBands();
|
||
536 | } |
||
537 | |||
538 | /**
|
||
539 | * Obtiene la estructura de ca cach?
|
||
540 | * @return CacheStruct
|
||
541 | */
|
||
542 | public CacheStruct getCacheStruct() {
|
||
543 | return cacheStruct;
|
||
544 | } |
||
545 | |||
546 | /**
|
||
547 | * Asigna la estructura de ca cach?
|
||
548 | * @param CacheStruct
|
||
549 | */
|
||
550 | public void setCacheStruct(CacheStruct cacheStruct) { |
||
551 | this.cacheStruct = cacheStruct;
|
||
552 | } |
||
553 | |||
554 | /**
|
||
555 | * Obtiene el n?mero de grupos de cach?
|
||
556 | * @return N?mero de grupos
|
||
557 | */
|
||
558 | public int getNGroups() { |
||
559 | return cacheStruct.getNGroups();
|
||
560 | } |
||
561 | |||
562 | /**
|
||
563 | * Obtiene el n?mero total de p?ginas del raster
|
||
564 | * @return N?mero total de p?ginas
|
||
565 | */
|
||
566 | public int getNTotalPags() { |
||
567 | return cacheStruct.getNTotalPags();
|
||
568 | } |
||
569 | |||
570 | /**
|
||
571 | * Obtiene el array con los n?meros de p?gina que hay cargados
|
||
572 | * en cada bloque de cache
|
||
573 | * @return array con los n?mero de p?gina
|
||
574 | */
|
||
575 | public int[] getPageNumberInCache() { |
||
576 | return this.pageNumberInCache; |
||
577 | } |
||
578 | |||
579 | /**
|
||
580 | * Para extraer el desplazamiento de una direcci?n (l?nea de raster) hay que hacer una operaci?n And con
|
||
581 | * con la altura de la p?gina -1. Por ejemplo, una p?gina de 16 l?neas de altura el desplazamiento ser?
|
||
582 | * 16 - 1 = 15 porque 15 en binario es 1111.
|
||
583 | *
|
||
584 | * Si queremos acceder a la linea del raster n?mero 83 (1010011) realizando la operaci?n And con el valor del
|
||
585 | * desplazamiento obtenemos (0001111 & 1010011 = 0000011), es decir el valor 3 en decimal. Esto quiere decir
|
||
586 | * que la l?nea 83 del raster es la 3 de su p?gina.
|
||
587 | * @return valor del desplazamiento
|
||
588 | */
|
||
589 | public int getOffset() { |
||
590 | return cacheStruct.getOffset();
|
||
591 | } |
||
592 | |||
593 | /**
|
||
594 | * Convierte una p?gina dentro de un grupo de la cach? en un n?mero de
|
||
595 | * p?gina de cach?. Por ejemplo, en una cach? de 10 grupos y 5 p?ginas por grupo
|
||
596 | * la p?gina 2 del grupo 4 devolver? el 23 (5 * 4 + 3 = 23) teniendo en cuenta que
|
||
597 | * la p?gina y el grupo cero tambi?n cuentan.
|
||
598 | * @param group
|
||
599 | * @param pageInGroup
|
||
600 | * @return
|
||
601 | */
|
||
602 | public int convertPageInGroupToPageInCache(int group, int pageInGroup) { |
||
603 | return (group * cacheStruct.getPagsPerGroup() + pageInGroup);
|
||
604 | } |
||
605 | |||
606 | /**
|
||
607 | * Actualiza los ?ltimos accesos del grupo pasado por par?metro. Se incrementar?
|
||
608 | * uno en todas las p?ginas del conjunto a excepci?n de las que valen -1 ya que
|
||
609 | * esto significa que no hay p?gina cargada en dicha posici?n.
|
||
610 | * @param group N?mero de grupo a actualizar sus accesos
|
||
611 | * @return La posici?n del elemento del grupo con valor m?ximo. Este elemento
|
||
612 | * es el candidato para el reemplazo.
|
||
613 | */
|
||
614 | public int updateLastAccess(int group) { |
||
615 | int max = Integer.MIN_VALUE; |
||
616 | int posMax = 0; |
||
617 | for(int i = 0; i < getPagsPerGroup(); i++) { |
||
618 | if(getLastAccess()[group][i] >= 0) |
||
619 | getLastAccess()[group][i] ++; |
||
620 | |||
621 | if(getLastAccess()[group][i] > max) {
|
||
622 | max = getLastAccess()[group][i]; |
||
623 | posMax = i; |
||
624 | } |
||
625 | } |
||
626 | return posMax;
|
||
627 | } |
||
628 | |||
629 | /**
|
||
630 | * Obtiene la posici?n del grupo de la p?gina a reemplazar, es decir la de m?ximo valor
|
||
631 | * en el vector lastAccess.
|
||
632 | * @param group N?mero de grupo a obtener la p?gina de reemplazo
|
||
633 | * @return La posici?n del elemento del grupo con valor m?ximo. Este elemento
|
||
634 | * es el candidato para el reemplazo.
|
||
635 | */
|
||
636 | public int posInGroupPagToReplace(int group) { |
||
637 | int max = Integer.MIN_VALUE; |
||
638 | int posMax = 0; |
||
639 | for(int i = 0; i < getPagsPerGroup(); i++) { |
||
640 | if(getLastAccess()[group][i] > max) {
|
||
641 | max = getLastAccess()[group][i]; |
||
642 | posMax = i; |
||
643 | } |
||
644 | } |
||
645 | return posMax;
|
||
646 | } |
||
647 | |||
648 | /**
|
||
649 | * Carga una p?gina especificada en el par?metro nPag con los datos necesarios. La
|
||
650 | * petici?n que ha de hacerse se calcula previamente con la estructura de la cach?.
|
||
651 | *
|
||
652 | * @param group Grupo sobre el que se carga la p?gina nPag
|
||
653 | * @param posInGroupPageToReplace Posici?n dentro del grupo sobre el que se carga la p?gina
|
||
654 | * @param nPag P?gina a cargar
|
||
655 | */
|
||
656 | public void loadPage(int group, int posInGroupPageToReplace, int nPag) { |
||
657 | page[group * getPagsPerGroup() + posInGroupPageToReplace].loadPage(nPag); |
||
658 | } |
||
659 | |||
660 | /**
|
||
661 | * Salva una p?gina especificada en el par?metro nPag a disco. La
|
||
662 | * petici?n que ha de hacerse se calcula previamente con la estructura de la cach?.
|
||
663 | *
|
||
664 | * @param group Grupo del que se salva la p?gina nPag
|
||
665 | * @param posInGroupPageToReplace Posici?n dentro del grupo del que se salva la p?gina
|
||
666 | * @param nPag P?gina a salvar
|
||
667 | * @throws IOException
|
||
668 | */
|
||
669 | public void savePage(int group, int posInGroupPageToReplace, int nPag) throws IOException { |
||
670 | page[group * getPagsPerGroup() + posInGroupPageToReplace].savePage(nPag); |
||
671 | } |
||
672 | |||
673 | /**
|
||
674 | * Salva a disco todas las p?ginas en memoria cach? e inicializa estructuras de datos.
|
||
675 | *
|
||
676 | * @throws IOException
|
||
677 | */
|
||
678 | public void resetCache() throws IOException { |
||
679 | for (int iCachePage = 0; iCachePage < page.length; iCachePage++) { |
||
680 | if(modified[iCachePage])
|
||
681 | page[iCachePage].savePage(this.getRasterPageNumberInPosition(iCachePage));
|
||
682 | } |
||
683 | initStructs(); |
||
684 | } |
||
685 | |||
686 | /**
|
||
687 | * Elimina una banda de la cach?. Antes salva a disco todos los trozos cacheados e inicializa
|
||
688 | * las estructuras de control de cach?.
|
||
689 | * @param nBand N?mero de banda a eliminar
|
||
690 | * @throws IOException
|
||
691 | */
|
||
692 | public void deleteBand(int nBand) throws IOException { |
||
693 | resetCache(); |
||
694 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
695 | hddPage[iPage].deleteBand(nBand); |
||
696 | } |
||
697 | |||
698 | /**
|
||
699 | * Asigna una banda de disco a todas las p?ginas.
|
||
700 | * @param cacheDataSource Fuente de las p?ginas. Es la referencia a disco de ellas.
|
||
701 | * @throws IOException
|
||
702 | */
|
||
703 | public void assignBand(int nBand, ICacheDataSource[] cacheDataSource) throws IOException { |
||
704 | resetCache(); |
||
705 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
706 | hddPage[iPage].assignBand(nBand, cacheDataSource[iPage]); |
||
707 | } |
||
708 | |||
709 | /**
|
||
710 | * Obtiene la fuente de datos de una banda de una p?gina de disco.
|
||
711 | * @param nPage P?gina de la que se quiere la banda
|
||
712 | * @param nBand Banda de la que se quiere la fuente de datos
|
||
713 | * @return HddPage
|
||
714 | */
|
||
715 | public ICacheDataSource getHddPage(int nPage, int nBand) { |
||
716 | return hddPage[nPage].getBandDataSource(nBand);
|
||
717 | } |
||
718 | |||
719 | /**
|
||
720 | * Consulta si alguna p?gina de memoria tiene modificaciones para volcar a disco
|
||
721 | * @return true si hay alguna p?gina con modificaciones y false si no la hay
|
||
722 | */
|
||
723 | public boolean anyPageModified() { |
||
724 | for (int iPage = 0; iPage < modified.length; iPage++) { |
||
725 | if(modified[iPage])
|
||
726 | return true; |
||
727 | } |
||
728 | return false; |
||
729 | } |
||
730 | |||
731 | /**
|
||
732 | * Imprime la informaci?n de estructura de cach?
|
||
733 | */
|
||
734 | public void show() { |
||
735 | cacheStruct.show(); |
||
736 | System.out.println("Cacheada:"); |
||
737 | for(int i = 0; i < cacheada.length; i++) |
||
738 | System.out.print(i + "=" + cacheada[i]+" "); |
||
739 | System.out.println();
|
||
740 | System.out.println("LastAccess:"); |
||
741 | for(int i = 0; i < cacheStruct.getNGroups(); i++) { |
||
742 | System.out.println("Grupo " + i +":"); |
||
743 | for(int j = 0; j < cacheStruct.getPagsPerGroup(); j++) |
||
744 | System.out.println("elem " + j + " : " + "Page " + pageNumberInCache[i * cacheStruct.getPagsPerGroup() + j] + " : " + lastAccess[i][j]); |
||
745 | |||
746 | } |
||
747 | } |
||
748 | |||
749 | } |