Merge pull request #21 from kostorr/ORC-103/superpage-flags

ORC-103/superpage-flags

new Readout version v0.15.0 has been released to comply with the new interface.
Please tag ReadoutCard and bump alidist with new versions of ReadoutCard + Readout v0.15.0 in single PR.

Author: sy-c

include/ReadoutCard/Parameters.h

@@ -73,9 +73,6 @@ class Parameters
     /// Type for the readout mode parameter
     using ReadoutModeType = ReadoutMode::type;
 
-    /// Type for the forced unlock enabled parameter
-    using ForcedUnlockEnabledType = bool;
-
     /// Type for the link mask parameter
     using LinkMaskType = std::set<uint32_t>;
 
@@ -210,28 +207,6 @@ class Parameters
     /// \return Reference to this object for chaining calls
     auto setReadoutMode(ReadoutModeType value) -> Parameters&;
 
-    /// Sets the ForcedUnlockEnabled parameter
-    ///
-    /// The channel uses two locks to enforce DMA channel exclusivity: a file lock (which is cleaned up automatically on/
-    /// a process exit) and a mutex (which remains locked in the case of a crash).
-    ///
-    /// Normally, when the mutex is left locked because of a crash, it must be cleaned up manually through
-    /// administrative action before the channel can be acquired again.
-    /// But in some cases, it can be safe to clean up the lock automatically.
-    /// For example, when the file lock is unlocked, the mutex is not, and the user process knows for sure it is not
-    /// holding the mutex itself.
-    ///
-    /// When this parameter is set to true, the channel will assume that it's safe to force the mutex.
-    /// The channel will first try to acquire the channel lock normally.
-    /// If it fails to acquire the mutex, it will forcibly clean up and acquire the lock.
-    /// A warning will be logged when the forced acquire is used.
-    ///
-    /// Note that this is a dangerous operation that can cause the system to crash if the assumption does not hold.
-    ///
-    /// \param value The value to set
-    /// \return Reference to this object for chaining calls
-    auto setForcedUnlockEnabled(ForcedUnlockEnabledType value) -> Parameters&;
-
     /// Sets the LinkMask parameter
     ///
     /// The BAR channel may transfer data from multiple links.
@@ -290,10 +265,6 @@ class Parameters
     /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
     auto getReadoutMode() const -> boost::optional<ReadoutModeType>;
 
-    /// Gets the ForcedUnlockEnabled parameter
-    /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
-    auto getForcedUnlockEnabled() const -> boost::optional<ForcedUnlockEnabledType>;
-
     /// Gets the LinkMask parameter
     /// \return The value wrapped in an optional if it is present, or an empty optional if it was not
     auto getLinkMask() const -> boost::optional<LinkMaskType>;
@@ -351,11 +322,6 @@ class Parameters
     /// \return The value
     auto getReadoutModeRequired() const -> ReadoutModeType;
 
-    /// Gets the ForcedUnlockEnabled parameter
-    /// \exception ParameterException The parameter was not present
-    /// \return The value
-    auto getForcedUnlockEnabledRequired() const -> ForcedUnlockEnabledType;
-
     /// Gets the LinkMask parameter
     /// \exception ParameterException The parameter was not present
     /// \return The value

include/ReadoutCard/Superpage.h

@@ -1,7 +1,8 @@
 /// \file Superpage.h
-/// \brief Definition of the SuperpageStatus struct
+/// \brief Definition of the Superpage struct
 ///
 /// \author Pascal Boeschoten (pascal.boeschoten@cern.ch)
+/// \author Kostas Alexopoulos (kostas.alexopoulos@cern.ch)
 
 #ifndef ALICEO2_INCLUDE_READOUTCARD_SUPERPAGE_H_
 #define ALICEO2_INCLUDE_READOUTCARD_SUPERPAGE_H_
