sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Started adding stuff to src/storage/dd/sylvan/InternalSylvanDdManager. 

Former-commit-id: cf8adfc43f
main
PBerger 9 years ago
parent
a73c48880c
commit
a0dd2064c1
3 changed files with 309 additions and 271 deletions
Unified View
  1. 273
      src/storage/dd/sylvan/InternalSylvanDdManager.cpp
  2. 278
      src/storage/dd/sylvan/InternalSylvanDdManager.h
  3. 29
      src/utility/sylvan.h

273
src/storage/dd/sylvan/InternalSylvanDdManager.cpp
View File

@ -1,127 +1,148 @@
#include "src/storage/dd/sylvan/InternalSylvanDdManager.h" #include "src/storage/dd/sylvan/InternalSylvanDdManager.h"
#include <cmath>
#include <cmath> #include "src/settings/SettingsManager.h"
#include "src/settings/modules/SylvanSettings.h"
#include "src/settings/SettingsManager.h" #include "src/utility/constants.h"
#include "src/settings/modules/SylvanSettings.h" #include "src/utility/macros.h"
#include "src/exceptions/NotSupportedException.h"
#include "src/utility/constants.h" namespace storm {
#include "src/utility/macros.h" namespace dd {
#include "src/exceptions/NotSupportedException.h" uint_fast64_t InternalDdManager<DdType::Sylvan>::numberOfInstances = 0;
// It is important that the variable pairs start at an even offset, because sylvan assumes this to be true for
namespace storm { // some operations.
namespace dd { uint_fast64_t InternalDdManager<DdType::Sylvan>::nextFreeVariableIndex = 0;
uint_fast64_t InternalDdManager<DdType::Sylvan>::numberOfInstances = 0; uint_fast64_t findLargestPowerOfTwoFitting(uint_fast64_t number) {
for (uint_fast64_t index = 0; index < 64; ++index) {
// It is important that the variable pairs start at an even offset, because sylvan assumes this to be true for if ((number & (1ull << (63 - index))) != 0) {
// some operations. return 63 - index;
uint_fast64_t InternalDdManager<DdType::Sylvan>::nextFreeVariableIndex = 0; }
}
uint_fast64_t findLargestPowerOfTwoFitting(uint_fast64_t number) { return 0;
for (uint_fast64_t index = 0; index < 64; ++index) { }
if ((number & (1ull << (63 - index))) != 0) { InternalDdManager<DdType::Sylvan>::InternalDdManager() {
return 63 - index; if (numberOfInstances == 0) {
} // Initialize lace: auto-detect number of workers.
} lace_init(storm::settings::getModule<storm::settings::modules::SylvanSettings>().getNumberOfThreads(), 1000000);
return 0; lace_startup(0, 0, 0);
} // Each node takes 24 bytes and the maximal memory is specified in megabytes.
uint_fast64_t totalNodesToStore = storm::settings::getModule<storm::settings::modules::SylvanSettings>().getMaximalMemory() * 1024 * 1024 / 24;
InternalDdManager<DdType::Sylvan>::InternalDdManager() { // Compute the power of two that still fits within the total numbers to store.
if (numberOfInstances == 0) { uint_fast64_t powerOfTwo = findLargestPowerOfTwoFitting(totalNodesToStore);
// Initialize lace: auto-detect number of workers. sylvan::Sylvan::initPackage(1ull << std::max(16ull, powerOfTwo > 24 ? powerOfTwo - 8 : 0ull), 1ull << (powerOfTwo - 1), 1ull << std::max(16ull, powerOfTwo > 24 ? powerOfTwo - 12 : 0ull), 1ull << (powerOfTwo - 1));
lace_init(storm::settings::getModule<storm::settings::modules::SylvanSettings>().getNumberOfThreads(), 1000000); sylvan::Sylvan::initBdd(1);
lace_startup(0, 0, 0); sylvan::Sylvan::initMtbdd();
}
// Each node takes 24 bytes and the maximal memory is specified in megabytes. ++numberOfInstances;
uint_fast64_t totalNodesToStore = storm::settings::getModule<storm::settings::modules::SylvanSettings>().getMaximalMemory() * 1024 * 1024 / 24; }
InternalDdManager<DdType::Sylvan>::~InternalDdManager() {
// Compute the power of two that still fits within the total numbers to store. --numberOfInstances;
uint_fast64_t powerOfTwo = findLargestPowerOfTwoFitting(totalNodesToStore); if (numberOfInstances == 0) {
// Enable this to print the sylvan statistics to a file.
sylvan::Sylvan::initPackage(1ull << std::max(16ull, powerOfTwo > 24 ? powerOfTwo - 8 : 0ull), 1ull << (powerOfTwo - 1), 1ull << std::max(16ull, powerOfTwo > 24 ? powerOfTwo - 12 : 0ull), 1ull << (powerOfTwo - 1)); // FILE* filePointer = fopen("sylvan.stats", "w");
sylvan::Sylvan::initBdd(1); // sylvan_stats_report(filePointer, 0);
sylvan::Sylvan::initMtbdd(); // fclose(filePointer);
} sylvan::Sylvan::quitPackage();
++numberOfInstances; lace_exit();
} }
}
InternalDdManager<DdType::Sylvan>::~InternalDdManager() { InternalBdd<DdType::Sylvan> InternalDdManager<DdType::Sylvan>::getBddOne() const {
--numberOfInstances; return InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddOne());
if (numberOfInstances == 0) { }
// Enable this to print the sylvan statistics to a file. template<>
// FILE* filePointer = fopen("sylvan.stats", "w"); InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const {
// sylvan_stats_report(filePointer, 0); return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(storm::utility::one<double>()));
// fclose(filePointer); }
template<>
sylvan::Sylvan::quitPackage(); InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const {
lace_exit(); return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(storm::utility::one<uint_fast64_t>()));
} }
} #ifdef STORM_HAVE_CARL
template<>
InternalBdd<DdType::Sylvan> InternalDdManager<DdType::Sylvan>::getBddOne() const { InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getAddOne() const {
return InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddOne()); return InternalAdd<DdType::Sylvan, storm::RationalFunction>(this, sylvan::Mtbdd::terminal(sylvan_storm_rational_function_get_type(), storm::utility::one<storm::RationalFunction>()));
} }
#endif
template<> InternalBdd<DdType::Sylvan> InternalDdManager<DdType::Sylvan>::getBddZero() const {
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const { return InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddZero());
return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(storm::utility::one<double>())); }
} template<>
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const {
template<> return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(storm::utility::zero<double>()));
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const { }
return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(storm::utility::one<uint_fast64_t>())); template<>
} InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const {
return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(storm::utility::zero<uint_fast64_t>()));
InternalBdd<DdType::Sylvan> InternalDdManager<DdType::Sylvan>::getBddZero() const { }
return InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddZero()); #ifdef STORM_HAVE_CARL
} template<>
InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getAddZero() const {
template<> return InternalAdd<DdType::Sylvan, storm::RationalFunction>(this, sylvan::Mtbdd::terminal(sylvan_storm_rational_function_get_type(), storm::utility::zero<storm::RationalFunction>()));
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const { }
return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(storm::utility::zero<double>())); #endif
} template<>
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const {
template<> return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(value));
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const { }
return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(storm::utility::zero<uint_fast64_t>())); template<>
} InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const {
return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(value));
template<> }
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const { #ifdef STORM_HAVE_CARL
return InternalAdd<DdType::Sylvan, double>(this, sylvan::Mtbdd::doubleTerminal(value)); template<>
} InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getConstant(storm::RationalFunction const& value) const {
return InternalAdd<DdType::Sylvan, storm::RationalFunction>(this, sylvan::Mtbdd::terminal(sylvan_storm_rational_function_get_type(), storm::utility::zero<storm::RationalFunction>()));
template<> }
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const { #endif
return InternalAdd<DdType::Sylvan, uint_fast64_t>(this, sylvan::Mtbdd::int64Terminal(value)); std::pair<InternalBdd<DdType::Sylvan>, InternalBdd<DdType::Sylvan>> InternalDdManager<DdType::Sylvan>::createNewDdVariablePair() {
} InternalBdd<DdType::Sylvan> first = InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddVar(nextFreeVariableIndex));
InternalBdd<DdType::Sylvan> second = InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddVar(nextFreeVariableIndex + 1));
std::pair<InternalBdd<DdType::Sylvan>, InternalBdd<DdType::Sylvan>> InternalDdManager<DdType::Sylvan>::createNewDdVariablePair() { nextFreeVariableIndex += 2;
InternalBdd<DdType::Sylvan> first = InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddVar(nextFreeVariableIndex)); return std::make_pair(first, second);
InternalBdd<DdType::Sylvan> second = InternalBdd<DdType::Sylvan>(this, sylvan::Bdd::bddVar(nextFreeVariableIndex + 1)); }
nextFreeVariableIndex += 2; void InternalDdManager<DdType::Sylvan>::allowDynamicReordering(bool value) {
return std::make_pair(first, second); STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan.");
} }
bool InternalDdManager<DdType::Sylvan>::isDynamicReorderingAllowed() const {
void InternalDdManager<DdType::Sylvan>::allowDynamicReordering(bool value) { STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan.");
STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan."); }
} void InternalDdManager<DdType::Sylvan>::triggerReordering() {
STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan.");
bool InternalDdManager<DdType::Sylvan>::isDynamicReorderingAllowed() const { }
STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan."); template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const;
} template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const;
template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const;
void InternalDdManager<DdType::Sylvan>::triggerReordering() { template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const;
STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Operation is not supported by sylvan."); template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const;
} template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const;
}
template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const;
template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const;
template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const;
template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const;
template InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const;
template InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const;
}
} }

