clusterspace.java

用Java写的面相对象的数据库管理系统

// You can redistribute this software and/or modify it under the terms of
// the Ozone Core License version 1 published by ozone-db.org.
//
// The original code and portions created by SMB are
// Copyright (C) 1997-2000 by SMB GmbH. All rights reserved.
//
// $Id: ClusterSpace.java,v 1.10 2000/10/28 16:55:17 daniela Exp $

package org.ozoneDB.core.classicStore;

import java.io.*;
import org.ozoneDB.*;
import org.ozoneDB.core.*;
import org.ozoneDB.util.*;
import org.ozoneDB.DxLib.*;
import org.ozoneDB.tools.*;


/**
 */
public class ClusterSpace {
    /** The environment of this object. */
    protected Env env;
    protected ClassicStore classicStore;
    
    protected PersistenceSpace persistenceSpace = null;
    protected DeathObjectBuffer dobjBuffer = new DeathObjectBuffer();
    protected int activatedObjects = 0;
    protected int loadedClusters = 0;
    protected int maxBufferSize = 10 * Cluster.MAX_SIZE;
    
    
    /**
     * Constructor
     */
    public ClusterSpace( Env _env ) {
        env = _env;
        classicStore = (ClassicStore)env.store;
        persistenceSpace = new PersistenceSpace( env );
        
        Cluster.MAX_SIZE = env.config.intProperty( Setup.CS_CLUSTER_SIZE, -1 );
        if (Cluster.MAX_SIZE == -1) {
            env.logWriter.newEntry( this, "Property " + Setup.CS_TABLE_BUFF_SIZE + " is not set.", LogWriter.WARN );
            env.logWriter.newEntry( this, "    " + Setup.CS_TABLE_BUFF_SIZE + " = 64*1024", LogWriter.WARN );
            Cluster.MAX_SIZE = 64 * 1024;
        } 
        
        maxBufferSize = env.config.intProperty( Setup.CS_CLUSTER_SPACE_SIZE, -1 );
        if (maxBufferSize == -1) {
            env.logWriter.newEntry( this, "Property " + Setup.CS_CLUSTER_SPACE_SIZE + " is not set.", LogWriter.WARN );
            env.logWriter.newEntry( this, "    " + Setup.CS_CLUSTER_SPACE_SIZE + " = 5MB", LogWriter.WARN );
            maxBufferSize = 5 * 1024 * 1024;
        } 
    }
    
    
    /**
     */
    protected synchronized void startup() throws Exception {
        env.logWriter.newEntry( this, "startup...", LogWriter.INFO );
        persistenceSpace.startup();
        persistenceSpace.fillObjectSpace();
    } 
    
    
    /**
     */
    protected synchronized void shutdown() throws Exception {
        env.logWriter.newEntry( this, "shutdown...", LogWriter.INFO );
        persistenceSpace.shutdown();
    } 
    
    
    /**
     */
    protected void setSizes( int csSize, int clSize ) {
        Cluster.MAX_SIZE = csSize;
        maxBufferSize = csSize;
        if (maxBufferSize < Cluster.MAX_SIZE) {
            maxBufferSize = Cluster.MAX_SIZE;
        } 
        if (csSize < dobjBuffer.size()) {
            freeSpace( dobjBuffer.size() - csSize );
        } 
    } 
    
    
    /**
     */
    protected synchronized void activateObject( ObjectContainer container ) throws Exception {
        // ObjectContainer os = env.objectSpace.objectForID (oid);
        ClassicObjectContainer os = (ClassicObjectContainer)container;
        if (os.target() == null) {
            DeathObject dobj = dobjBuffer.objectForId( os.id() );
            if (dobj == null) {
                loadCluster( os.clusterID() );
                dobj = dobjBuffer.objectForId( os.id() );
            } 
            if (dobj != null) {
                activatedObjects++;
                //env.logWriter.newEntry ("activatedObjects / loadedClusters: " + ((double)activatedObjects/loadedClusters), LogWriter.DEBUG3);
                //env.logWriter.newEntry ("ClusterSpace.activateObject: " + oid + " of " + dobjBuffer.count() + "(" + dobjBuffer.size() + ")", LogWriter.DEBUG3);
                os.setObject( dobj.enlive() );
            } 
        } 
    //env.logWriter.newEntry ("current buffer size: " + dobjBuffer.size(), LogWriter.DEBUG3);
    } 
    
    
    /**
     */
    protected synchronized void prepareCommit( TransactionID tid, DxCollection created, DxCollection modified ) 
            throws Exception {
        env.logWriter.newEntry( this, "ClusterSpace.commitObjects: " + created.count() + " : " + modified.count(),
                LogWriter.DEBUG3 );
        //long start = System.currentTimeMillis();
        
        persistenceSpace.startTransaction( tid );
        
        DeathObject dobj;
        
        // we commit the modified objects first
        DxIterator it = modified.iterator();
        ObjectID id;
        while ((id = (ObjectID)it.next()) != null) {
            ClassicObjectContainer os = (ClassicObjectContainer)classicStore.objectSpace.objectForID( id );
            dobj = dobjBuffer.objectForId( id );
            if (dobj == null) {
                loadCluster( os.clusterID );
                dobj = dobjBuffer.objectForId( id );
            } 
            
            // write the leak
            persistenceSpace.writeLeak( dobj.clusterID(), dobj );
            
            if (!os.isDeleted()) {
                dobjBuffer.remove( id );
                persistenceSpace.writeObject( dobj, true, true );
                freeSpace( dobj.size() );
                dobjBuffer.add( dobj );
            } else {
                dobjBuffer.remove( id );
                os.setObject( null );
            } 
        } 
        
        // commit the new objects
        it = created.iterator();
        ObjectContainer os;
        while ((os = (ObjectContainer)it.next()) != null) {
            dobj = new DeathObject( os.id() );
            persistenceSpace.writeObject( dobj, true, false );
            freeSpace( dobj.size() );
            dobjBuffer.add( dobj );
        } 
        
        persistenceSpace.prepareCommitTransaction( tid );
    //env.logWriter.newEntry ("commit time: " + (System.currentTimeMillis() - start), LogWriter.DEBUG3);
    } 
    
    
    /**
     */
    protected synchronized void commitTransaction( TransactionID tid ) {
        persistenceSpace.commitTransaction( tid );
    } 
    
    
    /**
     */
    protected synchronized void abortTransaction( TransactionID tid ) throws Exception {
        persistenceSpace.abortTransaction( tid );
    } 
    
    
    /**
     */
    protected synchronized void touchObject( ObjectID oid ) {
        //env.logWriter.newEntry ("ClusterSpace.touchObject: " + oid, LogWriter.DEBUG3);
        dobjBuffer.moveToTop( oid );
    } 
    
    
    /**
     * laedt den cluster cid und fuegt die objekte in die tabelle ein
     */
    private boolean loadCluster( ClusterID cid ) throws Exception {
        //env.logWriter.newEntry ("ClusterSpace.loadCluster: " + cid, LogWriter.DEBUG3);
        loadedClusters++;
        // cluster anfordern
        Cluster cl = persistenceSpace.readCluster( cid, Cluster.DATA );
        
        // free enough space to insert all objects
        freeSpace( cl.size() );
        
        // insert the objects
        DxIterator it = cl.objects().iterator();
        DeathObject dobj;
        while ((dobj = (DeathObject)it.next()) != null) {
            dobjBuffer.add( dobj );
        } 
        
        return true;
    } 
    
    
    private boolean freeSpace( long size ) {
        //env.logWriter.newEntry ("ClusterSpace.freeSpace: " + size, LogWriter.DEBUG3);
        while (dobjBuffer.size() + size > maxBufferSize) {
            DeathObject dobj = dobjBuffer.pushFromBottom();
            if (dobj != null) {
                dobj.container().setObject( null );
            } 
        } 
        return true;
    } 
}