@@ -14,55 +15,87 @@ namespace roc {
 /// Simple struct for holding basic info about a superpage
 struct Superpage
 {
+  public:
     Superpage() = default;
 
     Superpage(size_t offset, size_t size, void* userData = nullptr)
-        : offset(offset), size(size), userData(userData)
+        : mOffset(offset), mSize(size), mUserData(userData)
     {
     }
 
     /// Returns true if the superpage is ready, meaning the transfer is complete. This does not necessarily mean the
     /// superpage is filled.
     bool isReady() const
     {
-      return ready;
+      return mReady;
     }
 
     /// Returns true if the superpage is completely filled
     bool isFilled() const
     {
-      return received == getSize();
+      return mReceived == getSize();
     }
 
     /// Offset from the start of the DMA buffer to the start of the superpage.
     size_t getOffset() const
     {
-      return offset;
+      return mOffset;
     }
 
     /// Size of the superpage in bytes
     size_t getSize() const
     {
-      return size;
+      return mSize;
     }
 
     /// Size of the received data in bytes
     size_t getReceived() const
     {
-      return received;
+      return mReceived;
     }
 
     /// Get the user data pointer
     void* getUserData() const
     {
-      return userData;
+      return mUserData;
     }
 
-    size_t offset = 0; ///< Offset from the start of the DMA buffer to the start of the superpage
-    size_t size = 0; ///< Size of the superpage in bytes
-    void* userData = nullptr; ///< Pointer that users can use for whatever, e.g. to associate data with the superpage
-    size_t received = 0; ///< Size of the received data in bytes
-    bool ready = false; ///< Indicates this superpage is ready
+    /// Set the ready flag
+    void setReady(bool ready)
+    {
+      mReady = ready;
+    }
+
+    /// Set the size of the received data in bytes
+    void setReceived(size_t received)
+    {
+      mReceived = received;
+    }
+
+    /// Set the offset from the start of the DMA buffer to the start of the superpage
+    void setOffset(size_t offset)
+    {
+      mOffset = offset;
+    }
+
+    /// Set the size of the Superpage in bytes
+    void setSize(size_t size)
+    {
+      mSize = size;
+    }
+
+    /// Get the user data pointer
+    void setUserData(void* userData)
+    {
+      mUserData = userData;
+    }
+
+  private:
+    size_t mOffset = 0; ///< Offset from the start of the DMA buffer to the start of the superpage
+    size_t mSize = 0; ///< Size of the superpage in bytes
+    void* mUserData = nullptr; ///< Pointer that users can use for whatever, e.g. to associate data with the superpage
+    size_t mReceived = 0; ///< Size of the received data in bytes
+    bool mReady = false; ///< Indicates this superpage is ready
 };
 
 } // namespace roc

src/CommandLineUtilities/ProgramCleanup.cxx

@@ -30,8 +30,8 @@ class ProgramCleanup: public Program
     {
       Options::addOptionCardId(options);
       Options::addOptionChannel(options);
-      options.add_options()("force",po::bool_switch(&mForceCleanup),
-          "Force cleanup of shared state files if normal cleanup fails");
+      //options.add_options()("force",po::bool_switch(&mForceCleanup),
+       //   "Force cleanup of shared state files if normal cleanup fails");
     }
 
     virtual void run(const boost::program_options::variables_map& map)
@@ -43,14 +43,14 @@ class ProgramCleanup: public Program
       // It will not succeed if the channel was not initialized properly before the running of this program.
       cout << "### Attempting cleanup...\n";
       auto params = AliceO2::roc::Parameters::makeParameters(cardId, channelNumber);
-      params.setForcedUnlockEnabled(mForceCleanup);
+      //params.setForcedUnlockEnabled(mForceCleanup);
       params.setBufferParameters(buffer_parameters::Null());
       auto channel = ChannelFactory().getDmaChannel(params);
       cout << "### Done!\n";
     }
 
   private:
-    bool mForceCleanup;
+    //bool mForceCleanup;
 };
 } // Anonymous namespace