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-@year@ by SMB GmbH. All rights reserved.
//
// $Id$

package org.ozoneDB.core.storage.classicStore;

import org.ozoneDB.DxLib.DxCollection;
import org.ozoneDB.DxLib.DxIterator;
import org.ozoneDB.Setup;
import org.ozoneDB.OzoneInternalException;
import org.ozoneDB.core.*;
import org.ozoneDB.core.storage.classicStore.ClassicObjectContainer;
import org.ozoneDB.core.storage.classicStore.ClassicStore;
import org.ozoneDB.core.storage.classicStore.Cluster;
import org.ozoneDB.core.storage.classicStore.ClusterID;
import org.ozoneDB.util.LogWriter;

import java.io.IOException;


/**
 * @author <a href="http://www.softwarebuero.de/">SMB</a>
 */
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.getStoreManager();
        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 OzoneInternalException {
        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 );
                try {
                    persistenceSpace.writeObject( dobj, true, true );
                } catch (IOException e) {
                    throw new OzoneInternalException("prepareCommit() failed for modified objects (failed to write object)",e);
                }
                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() );
            try {
                persistenceSpace.writeObject( dobj, true, false );
            } catch (IOException e) {
                throw new OzoneInternalException("prepareCommit() failed for new objects (failed to write object)",e);
            }
            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 OzoneInternalException {
        //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;
    }
}