278
src/storage/dd/sylvan/InternalSylvanDdManager.h
View File

@ -1,132 +1,148 @@
#ifndef STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_ #ifndef STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_
#define STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_ #define STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_
#include "src/storage/dd/DdType.h"
#include "src/storage/dd/DdType.h" #include "src/storage/dd/InternalDdManager.h"
#include "src/storage/dd/InternalDdManager.h" #include "src/storage/dd/sylvan/InternalSylvanBdd.h"
#include "src/storage/dd/sylvan/InternalSylvanAdd.h"
#include "src/storage/dd/sylvan/InternalSylvanBdd.h" #include "src/adapters/CarlAdapter.h"
#include "src/storage/dd/sylvan/InternalSylvanAdd.h" namespace storm {
namespace dd {
namespace storm { template<DdType LibraryType, typename ValueType>
namespace dd { class InternalAdd;
template<DdType LibraryType, typename ValueType> template<DdType LibraryType>
class InternalAdd; class InternalBdd;
template<>
template<DdType LibraryType> class InternalDdManager<DdType::Sylvan> {
class InternalBdd; public:
friend class InternalBdd<DdType::Sylvan>;
template<> template<DdType LibraryType, typename ValueType>
class InternalDdManager<DdType::Sylvan> { friend class InternalAdd;
public: /*!
friend class InternalBdd<DdType::Sylvan>; * Creates a new internal manager for Sylvan DDs.
*/
template<DdType LibraryType, typename ValueType> InternalDdManager();
friend class InternalAdd; /*!
* Destroys the internal manager.
/*! */
* Creates a new internal manager for Sylvan DDs. ~InternalDdManager();
*/ /*!
InternalDdManager(); * Retrieves a BDD representing the constant one function.
*
/*! * @return A BDD representing the constant one function.
* Destroys the internal manager. */
*/ InternalBdd<DdType::Sylvan> getBddOne() const;
~InternalDdManager(); /*!
* Retrieves an ADD representing the constant one function.
/*! *
* Retrieves a BDD representing the constant one function. * @return An ADD representing the constant one function.
* */
* @return A BDD representing the constant one function. template<typename ValueType>
*/ InternalAdd<DdType::Sylvan, ValueType> getAddOne() const;
InternalBdd<DdType::Sylvan> getBddOne() const; /*!
* Retrieves a BDD representing the constant zero function.
/*! *
* Retrieves an ADD representing the constant one function. * @return A BDD representing the constant zero function.
* */
* @return An ADD representing the constant one function. InternalBdd<DdType::Sylvan> getBddZero() const;
*/ /*!
template<typename ValueType> * Retrieves an ADD representing the constant zero function.
InternalAdd<DdType::Sylvan, ValueType> getAddOne() const; *
* @return An ADD representing the constant zero function.
/*! */
* Retrieves a BDD representing the constant zero function. template<typename ValueType>
* InternalAdd<DdType::Sylvan, ValueType> getAddZero() const;
* @return A BDD representing the constant zero function. /*!
*/ * Retrieves an ADD representing the constant function with the given value.
InternalBdd<DdType::Sylvan> getBddZero() const; *
* @return An ADD representing the constant function with the given value.
/*! */
* Retrieves an ADD representing the constant zero function. template<typename ValueType>
* InternalAdd<DdType::Sylvan, ValueType> getConstant(ValueType const& value) const;
* @return An ADD representing the constant zero function. /*!
*/ * Creates a new pair of DD variables and returns the two cubes as a result.
template<typename ValueType> *
InternalAdd<DdType::Sylvan, ValueType> getAddZero() const; * @return The two cubes belonging to the DD variables.
*/
/*! std::pair<InternalBdd<DdType::Sylvan>, InternalBdd<DdType::Sylvan>> createNewDdVariablePair();
* Retrieves an ADD representing the constant function with the given value. /*!
* * Sets whether or not dynamic reordering is allowed for the DDs managed by this manager.
* @return An ADD representing the constant function with the given value. *
*/ * @param value If set to true, dynamic reordering is allowed and forbidden otherwise.
template<typename ValueType> */
InternalAdd<DdType::Sylvan, ValueType> getConstant(ValueType const& value) const; void allowDynamicReordering(bool value);
/*!
/*! * Retrieves whether dynamic reordering is currently allowed.
* Creates a new pair of DD variables and returns the two cubes as a result. *
* * @return True iff dynamic reordering is currently allowed.
* @return The two cubes belonging to the DD variables. */
*/ bool isDynamicReorderingAllowed() const;
std::pair<InternalBdd<DdType::Sylvan>, InternalBdd<DdType::Sylvan>> createNewDdVariablePair(); /*!
* Triggers a reordering of the DDs managed by this manager.
/*! */
* Sets whether or not dynamic reordering is allowed for the DDs managed by this manager. void triggerReordering();
* private:
* @param value If set to true, dynamic reordering is allowed and forbidden otherwise. // A counter for the number of instances of this class. This is used to determine when to initialize and
*/ // quit the sylvan. This is because Sylvan does not know the concept of managers but implicitly has a
void allowDynamicReordering(bool value); // 'global' manager.
static uint_fast64_t numberOfInstances;
/*! // The index of the next free variable index. This needs to be shared across all instances since the sylvan
* Retrieves whether dynamic reordering is currently allowed. // manager is implicitly 'global'.
* static uint_fast64_t nextFreeVariableIndex;
* @return True iff dynamic reordering is currently allowed. };
*/ template<>
bool isDynamicReorderingAllowed() const; InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const;
template<>
/*! InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const;
* Triggers a reordering of the DDs managed by this manager. #ifdef STORM_HAVE_CARL
*/ template<>
void triggerReordering(); InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getAddOne() const;
#endif
private: template<>
// A counter for the number of instances of this class. This is used to determine when to initialize and InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const;
// quit the sylvan. This is because Sylvan does not know the concept of managers but implicitly has a template<>
// 'global' manager. InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const;
static uint_fast64_t numberOfInstances; #ifdef STORM_HAVE_CARL
template<>
// The index of the next free variable index. This needs to be shared across all instances since the sylvan InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getAddZero() const;
// manager is implicitly 'global'. #endif
static uint_fast64_t nextFreeVariableIndex; template<>
}; InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const;
template<>
template<> InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const;
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddOne() const; #ifdef STORM_HAVE_CARL
template<>
template<> InternalAdd<DdType::Sylvan, storm::RationalFunction> InternalDdManager<DdType::Sylvan>::getConstant(storm::RationalNumber const& value) const;
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddOne() const; #endif
}
template<> }
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getAddZero() const;
template<>
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getAddZero() const;
template<>
InternalAdd<DdType::Sylvan, double> InternalDdManager<DdType::Sylvan>::getConstant(double const& value) const;
template<>
InternalAdd<DdType::Sylvan, uint_fast64_t> InternalDdManager<DdType::Sylvan>::getConstant(uint_fast64_t const& value) const;
}
}
#endif /* STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_ */ #endif /* STORM_STORAGE_DD_SYLVAN_INTERNALSYLVANDDMANAGER_H_ */

