Commit 792f5a97 authored by Cedric Caffy's avatar Cedric Caffy
Browse files

[lto_rao] InterpolationFilePositionEstimator WIP

parent 29d241ec
......@@ -295,6 +295,7 @@ Unit tests and system tests with virtual tape drives
%{_libdir}/libctamediachangerunittests.so*
%{_libdir}/libctadiskunittests.so*
%{_libdir}/libctatapelabelunittests.so*
%{_libdir}/libctatapeserverraounittests.so*
%{_bindir}/cta-systemTests
%{_libdir}/libctadaemonunittests-multiprocess.so*
%attr(0644,root,root) %{_datadir}/%{name}-%{ctaVersion}/unittest/*.suppr
......
......@@ -4,7 +4,7 @@ include_directories(${PROJECT_SOURCE_DIR}/tapeserver)
include_directories(${PROJECT_SOURCE_DIR}/tapeserver/h)
set(CTARAO_LIBRARY_SRCS
RAOConfigurationData.cpp
RAOParams.cpp
RAOManager.cpp
RAOAlgorithm.cpp
EnterpriseRAOAlgorithm.cpp
......@@ -22,9 +22,18 @@ set(CTARAO_LIBRARY_SRCS
Position.cpp
FilePositionEstimator.cpp
InterpolationFilePositionEstimator.cpp
RAOHelpers.cpp
)
add_library (ctarao SHARED
${CTARAO_LIBRARY_SRCS})
install(TARGETS ctarao DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
\ No newline at end of file
install(TARGETS ctarao DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
add_library(ctatapeserverraounittests SHARED
RAOTest.cpp)
set_property(TARGET ctatapeserverraounittests PROPERTY SOVERSION "${CTA_SOVERSION}")
set_property(TARGET ctatapeserverraounittests PROPERTY VERSION "${CTA_LIBVERSION}")
install(TARGETS ctatapeserverraounittests DESTINATION usr/${CMAKE_INSTALL_LIBDIR})
\ No newline at end of file
......@@ -22,17 +22,17 @@
namespace castor { namespace tape { namespace tapeserver { namespace rao {
ConfigurableRAOAlgorithmFactory::ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOConfigurationData & raoConfigurationData):m_drive(drive),
m_catalogue(catalogue), m_raoConfigurationData(raoConfigurationData){}
ConfigurableRAOAlgorithmFactory::ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOParams & raoParams):m_drive(drive),
m_catalogue(catalogue), m_raoParams(raoParams){}
ConfigurableRAOAlgorithmFactory::~ConfigurableRAOAlgorithmFactory() {
}
std::unique_ptr<RAOAlgorithm> ConfigurableRAOAlgorithmFactory::createRAOAlgorithm() {
std::unique_ptr<RAOAlgorithm> ret;
switch(m_raoConfigurationData.getAlgorithmType()){
case RAOConfigurationData::RAOAlgorithmType::sltf:{
SLTFRAOAlgorithm::Builder builder(m_raoConfigurationData,m_drive,m_catalogue);
switch(m_raoParams.getAlgorithmType()){
case RAOParams::RAOAlgorithmType::sltf:{
SLTFRAOAlgorithm::Builder builder(m_raoParams,m_drive,m_catalogue);
ret.reset(builder.build().release());
break;
}
......
......@@ -18,7 +18,7 @@
#pragma once
#include "RAOConfigurationData.hpp"
#include "RAOParams.hpp"
#include "RAOAlgorithmFactory.hpp"
#include "castor/tape/tapeserver/drive/DriveInterface.hpp"
#include "RAOManager.hpp"
......@@ -27,13 +27,13 @@ namespace castor { namespace tape { namespace tapeserver { namespace rao {
class ConfigurableRAOAlgorithmFactory : public RAOAlgorithmFactory{
public:
ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOConfigurationData & raoConfigurationData);
ConfigurableRAOAlgorithmFactory(drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue, const RAOParams & raoParams);
std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() override;
virtual ~ConfigurableRAOAlgorithmFactory();
private:
drive::DriveInterface * m_drive;
cta::catalogue::Catalogue * m_catalogue;
RAOConfigurationData m_raoConfigurationData;
RAOParams m_raoParams;
};
}}}}
......
......@@ -28,7 +28,62 @@ InterpolationFilePositionEstimator::~InterpolationFilePositionEstimator() {
}
FilePosition InterpolationFilePositionEstimator::getFilePosition(const cta::RetrieveJob& job) const {
return FilePosition();
FilePosition ret;
cta::common::dataStructures::TapeFile tapeFile = job.selectedTapeFile();
uint64_t startBlock = tapeFile.blockId;
Position startPosition = getPhysicalPosition(startBlock);
ret.setStartPosition(startPosition);
return ret;
}
Position InterpolationFilePositionEstimator::getPhysicalPosition(const uint64_t blockId) const {
Position ret;
ret.setWrap(determineWrapNb(blockId));
ret.setLPos(determineLPos(blockId,ret.getWrap()));
return ret;
}
uint64_t InterpolationFilePositionEstimator::determineWrapNb(const uint64_t blockId) const {
if(m_endOfWrapPositions.empty()){
std::string errorMsg = "In InterpolationFilePositionEstimator::determineWrapNb(), unable to find the wrap number of the blockId " + std::to_string(blockId) + " because no EOWP informations have been found.";
throw cta::exception::Exception(errorMsg);
}
auto eowpItor = m_endOfWrapPositions.begin();
while(eowpItor != m_endOfWrapPositions.end() && blockId > eowpItor->blockId){
eowpItor++;
}
if(eowpItor == m_endOfWrapPositions.end()){
eowpItor--;
std::string errorMsg = "In InterpolationFilePositionEstimator::determineWrapNb(), the blockId " + std::to_string(blockId) + " is greater than the last wrap EOWP blockId ("+std::to_string(eowpItor->blockId)+")";
throw cta::exception::Exception(errorMsg);
}
return eowpItor->wrapNumber;
}
uint64_t InterpolationFilePositionEstimator::determineLPos(const uint64_t blockId, const uint64_t wrapNumber) const {
uint64_t fileLpos;
cta::optional<uint64_t> minTapeLpos = m_mediaType.minLPos;
cta::optional<uint64_t> maxTapeLpos = m_mediaType.maxLPos;
uint64_t fileBlockId = blockId;
if(!minTapeLpos || !maxTapeLpos){
std::string errorMsg = "In InterpolationFilePositionEstimator::determineLPos(), the media type (" + m_mediaType.name + ") associated to the tape tape does not give informations about the minLPos and maxLPos.";
throw cta::exception::Exception(errorMsg);
}
uint64_t minLpos = minTapeLpos.value();
uint64_t maxLpos = maxTapeLpos.value();
uint64_t b_max = m_endOfWrapPositions.at(wrapNumber).blockId;
if(wrapNumber > 0){
drive::endOfWrapPosition previousWrapPositionInfos = m_endOfWrapPositions.at(wrapNumber-1);
b_max -= previousWrapPositionInfos.blockId;
fileBlockId -= previousWrapPositionInfos.blockId;
}
if(wrapNumber % 2 == 0){
fileLpos = minLpos + fileBlockId * (maxLpos - minLpos) / b_max;
} else {
fileLpos = maxLpos - fileBlockId * (maxLpos - minLpos) / b_max;
}
return fileLpos;
}
......
......@@ -31,6 +31,9 @@ public:
FilePosition getFilePosition(const cta::RetrieveJob& job) const override;
virtual ~InterpolationFilePositionEstimator();
private:
Position getPhysicalPosition(const uint64_t blockId) const;
uint64_t determineWrapNb(const uint64_t blockId) const;
uint64_t determineLPos(const uint64_t blockId, const uint64_t wrapNumber) const;
std::vector<drive::endOfWrapPosition> m_endOfWrapPositions;
cta::catalogue::MediaType m_mediaType;
};
......
......@@ -23,16 +23,13 @@
namespace castor { namespace tape { namespace tapeserver { namespace rao {
class NonConfigurableRAOAlgorithmFactory;
/**
* This class represents a LinearRAOAlgorithm
*/
class LinearRAOAlgorithm : public RAOAlgorithm {
public:
friend NonConfigurableRAOAlgorithmFactory;
LinearRAOAlgorithm();
/**
* This method will return the indexes of the jobs that are reoreded in a linear way (sorted by fseq ascendant)
* Example : if the fseqs of jobs in parameter are arranged like this [2, 3, 1, 4] the
......@@ -42,8 +39,7 @@ public:
*/
std::vector<uint64_t> performRAO(const std::vector<std::unique_ptr<cta::RetrieveJob> >& jobs) override;
virtual ~LinearRAOAlgorithm();
private:
LinearRAOAlgorithm();
};
}}}}
\ No newline at end of file
......@@ -22,7 +22,7 @@
namespace castor { namespace tape { namespace tapeserver { namespace rao {
NonConfigurableRAOAlgorithmFactory::NonConfigurableRAOAlgorithmFactory(const RAOConfigurationData::RAOAlgorithmType & type) : m_type(type) {
NonConfigurableRAOAlgorithmFactory::NonConfigurableRAOAlgorithmFactory(const RAOParams::RAOAlgorithmType & type) : m_type(type) {
}
NonConfigurableRAOAlgorithmFactory::~NonConfigurableRAOAlgorithmFactory() {
......@@ -31,11 +31,11 @@ NonConfigurableRAOAlgorithmFactory::~NonConfigurableRAOAlgorithmFactory() {
std::unique_ptr<RAOAlgorithm> NonConfigurableRAOAlgorithmFactory::createRAOAlgorithm() {
std::unique_ptr<RAOAlgorithm> ret;
switch(m_type){
case RAOConfigurationData::linear:{
case RAOParams::linear:{
ret.reset(new LinearRAOAlgorithm());
break;
}
case RAOConfigurationData::random:{
case RAOParams::random:{
ret.reset(new RandomRAOAlgorithm());
break;
}
......
......@@ -18,7 +18,7 @@
#pragma once
#include "RAOConfigurationData.hpp"
#include "RAOParams.hpp"
#include "RAOAlgorithmFactory.hpp"
namespace castor { namespace tape { namespace tapeserver { namespace rao {
......@@ -35,7 +35,7 @@ public:
* @param type the type given will be used by the createRAOAlgorithm() method
* to instanciate the correct algorithm regarding its type
*/
NonConfigurableRAOAlgorithmFactory(const RAOConfigurationData::RAOAlgorithmType & type);
NonConfigurableRAOAlgorithmFactory(const RAOParams::RAOAlgorithmType & type);
/**
* Returns the correct instance of RAO algorithm regarding the type
* given while constructing this factory.
......@@ -44,7 +44,7 @@ public:
std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() override;
virtual ~NonConfigurableRAOAlgorithmFactory();
private:
RAOConfigurationData::RAOAlgorithmType m_type;
RAOParams::RAOAlgorithmType m_type;
};
}}}}
\ No newline at end of file
......@@ -26,19 +26,19 @@ Position::Position():m_wrap(0),m_lpos(0) {
Position::~Position() {
}
uint32_t Position::getLPos() const {
uint64_t Position::getLPos() const {
return m_lpos;
}
uint32_t Position::getWrap() const {
uint64_t Position::getWrap() const {
return m_wrap;
}
}
void Position::setLPos(const uint32_t lpos) {
void Position::setLPos(const uint64_t lpos) {
m_lpos = lpos;
}
void Position::setWrap(const uint32_t wrap) {
void Position::setWrap(const uint64_t wrap) {
m_wrap = wrap;
}
......
......@@ -26,13 +26,13 @@ class Position {
public:
Position();
virtual ~Position();
uint32_t getWrap() const;
uint32_t getLPos() const;
void setWrap(const uint32_t wrap);
void setLPos(const uint32_t lpos);
uint64_t getWrap() const;
uint64_t getLPos() const;
void setWrap(const uint64_t wrap);
void setLPos(const uint64_t lpos);
private:
uint32_t m_wrap;
unsigned int m_lpos;
uint64_t m_wrap;
uint64_t m_lpos;
};
}}}}
......@@ -18,6 +18,7 @@
#include "RAOAlgorithmFactory.hpp"
#include "LinearRAOAlgorithm.hpp"
namespace castor { namespace tape { namespace tapeserver { namespace rao {
......@@ -26,4 +27,11 @@ namespace castor { namespace tape { namespace tapeserver { namespace rao {
RAOAlgorithmFactory::~RAOAlgorithmFactory() {
}
std::unique_ptr<RAOAlgorithm> RAOAlgorithmFactory::createDefaultLinearAlgorithm() {
std::unique_ptr<RAOAlgorithm> ret;
ret.reset(new LinearRAOAlgorithm());
return ret;
}
}}}}
\ No newline at end of file
......@@ -34,6 +34,9 @@ public:
* @return the RAO algorithm instance
*/
virtual std::unique_ptr<RAOAlgorithm> createRAOAlgorithm() = 0;
std::unique_ptr<RAOAlgorithm> createDefaultLinearAlgorithm();
virtual ~RAOAlgorithmFactory();
private:
......
......@@ -37,9 +37,9 @@ std::unique_ptr<RAOAlgorithmFactory> RAOAlgorithmFactoryFactory::createAlgorithm
ret.reset(new EnterpriseRAOAlgorithmFactory(m_raoManager.getDrive(),maxFilesSupported.value()));
}
} else {
RAOConfigurationData raoData = m_raoManager.getRAODataConfig();
RAOParams raoData = m_raoManager.getRAODataConfig();
//We will instanciate a CTA RAO algorithm
RAOConfigurationData::RAOAlgorithmType raoAlgoType;
RAOParams::RAOAlgorithmType raoAlgoType;
try {
raoAlgoType = raoData.getAlgorithmType();
} catch (const cta::exception::Exception & ex) {
......@@ -49,16 +49,16 @@ std::unique_ptr<RAOAlgorithmFactory> RAOAlgorithmFactoryFactory::createAlgorithm
" in the tapeserver configuration is " + raoData.getRAOAlgorithmName() + " the available algorithm names are " + raoData.getCTARAOAlgorithmNameAvailable()
+ ". We will apply a linear algorithm instead.";
m_lc.log(cta::log::WARNING, msg);
raoAlgoType = RAOConfigurationData::RAOAlgorithmType::linear;
raoAlgoType = RAOParams::RAOAlgorithmType::linear;
}
switch(raoAlgoType){
case RAOConfigurationData::RAOAlgorithmType::linear:
case RAOConfigurationData::RAOAlgorithmType::random:
case RAOParams::RAOAlgorithmType::linear:
case RAOParams::RAOAlgorithmType::random:
{
ret.reset(new NonConfigurableRAOAlgorithmFactory(raoAlgoType));
break;
}
case RAOConfigurationData::RAOAlgorithmType::sltf:
case RAOParams::RAOAlgorithmType::sltf:
{
ret.reset(new ConfigurableRAOAlgorithmFactory(m_raoManager.getDrive(),m_raoManager.getCatalogue(), raoData));
break;
......
......@@ -41,7 +41,6 @@ public:
/**
* Returns the correct RAOAlgorithmFactory according to the informations
* stored in the RAO manager
* @return
*/
std::unique_ptr<RAOAlgorithmFactory> createAlgorithmFactory();
virtual ~RAOAlgorithmFactoryFactory();
......
/*
* The CERN Tape Archive (CTA) project
* Copyright (C) 2019 CERN
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "RAOHelpers.hpp"
#include "tapeserver/castor/tape/tapeserver/drive/DriveInterface.hpp"
namespace castor { namespace tape { namespace tapeserver { namespace rao {
void RAOHelpers::improveEndOfLastWrapPositionIfPossible(std::vector<drive::endOfWrapPosition>& endOfWrapPositions) {
uint64_t nbBlocksPerWrap = 0;
auto nbEndOfWrapPositions = endOfWrapPositions.size();
if(nbEndOfWrapPositions < 2){
//No improvement possible
return;
}
for(uint64_t i = 0; i < nbEndOfWrapPositions - 1; ++i){
nbBlocksPerWrap += (endOfWrapPositions.at(i).blockId - endOfWrapPositions.at(i-1).blockId);
}
uint64_t meanNbBlocksPerWrap = nbBlocksPerWrap / nbEndOfWrapPositions;
endOfWrapPositions[nbEndOfWrapPositions-1].blockId = endOfWrapPositions.at(nbEndOfWrapPositions-2).blockId + meanNbBlocksPerWrap;
}
}}}}
\ No newline at end of file
/*
* The CERN Tape Archive (CTA) project
* Copyright (C) 2019 CERN
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <vector>
#include "castor/tape/tapeserver/drive/DriveInterface.hpp"
namespace castor { namespace tape { namespace tapeserver { namespace rao {
class RAOHelpers {
public:
/**
* In the LTO documentation, the Read End Of Wrap Position (REOWP) command will not give the last
* wrap correct EOWP. It will give the last blockId written by the drive
* on the tape
* This method will modify the last wrap EOWP (blockId) from the vector of EOWP passed in parameter
* to set it to the penultimate wrap EOWP + the mean of the number of blocks each wrap contains
*/
static void improveEndOfLastWrapPositionIfPossible(std::vector<drive::endOfWrapPosition> & endOfWrapPositions);
};
}}}}
\ No newline at end of file
......@@ -23,6 +23,7 @@
#include "NonConfigurableRAOAlgorithmFactory.hpp"
#include "RAOAlgorithmFactoryFactory.hpp"
#include "catalogue/Catalogue.hpp"
#include "LinearRAOAlgorithm.hpp"
namespace castor { namespace tape { namespace tapeserver { namespace rao {
......@@ -30,7 +31,7 @@ RAOManager::RAOManager() {
}
RAOManager::RAOManager(const RAOConfigurationData & config, drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue):m_raoConfigurationData(config),
RAOManager::RAOManager(const RAOParams & config, drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue):m_raoParams(config),
m_drive(drive), m_catalogue(catalogue){}
RAOManager::RAOManager(const RAOManager& manager){
......@@ -41,7 +42,7 @@ RAOManager::RAOManager(const RAOManager& manager){
m_hasUDS = manager.m_hasUDS;
m_isDriveEnterpriseEnabled = manager.m_isDriveEnterpriseEnabled;
m_maxFilesSupported = manager.m_maxFilesSupported;
m_raoConfigurationData = manager.m_raoConfigurationData;
m_raoParams = manager.m_raoParams;
}
}
......@@ -53,7 +54,7 @@ RAOManager& RAOManager::operator=(const RAOManager& manager) {
m_hasUDS = manager.m_hasUDS;
m_isDriveEnterpriseEnabled = manager.m_isDriveEnterpriseEnabled;
m_maxFilesSupported = manager.m_maxFilesSupported;
m_raoConfigurationData = manager.m_raoConfigurationData;
m_raoParams = manager.m_raoParams;
}
return *this;
}
......@@ -63,7 +64,7 @@ RAOManager::~RAOManager() {
}
bool RAOManager::useRAO() const{
return m_raoConfigurationData.useRAO();
return m_raoParams.useRAO();
}
bool RAOManager::hasUDS() const {
......@@ -84,7 +85,7 @@ cta::catalogue::Catalogue* RAOManager::getCatalogue() const {
void RAOManager::disableRAO(){
m_raoConfigurationData.disableRAO();
m_raoParams.disableRAO();
}
void RAOManager::setEnterpriseRAOUdsLimits(const SCSI::Structures::RAO::udsLimits& raoLimits) {
......@@ -98,14 +99,41 @@ cta::optional<uint64_t> RAOManager::getMaxFilesSupported() const{
return m_maxFilesSupported;
}
RAOConfigurationData RAOManager::getRAODataConfig() const {
return m_raoConfigurationData;
RAOParams RAOManager::getRAODataConfig() const {
return m_raoParams;
}
std::vector<uint64_t> RAOManager::queryRAO(const std::vector<std::unique_ptr<cta::RetrieveJob>> & jobs, cta::log::LogContext & lc){
RAOAlgorithmFactoryFactory raoAlgoFactoryFactory(*this,lc);
std::unique_ptr<RAOAlgorithm> raoAlgo = raoAlgoFactoryFactory.createAlgorithmFactory()->createRAOAlgorithm();
return raoAlgo->performRAO(jobs);
std::unique_ptr<RAOAlgorithmFactory> raoAlgoFactory = raoAlgoFactoryFactory.createAlgorithmFactory();
std::unique_ptr<RAOAlgorithm> raoAlgo;
std::vector<uint64_t> ret;
try {
raoAlgo = raoAlgoFactory->createRAOAlgorithm();
} catch(const cta::exception::Exception & ex){
cta::log::ScopedParamContainer spc(lc);
spc.add("errorMsg",ex.getMessageValue())
.add("raoAlgorithmName",m_raoParams.getRAOAlgorithmName())
.add("raoAlgorithmOptions",m_raoParams.getRAOAlgorithmOptions().getOptionsString())
.add("useRAO",m_raoParams.useRAO())
.add("vid",m_raoParams.getMountedVid());
lc.log(cta::log::WARNING,"In RAOManager::queryRAO(), failed to instanciate the RAO algorithm, will perform a linear RAO.");
raoAlgo = raoAlgoFactory->createDefaultLinearAlgorithm();
}
try {
ret = raoAlgo->performRAO(jobs);
} catch (const cta::exception::Exception & ex) {
cta::log::ScopedParamContainer spc(lc);
spc.add("errorMsg",ex.getMessageValue())
.add("raoAlgorithmName",m_raoParams.getRAOAlgorithmName())
.add("raoAlgorithmOptions",m_raoParams.getRAOAlgorithmOptions().getOptionsString())
.add("useRAO",m_raoParams.useRAO())
.add("vid",m_raoParams.getMountedVid());
lc.log(cta::log::WARNING,"In RAOManager::queryRAO(), failed to perform the RAO algorithm, will perform a linear RAO.");
raoAlgo = raoAlgoFactory->createDefaultLinearAlgorithm();
ret = raoAlgo->performRAO(jobs);
}
return ret;
}
......
......@@ -19,7 +19,7 @@
#pragma once
#include <vector>
#include <memory>
#include "castor/tape/tapeserver/RAO/RAOConfigurationData.hpp"
#include "castor/tape/tapeserver/RAO/RAOParams.hpp"
#include "castor/tape/tapeserver/drive/DriveInterface.hpp"
#include "castor/tape/tapeserver/SCSI/Structures.hpp"
#include "scheduler/RetrieveJob.hpp"
......@@ -46,7 +46,7 @@ public:
* @param drive the DriveInterface of the drive that is mounting.
* @param catalogue the pointer to the CTA catalogue
*/
RAOManager(const RAOConfigurationData & config, castor::tape::tapeserver::drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue);
RAOManager(const RAOParams & config, castor::tape::tapeserver::drive::DriveInterface * drive, cta::catalogue::Catalogue * catalogue);
/**
* Copy constructor
......@@ -101,7 +101,7 @@ public:
private:
//RAO Configuration Data
RAOConfigurationData m_raoConfigurationData;
RAOParams m_raoParams;
/** Enterprise Drive-specific RAO parameters */
SCSI::Structures::RAO::udsLimits m_enterpriseRaoLimits;
//Is true if the drive have been able to get the RAO UDS limits numbers
......@@ -132,7 +132,7 @@ private:
/**
* Returns the RAO data that is used by this RAOManager
*/
RAOConfigurationData getRAODataConfig() const;
RAOParams getRAODataConfig() const;
};
......
......@@ -105,5 +105,9 @@ RAOOptions::FilePositionEstimatorType RAOOptions::getFilePositionEstimatorType()
return RAOOptions::FilePositionEstimatorType::interpolation;
}
std::string RAOOptions::getOptionsString() {
return m_options;
}
}}}}
\ No newline at end of file