root / trunk / libraries / libRaster / src / org / gvsig / raster / dataaccess / cache / Cache.java @ 10960
History | View | Annotate | Download (24.8 KB)
| 1 | 10740 | 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.dataaccess.cache; |
||
| 21 | |||
| 22 | 10759 | nacho | import java.io.File; |
| 23 | import java.io.FileNotFoundException; |
||
| 24 | 10740 | nacho | import java.io.IOException; |
| 25 | |||
| 26 | 10939 | nacho | import org.gvsig.raster.dataset.NotSupportedExtensionException; |
| 27 | import org.gvsig.raster.dataset.RasterDataset; |
||
| 28 | import org.gvsig.raster.dataset.RasterDriverException; |
||
| 29 | 10759 | nacho | import org.gvsig.raster.shared.Extent; |
| 30 | |||
| 31 | 10740 | nacho | /**
|
| 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 | */
|
||
| 117 | 10759 | nacho | public Cache(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight, String filePath) throws FileNotFoundException, NotSupportedExtensionException, RasterDriverException{ |
| 118 | File file = new File(filePath); |
||
| 119 | if(!file.exists())
|
||
| 120 | throw new FileNotFoundException("I can't make read only cache structure."); |
||
| 121 | |||
| 122 | init(nBands, dataType, dataSourceWidth, dataSourceHeight); |
||
| 123 | |||
| 124 | 10792 | nacho | //Creamos las estructuras de las p?ginas de disco
|
| 125 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
| 126 | |||
| 127 | 10759 | nacho | RasterDataset dataset = RasterDataset.openFile(null, filePath);
|
| 128 | Extent[] extentList = calcExtentPages(dataset, hddPage.length);
|
||
| 129 | |||
| 130 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
| 131 | hddPage[iPage] = new HddPage(iPage, dataset, extentList[iPage]);
|
||
| 132 | |||
| 133 | //Creamos las p?ginas de memoria
|
||
| 134 | for(int i = 0; i < cacheStruct.getNPags(); i++){ |
||
| 135 | page[i] = new PageBuffer(dataType, dataSourceWidth, cacheStruct.getHPag(), nBands, true, i); |
||
| 136 | page[i].setHddPages(hddPage); |
||
| 137 | } |
||
| 138 | } |
||
| 139 | |||
| 140 | /**
|
||
| 141 | * Calcula la extensi?n de las p?ginas en coordenadas del mundo real
|
||
| 142 | * @param dataset Dataset
|
||
| 143 | * @param nPages N?mero de p?ginas en que se divide el raster
|
||
| 144 | * @return Extensi?n de cada p?gina
|
||
| 145 | */
|
||
| 146 | 10782 | nacho | private Extent[] calcExtentPages(RasterDataset dataset, int nPages) { |
| 147 | 10759 | nacho | Extent datasetExtent = dataset.getExtent(); |
| 148 | double h = cacheStruct.getHPag() * (dataset.getExtent().height() / dataset.getHeight());
|
||
| 149 | Extent[] ext = new Extent[nPages]; |
||
| 150 | |||
| 151 | double minX = datasetExtent.getMin().getX();
|
||
| 152 | double maxX = datasetExtent.getMax().getX();
|
||
| 153 | double maxY = datasetExtent.getMax().getY();
|
||
| 154 | double minY = maxY - h;
|
||
| 155 | for (int i = 0; i < ext.length; i++) { |
||
| 156 | ext[0] = new Extent(minX, maxY, maxX, minY); |
||
| 157 | maxY = minY; |
||
| 158 | minY -= h; |
||
| 159 | } |
||
| 160 | return ext;
|
||
| 161 | } |
||
| 162 | |||
| 163 | /**
|
||
| 164 | * Inicializamos la variables. Para ello creamos el objeto Cache que contendr? todos los
|
||
| 165 | * par?metros necesarios para crear el array que controla los accesos m?s recientes y el
|
||
| 166 | * array que dice si una p?gina est? en memoria o no.
|
||
| 167 | * @param nBands N?mero de bandas
|
||
| 168 | * @param dataType Tipo de dato de la p?gina
|
||
| 169 | * @param dataSourceWidth ancho de la fuente de datos
|
||
| 170 | */
|
||
| 171 | 10782 | nacho | public Cache(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight) { |
| 172 | 10759 | nacho | init(nBands, dataType, dataSourceWidth, dataSourceHeight); |
| 173 | |||
| 174 | //Creamos las estructuras de las p?ginas de disco
|
||
| 175 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
| 176 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
| 177 | hddPage[iPage] = new HddPage(iPage, getNBands());
|
||
| 178 | |||
| 179 | //Creamos las p?ginas de memoria
|
||
| 180 | for(int i = 0; i < cacheStruct.getNPags(); i++){ |
||
| 181 | page[i] = new PageBuffer(dataType, dataSourceWidth, cacheStruct.getHPag(), nBands, true, i); |
||
| 182 | page[i].setHddPages(hddPage); |
||
| 183 | } |
||
| 184 | } |
||
| 185 | |||
| 186 | 10782 | nacho | /**
|
| 187 | 10785 | nacho | * Contructor
|
| 188 | * @param cacheStruct
|
||
| 189 | */
|
||
| 190 | public Cache(CacheStruct cacheStruct, int dataSourceWidth) { |
||
| 191 | this.cacheStruct = cacheStruct;
|
||
| 192 | |||
| 193 | //Inicializamos la antig?edad de acceso
|
||
| 194 | lastAccess = new int[cacheStruct.getNGroups()][cacheStruct.getPagsPerGroup()]; |
||
| 195 | |||
| 196 | //Creamos el buffer de la cach?
|
||
| 197 | page = new PageBuffer[cacheStruct.getNPags()];
|
||
| 198 | pageNumberInCache = new int[cacheStruct.getNPags()]; |
||
| 199 | modified = new boolean[cacheStruct.getNPags()]; |
||
| 200 | cacheada = new boolean[cacheStruct.getNTotalPags()]; |
||
| 201 | |||
| 202 | //Creamos las estructuras de las p?ginas de disco
|
||
| 203 | hddPage = new HddPage[cacheStruct.getNTotalPags()];
|
||
| 204 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
| 205 | hddPage[iPage] = new HddPage(iPage, getNBands());
|
||
| 206 | |||
| 207 | //Creamos las p?ginas de memoria
|
||
| 208 | for(int i = 0; i < cacheStruct.getNPags(); i++) { |
||
| 209 | page[i] = new PageBuffer(cacheStruct.getDataType(), dataSourceWidth, cacheStruct.getHPag(), cacheStruct.getNBands(), true, i); |
||
| 210 | page[i].setHddPages(hddPage); |
||
| 211 | } |
||
| 212 | |||
| 213 | initStructs(); |
||
| 214 | } |
||
| 215 | |||
| 216 | /**
|
||
| 217 | 10782 | nacho | *
|
| 218 | * @param nBands
|
||
| 219 | * @param dataType
|
||
| 220 | * @param dataSourceWidth
|
||
| 221 | * @param dataSourceHeight
|
||
| 222 | */
|
||
| 223 | private void init(int nBands, int dataType, int dataSourceWidth, int dataSourceHeight) { |
||
| 224 | 10740 | nacho | //Creamos la estructura de la cach?
|
| 225 | cacheStruct = new CacheStruct(nBands, dataType, dataSourceWidth, dataSourceHeight);
|
||
| 226 | |||
| 227 | //Inicializamos la antig?edad de acceso
|
||
| 228 | lastAccess = new int[cacheStruct.getNGroups()][cacheStruct.getPagsPerGroup()]; |
||
| 229 | |||
| 230 | //Creamos el buffer de la cach?
|
||
| 231 | page = new PageBuffer[cacheStruct.getNPags()];
|
||
| 232 | pageNumberInCache = new int[cacheStruct.getNPags()]; |
||
| 233 | modified = new boolean[cacheStruct.getNPags()]; |
||
| 234 | cacheada = new boolean[cacheStruct.getNTotalPags()]; |
||
| 235 | 10781 | nacho | |
| 236 | this.initStructs();
|
||
| 237 | } |
||
| 238 | |||
| 239 | /**
|
||
| 240 | * Inicializa las estructuras de mantenimiento de cach?. Estas son array de paginas
|
||
| 241 | * accedidas por ?ltima vez, numeros de p?gina cargadas en cada posici?n de cach?,
|
||
| 242 | * array con la informaci?n de p?gina modificada y array que dice si una p?gina de disco
|
||
| 243 | * est? cacheada o no.
|
||
| 244 | */
|
||
| 245 | 10782 | nacho | private void initStructs() { |
| 246 | 10781 | nacho | for(int i = 0; i < cacheStruct.getNGroups(); i ++) |
| 247 | for(int j = 0; j < cacheStruct.getPagsPerGroup(); j ++) |
||
| 248 | lastAccess[i][j] = -1;
|
||
| 249 | |||
| 250 | 10740 | nacho | for(int i = 0; i < cacheada.length; i++) |
| 251 | cacheada[i] = false;
|
||
| 252 | 10781 | nacho | |
| 253 | for(int i = 0; i < cacheStruct.getNPags(); i++){ |
||
| 254 | pageNumberInCache[i] = -1;
|
||
| 255 | modified[i] = false;
|
||
| 256 | } |
||
| 257 | 10740 | nacho | } |
| 258 | 10781 | nacho | |
| 259 | 10740 | nacho | /**
|
| 260 | * Obtiene el n?mero de bits por p?gina para poder calcular el desplazamiento binario
|
||
| 261 | * de la direcci?n de acceso de la petici?n. Es decir si se solicita un dato en la l?nea
|
||
| 262 | * 36 (en decimal) del raster 100100(en binario) y el desplazamiento es 4 bits el n?mero de
|
||
| 263 | * p?gina resultante ser? 10(en binario) 2 (en decimal)
|
||
| 264 | * @return
|
||
| 265 | */
|
||
| 266 | public int getBitsPag() { |
||
| 267 | return cacheStruct.getBitsPag();
|
||
| 268 | } |
||
| 269 | |||
| 270 | /**
|
||
| 271 | * Obtiene la altura de la p?gina de cache en l?neas.
|
||
| 272 | * @return N?mero de l?neas de altura de p?gina.
|
||
| 273 | */
|
||
| 274 | public int getHPag() { |
||
| 275 | return cacheStruct.getHPag();
|
||
| 276 | } |
||
| 277 | |||
| 278 | /**
|
||
| 279 | * Array de booleanos donde cada elemento es una p?gina del raster y dice si la p?gina
|
||
| 280 | * est? cacheada o no.
|
||
| 281 | * @return true si la p?gina est? en cach? y false si no lo est?
|
||
| 282 | */
|
||
| 283 | public boolean isInCache(int nPag) { |
||
| 284 | if(nPag < 0 || nPag >= cacheada.length) |
||
| 285 | return false; |
||
| 286 | return cacheada[nPag];
|
||
| 287 | } |
||
| 288 | |||
| 289 | /**
|
||
| 290 | * Marca una p?gina como cargada en cach?.
|
||
| 291 | * @param nPag N?mero de p?gina a marcar.
|
||
| 292 | */
|
||
| 293 | 10782 | nacho | public void setPageAsLoadInCache(int nPag) { |
| 294 | 10740 | nacho | if(nPag < 0 || nPag >= cacheada.length) |
| 295 | return;
|
||
| 296 | cacheada[nPag] = true;
|
||
| 297 | } |
||
| 298 | |||
| 299 | /**
|
||
| 300 | * Desmarca una p?gina como cargada en cach?.
|
||
| 301 | * @param nPag N?mero de p?gina a desmarcar.
|
||
| 302 | */
|
||
| 303 | 10782 | nacho | public void setPageAsNotLoadInCache(int nPag) { |
| 304 | 10740 | nacho | if(nPag < 0 || nPag >= cacheada.length) |
| 305 | return;
|
||
| 306 | cacheada[nPag] = false;
|
||
| 307 | } |
||
| 308 | |||
| 309 | /**
|
||
| 310 | * Obtiene el n?mero de p?gina del raster cargada en una p?gina de cach? especificada
|
||
| 311 | * en el par?metro.
|
||
| 312 | * @param nCachePage N?mero de p?gina de cach? de la que se quiere saber que p?gina del
|
||
| 313 | * raster hay cargada.
|
||
| 314 | * @return N?mero de p?gina del raster
|
||
| 315 | */
|
||
| 316 | 10782 | nacho | public int getRasterPageNumberInPosition(int nCachePage) { |
| 317 | 10740 | nacho | return pageNumberInCache[nCachePage];
|
| 318 | } |
||
| 319 | |||
| 320 | /**
|
||
| 321 | * Obtiene el n?mero de p?gina del raster cargada en una p?gina de cach? especificada
|
||
| 322 | * en el par?metro.
|
||
| 323 | * @param group Grupo en el que se encuentra la p?gina
|
||
| 324 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
| 325 | * @return N?mero de p?gina del raster
|
||
| 326 | */
|
||
| 327 | 10782 | nacho | public int getRasterPageNumberInPosition(int group, int posInGroup) { |
| 328 | 10740 | nacho | return pageNumberInCache[group * getPagsPerGroup() + posInGroup];
|
| 329 | } |
||
| 330 | |||
| 331 | /**
|
||
| 332 | * Asigna el n?mero de p?gina del raster cargada en una p?gina de cach? especificada.
|
||
| 333 | * @param nCachePage N?mero de p?gina de cach?
|
||
| 334 | * @param nRasterPage N?mero de p?gina de raster a asignar
|
||
| 335 | */
|
||
| 336 | 10782 | nacho | public void setRasterPageNumberInPosition(int nCachePage, int nRasterPage) { |
| 337 | 10740 | nacho | pageNumberInCache[nCachePage] = nRasterPage; |
| 338 | } |
||
| 339 | |||
| 340 | /**
|
||
| 341 | * Asigna el n?mero de p?gina del raster cargada en una p?gina de cach? especificada.
|
||
| 342 | * @param nCachePage N?mero de p?gina de cach?
|
||
| 343 | * @param nRasterPage N?mero de p?gina de raster a asignar
|
||
| 344 | */
|
||
| 345 | 10782 | nacho | public void setRasterPageNumberInPosition(int group, int posInGroup, int nRasterPage) { |
| 346 | 10740 | nacho | pageNumberInCache[group * getPagsPerGroup() + posInGroup] = nRasterPage; |
| 347 | } |
||
| 348 | |||
| 349 | /**
|
||
| 350 | * Obtiene el n?mero de p?gina de cach? donde est? cargada la p?gina del raster
|
||
| 351 | * que se ha pasado por par?metro.
|
||
| 352 | * @param pag P?gina del raster
|
||
| 353 | * @return N?mero de p?gina del raster
|
||
| 354 | */
|
||
| 355 | 10782 | nacho | public int getNumberCachePageFromNumberRasterPage(int pag) { |
| 356 | int group = pag % getNGroups();
|
||
| 357 | 10740 | nacho | for(int i = 0; i < getPagsPerGroup(); i++) |
| 358 | if(pageNumberInCache[group + i] == pag)
|
||
| 359 | return (group * getPagsPerGroup() + i);
|
||
| 360 | return -1; |
||
| 361 | } |
||
| 362 | |||
| 363 | /**
|
||
| 364 | * Obtiene el n?mero de p?gina de cach? (en formato grupo/p?gina dentro del grupo)
|
||
| 365 | * donde est? cargada la p?gina del raster que se ha pasado por par?metro.
|
||
| 366 | * @param pag P?gina del raster
|
||
| 367 | * @return N?mero de p?gina del raster
|
||
| 368 | */
|
||
| 369 | 10782 | nacho | public int[] getNumberGroupFromNumberRasterPage(int pag) { |
| 370 | 10740 | nacho | int group = pag % getNGroups();
|
| 371 | for(int i = 0; i < getPagsPerGroup(); i++) |
||
| 372 | if(pageNumberInCache[(group * getPagsPerGroup()) + i] == pag)
|
||
| 373 | return new int[]{group, i}; |
||
| 374 | return null; |
||
| 375 | } |
||
| 376 | |||
| 377 | /**
|
||
| 378 | * Obtiene el array que contiene los valores de la antig?edad del acceso dentro del
|
||
| 379 | * grupo. La primera dimensi?n del array corresponde al n?mero de grupo y la segunda
|
||
| 380 | * a los elementos del grupo. El elemento del grupo con un acceso m?s reciente tendr?
|
||
| 381 | * un n?mero menor y el de mayor valor ser? el candidato para la sustituci?n en el pr?ximo
|
||
| 382 | * remplazamiento.
|
||
| 383 | * @return Array bidimensional con los valores de antig?edad.
|
||
| 384 | */
|
||
| 385 | public int[][] getLastAccess() { |
||
| 386 | return lastAccess;
|
||
| 387 | } |
||
| 388 | |||
| 389 | /**
|
||
| 390 | * Asigna un cero en la posici?n del array que contiene la antig?edad de acceso dentro
|
||
| 391 | * del grupo. Esta operaci?n se realiza cada vez que se accede a un dato del la p?gina
|
||
| 392 | * cacheada y significa que es la p?gina m?s recientemente accedida.
|
||
| 393 | * @param group N?mero de grupo
|
||
| 394 | * @param posInGroup Posici?n de la p?gina dentro del grupo.
|
||
| 395 | */
|
||
| 396 | 10782 | nacho | public void setZeroInLastAccess(int group, int posInGroup) { |
| 397 | 10740 | nacho | lastAccess[group][posInGroup] = 0;
|
| 398 | } |
||
| 399 | |||
| 400 | /**
|
||
| 401 | * Obtiene el n?mero de p?gina cargada en el buffer
|
||
| 402 | * @return Entero con el n?mero de p?gina
|
||
| 403 | */
|
||
| 404 | public int getNumberInAccessPage() { |
||
| 405 | return numberInAccessPage;
|
||
| 406 | } |
||
| 407 | |||
| 408 | /**
|
||
| 409 | * Obtiene el n?mero de p?ginas que tiene cada grupo
|
||
| 410 | * @return Entero con el n?mero de p?ginas por grupo
|
||
| 411 | */
|
||
| 412 | public int getPagsPerGroup() { |
||
| 413 | return cacheStruct.getPagsPerGroup();
|
||
| 414 | } |
||
| 415 | |||
| 416 | /**
|
||
| 417 | * Obtiene la p?gina de datos de la posici?n pag
|
||
| 418 | * @param pag N?mero de p?gina de cach? a recuperar
|
||
| 419 | * @return PageBuffer correspondiente a la p?gina recuperada
|
||
| 420 | */
|
||
| 421 | public PageBuffer getPageBufferFromNumberCachePage(int pag) { |
||
| 422 | return page[pag];
|
||
| 423 | } |
||
| 424 | |||
| 425 | /**
|
||
| 426 | * Obtiene la p?gina de datos a partir del n?mero de p?gina de raster
|
||
| 427 | * @param pag N?mero de p?gina raster a recuperar
|
||
| 428 | * @return PageBuffer correspondiente a la p?gina recuperada o null si no est? en cach?
|
||
| 429 | */
|
||
| 430 | public PageBuffer getPageBufferFromNumberRasterPage(int pag) { |
||
| 431 | int group = pag % getNGroups();
|
||
| 432 | for(int i = 0; i < getPagsPerGroup(); i++) |
||
| 433 | if(pageNumberInCache[group * getPagsPerGroup() + i] == pag)
|
||
| 434 | return page[group * getPagsPerGroup() + i];
|
||
| 435 | return null; |
||
| 436 | } |
||
| 437 | |||
| 438 | /**
|
||
| 439 | * Obtiene la p?gina de datos del grupo definido en el par?metro group y de la
|
||
| 440 | * posici?n pag dentro de ese grupo.
|
||
| 441 | * @param group Grupo de la p?gina requerida
|
||
| 442 | * @param pag N?mero de p?gina dentro del grupo
|
||
| 443 | * @return PageBuffer correspondiente a la p?gina recuperada
|
||
| 444 | */
|
||
| 445 | public PageBuffer getPageBuffer(int group, int posInGroup) { |
||
| 446 | return page[group * getPagsPerGroup() + posInGroup];
|
||
| 447 | } |
||
| 448 | |||
| 449 | /**
|
||
| 450 | * Obtiene la p?gina de datos actualmente accedida
|
||
| 451 | * @return PageBuffer correspondiente a la p?gina que se est? accediendo
|
||
| 452 | */
|
||
| 453 | public PageBuffer getAccessPage() {
|
||
| 454 | return accessPage;
|
||
| 455 | } |
||
| 456 | |||
| 457 | /**
|
||
| 458 | * Asigna el buffer de la p?gina accedida por referencia
|
||
| 459 | * @param pb
|
||
| 460 | */
|
||
| 461 | public void setAccessPage(PageBuffer pb, int pagNumber){ |
||
| 462 | accessPage = pb; |
||
| 463 | numberInAccessPage = pagNumber; |
||
| 464 | } |
||
| 465 | |||
| 466 | /**
|
||
| 467 | * Consulta si una p?gina de cach? ha sido modificada desde que se carg? en cach? o no.
|
||
| 468 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
| 469 | * @return true si ha sido modificada y false si no lo ha sido.
|
||
| 470 | */
|
||
| 471 | public boolean isModified(int nCachePag){ |
||
| 472 | return modified[nCachePag];
|
||
| 473 | } |
||
| 474 | |||
| 475 | /**
|
||
| 476 | * Consulta si una p?gina de cach? ha sido modificada desde que se carg? en cach? o no.
|
||
| 477 | * @param group Grupo en el que se encuentra la p?gina
|
||
| 478 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
| 479 | * @return true si ha sido modificada y false si no lo ha sido.
|
||
| 480 | */
|
||
| 481 | public boolean isModified(int group, int posInGroup){ |
||
| 482 | return modified[group * getPagsPerGroup() + posInGroup];
|
||
| 483 | } |
||
| 484 | |||
| 485 | /**
|
||
| 486 | * Pone como modificada una p?gina de cach?
|
||
| 487 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
| 488 | */
|
||
| 489 | public void setModify(int nCachePag){ |
||
| 490 | modified[nCachePag] = true;
|
||
| 491 | } |
||
| 492 | |||
| 493 | /**
|
||
| 494 | * Pone como modificada una p?gina de cach?
|
||
| 495 | * @param group Grupo en el que se encuentra la p?gina
|
||
| 496 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
| 497 | */
|
||
| 498 | public void setModify(int group, int posInGroup){ |
||
| 499 | modified[group * getPagsPerGroup() + posInGroup] = true;
|
||
| 500 | } |
||
| 501 | |||
| 502 | /**
|
||
| 503 | * Pone como no modificada una p?gina de cach?
|
||
| 504 | * @param nCachePag N?mero de p?gina de cach? (posici?n de esta)
|
||
| 505 | */
|
||
| 506 | public void unsetModify(int nCachePag){ |
||
| 507 | modified[nCachePag] = false;
|
||
| 508 | } |
||
| 509 | |||
| 510 | /**
|
||
| 511 | * Pone como no modificada una p?gina de cach?
|
||
| 512 | * @param group Grupo en el que se encuentra la p?gina
|
||
| 513 | * @param posInGroup Posici?n dentro del grupo en el que est? la p?gina
|
||
| 514 | */
|
||
| 515 | public void unsetModify(int group, int posInGroup){ |
||
| 516 | modified[group * getPagsPerGroup() + posInGroup] = false;
|
||
| 517 | } |
||
| 518 | |||
| 519 | /**
|
||
| 520 | * Obtiene el n?mero de p?ginas de la cach?
|
||
| 521 | * @return N?mero total de p?ginas de la cach?
|
||
| 522 | */
|
||
| 523 | public int getNPags() { |
||
| 524 | return cacheStruct.getNPags();
|
||
| 525 | } |
||
| 526 | |||
| 527 | /**
|
||
| 528 | * Obtiene el n?mero de bandas
|
||
| 529 | * @return N?mero de bandas
|
||
| 530 | */
|
||
| 531 | public int getNBands() { |
||
| 532 | return cacheStruct.getNBands();
|
||
| 533 | } |
||
| 534 | |||
| 535 | /**
|
||
| 536 | * Obtiene la estructura de ca cach?
|
||
| 537 | * @return CacheStruct
|
||
| 538 | */
|
||
| 539 | public CacheStruct getCacheStruct() {
|
||
| 540 | return cacheStruct;
|
||
| 541 | } |
||
| 542 | |||
| 543 | /**
|
||
| 544 | 10785 | nacho | * Asigna la estructura de ca cach?
|
| 545 | * @param CacheStruct
|
||
| 546 | */
|
||
| 547 | public void setCacheStruct(CacheStruct cacheStruct) { |
||
| 548 | this.cacheStruct = cacheStruct;
|
||
| 549 | } |
||
| 550 | |||
| 551 | /**
|
||
| 552 | 10740 | nacho | * Obtiene el n?mero de grupos de cach?
|
| 553 | * @return N?mero de grupos
|
||
| 554 | */
|
||
| 555 | public int getNGroups() { |
||
| 556 | return cacheStruct.getNGroups();
|
||
| 557 | } |
||
| 558 | |||
| 559 | /**
|
||
| 560 | * Obtiene el n?mero total de p?ginas del raster
|
||
| 561 | * @return N?mero total de p?ginas
|
||
| 562 | */
|
||
| 563 | public int getNTotalPags() { |
||
| 564 | return cacheStruct.getNTotalPags();
|
||
| 565 | } |
||
| 566 | |||
| 567 | /**
|
||
| 568 | * Obtiene el array con los n?meros de p?gina que hay cargados
|
||
| 569 | * en cada bloque de cache
|
||
| 570 | * @return array con los n?mero de p?gina
|
||
| 571 | */
|
||
| 572 | public int[] getPageNumberInCache(){ |
||
| 573 | return this.pageNumberInCache; |
||
| 574 | } |
||
| 575 | |||
| 576 | /**
|
||
| 577 | * Para extraer el desplazamiento de una direcci?n (l?nea de raster) hay que hacer una operaci?n And con
|
||
| 578 | * con la altura de la p?gina -1. Por ejemplo, una p?gina de 16 l?neas de altura el desplazamiento ser?
|
||
| 579 | * 16 - 1 = 15 porque 15 en binario es 1111.
|
||
| 580 | *
|
||
| 581 | * Si queremos acceder a la linea del raster n?mero 83 (1010011) realizando la operaci?n And con el valor del
|
||
| 582 | * desplazamiento obtenemos (0001111 & 1010011 = 0000011), es decir el valor 3 en decimal. Esto quiere decir
|
||
| 583 | * que la l?nea 83 del raster es la 3 de su p?gina.
|
||
| 584 | * @return valor del desplazamiento
|
||
| 585 | */
|
||
| 586 | public int getOffset() { |
||
| 587 | return cacheStruct.getOffset();
|
||
| 588 | } |
||
| 589 | |||
| 590 | /**
|
||
| 591 | * Convierte una p?gina dentro de un grupo de la cach? en un n?mero de
|
||
| 592 | * p?gina de cach?. Por ejemplo, en una cach? de 10 grupos y 5 p?ginas por grupo
|
||
| 593 | * la p?gina 2 del grupo 4 devolver? el 23 (5 * 4 + 3 = 23) teniendo en cuenta que
|
||
| 594 | * la p?gina y el grupo cero tambi?n cuentan.
|
||
| 595 | * @param group
|
||
| 596 | * @param pageInGroup
|
||
| 597 | * @return
|
||
| 598 | */
|
||
| 599 | public int convertPageInGroupToPageInCache(int group, int pageInGroup){ |
||
| 600 | return (group * cacheStruct.getPagsPerGroup() + pageInGroup);
|
||
| 601 | } |
||
| 602 | |||
| 603 | /**
|
||
| 604 | * Actualiza los ?ltimos accesos del grupo pasado por par?metro. Se incrementar?
|
||
| 605 | * uno en todas las p?ginas del conjunto a excepci?n de las que valen -1 ya que
|
||
| 606 | * esto significa que no hay p?gina cargada en dicha posici?n.
|
||
| 607 | * @param group N?mero de grupo a actualizar sus accesos
|
||
| 608 | * @return La posici?n del elemento del grupo con valor m?ximo. Este elemento
|
||
| 609 | * es el candidato para el reemplazo.
|
||
| 610 | */
|
||
| 611 | public int updateLastAccess(int group){ |
||
| 612 | int max = Integer.MIN_VALUE; |
||
| 613 | int posMax = 0; |
||
| 614 | for(int i = 0; i < getPagsPerGroup(); i++){ |
||
| 615 | if(getLastAccess()[group][i] >= 0) |
||
| 616 | getLastAccess()[group][i] ++; |
||
| 617 | |||
| 618 | if(getLastAccess()[group][i] > max){
|
||
| 619 | max = getLastAccess()[group][i]; |
||
| 620 | posMax = i; |
||
| 621 | } |
||
| 622 | } |
||
| 623 | return posMax;
|
||
| 624 | } |
||
| 625 | |||
| 626 | /**
|
||
| 627 | * Obtiene la posici?n del grupo de la p?gina a reemplazar, es decir la de m?ximo valor
|
||
| 628 | * en el vector lastAccess.
|
||
| 629 | * @param group N?mero de grupo a obtener la p?gina de reemplazo
|
||
| 630 | * @return La posici?n del elemento del grupo con valor m?ximo. Este elemento
|
||
| 631 | * es el candidato para el reemplazo.
|
||
| 632 | */
|
||
| 633 | public int posInGroupPagToReplace(int group){ |
||
| 634 | int max = Integer.MIN_VALUE; |
||
| 635 | int posMax = 0; |
||
| 636 | for(int i = 0; i < getPagsPerGroup(); i++){ |
||
| 637 | if(getLastAccess()[group][i] > max){
|
||
| 638 | max = getLastAccess()[group][i]; |
||
| 639 | posMax = i; |
||
| 640 | } |
||
| 641 | } |
||
| 642 | return posMax;
|
||
| 643 | } |
||
| 644 | |||
| 645 | /**
|
||
| 646 | * Carga una p?gina especificada en el par?metro nPag con los datos necesarios. La
|
||
| 647 | * petici?n que ha de hacerse se calcula previamente con la estructura de la cach?.
|
||
| 648 | *
|
||
| 649 | * @param group Grupo sobre el que se carga la p?gina nPag
|
||
| 650 | * @param posInGroupPageToReplace Posici?n dentro del grupo sobre el que se carga la p?gina
|
||
| 651 | * @param nPag P?gina a cargar
|
||
| 652 | */
|
||
| 653 | public void loadPage(int group, int posInGroupPageToReplace, int nPag){ |
||
| 654 | page[group * getPagsPerGroup() + posInGroupPageToReplace].loadPage(nPag); |
||
| 655 | } |
||
| 656 | |||
| 657 | /**
|
||
| 658 | * Salva una p?gina especificada en el par?metro nPag a disco. La
|
||
| 659 | * petici?n que ha de hacerse se calcula previamente con la estructura de la cach?.
|
||
| 660 | *
|
||
| 661 | * @param group Grupo del que se salva la p?gina nPag
|
||
| 662 | * @param posInGroupPageToReplace Posici?n dentro del grupo del que se salva la p?gina
|
||
| 663 | * @param nPag P?gina a salvar
|
||
| 664 | * @throws IOException
|
||
| 665 | */
|
||
| 666 | 10782 | nacho | public void savePage(int group, int posInGroupPageToReplace, int nPag) throws IOException { |
| 667 | 10740 | nacho | page[group * getPagsPerGroup() + posInGroupPageToReplace].savePage(nPag); |
| 668 | } |
||
| 669 | |||
| 670 | /**
|
||
| 671 | 10781 | nacho | * Salva a disco todas las p?ginas en memoria cach? e inicializa estructuras de datos.
|
| 672 | 10740 | nacho | *
|
| 673 | * @throws IOException
|
||
| 674 | */
|
||
| 675 | 10782 | nacho | public void resetCache() throws IOException { |
| 676 | for (int iCachePage = 0; iCachePage < page.length; iCachePage++){ |
||
| 677 | if(modified[iCachePage])
|
||
| 678 | page[iCachePage].savePage(this.getRasterPageNumberInPosition(iCachePage));
|
||
| 679 | } |
||
| 680 | 10781 | nacho | initStructs(); |
| 681 | 10740 | nacho | } |
| 682 | |||
| 683 | /**
|
||
| 684 | 10781 | nacho | * Elimina una banda de la cach?. Antes salva a disco todos los trozos cacheados e inicializa
|
| 685 | * las estructuras de control de cach?.
|
||
| 686 | * @param nBand N?mero de banda a eliminar
|
||
| 687 | * @throws IOException
|
||
| 688 | */
|
||
| 689 | 10782 | nacho | public void deleteBand(int nBand) throws IOException { |
| 690 | 10781 | nacho | resetCache(); |
| 691 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
| 692 | hddPage[iPage].deleteBand(nBand); |
||
| 693 | } |
||
| 694 | |||
| 695 | /**
|
||
| 696 | * Asigna una banda de disco a todas las p?ginas.
|
||
| 697 | * @param cacheDataSource Fuente de las p?ginas. Es la referencia a disco de ellas.
|
||
| 698 | * @throws IOException
|
||
| 699 | */
|
||
| 700 | 10782 | nacho | public void assignBand(int nBand, ICacheDataSource[] cacheDataSource) throws IOException { |
| 701 | 10781 | nacho | resetCache(); |
| 702 | for (int iPage = 0; iPage < hddPage.length; iPage++) |
||
| 703 | hddPage[iPage].assignBand(nBand, cacheDataSource[iPage]); |
||
| 704 | } |
||
| 705 | |||
| 706 | /**
|
||
| 707 | 10782 | nacho | * Obtiene la fuente de datos de una banda de una p?gina de disco.
|
| 708 | * @param nPage P?gina de la que se quiere la banda
|
||
| 709 | * @param nBand Banda de la que se quiere la fuente de datos
|
||
| 710 | * @return HddPage
|
||
| 711 | */
|
||
| 712 | public ICacheDataSource getHddPage(int nPage, int nBand) { |
||
| 713 | return hddPage[nPage].getBandDataSource(nBand);
|
||
| 714 | } |
||
| 715 | |||
| 716 | /**
|
||
| 717 | * Consulta si alguna p?gina de memoria tiene modificaciones para volcar a disco
|
||
| 718 | * @return true si hay alguna p?gina con modificaciones y false si no la hay
|
||
| 719 | */
|
||
| 720 | public boolean anyPageModified(){ |
||
| 721 | for (int iPage = 0; iPage < modified.length; iPage++) { |
||
| 722 | if(modified[iPage])
|
||
| 723 | return true; |
||
| 724 | } |
||
| 725 | return false; |
||
| 726 | } |
||
| 727 | |||
| 728 | /**
|
||
| 729 | 10740 | nacho | * Imprime la informaci?n de estructura de cach?
|
| 730 | */
|
||
| 731 | 10782 | nacho | public void show() { |
| 732 | 10740 | nacho | cacheStruct.show(); |
| 733 | System.out.println("Cacheada:"); |
||
| 734 | for(int i = 0; i < cacheada.length; i++) |
||
| 735 | System.out.print(i + "=" + cacheada[i]+" "); |
||
| 736 | System.out.println();
|
||
| 737 | System.out.println("LastAccess:"); |
||
| 738 | for(int i = 0; i < cacheStruct.getNGroups(); i++){ |
||
| 739 | System.out.println("Grupo " + i +":"); |
||
| 740 | for(int j = 0; j < cacheStruct.getPagsPerGroup(); j++) |
||
| 741 | System.out.println("elem " + j + " : " + "Page " + pageNumberInCache[i * cacheStruct.getPagsPerGroup() + j] + " : " + lastAccess[i][j]); |
||
| 742 | |||
| 743 | } |
||
| 744 | } |
||
| 745 | |||
| 746 | } |