29
src/utility/sylvan.h
View File

@ -1,15 +1,16 @@
#ifndef STORM_STORAGE_DD_SYLVAN_SYLVAN_H_ #ifndef STORM_STORAGE_DD_SYLVAN_SYLVAN_H_
#define STORM_STORAGE_DD_SYLVAN_SYLVAN_H_ #define STORM_STORAGE_DD_SYLVAN_SYLVAN_H_
#pragma clang diagnostic push
#pragma clang diagnostic push #pragma clang diagnostic ignored "-Wextra-semi"
#pragma clang diagnostic ignored "-Wextra-semi" #pragma clang diagnostic ignored "-Wzero-length-array"
#pragma clang diagnostic ignored "-Wzero-length-array" #pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" #pragma clang diagnostic ignored "-Wdeprecated-register"
#pragma clang diagnostic ignored "-Wdeprecated-register" #pragma clang diagnostic ignored "-Wc99-extensions"
#pragma clang diagnostic ignored "-Wc99-extensions" #include "sylvan_obj.hpp"
#include "sylvan_storm_rational_function.h"
#include "sylvan_obj.hpp" #pragma clang diagnostic pop
#pragma clang diagnostic pop
#endif /* STORM_STORAGE_DD_SYLVAN_SYLVAN_H_ */ #endif /* STORM_STORAGE_DD_SYLVAN_SYLVAN_H_ */
Write Preview
|||||||
100:0
Loading…
Cancel
Save