# Buffer Manager für Datenbank



## J~man (3. Dez 2009)

Hallo!

Freut mich, dass ich dieses Forum hier gefunden habe! Ich hoffe, dass ich hier einiges lernen kann :toll:

Zu diesem Zweck komme ich auch direkt mal mit meiner ersten Frage daher, wobei ich mir nicht sicher bin, ob die hier in der Datenbanksektion oder im Anfängerbereich besser aufgehoben wäre.

Also, folgende Aufgabe:
Ich soll einen "storage layer" für eine neue Datenbank schreiben. Dazu gehört u.a. auch, dass ich einen Buffer Manager schreiben soll, der den Buffer Pool steuert, dessen Größe bei der Datenbankinit. angegeben wird. Der Buffer Manager soll dabei LRU verwenden um Pages vom Speicher auf die Festplatte zu schreiben.
Hier ein paar Begrifferklärungen aus unseren Folien:


> bufferSize = size of buffer pool in pages
> Page frame: can hold single page in memory
> Buffer pool: collection of page frames
> Buffer manager: manages buffer pool



So, nun stellt sich mir natürlich die Frage, wie ich das am besten in Java hinkrieg. Dazu habe ich folgendes im Internet gefunden: java:lru-cache - Java Wiki
Dazu ein paar Fragen:
- was ist der load factor?
- jedes Mal wenn ich put mache, wird removeEldestEntry ausgeführt. Wenn das true zurück gibt, wird der Parameter aus der Liste gelöscht?
- woher genau weiß ich, welches der LRU Entry der Map ist?
- Warum wird hier: LinkedHashMap (Java 2 Platform SE v1.4.2) behauptet, dass diese Impl. immer true zurück gibt?!
- Bessere Möglichkeiten?

Danke vielmals!
J~man


----------



## SlaterB (5. Dez 2009)

J~man hat gesagt.:


> - was ist der load factor?


davon steht doch nix in dem Link

meinst du bei LinkedHashMap?
API hift:
> A linked hash map has two parameters that affect its performance: initial capacity and load factor. They are defined precisely as for HashMap.
->
> The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the capacity is roughly doubled by calling the rehash method. 

dazu sollte man aber allgemein das Verfahren einer Hashtabelle kennen
Hashtabelle ? Wikipedia



> - jedes Mal wenn ich put mache, wird removeEldestEntry ausgeführt. Wenn das true zurück gibt, wird der Parameter aus der Liste gelöscht?


genau


> - woher genau weiß ich, welches der LRU Entry der Map ist?


musst du nicht wissen, die Map weiß das,
wahrscheinlich liefert keySet().iterator().next() als ersten Key den ältesten,
falls du es auch erfahren willst



> - Warum wird hier: [..] behauptet, dass diese Impl. immer true zurück gibt?!


wird nicht oder genauer bitte


----------



## J~man (5. Dez 2009)

Danke für deine Antwort. Das mit dem Load Factor zumindest hätte ich wohl selbst herausfinden können.



SlaterB hat gesagt.:


> wird nicht oder genauer bitte


wenn du hier schaust: LinkedHashMap (Java 2 Platform SE v1.4.2))
Dann steht da:

_"This implementation merely returns false (so that this map acts like a normal map - the eldest element is never removed). "_

Und ich seh nicht ein warum...Wahrscheinlich versteh ich nur den Text irgendwie falsch.

Für meine derzeitige Aufgabe ist das leider jedoch auch nicht so wichtig, weil wir wohl alles selbst schreiben sollen.
D.h. als Buffer reserviere ich mir nur Speicher, und ich glaube das geht so:

```
Byte[] cache = new Byte[2048];
```
 richtig?


----------



## maki (5. Dez 2009)

> "This implementation merely returns false (so that this map acts like a normal map - the eldest element is never removed)."


Das umschreibt doch nur das Verhalten der default Implementierung:

```
protected boolean removeEldestEntry(Map.Entry JavaDoc<K,V> eldest) {
         return false;
     }
```

und das was passiert wenn man sie wie folgt überschreibt:

```
private static final int MAX_ENTRIES = 100;

    protected boolean removeEldestEntry(Map.Entry eldest) {
       return size() > MAX_ENTRIES;
    }
```
steht ja in der Doku 

Ein Blick in den in den Aufruf  könnte auch zu Aufklärung beitragen:

```
/**
      * This override alters behavior of superclass put method. It causes newly
      * allocated entry to get inserted at the end of the linked list and
      * removes the eldest entry if appropriate.
      */
     void addEntry(int hash, K key, V value, int bucketIndex) {
         createEntry(hash, key, value, bucketIndex);

         // Remove eldest entry if instructed, else grow capacity if appropriate
         Entry<K,V> eldest = header.after;
         if (removeEldestEntry(eldest)) {
             removeEntryForKey(eldest.key);
         } else {
             if (size >= threshold)
                 resize(2 * table.length);
         }
     }
```


----------



## J~man (6. Dez 2009)

hm, okay, ich denke das habe ich jetzt verstanden 

Da wir allerdings so Datenstrukturen nun nicht verwenden dürfen, muss ich irgendwie auf "einfachen Speicher" zurückgreifen.

Ist es richtig, dass ich mir mit 
	
	
	
	





```
byte[] cache = new byte[x*2048]
```
x*2048 byte im Speicher "reserviere"?
Wenn ich jetzt einen Integer hab, der 4 byte groß ist, wie schreibe ich den dann darein?

Ich hoffe ihr versteht was ich meine. Ich muss sozusagen einen Cache für die Datenbank wirklich selber schreiben, der dann nach dem LRU Prinzip arbeitet.


----------

