+++ /dev/null
-// ANNA - Anna is Not Nothingness Anymore //
-// //
-// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
-// //
-// See project site at http://redmine.teslayout.com/projects/anna-suite //
-// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
-
-
-#include <typeinfo>
-
-#include <algorithm>
-
-#include <anna/core/tracing/Logger.hpp>
-#include <anna/core/functions.hpp>
-
-#include <anna/dbms/dbms.hpp>
-#include <anna/dbos/dbos.hpp>
-
-#include <anna/xml/Node.hpp>
-#include <anna/xml/Attribute.hpp>
-
-using namespace std;
-using namespace anna;
-
-StorageArea::StorageArea(const char* name, const Size maxSize, ObjectAllocator objectAllocator, const StorageArea::AccessMode::_v accessMode, const int errorCode) :
- a_name(name),
- a_maxSize(maxSize),
- a_objectAllocator(objectAllocator),
- a_accessMode(accessMode),
- a_errorCode(errorCode),
- a_indexBlock(0),
- a_sizeof(0),
- a_doneReuse(0) {
- a_blocks.push_back(a_currentBlock = new Block(objectAllocator, maxSize));
- a_hit = a_fault = 0;
-}
-
-StorageArea::~StorageArea() {
-}
-
-//------------------------------------------------------------------------------------------------
-// Carga los datos del objeto y los guarda en el area de almacemiento.
-//
-// (1) Si no esta en memoria => se carga.
-// (1.1) Si el registro no existe => se progresa la posible excepcion.
-//
-// (2) Cambia la politica de refresco de las areas de almacenamiento ReadWrite/Dirty. La carga solo se
-// realizara cuando la copia de utilizacion sea 0. Ademas de la mejora de rendimiento aseguramos que
-// la estabilidad de una instancia se mantiene durante toda la vida de esta. Por ejmplo evitamos que
-// una instancia A este trabajando con una copia de una instancia que estamos liberando y volviendo
-// a cargar con datos totalmente distintos ... imaginad que estamos recorriendo un vector asociado
-// o algo asi.
-//
-// (3) Si no ha podido ser recargada (seguramente tiene mas de una referencia) debe evitar el
-// uso en caso de que este marcada como Dirty.
-// (4) Si el contador de uso es cero => que ya esta marcado como memoria libre, pero recordar que
-// tambien puede estar en la memoria activa (pendiente de liberar y/o volver a usar). En este
-// caso se ha reusado.
-//------------------------------------------------------------------------------------------------
-Object* StorageArea::instance(Connection* connection, Loader& loader)
-throw(RuntimeException, DatabaseException) {
- const Index index = loader.getIndex();
- Object* result(NULL);
- Instance* instance(NULL);
- LOGDEBUG(
- string msg("Instantiate (init) | ");
- msg += asString();
- msg += " | ";
- msg += loader.asString();
- msg += " | Index: ";
- msg += functions::asHexString(index);
- Logger::write(Logger::Debug, msg, ANNA_FILE_LOCATION)
- );
- loader.a_connection = connection;
- std::string name("dbos::StorageArea::instance with ");
- name += typeid(loader).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(index);
-
- if(ii == a_directory.end()) { // (1)
- a_fault ++;
-
- if(loader.load(connection, this) == true) { // (1.1)
- pair <iterator, bool> rr;
- bool wasInserted = false;
- instance = allocate();
-
- try {
- instance->object->setIndex(index);
- /* Al añadir la instancia antes de invocar al método Object::initialize
- * nos aseguramos de que se permitan implementar relaciones circulares
- */
- rr = a_directory.insert(value_type(index, instance));
- wasInserted = true;
- result = instance->object;
- instance->flags |= Flag::InProgress;
- instance->object->initialize(loader);
- instance->object->a_isStored = true;
- instance->flags &= Flag::Done;
- } catch(DatabaseException&) {
- instance->flags &= Flag::Done;
-
- if(wasInserted)
- a_directory.erase(rr.first);
-
- a_holes.insert(instance, Holes::Mode::ReadyToReuse);
- throw;
- } catch(RuntimeException&) {
- instance->flags &= Flag::Done;
-
- if(wasInserted)
- a_directory.erase(rr.first);
-
- a_holes.insert(instance, Holes::Mode::ReadyToReuse);
- throw;
- }
- }
- } else {
- static const bool IgnoreDirty = true;
- verifyStatus(instance = StorageArea::instance(ii), IgnoreDirty);
-
- switch(a_accessMode) {
- case AccessMode::ReadOnly:
- result = ((instance->flags & Flag::Dirty) == 0) ? instance->object : reload(connection, loader, instance);
- break;
- case AccessMode::ReadWrite:
- result = (instance->copyCounter > 0) ? instance->object : reload(connection, loader, instance);
- break;
- case AccessMode::ReadEver:
- result = reload(connection, loader, instance);
- break;
- }
-
- if(instance->flags & Flag::Dirty) { // (3)
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Instance selected as unusable";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- if(result != NULL) {
- a_holes.erase(instance); // (4)
- instance->copyCounter ++;
- a_hit ++;
- }
- }
-
- LOGINFORMATION(
- string msg("Instantiate (final) | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION)
- );
- return result;
-}
-
-Object* StorageArea::instance(Connection* connection, CrossedLoader& crossedLoader, Loader& loader)
-throw(RuntimeException, DatabaseException) {
- Object* result = NULL;
- crossedLoader.a_connection = connection;
- // Si el seek devuelve 'true' es que ya tiene cargada la correspondencia entre la clave alternativa y la
- // clave principal usada en el Loader recibido como parámetro.
- bool loaded = (crossedLoader.seek() == false) ? crossedLoader.load(connection, this) : true;
-
- if(loaded == true) {
- /*
- * Transfiere la clave principal conseguida por el cargador cruzado.
- */
- loader.upload(crossedLoader);
- result = instance(connection, loader);
- /*
- * Da la posibilidad de que el cargador cruzado mantenga la correspondencia entre sus claves y las claves primarias
- */
- crossedLoader.download(loader);
- }
-
- return result;
-}
-
-//-------------------------------------------------------------------------
-// Crea un nuevo objeto en el area de almacenamiento.
-//-------------------------------------------------------------------------
-Object* StorageArea::create(Connection* connection, Creator& creator)
-throw(RuntimeException, DatabaseException) {
- const Index index = creator.getIndex();
- Instance* instance = NULL;
- Object* result = NULL;
-
- if(a_accessMode == AccessMode::ReadOnly) {
- string msg(asString());
- msg += " | Cannot create object with AccessMode::ReadOnly";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- LOGDEBUG(
- string msg(asString());
- msg += " | ";
- msg += creator.asString();
- msg += " | Index: ";
- msg += functions::asHexString(index);
- Logger::write(Logger::Debug, msg, ANNA_FILE_LOCATION)
- );
- creator.a_connection = connection;
- std::string name("dbos::StorageArea::create with ");
- name += typeid(creator).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(index);
-
- if(ii == a_directory.end()) {
- pair <iterator, bool> rr;
- bool wasInserted = false;
- a_fault ++;
- instance = allocate();
-
- try {
- instance->object->setIndex(index);
- instance->copyCounter = 1;
- result = instance->object;
- rr = a_directory.insert(value_type(index, instance));
- wasInserted = true;
- instance->flags |= Flag::InProgress;
- instance->object->create(creator);
- instance->flags &= Flag::Done;
- instance->object->a_isStored = false;
- } catch(DatabaseException&) {
- instance->flags &= Flag::Done;
-
- if(wasInserted)
- a_directory.erase(rr.first);
-
- a_holes.insert(instance, Holes::Mode::ReadyToReuse);
- throw;
- } catch(RuntimeException&) {
- instance->flags &= Flag::Done;
-
- if(wasInserted)
- a_directory.erase(rr.first);
-
- a_holes.insert(instance, Holes::Mode::ReadyToReuse);
- throw;
- }
- } else {
- verifyStatus(instance = StorageArea::instance(ii));
- a_hit ++;
- a_holes.erase(instance);
- instance->copyCounter ++;
- result = instance->object;
- }
-
- LOGINFORMATION(
- string msg("Create | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION)
- );
- return result;
-}
-
-//-------------------------------------------------------------------------
-// Carga los datos del objeto y los guarda en el area de almacemiento.
-//
-// (1) Si tiene cuenta 0 => estaba en la lista de objetos liberados =>
-// lo sacamos de ah�
-//-------------------------------------------------------------------------
-Object* StorageArea::find(Loader& loader)
-throw(RuntimeException) {
- const Index index = loader.getIndex();
- Instance* instance = NULL;
- Object* result = NULL;
- LOGDEBUG(
- string msg(asString());
- msg += " | ";
- msg += loader.asString();
- msg += " | Index: ";
- msg += functions::asHexString(index);
- Logger::write(Logger::Debug, msg, ANNA_FILE_LOCATION)
- );
- std::string name("dbos::StorageArea::find with ");
- name += typeid(loader).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(index);
-
- if(ii != a_directory.end()) {
- verifyStatus(instance = StorageArea::instance(ii));
- a_hit ++;
- a_holes.erase(instance);
- instance->copyCounter ++;
- result = instance->object;
- } else
- a_fault ++;
-
- LOGDEBUG(
- string msg("Find | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::write(Logger::Debug, msg, ANNA_FILE_LOCATION)
- );
- return result;
-}
-
-Object* StorageArea::duplicate(const Object* object)
-throw(RuntimeException) {
- if(object == NULL) return NULL;
-
- std::string name("dbos::StorageArea::duplicate with ");
- name += typeid(*object).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(object->getIndex());
-
- if(ii == a_directory.end()) {
- a_fault ++;
- string msg(asString());
- msg += " | Index: ";
- msg += functions::asHexString(object->getIndex());
- msg += " | Invalid instance";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- Instance* instance = NULL;
- verifyStatus(instance = StorageArea::instance(ii));
- a_holes.erase(instance);
- instance->copyCounter ++;
- a_hit ++;
- LOGINFORMATION(
- string msg("Duplicate | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION)
- );
- return instance->object;
-}
-
-bool StorageArea::isLoaded(const Loader& loader)
-throw(RuntimeException) {
- const Index index = loader.getIndex();
- std::string name("dbos::StorageArea::isLoaded with ");
- name += typeid(loader).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(index);
- const bool result = (ii != a_directory.end());
- LOGDEBUG(
- string msg(asString());
- msg += " | ";
- msg += loader.asString();
- msg += " | Index: ";
- msg += functions::asHexString((int) index);
- msg += functions::asText(" | isLoaded: ", result);
- Logger::debug(msg, ANNA_FILE_LOCATION);
- );
- return result;
-}
-
-void StorageArea::apply(Connection& connection, Recorder& recorder)
-throw(RuntimeException, DatabaseException) {
- ResultCode resultCode = connection.execute(recorder.getStatement());
-
- if(resultCode.successful() == false)
- throw DatabaseException(resultCode, ANNA_FILE_LOCATION);
-}
-
-//------------------------------------------------------------------------------------------------
-// Borra un objeto del medio fisico => lo borra tambien de la cache
-//
-// (1) Como copyCounter = 0 => Lo metera en lista de huecos, le quitara del directorio y
-// si fuera necesario invocara al 'destroy'.
-// (2) No la puede sacar de la memoria porque tiene referencias activas, pero por lo menos la
-// marca como no usable para intentar provocar los avisos de uso incorrecto y expulsar la
-// instancia en cuanto pueda.
-//------------------------------------------------------------------------------------------------
-void StorageArea::apply(Connection& connection, Eraser& eraser)
-throw(RuntimeException, DatabaseException) {
- if(a_accessMode == AccessMode::ReadOnly) {
- string msg(asString());
- msg += " | Cannot erase object with AccessMode::ReadOnly";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- Object* object = eraser.getObject();
- eraser.a_connection = &connection;
- std::string name("dbos::StorageArea::apply with ");
- name += typeid(eraser).name();
- Guard guard(this, name.c_str());
- Instance* instance = NULL;
-
- if(object != NULL) {
- iterator ii = a_directory.find(object->getIndex());
-
- if(ii != a_directory.end()) {
- instance = StorageArea::instance(ii);
-
- if(instance->copyCounter > 1) {
- instance->flags |= Flag::Incoherent; // (2)
- string msg(eraser.asString());
- msg += " | Instances: ";
- msg += functions::asString(instance->copyCounter);
- msg += " | Cannot delete object";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
- }
- }
-
- ResultCode resultCode = connection.execute(eraser.getStatement());
-
- if(resultCode.successful() == false)
- throw DatabaseException(resultCode, ANNA_FILE_LOCATION);
-
- if(instance != NULL) {
- instance->copyCounter = 0;
- quickReusing(instance); // (1)
- }
-}
-
-//------------------------------------------------------------------------------------------------
-// Decrementa la cuenta de utilizacin del objeto recibido como parametro.
-//
-// (1) Si la instancia que estamos liberando esta marcada como 'Incoherente' y es la ultima
-// referencia => es el momento de expulsarla de la memoria.
-// (2) Queda a la espera de que se vuelva a usar la referencia o que el numero de registros en
-// memoria alcance un numero tal que implique comenzar a reusar objetos liberados.
-//------------------------------------------------------------------------------------------------
-void StorageArea::release(Object** object)
-throw(RuntimeException) {
- if(object == NULL) return;
-
- if(*object == NULL) return;
-
- std::string name("dbos::StorageArea::release with ");
- name += typeid(**object).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find((*object)->getIndex());
-
- if(ii == a_directory.end())
- return;
-
- Instance* instance = StorageArea::instance(ii);
-
- if(instance->copyCounter > 0) {
- if(-- instance->copyCounter == 0) {
- if(instance->flags & Flag::Incoherent) // (1)
- quickReusing(instance);
- else
- a_holes.insert(instance, Holes::Mode::TimeWait); // (2)
- }
- }
-
- LOGINFORMATION(
- string msg("Release | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION)
- );
- *object = NULL;
-}
-
-//------------------------------------------------------------------------------------------------
-// Elimina toda la informacin referente al objeto recibido como parametro.
-//
-// (1) No la puede sacar de la memoria porque tiene referencias activas, pero por lo menos la
-// marca como no usable para intentar provocar los avisos de uso incorrecto y expulsar la
-// instancia en cuanto pueda.
-// (2) Como copyCounter = 0 => Lo metera en lista de huecos, le quitara del directorio y
-// si fuera necesario invocara al 'destroy'.
-//------------------------------------------------------------------------------------------------
-void StorageArea::erase(Object** object)
-throw(RuntimeException) {
- if(object == NULL) return;
-
- if(*object == NULL) return;
-
- std::string name("dbos::StorageArea::erase with ");
- name += typeid(**object).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find((*object)->getIndex());
-
- if(ii == a_directory.end())
- return;
-
- Instance* instance = StorageArea::instance(ii);
-
- if(instance->copyCounter > 1) {
- instance->flags |= Flag::Incoherent; // (1)
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Cannot dump instance";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- LOGDEBUG(
- string msg("Erase | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::debug(msg, ANNA_FILE_LOCATION)
- );
- instance->copyCounter = 0;
- quickReusing(instance); // (2)
- *object = NULL;
-}
-
-void StorageArea::dirty(Object* object)
-throw(RuntimeException) {
- if(object == NULL) return;
-
- std::string name("dbos::StorageArea::dirty with ");
- name += typeid(*object).name();
- Guard guard(this, name.c_str());
- iterator ii = a_directory.find(object->getIndex());
-
- if(ii == a_directory.end())
- return;
-
- Instance* instance = StorageArea::instance(ii);
-
- if(instance->copyCounter > 1 && Logger::isActive(Logger::Warning)) {
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | More than one copy on instance to be selected";
- Logger::warning(msg, ANNA_FILE_LOCATION);
- }
-
- LOGDEBUG(
- string msg("Dirty | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::debug(msg, ANNA_FILE_LOCATION)
- );
-}
-
-//--------------------------------------------------------------------------------------------
-// Descarga todos los objetos de este area de almacenamiento.
-//
-// (1) Para que permite incluirla en los huecos.
-// (3) Si fuera necesario invoca al destroy => cuando se reuse no tendra que hacerlo.
-// (4) Si la entrada estaba marcada como 'incoherente' la desmarca, ya que hemos conseguido
-// expulsarla de cache.
-//--------------------------------------------------------------------------------------------
-void StorageArea::clear()
-throw(RuntimeException) {
- Guard guard(this, "dbos::StorageArea::clear");
- Instance* instance;
- int n = 0;
-
- for(iterator ii = begin(), maxii = end(); ii != maxii; ii ++) {
- instance = StorageArea::instance(ii);
- instance->copyCounter = 0; // (1)
- a_holes.insert(instance, Holes::Mode::ReadyToReuse);
-
- if((instance->flags & Flag::Empty) == 0) { // (3)
- LOGINFORMATION(
- string msg("Destroy (clear) | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION);
- );
- instance->object->destroy();
- instance->flags |= Flag::Empty;
- }
-
- instance->flags &= Flag::NoIncoherent; // (4)
- n ++;
- }
-
- a_directory.clear();
- LOGWARNING(
- string msg("Clear | ");
- msg += asString();
- msg += functions::asText(" | Destroyed objects: ", n);
- Logger::warning(msg, ANNA_FILE_LOCATION)
- );
-}
-
-//---------------------------------------------------------------------------------------------------
-// Intenta recargar la informacion del medio fisico en la instancia del objeto.
-// Si hay algun problema y la instancia no puede guardarse en la de objetos disponibles
-// (a_holes.insert == false) => se marca como corrupto y no se podra usar hasta que
-// que no se libere su ultima instancia.
-//
-// (1) Si hubiera algun problema al invocar al 'initialize' no habria que volver a invocar
-// a este metodo.
-// (2) Recordar que la recarga solo se intenta cuando la copyCounter = 0, por tanto en el caso de
-// intentar recargar un registro que ha sido borrado no se vuelve a grabar como Ready porque
-// YA esta en la lista de huecos y seria necesario borrarlo de esta, cambiarle el msHoleTime y
-// volverlo a grabar, pero la cosa funciona porque se saca del directorio de objetos cargados
-// y se libera su memoria.
-//---------------------------------------------------------------------------------------------------
-Object* StorageArea::reload(dbms::Connection* connection, Loader& loader, StorageArea::Instance* instance)
-throw(RuntimeException, dbms::DatabaseException) {
- const bool enableUpdate = (instance->flags & Flag::Dirty) ? true : instance->object->enableUpdate();
- bool hasChanges(false);
-
- if(enableUpdate == true) {
- try {
- if(loader.load(connection, this) == false) {
- checkIncoherence(instance); // (2)
- return NULL;
- }
- } catch(RuntimeException&) {
- checkIncoherence(instance);
- throw;
- } catch(dbms::DatabaseException&) {
- checkIncoherence(instance);
- throw;
- }
-
- hasChanges = (instance->flags & Flag::Dirty) ? true : instance->object->hasChanges(loader);
- }
-
- LOGDEBUG(
- string msg("Reload | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- msg += anna::functions::asText(" | EnableUpdate: ", enableUpdate);
- msg += anna::functions::asText(" | HasChanges: ", hasChanges);
- Logger::debug(msg, ANNA_FILE_LOCATION);
- );
-
- if(hasChanges == true) {
- LOGINFORMATION(
- string msg("Destroy (reload) | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION);
- );
- instance->object->destroy();
- instance->flags |= Flag::Empty; // (1)
- instance->object->initialize(loader);
- instance->flags &= Flag::NoEmpty;
- instance->flags &= Flag::NoDirty;
- }
-
- return instance->object;
-}
-
-//------------------------------------------------------------------------------------------------
-// Cuando intenta recargar la informacion de una instancia desde el medio fisico, pero el
-// registro ha sido borrado =>
-// 1.- Si hay alguna instancia en uso => no puede liberar la instancia porque algun otro
-// objeto la tiene referenciada => la marca como corrupta.
-// 2.- Si hay una unica instancia en uso => puede liberarla
-//
-// (1) si la puede grabar en los huecos o la instancia ya esta en los huecos => saca el objeto
-// del directorio porque yo no es valido. Recupera la coherencia memoria-medio_fisico
-// porque ha conseguido "expulsar" de la cache el registro borrado.
-// (2) No puede "expulsar" el registro de la cache porque hay algun otro objeto que lo esta
-// referenciando => Marca ESTA instancia como incoherente => no se podra duplicar y volver
-// a instanciar, etc, etc
-//------------------------------------------------------------------------------------------------
-void StorageArea::checkIncoherence(StorageArea::Instance* instance)
-throw() {
- if(quickReusing(instance) == true) {
- LOGWARNING(
- string msg("dbos::StorageArea::checkIncoherence | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- msg += " | Recover coherence between physical media and memory";
- Logger::warning(msg, ANNA_FILE_LOCATION);
- );
- } else { // (2)
- instance->flags |= Flag::Incoherent;
- LOGWARNING(
- string msg("dbos::StorageArea::checkIncoherence | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- msg += " | Detected incoherence between physical media and memory";
- Logger::warning(msg, ANNA_FILE_LOCATION);
- );
- }
-}
-
-//------------------------------------------------------------------------------------------------
-// (1) si la puede grabar en los huecos o la instancia ya esta en los huecos => (2)
-// (2) saca el objeto del directorio porque yo no es valido.
-// (3) Si fuera necesario invoca al destroy => cuando se reuse no tendra que hacerlo.
-// (4) Si la entrada estaba marcada como 'incoherente' la desmarca, ya que hemos conseguido
-// expulsarla de cache.
-//
-// Recordar que en el caso de intentar recargar un registro que ha sido borrado no se vuelve
-// a grabar como Ready porque ya esta en la lista de huecos y seria necesario borrarlo de
-// esta, cambiarle el msHoleTime y volverlo a grabar.
-//------------------------------------------------------------------------------------------------
-bool StorageArea::quickReusing(StorageArea::Instance* instance)
-throw() {
- bool result(false);
-
- if(a_holes.insert(instance, Holes::Mode::ReadyToReuse) == true) { // (1)
- iterator ii = a_directory.find(instance->object->getIndex());
-
- if(ii != a_directory.end()) // (2)
- a_directory.erase(ii);
-
- if((instance->flags & Flag::Empty) == 0) { // (3)
- LOGINFORMATION(
- string msg("Destroy (quickreusing) | ");
- msg += asString();
- msg += " | ";
- msg += asString(instance);
- Logger::information(msg, ANNA_FILE_LOCATION);
- );
- instance->object->destroy();
- instance->flags |= Flag::Empty;
- }
-
- instance->flags &= Flag::NoIncoherent; // (4)
- result = true;
- }
-
- return result;
-}
-
-void StorageArea::verifyStatus(StorageArea::Instance* instance, const bool ignoreDirty)
-throw(RuntimeException) {
- if(instance->flags & Flag::Incoherent) {
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Physical media and memory do not match";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- if(instance->flags & Flag::Empty) {
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Instance is empty";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- if(ignoreDirty == false && (instance->flags & Flag::Dirty)) {
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Instance is temporary locked";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-
- if(instance->flags & Flag::InProgress) {
- string msg(asString());
- msg += " | ";
- msg += asString(instance);
- msg += " | Instance already has word in progress";
- throw RuntimeException(msg, ANNA_FILE_LOCATION);
- }
-}
-
-string StorageArea::asString() const
-throw() {
- string result("dbos::StorageArea { Name: ");
- const int ratio = (a_hit == 0) ? 0 : (a_hit * 100) / (a_fault + a_hit);
- /* Nº real de objetos en uso. En el directorio también se mantienen los que tienen la cuenta de utilización a 0 */
- const int n = a_directory.size() - a_holes.size();
- result += a_name;
- result += " | N: ";
- result += functions::asString(a_maxSize);
- result += " | n: ";
- result += functions::asString(n);
- result += " | r: ";
- result += functions::asString(a_directory.size());
- result += " | AccessMode: ";
- result += AccessMode::asString(a_accessMode);
- result += " | Holes: ";
- result += functions::asString(a_holes.size());
- result += " | Reuse: ";
- result += functions::asString(a_doneReuse);
- result += " | Hit: ";
- result += functions::asString(a_hit);
- result += " | Fault: ";
- result += functions::asString(a_fault);
- result += " | Ratio: ";
- result += functions::asString(ratio);
- return result += "% }";
-}
-
-xml::Node* StorageArea::asXML(xml::Node* parent) const
-throw() {
- xml::Node* result = parent->createChild("dbos.StorageArea");
- xml::Node* node;
- const int ratio = (a_hit == 0) ? 0 : (a_hit * 100) / (a_fault + a_hit);
- result->createAttribute("Name", a_name);
- result->createAttribute("AccessMode", AccessMode::asString(a_accessMode));
- node = result->createChild("Size");
- node->createAttribute("Value", a_directory.size() - a_holes.size());
- node->createAttribute("Reserve", a_directory.size());
- node->createAttribute("MaxValue", a_maxSize);
- node->createAttribute("Holes", a_holes.size());
- node = result->createChild("SizeOf");
- node->createAttribute("Value", asMemorySize(getSizeOf()));
- node->createAttribute("MaxValue", asMemorySize(getMaxSizeOf()));
- node = result->createChild("Statistics");
- node->createAttribute("Hit", a_hit);
- node->createAttribute("Fault", a_fault);
- node->createAttribute("Ratio", anna::functions::asString("%d%%", ratio));
- node->createAttribute("DoneReuse", a_doneReuse);
- return result;
-}
-
-string StorageArea::asMemorySize(const Size size)
-throw() {
- string result;
-
- if(size < 1024) {
- result = functions::asString("%u bytes", size);
- } else if(size < 1024 * 1024) {
- static const Size ka = 1024;
- result += functions::asString("%u Kb", size / ka);
- } else {
- static const Size mega = 1024 * 1024;
- result += functions::asString("%u Mb", size / mega);
- }
-
- return result;
-}
-
-StorageArea::Instance* StorageArea::allocate()
-throw() {
- Instance* result = NULL;
-
- if((result = reuse()) == NULL) {
- if((result = a_currentBlock->getInstance()) == NULL) {
- if(++ a_indexBlock == a_blocks.size())
- a_blocks.push_back(a_currentBlock = new Block(a_objectAllocator, a_maxSize));
- else
- a_currentBlock = a_blocks [a_indexBlock];
-
- result = a_currentBlock->getInstance();
- }
- }
-
- result->copyCounter = 1;
-//xxx result->msHoleTime = 0;
- result->flags = Flag::None;
-//xxx result->hasHole = false;
- return result;
-}
-
-//-----------------------------------------------------------------------------------------------------
-// Reusa un objeto que lleva demasiado tiempo sin ser utilizado.
-//
-// (0) Si el tiempo que lleva en la lista de objetos liberados es cero => Podemos usar el re-usado
-// rapido; ya ha sido eliminado del directorio, invoca al destroy, etc, etc.
-// (0.1) Para asegurar que NO desborde los 32 bits.
-// (1) Cuando n -> Nmax => Talpha = now => a poco tiempo que pase sin reusar los registros, estos
-// se comienzan a resuar. Cuando n -> 0 => talpha = 0 => No se reusan registros, sino que se crearan
-// nuevos.
-// (2) Si el primero de los registros disponibles no es suficientemente antiguo => no hay huecos libres
-//-----------------------------------------------------------------------------------------------------
-StorageArea::Instance* StorageArea::reuse()
-throw() {
- if(a_holes.empty() == true)
- return NULL;
-
- Instance* result = NULL;
- Instance* front = a_holes.front();
- bool quickReuse;
-
- if((front->flags & Flag::Ready) == false) {
- if(a_directory.size() >= a_maxSize) { // El directorio contiene los que tienen cuenta 0 + los que están activos.
- result = front;
- iterator ii = a_directory.find(result->object->getIndex());
-
- if(ii != a_directory.end())
- a_directory.erase(ii);
-
- if((result->flags & Flag::Empty) == 0) {
- LOGINFORMATION(
- string msg("Destroy (reuse) | ");
- msg += asString();
- msg += " | ";
- msg += asString(result);
- Logger::information(msg, ANNA_FILE_LOCATION);
- );
- result->object->destroy();
- result->flags &= Flag::NoEmpty;
- }
- }
-
- quickReuse = false;
- } else {
- // Si la entrada se cargó en los huecos como "usado rápido" se toma
- result = front;
- quickReuse = true;
- }
-
- if(result != NULL) {
- a_doneReuse ++;
- result->flags &= Flag::NoReady;
- result->flags &= Flag::NoHasHole;
- a_holes.pop_front();
- }
-
- LOGDEBUG(
- string msg("dbos::StorageArea::reuse | ");
- msg += asString();
- msg += " | ";
- msg += StorageArea::asString(result);
- msg += functions::asText(" | QuickReuse: ", quickReuse);
- Logger::debug(msg, ANNA_FILE_LOCATION);
- );
- return result;
-}
-
-std::string StorageArea::asString(const Instance* instance)
-throw() {
- std::string result("Instance { ");
-
- if(instance == NULL)
- return result += "<null> } ";
-
- result += "Reference: ";
- result += functions::asHexString(anna_ptrnumber_cast(instance->object));
- result += " | Index: ";
- result += functions::asHexString(instance->object->getIndex());
- result += functions::asText(" | Stored: ", instance->object->a_isStored);
- result += " | CopyCounter: ";
- result += functions::asString((unsigned int) instance->copyCounter);
- result += " | Flags (";
- result += functions::asHexString(instance->flags);
- result += "):";
-
- if(instance->flags == Flag::None)
- result += " None";
- else {
- if(instance->flags & Flag::Dirty)
- result += " Dirty";
-
- if(instance->flags & Flag::Incoherent)
- result += " Incoherent";
-
- if(instance->flags & Flag::Empty)
- result += " Empty";
-
- if(instance->flags & Flag::HasHole)
- result += " HasHole";
-
- if(instance->flags & Flag::InProgress)
- result += " InProgress";
-
- result += (instance->flags & Flag::Ready) ? " Ready" : " TimeWait";
- }
-
- return result += " }";
-}
-
-const char* StorageArea::AccessMode::asString(const AccessMode::_v v)
-throw() {
- static const char* text [] = { "ReadOnly", "ReadWrite", "ReadEver" };
- return text [v];
-}
-
-/****************************************************************************************
-* Bloque de memoria.
-****************************************************************************************/
-StorageArea::Block::Block(ObjectAllocator objectAllocator, const Size maxSize) :
- a_size(0) {
- a_maxSize = std::min(8U, std::max(256U, maxSize >> 7));
- a_instances = new Instance [a_maxSize];
-
- for(int i = 0; i < a_maxSize; i ++)
- a_instances [i].object = (*objectAllocator)();
-}
-
-bool StorageArea::Holes::insert(Instance* instance, const StorageArea::Holes::Mode::_v mode)
-throw() {
- if(instance->copyCounter > 0)
- return false;
-
- /* Si la instancia ya ha sido registrada en la lista de huecos, sale sin más */
- if((instance->flags & Flag::HasHole) == true)
- return true;
-
- switch(mode) {
- case Mode::ReadyToReuse:
- instance->holeIterator = a_holes.insert(a_holes.begin(), instance);
- instance->flags |= Flag::HasHole;
- instance->flags |= Flag::Ready;
- a_size ++;
- break;
- case Mode::TimeWait:
- instance->holeIterator = a_holes.insert(a_holes.end(), instance);
- instance->flags |= Flag::HasHole;
- instance->flags &= Flag::NoReady;
- a_size ++;
- break;
- }
-
- LOGLOCAL6(
- string msg("dbos::StorageArea::Holes::insert | This: ");
- msg += functions::asHexString(anna_ptrnumber_cast(this));
- msg += " | ";
- msg += StorageArea::asString(instance);
- Logger::write(Logger::Local6, msg, ANNA_FILE_LOCATION);
- );
- return true;
-}
-
-void StorageArea::Holes::erase(Instance* instance)
-throw() {
- // instance->msHoleTime = 0;
- instance->flags |= Flag::Ready;
-
- if(instance->copyCounter != 0)
- return;
-
- /* Si la instancia NO ha sido registrada en la lista de huecos, sale sin más */
- if((instance->flags & Flag::HasHole) == false)
- return;
-
- LOGLOCAL6(
- string msg("dbos::StorageArea::Holes::erase | This: ");
- msg += functions::asHexString(anna_ptrnumber_cast(this));
- msg += " | ";
- msg += StorageArea::asString(instance);
- Logger::write(Logger::Local6, msg, ANNA_FILE_LOCATION);
- );
- a_holes.erase(instance->holeIterator);
- instance->flags &= Flag::NoHasHole;
- a_size --;
-}
-
-/****************************************************************************************
-* Iterador
-
-class A {
-public:
- A () : a (0) { cout << "C0: " << (int) this << endl; }
- A (const int _a): a (_a) { cout << "C1: " << (int) this << " " << a << endl; }
- A (const A& other) : a (other.a) { cout << "C2: " << (int) this << " " << a << endl; }
-
- A& operator = (const A& other) {
- cout << "CP: " << (int) this << " " << (a = other.a) << endl;
- return *this;
- }
-
- int get () const { return a; }
-private:
- int a;
-};
-
-A fx () { return A (2000); }
-
-int main ()
-{
- A aa = 100;
- A bb (200);
- A xx = aa;
- A cc = fx ();
-
- cout << "CC: " << (int) &cc << " " << cc.get () << endl;
-
-}
-
-La salida del programucho es la siguiente:
-
-C1: -4198808 100
-C1: -4198812 200
-C2: -4198816 100
-C1: -4198820 2000
-CC: -4198820 2000
-
-Lo que quiere decir que la "cc" la crea directamente sobre la pila y la asigna en fx sin aplicar ningn
-otro constructor.
-
-Por eso cuando hac� StorageArea::Iterator ii = xxx->begin (), maxi = xxx->end (); .....
-no estaba pasando por el contructor copia ni por ningn otro constructor.
-
-****************************************************************************************/
-// Dejo todo el ejemplo para que sirva de recordatorio.
-
projects / anna.git / blobdiff