From 44fbdec051fb0d8473c9afac96c89080db9d1c54 Mon Sep 17 00:00:00 2001
From: Andreas Joachim Peters <andreas.joachim.peters@cern.ch>
Date: Tue, 11 Jun 2024 13:44:45 +0200
Subject: [PATCH] XrdApps::JCache: fix indention/formatting
---
.../app/XrdClCacheCleaner.cc | 175 +++---
.../XrdClJCachePlugin/cache/IntervalTree.hh | 115 ++--
.../XrdClJCachePlugin/cache/Journal.cc | 165 +++---
.../XrdClJCachePlugin/cache/Journal.hh | 113 ++--
src/XrdApps/XrdClJCachePlugin/cache/RbTree.hh | 359 +++++-------
src/XrdApps/XrdClJCachePlugin/file/Art.hh | 137 ++---
.../XrdClJCachePlugin/file/CacheStats.hh | 515 ++++++++++--------
.../XrdClJCachePlugin/file/TimeBench.hh | 117 ++--
.../XrdClJCachePlugin/file/XrdClJCacheFile.cc | 353 +++++-------
.../XrdClJCachePlugin/file/XrdClJCacheFile.hh | 138 ++---
.../handler/XrdClJCachePgReadHandler.hh | 55 +-
.../handler/XrdClJCacheReadHandler.hh | 55 +-
.../handler/XrdClJCacheReadVHandler.hh | 97 ++--
.../plugin/XrdClJCachePlugin.cc | 13 +-
.../plugin/XrdClJCachePlugin.hh | 154 +++---
.../vector/XrdClVectorCache.cc | 353 ++++++------
.../vector/XrdClVectorCache.hh | 46 +-
17 files changed, 1407 insertions(+), 1553 deletions(-)
diff --git a/src/XrdApps/XrdClJCachePlugin/app/XrdClCacheCleaner.cc b/src/XrdApps/XrdClJCachePlugin/app/XrdClCacheCleaner.cc
index f33c5a82fac..c3d156ccf43 100644
--- a/src/XrdApps/XrdClJCachePlugin/app/XrdClCacheCleaner.cc
+++ b/src/XrdApps/XrdClJCachePlugin/app/XrdClCacheCleaner.cc
@@ -21,109 +21,122 @@
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
-#include <iostream>
-#include <filesystem>
-#include <chrono>
-#include <thread>
-#include <vector>
#include <algorithm>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#include <chrono>
#include <ctime>
+#include <filesystem>
#include <iomanip>
+#include <iostream>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <thread>
+#include <unistd.h>
+#include <vector>
namespace fs = std::filesystem;
void printCurrentTime() {
- auto now = std::chrono::system_clock::now();
- auto now_ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
- auto now_ns_since_epoch = now_ns.time_since_epoch();
- auto seconds = std::chrono::duration_cast<std::chrono::seconds>(now_ns_since_epoch);
- auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(now_ns_since_epoch - seconds);
-
- auto now_t = std::chrono::system_clock::to_time_t(now);
- struct tm* tm = std::localtime(&now_t);
-
- int year = tm->tm_year - 100; // tm_year represents years since 1900
-
- std::cout << std::setfill('0') << std::setw(2) << year << std::setfill('0') << std::setw(4) << (tm->tm_mon + 1) * 100 + tm->tm_mday << " ";
- std::cout << std::setw(2) << std::setfill('0') << tm->tm_hour << ":" << std::setw(2) << tm->tm_min << ":" << std::setw(2) << tm->tm_sec << " ";
- std::cout << "time=" << seconds.count() << "." << std::setw(9) << std::setfill('0') << nanoseconds.count() << " ";
+ auto now = std::chrono::system_clock::now();
+ auto now_ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
+ auto now_ns_since_epoch = now_ns.time_since_epoch();
+ auto seconds =
+ std::chrono::duration_cast<std::chrono::seconds>(now_ns_since_epoch);
+ auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(
+ now_ns_since_epoch - seconds);
+
+ auto now_t = std::chrono::system_clock::to_time_t(now);
+ struct tm *tm = std::localtime(&now_t);
+
+ int year = tm->tm_year - 100; // tm_year represents years since 1900
+
+ std::cout << std::setfill('0') << std::setw(2) << year << std::setfill('0')
+ << std::setw(4) << (tm->tm_mon + 1) * 100 + tm->tm_mday << " ";
+ std::cout << std::setw(2) << std::setfill('0') << tm->tm_hour << ":"
+ << std::setw(2) << tm->tm_min << ":" << std::setw(2) << tm->tm_sec
+ << " ";
+ std::cout << "time=" << seconds.count() << "." << std::setw(9)
+ << std::setfill('0') << nanoseconds.count() << " ";
}
-time_t getLastAccessTime(const fs::path& filePath) {
- struct stat fileInfo;
- if (stat(filePath.c_str(), &fileInfo) != 0) {
- return -1; // Error occurred
- }
- return fileInfo.st_atime;
+time_t getLastAccessTime(const fs::path &filePath) {
+ struct stat fileInfo;
+ if (stat(filePath.c_str(), &fileInfo) != 0) {
+ return -1; // Error occurred
+ }
+ return fileInfo.st_atime;
}
-long long getDirectorySize(const fs::path& directory) {
- long long totalSize = 0;
- for (const auto& entry : fs::recursive_directory_iterator(directory)) {
- if (fs::is_regular_file(entry)) {
- totalSize += fs::file_size(entry);
- }
+long long getDirectorySize(const fs::path &directory) {
+ long long totalSize = 0;
+ for (const auto &entry : fs::recursive_directory_iterator(directory)) {
+ if (fs::is_regular_file(entry)) {
+ totalSize += fs::file_size(entry);
}
- return totalSize;
+ }
+ return totalSize;
}
-std::vector<std::pair<long long, fs::path>> getFilesByAccessTime(const fs::path& directory) {
- std::vector<std::pair<long long, fs::path>> fileList;
- for (const auto& entry : fs::recursive_directory_iterator(directory)) {
- if (fs::is_regular_file(entry)) {
- auto accessTime = getLastAccessTime(entry.path());
- fileList.emplace_back(accessTime, entry.path());
- }
+std::vector<std::pair<long long, fs::path>>
+getFilesByAccessTime(const fs::path &directory) {
+ std::vector<std::pair<long long, fs::path>> fileList;
+ for (const auto &entry : fs::recursive_directory_iterator(directory)) {
+ if (fs::is_regular_file(entry)) {
+ auto accessTime = getLastAccessTime(entry.path());
+ fileList.emplace_back(accessTime, entry.path());
}
- std::sort(fileList.begin(), fileList.end());
- return fileList;
+ }
+ std::sort(fileList.begin(), fileList.end());
+ return fileList;
}
-void cleanDirectory(const fs::path& directory, long long highWatermark, long long lowWatermark) {
- long long currentSize = getDirectorySize(directory);
- if (currentSize <= highWatermark) {
- printCurrentTime();
- std::cout << "Directory size is within the limit. No action needed." << std::endl;
- return;
- }
+void cleanDirectory(const fs::path &directory, long long highWatermark,
+ long long lowWatermark) {
+ long long currentSize = getDirectorySize(directory);
+ if (currentSize <= highWatermark) {
+ printCurrentTime();
+ std::cout << "Directory size is within the limit. No action needed."
+ << std::endl;
+ return;
+ }
+
+ auto files = getFilesByAccessTime(directory);
- auto files = getFilesByAccessTime(directory);
-
- for (const auto& [accessTime, filePath] : files) {
- if (currentSize <= lowWatermark) {
- break;
- }
- long long fileSize = fs::file_size(filePath);
- try {
- fs::remove(filePath);
- currentSize -= fileSize;
- printCurrentTime();
- std::cout << "Deleted: " << filePath << " (Size: " << fileSize << " bytes)" << std::endl;
- } catch (const std::exception& e) {
- printCurrentTime();
- std::cerr << "Error deleting " << filePath << ": " << e.what() << std::endl;
- }
+ for (const auto &[accessTime, filePath] : files) {
+ if (currentSize <= lowWatermark) {
+ break;
}
+ long long fileSize = fs::file_size(filePath);
+ try {
+ fs::remove(filePath);
+ currentSize -= fileSize;
+ printCurrentTime();
+ std::cout << "Deleted: " << filePath << " (Size: " << fileSize
+ << " bytes)" << std::endl;
+ } catch (const std::exception &e) {
+ printCurrentTime();
+ std::cerr << "Error deleting " << filePath << ": " << e.what()
+ << std::endl;
+ }
+ }
}
-int main(int argc, char* argv[]) {
- if (argc != 5) {
- std::cerr << "Usage: " << argv[0] << " <directory> <highwatermark> <lowwatermark> <interval>" << std::endl;
- return 1;
- }
+int main(int argc, char *argv[]) {
+ if (argc != 5) {
+ std::cerr << "Usage: " << argv[0]
+ << " <directory> <highwatermark> <lowwatermark> <interval>"
+ << std::endl;
+ return 1;
+ }
- fs::path directory = argv[1];
- long long highWatermark = std::stoll(argv[2]);
- long long lowWatermark = std::stoll(argv[3]);
- int interval = std::stoi(argv[4]);
+ fs::path directory = argv[1];
+ long long highWatermark = std::stoll(argv[2]);
+ long long lowWatermark = std::stoll(argv[3]);
+ int interval = std::stoi(argv[4]);
- while (true) {
- cleanDirectory(directory, highWatermark, lowWatermark);
- std::this_thread::sleep_for(std::chrono::seconds(interval));
- }
+ while (true) {
+ cleanDirectory(directory, highWatermark, lowWatermark);
+ std::this_thread::sleep_for(std::chrono::seconds(interval));
+ }
- return 0;
+ return 0;
}
diff --git a/src/XrdApps/XrdClJCachePlugin/cache/IntervalTree.hh b/src/XrdApps/XrdClJCachePlugin/cache/IntervalTree.hh
index aa9bc81f904..e281c8525bb 100644
--- a/src/XrdApps/XrdClJCachePlugin/cache/IntervalTree.hh
+++ b/src/XrdApps/XrdClJCachePlugin/cache/IntervalTree.hh
@@ -1,7 +1,7 @@
//------------------------------------------------------------------------------
// Copyright (c) 2024 by European Organization for Nuclear Research (CERN)
// Author: Andreas-Joachim Peters <andreas.joachim.peters@cern.ch>
-// Michal Simon
+// Michal Simon
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
@@ -27,79 +27,68 @@
/*----------------------------------------------------------------------------*/
#include "RbTree.hh"
/*----------------------------------------------------------------------------*/
-#include <set>
-#include <memory>
-#include <vector>
-#include <exception>
#include <algorithm>
#include <cstdlib>
+#include <exception>
+#include <memory>
+#include <set>
+#include <vector>
/*----------------------------------------------------------------------------*/
-template<typename I, typename V>
-class interval_node_t
-{
+template <typename I, typename V> class interval_node_t {
public:
-
- template<typename, typename> friend class interval_tree;
- template<typename, typename, typename> friend class rbtree;
+ template <typename, typename> friend class interval_tree;
+ template <typename, typename, typename> friend class rbtree;
friend class IntervalTreeTest;
public:
-
- interval_node_t(I low, I high, const V& value) :
- low(low), high(high), value(value), key(this->low), max(high), colour(RED),
- parent(nullptr) { }
+ interval_node_t(I low, I high, const V &value)
+ : low(low), high(high), value(value), key(this->low), max(high),
+ colour(RED), parent(nullptr) {}
const I low;
const I high;
V value;
private:
- const I& key;
+ const I &key;
I max;
colour_t colour;
- interval_node_t* parent;
+ interval_node_t *parent;
std::unique_ptr<interval_node_t> left;
std::unique_ptr<interval_node_t> right;
};
-template<typename I, typename V>
-class interval_tree : public rbtree< I, V, interval_node_t<I, V> >
-{
+template <typename I, typename V>
+class interval_tree : public rbtree<I, V, interval_node_t<I, V>> {
private:
-
typedef interval_node_t<I, V> N;
typedef typename rbtree<I, V, N>::leaf_node_t leaf_node_t;
- std::unique_ptr<N> make_node(I low, I high, const V& value)
- {
+ std::unique_ptr<N> make_node(I low, I high, const V &value) {
return std::unique_ptr<N>(new N(low, high, value));
}
public:
-
typedef typename rbtree<I, V, N>::iterator iterator;
struct less {
- bool operator()(const iterator& x, const iterator& y) const
- {
+ bool operator()(const iterator &x, const iterator &y) const {
return x->low < y->low;
}
};
- virtual ~interval_tree() { }
+ virtual ~interval_tree() {}
- void insert(I low, I high, const V& value)
- {
+ void insert(I low, I high, const V &value) {
insert_into(low, high, value, this->tree_root);
}
- void erase(I low, I high)
- {
- std::unique_ptr<N>& node = this->find_in(low, this->tree_root);
+ void erase(I low, I high) {
+ std::unique_ptr<N> &node = this->find_in(low, this->tree_root);
if (!node || node->low != low || node->high != high) {
return;
@@ -108,21 +97,18 @@ public:
this->erase_node(node);
}
- std::set<iterator, less> query(I low, I high)
- {
+ std::set<iterator, less> query(I low, I high) {
std::set<iterator, less> result;
query(low, high, this->tree_root, result);
return result;
}
private:
-
using rbtree<I, V, N>::insert;
using rbtree<I, V, N>::erase;
using rbtree<I, V, N>::find;
- static bool overlaps(I low, I high, const N* node)
- {
+ static bool overlaps(I low, I high, const N *node) {
int64_t s1 = low + high;
int64_t d1 = high - low;
int64_t s2 = node->low + node->high;
@@ -130,9 +116,8 @@ private:
return std::abs(s2 - s1) < d1 + d2;
}
- static void query(I low, I high, std::unique_ptr<N>& node,
- std::set<iterator, less>& result)
- {
+ static void query(I low, I high, std::unique_ptr<N> &node,
+ std::set<iterator, less> &result) {
// base case
if (!node) {
return;
@@ -157,9 +142,8 @@ private:
}
}
- void insert_into(I low, I high, const V& value, std::unique_ptr<N>& node,
- N* parent = nullptr)
- {
+ void insert_into(I low, I high, const V &value, std::unique_ptr<N> &node,
+ N *parent = nullptr) {
if (!node) {
node = make_node(low, high, value);
node->parent = parent;
@@ -180,8 +164,7 @@ private:
}
}
- void erase_node(std::unique_ptr<N>& node)
- {
+ void erase_node(std::unique_ptr<N> &node) {
if (!node) {
return;
}
@@ -191,8 +174,8 @@ private:
// 1. look for the in-order successor
// 2. replace the node with the in-order successor
// 3. erase the in-order successor
- N* n = node.get();
- std::unique_ptr<N>& successor = this->find_successor(node);
+ N *n = node.get();
+ std::unique_ptr<N> &successor = this->find_successor(node);
this->swap_successor(node, successor);
// we don't update max since in erase_node we
@@ -201,12 +184,12 @@ private:
// 'successor' unique pointer holds now the node
if (successor.get() == n) {
erase_node(successor);
- }// otherwise the successor was the right child of node,
+ } // otherwise the successor was the right child of node,
// hence node should be now the right child of 'node'
// unoique pointer
else if (node->right.get() == n) {
erase_node(node->right);
- }// there are no other cases so anything else is wrong
+ } // there are no other cases so anything else is wrong
else {
throw std::logic_error("Bad rbtree swap.");
}
@@ -217,8 +200,8 @@ private:
// node has at most one child
// in this case simply replace the node with the
// single child or null if there are no children
- N* parent = node->parent;
- std::unique_ptr<N>& child = node->left ? node->left : node->right;
+ N *parent = node->parent;
+ std::unique_ptr<N> &child = node->left ? node->left : node->right;
colour_t old_colour = node->colour;
if (child) {
@@ -243,17 +226,16 @@ private:
this->rb_erase_case1(leaf_node_t(parent));
}
} else if (node)
- // if the node was red it has to have two BLACK children
- // and since at most one of those children is a non-leaf
- // child actually both have to be leafs (null) in order
- // to satisfy the red-black tree invariant
+ // if the node was red it has to have two BLACK children
+ // and since at most one of those children is a non-leaf
+ // child actually both have to be leafs (null) in order
+ // to satisfy the red-black tree invariant
{
throw rb_invariant_error();
}
}
- void update_max(N* node, I new_high)
- {
+ void update_max(N *node, I new_high) {
while (node) {
if (new_high > node->max) {
node->max = new_high;
@@ -264,16 +246,14 @@ private:
}
}
- void update_max(N* node)
- {
+ void update_max(N *node) {
while (node) {
set_max(node);
node = node->parent;
}
}
- void set_max(N* node)
- {
+ void set_max(N *node) {
if (!node->left && !node->right) {
node->max = node->high;
return;
@@ -285,20 +265,19 @@ private:
return;
}
- node->max = std::max(node->high, std::max(node->left->max, node->right->max));
+ node->max =
+ std::max(node->high, std::max(node->left->max, node->right->max));
}
- virtual void right_rotation(N* node)
- {
- N* pivot = node->left.get();
+ virtual void right_rotation(N *node) {
+ N *pivot = node->left.get();
rbtree<I, V, N>::right_rotation(node);
set_max(node); // set first max for node since now it's lower in the tree
set_max(pivot);
}
- virtual void left_rotation(N* node)
- {
- N* pivot = node->right.get();
+ virtual void left_rotation(N *node) {
+ N *pivot = node->right.get();
rbtree<I, V, N>::left_rotation(node);
set_max(node); // set first max for node since now it's lower in the tree
set_max(pivot);
diff --git a/src/XrdApps/XrdClJCachePlugin/cache/Journal.cc b/src/XrdApps/XrdClJCachePlugin/cache/Journal.cc
index 9bcff9c50f0..c164236e9b5 100644
--- a/src/XrdApps/XrdClJCachePlugin/cache/Journal.cc
+++ b/src/XrdApps/XrdClJCachePlugin/cache/Journal.cc
@@ -1,7 +1,7 @@
//------------------------------------------------------------------------------
// Copyright (c) 2024 by European Organization for Nuclear Research (CERN)
// Author: Andreas-Joachim Peters <andreas.joachim.peters@cern.ch>
-// Michal Simon
+// Michal Simon
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
@@ -22,24 +22,21 @@
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
-
/*----------------------------------------------------------------------------*/
#include "Journal.hh"
/*----------------------------------------------------------------------------*/
#include <algorithm>
+#include <fcntl.h>
#include <iostream>
-#include <unistd.h>
-#include <sys/types.h>
#include <sys/stat.h>
-#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
/*----------------------------------------------------------------------------*/
//------------------------------------------------------------------------------
//! Journal Constructor
//------------------------------------------------------------------------------
-Journal::Journal() : cachesize(0),
- max_offset(0), fd(-1)
-{
+Journal::Journal() : cachesize(0), max_offset(0), fd(-1) {
std::lock_guard<std::mutex> guard(mtx);
jheader.magic = JOURNAL_MAGIC;
jheader.mtime = 0;
@@ -53,8 +50,7 @@ Journal::Journal() : cachesize(0),
//------------------------------------------------------------------------------
//! Journal Destructor
//------------------------------------------------------------------------------
-Journal::~Journal()
-{
+Journal::~Journal() {
std::lock_guard<std::mutex> guard(mtx);
if (fd > 0) {
int rc = close(fd);
@@ -70,48 +66,50 @@ Journal::~Journal()
//------------------------------------------------------------------------------
//! Routine to read a journal header
//------------------------------------------------------------------------------
-void Journal::read_jheader()
-{
+void Journal::read_jheader() {
jheader_t fheader;
auto hr = ::pread64(fd, &fheader, sizeof(jheader), 0);
- if ( (hr>0) &&
- ( (hr != sizeof(jheader)) ||
- (fheader.magic != JOURNAL_MAGIC)) ) {
- std::cerr << "warning: inconsistent journal header found (I) - purging path:" << path << std::endl;
+ if ((hr > 0) &&
+ ((hr != sizeof(jheader)) || (fheader.magic != JOURNAL_MAGIC))) {
+ std::cerr
+ << "warning: inconsistent journal header found (I) - purging path:"
+ << path << std::endl;
reset();
return;
}
// TODO: understand why the mtime is +-1s
- if ( ( abs(fheader.mtime - jheader.mtime) > 1 )
- || (fheader.mtime_nsec != jheader.mtime_nsec)
- || (fheader.filesize != jheader.filesize) ) {
+ if ((abs(fheader.mtime - jheader.mtime) > 1) ||
+ (fheader.mtime_nsec != jheader.mtime_nsec) ||
+ (fheader.filesize != jheader.filesize)) {
if (fheader.mtime) {
- std::cerr << "warning: remote file change detected - purging path:" << path << std::endl;
- std::cerr << fheader.mtime << ":" << jheader.mtime << " " << fheader.mtime_nsec << ":" << jheader.mtime_nsec << " " << fheader.filesize << ":" << jheader.filesize << std::endl;
+ std::cerr << "warning: remote file change detected - purging path:"
+ << path << std::endl;
+ std::cerr << fheader.mtime << ":" << jheader.mtime << " "
+ << fheader.mtime_nsec << ":" << jheader.mtime_nsec << " "
+ << fheader.filesize << ":" << jheader.filesize << std::endl;
}
reset();
return;
}
- }
+}
//------------------------------------------------------------------------------
//! Routine to write a journal header
//------------------------------------------------------------------------------
-int Journal::write_jheader()
-{
+int Journal::write_jheader() {
auto hw = ::pwrite64(fd, &jheader, sizeof(jheader), 0);
- if ( (hw != sizeof(jheader)) ) {
- std::cerr << "warning: failed to write journal header - purging path:" << path << std::endl;
+ if ((hw != sizeof(jheader))) {
+ std::cerr << "warning: failed to write journal header - purging path:"
+ << path << std::endl;
return -errno;
}
return 0;
- }
+}
//------------------------------------------------------------------------------
//! Routine to read a journal
//------------------------------------------------------------------------------
-int Journal::read_journal()
-{
+int Journal::read_journal() {
journal.clear();
const size_t bufsize = sizeof(header_t);
char buffer[bufsize];
@@ -123,29 +121,30 @@ int Journal::read_journal()
do {
bytesRead = ::pread(fd, buffer, bufsize, totalBytesRead);
if (bytesRead < (ssize_t)bufsize) {
- if (bytesRead == 0 && (totalBytesRead==journalsize)) {
+ if (bytesRead == 0 && (totalBytesRead == journalsize)) {
break;
} else {
- std::cerr << "warning: inconsistent journal found - purging path:" << path << std::endl;
+ std::cerr << "warning: inconsistent journal found - purging path:"
+ << path << std::endl;
reset();
return 0;
}
}
- header_t* header = reinterpret_cast<header_t*>(buffer);
+ header_t *header = reinterpret_cast<header_t *>(buffer);
journal.insert(header->offset, header->offset + header->size,
- totalBytesRead);
+ totalBytesRead);
totalBytesRead += header->size; // size of the fragment
- totalBytesRead += bytesRead; // size of the header
+ totalBytesRead += bytesRead; // size of the header
} while (pos < bytesRead);
-
+
return totalBytesRead;
}
//------------------------------------------------------------------------------
//! Journal attach
//------------------------------------------------------------------------------
-int Journal::attach(const std::string& lpath, uint64_t mtime, uint64_t mtime_nsec, uint64_t size)
-{
+int Journal::attach(const std::string &lpath, uint64_t mtime,
+ uint64_t mtime_nsec, uint64_t size) {
std::lock_guard<std::mutex> guard(mtx);
path = lpath;
jheader.mtime = mtime;
@@ -188,8 +187,7 @@ int Journal::attach(const std::string& lpath, uint64_t mtime, uint64_t mtime_nse
//------------------------------------------------------------------------------
//! Journal detach
//------------------------------------------------------------------------------
-int Journal::detach()
-{
+int Journal::detach() {
std::lock_guard<std::mutex> guard(mtx);
return 0;
}
@@ -197,8 +195,7 @@ int Journal::detach()
//------------------------------------------------------------------------------
//! Journal unlink
//------------------------------------------------------------------------------
-int Journal::unlink()
-{
+int Journal::unlink() {
std::lock_guard<std::mutex> guard(mtx);
struct stat buf;
int rc = stat(path.c_str(), &buf);
@@ -212,14 +209,13 @@ int Journal::unlink()
//------------------------------------------------------------------------------
//! Journal pread
//------------------------------------------------------------------------------
-ssize_t Journal::pread(void* buf, size_t count, off_t offset, bool& eof)
-{
- if (fd<0) {
+ssize_t Journal::pread(void *buf, size_t count, off_t offset, bool &eof) {
+ if (fd < 0) {
return 0;
}
// rewrite reads to not go over EOF!
- if ( (off_t)(offset + count) > (off_t) jheader.filesize ) {
+ if ((off_t)(offset + count) > (off_t)jheader.filesize) {
if ((off_t)jheader.filesize > offset) {
count = (off_t)jheader.filesize - offset;
} else {
@@ -236,12 +232,11 @@ ssize_t Journal::pread(void* buf, size_t count, off_t offset, bool& eof)
return 0;
}
- char* buffer = reinterpret_cast<char*>(buf);
+ char *buffer = reinterpret_cast<char *>(buf);
uint64_t off = offset;
uint64_t bytesRead = 0;
-
- for (auto& itr : result) {
+ for (auto &itr : result) {
if (itr->low <= off && off < itr->high) {
// read from cache
uint64_t cacheoff = itr->value + sizeof(header_t) + (off - itr->low);
@@ -274,10 +269,10 @@ ssize_t Journal::pread(void* buf, size_t count, off_t offset, bool& eof)
//------------------------------------------------------------------------------
//! Journal process intersection
//------------------------------------------------------------------------------
-void Journal::process_intersection(interval_tree<uint64_t, const void*>&
- to_write, interval_tree<uint64_t, uint64_t>::iterator itr,
- std::vector<chunk_t>& updates)
-{
+void Journal::process_intersection(
+ interval_tree<uint64_t, const void *> &to_write,
+ interval_tree<uint64_t, uint64_t>::iterator itr,
+ std::vector<chunk_t> &updates) {
auto result = to_write.query(itr->low, itr->high);
if (result.empty()) {
@@ -288,7 +283,8 @@ void Journal::process_intersection(interval_tree<uint64_t, const void*>&
throw std::logic_error("Journal: overlapping journal entries");
}
- const interval_tree<uint64_t, const void*>::iterator to_wrt = *result.begin();
+ const interval_tree<uint64_t, const void *>::iterator to_wrt =
+ *result.begin();
// the intersection
uint64_t low = std::max(to_wrt->low, itr->low);
uint64_t high = std::min(to_wrt->high, itr->high);
@@ -296,12 +292,12 @@ void Journal::process_intersection(interval_tree<uint64_t, const void*>&
chunk_t update;
update.offset = offset_for_update(itr->value, low - itr->low);
update.size = high - low;
- update.buff = static_cast<const char*>(to_wrt->value) + (low - to_wrt->low);
+ update.buff = static_cast<const char *>(to_wrt->value) + (low - to_wrt->low);
updates.push_back(std::move(update));
// update the 'to write' intervals
uint64_t wrtlow = to_wrt->low;
uint64_t wrthigh = to_wrt->high;
- const void* wrtbuff = to_wrt->value;
+ const void *wrtbuff = to_wrt->value;
to_write.erase(wrtlow, wrthigh);
// the intersection overlaps with the given
@@ -312,7 +308,7 @@ void Journal::process_intersection(interval_tree<uint64_t, const void*>&
if (high < wrthigh) {
// the remaining right-hand-side interval
- const char* buff = static_cast<const char*>(wrtbuff) + (high - wrtlow);
+ const char *buff = static_cast<const char *>(wrtbuff) + (high - wrtlow);
to_write.insert(high, wrthigh, buff);
}
@@ -323,15 +319,14 @@ void Journal::process_intersection(interval_tree<uint64_t, const void*>&
}
//------------------------------------------------------------------------------
-//! Journal update
+//! Journal update
//------------------------------------------------------------------------------
-int Journal::update_cache(std::vector<chunk_t>& updates)
-{
+int Journal::update_cache(std::vector<chunk_t> &updates) {
// make sure we are updating the cache in ascending order
std::sort(updates.begin(), updates.end());
int rc = 0;
- for (auto& u : updates) {
+ for (auto &u : updates) {
rc = ::pwrite(fd, u.buff, u.size,
u.offset); // TODO is it safe to assume it will write it all
@@ -346,9 +341,8 @@ int Journal::update_cache(std::vector<chunk_t>& updates)
//------------------------------------------------------------------------------
//! Journal pwrite
//------------------------------------------------------------------------------
-ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
-{
- if (fd<0) {
+ssize_t Journal::pwrite(const void *buf, size_t count, off_t offset) {
+ if (fd < 0) {
return 0;
}
@@ -357,7 +351,7 @@ ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
return 0;
}
- interval_tree<uint64_t, const void*> to_write;
+ interval_tree<uint64_t, const void *> to_write;
std::vector<chunk_t> updates;
to_write.insert(offset, offset + count, buf);
auto res = journal.query(offset, offset + count);
@@ -372,7 +366,7 @@ ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
return -1;
}
- interval_tree<uint64_t, const void*>::iterator itr;
+ interval_tree<uint64_t, const void *>::iterator itr;
for (itr = to_write.begin(); itr != to_write.end(); ++itr) {
uint64_t size = itr->high - itr->low;
@@ -382,7 +376,7 @@ ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
iovec iov[2];
iov[0].iov_base = &header;
iov[0].iov_len = sizeof(header_t);
- iov[1].iov_base = const_cast<void*>(itr->value);
+ iov[1].iov_base = const_cast<void *>(itr->value);
iov[1].iov_len = size;
rc = ::pwrite(fd, iov[0].iov_base, iov[0].iov_len, cachesize);
@@ -397,7 +391,7 @@ ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
cachesize += sizeof(header_t) + size;
}
- if ((ssize_t)(offset + count) > max_offset) {
+ if ((ssize_t)(offset + count) > max_offset) {
max_offset = offset + count;
}
@@ -407,9 +401,8 @@ ssize_t Journal::pwrite(const void* buf, size_t count, off_t offset)
//------------------------------------------------------------------------------
//! Journal data sync
//------------------------------------------------------------------------------
-int Journal::sync()
-{
- if (fd<0) {
+int Journal::sync() {
+ if (fd < 0) {
return -1;
}
return ::fdatasync(fd);
@@ -418,8 +411,7 @@ int Journal::sync()
//------------------------------------------------------------------------------
//! Journal get size
//------------------------------------------------------------------------------
-size_t Journal::size()
-{
+size_t Journal::size() {
std::lock_guard<std::mutex> guard(mtx);
return cachesize;
}
@@ -427,8 +419,7 @@ size_t Journal::size()
//------------------------------------------------------------------------------
//! Journal get max offset in the journal
//------------------------------------------------------------------------------
-off_t Journal::get_max_offset()
-{
+off_t Journal::get_max_offset() {
std::lock_guard<std::mutex> guard(mtx);
return max_offset;
}
@@ -436,12 +427,11 @@ off_t Journal::get_max_offset()
//------------------------------------------------------------------------------
//! Journal reset
//------------------------------------------------------------------------------
-int Journal::reset()
-{
+int Journal::reset() {
journal.clear();
- int retc=0;
- if (fd>=0) {
- retc = ftruncate(fd,0);
+ int retc = 0;
+ if (fd >= 0) {
+ retc = ftruncate(fd, 0);
retc |= write_jheader();
}
cachesize = 0;
@@ -449,8 +439,7 @@ int Journal::reset()
return retc;
}
-std::string Journal::dump()
-{
+std::string Journal::dump() {
std::lock_guard<std::mutex> guard(mtx);
std::string out;
out += "fd=";
@@ -465,18 +454,16 @@ std::string Journal::dump()
//------------------------------------------------------------------------------
//! Journal get chunks
//------------------------------------------------------------------------------
-std::vector<Journal::chunk_t> Journal::get_chunks(off_t offset,
- size_t size)
-{
+std::vector<Journal::chunk_t> Journal::get_chunks(off_t offset, size_t size) {
auto result = journal.query(offset, offset + size);
std::vector<chunk_t> ret;
- for (auto& itr : result) {
- uint64_t off = (off_t) itr->low < (off_t) offset ? offset : itr->low;
- uint64_t count = itr->high < offset + size ? itr->high - off : offset + size -
- off;
+ for (auto &itr : result) {
+ uint64_t off = (off_t)itr->low < (off_t)offset ? offset : itr->low;
+ uint64_t count =
+ itr->high < offset + size ? itr->high - off : offset + size - off;
uint64_t cacheoff = itr->value + sizeof(header_t) + (off - itr->low);
- std::unique_ptr<char[] > buffer(new char[count]);
+ std::unique_ptr<char[]> buffer(new char[count]);
ssize_t rc = ::pread(fd, buffer.get(), count, cacheoff);
if (rc < 0) {
diff --git a/src/XrdApps/XrdClJCachePlugin/cache/Journal.hh b/src/XrdApps/XrdClJCachePlugin/cache/Journal.hh
index 936660de751..405bc9a20cb 100644
--- a/src/XrdApps/XrdClJCachePlugin/cache/Journal.hh
+++ b/src/XrdApps/XrdClJCachePlugin/cache/Journal.hh
@@ -1,7 +1,7 @@
//------------------------------------------------------------------------------
// Copyright (c) 2024 by European Organization for Nuclear Research (CERN)
// Author: Andreas-Joachim Peters <andreas.joachim.peters@cern.ch>
-// Michal Simon
+// Michal Simon
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
@@ -26,18 +26,18 @@
/*----------------------------------------------------------------------------*/
#include "IntervalTree.hh"
/*----------------------------------------------------------------------------*/
+#include <map>
+#include <mutex>
#include <stdint.h>
#include <string>
-#include <mutex>
-#include <map>
/*----------------------------------------------------------------------------*/
-class Journal
-{
+class Journal {
static constexpr uint64_t JOURNAL_MAGIC = 0xcafecafecafecafe;
struct jheader_t {
jheader_t() {
- mtime = mtime_nsec = filesize = placeholder1 = placeholder2 = placeholder3 = placeholder4 = magic = 0;
+ mtime = mtime_nsec = filesize = placeholder1 = placeholder2 =
+ placeholder3 = placeholder4 = magic = 0;
}
uint64_t magic;
uint64_t mtime;
@@ -48,48 +48,45 @@ class Journal
uint64_t placeholder3;
uint64_t placeholder4;
};
-
+
struct header_t {
uint64_t offset;
uint64_t size;
};
public:
-
struct chunk_t {
- chunk_t() : offset(0), size(0), buff(0) { }
+ chunk_t() : offset(0), size(0), buff(0) {}
/* constructor - no ownership of underlying buffer */
- chunk_t(off_t offset, size_t size, const void* buff) : offset(offset),
- size(size), buff(buff) { }
+ chunk_t(off_t offset, size_t size, const void *buff)
+ : offset(offset), size(size), buff(buff) {}
/* constructor - with ownership of underlying buffer */
- chunk_t(off_t offset, size_t size, std::unique_ptr<char[]> buff) :
- offset(offset), size(size), buffOwnership(std::move(buff)),
- buff((const void*) buffOwnership.get()) {}
+ chunk_t(off_t offset, size_t size, std::unique_ptr<char[]> buff)
+ : offset(offset), size(size), buffOwnership(std::move(buff)),
+ buff((const void *)buffOwnership.get()) {}
off_t offset;
size_t size;
std::unique_ptr<char[]> buffOwnership;
- const void* buff;
+ const void *buff;
- bool operator<(const chunk_t& u) const
- {
- return offset < u.offset;
- }
+ bool operator<(const chunk_t &u) const { return offset < u.offset; }
};
Journal();
virtual ~Journal();
// base class interface
- int attach(const std::string& path, uint64_t mtime, uint64_t mtime_nsec, uint64_t size);
+ int attach(const std::string &path, uint64_t mtime, uint64_t mtime_nsec,
+ uint64_t size);
int detach();
int unlink();
- ssize_t pread(void* buf, size_t count, off_t offset, bool& eof);
- ssize_t pwrite(const void* buf, size_t count, off_t offset);
+ ssize_t pread(void *buf, size_t count, off_t offset, bool &eof);
+ ssize_t pwrite(const void *buf, size_t count, off_t offset);
int sync();
@@ -102,23 +99,23 @@ public:
std::vector<chunk_t> get_chunks(off_t offset, size_t size);
std::string dump();
-private:
- void process_intersection(interval_tree<uint64_t, const void*>& write,
- interval_tree<uint64_t, uint64_t>::iterator acr, std::vector<chunk_t>& updates);
+private:
+ void process_intersection(interval_tree<uint64_t, const void *> &write,
+ interval_tree<uint64_t, uint64_t>::iterator acr,
+ std::vector<chunk_t> &updates);
- static uint64_t offset_for_update(uint64_t offset, uint64_t shift)
- {
+ static uint64_t offset_for_update(uint64_t offset, uint64_t shift) {
return offset + sizeof(header_t) + shift;
}
- int update_cache(std::vector<chunk_t>& updates);
+ int update_cache(std::vector<chunk_t> &updates);
int read_journal();
-
+
jheader_t jheader;
int write_jheader();
void read_jheader();
-
+
std::string path;
size_t cachesize;
off_t max_offset;
@@ -128,43 +125,43 @@ private:
interval_tree<uint64_t, uint64_t> journal;
std::mutex mtx;
int flags;
-
};
class JournalManager {
private:
- std::map<std::string, std::shared_ptr<Journal>> journals;
- std::mutex jMutex;
+ std::map<std::string, std::shared_ptr<Journal>> journals;
+ std::mutex jMutex;
public:
JournalManager() {}
virtual ~JournalManager() {}
-
- // Attach method: creates or retrieves a Journal object by key
- std::shared_ptr<Journal> attach(const std::string &key) {
- std::lock_guard<std::mutex> guard(jMutex);
- auto it = journals.find(key);
- if (it == journals.end()) {
- // Create a new Journal object if it doesn't exist
- auto journal = std::make_shared<Journal>();
- journals[key] = journal;
- return journal;
- } else {
- // Return the existing Journal object
- return it->second;
- }
+
+ // Attach method: creates or retrieves a Journal object by key
+ std::shared_ptr<Journal> attach(const std::string &key) {
+ std::lock_guard<std::mutex> guard(jMutex);
+ auto it = journals.find(key);
+ if (it == journals.end()) {
+ // Create a new Journal object if it doesn't exist
+ auto journal = std::make_shared<Journal>();
+ journals[key] = journal;
+ return journal;
+ } else {
+ // Return the existing Journal object
+ return it->second;
}
+ }
- // Detach method: checks reference count and removes Journal object if necessary
- void detach(const std::string &key) {
- std::lock_guard<std::mutex> guard(jMutex);
- auto it = journals.find(key);
- if (it != journals.end()) {
- if (it->second.use_count() == 1) {
- // Only one reference exists, so erase the entry from the map
- journals.erase(it);
- }
- // If more than one reference exists, do nothing
- }
+ // Detach method: checks reference count and removes Journal object if
+ // necessary
+ void detach(const std::string &key) {
+ std::lock_guard<std::mutex> guard(jMutex);
+ auto it = journals.find(key);
+ if (it != journals.end()) {
+ if (it->second.use_count() == 1) {
+ // Only one reference exists, so erase the entry from the map
+ journals.erase(it);
+ }
+ // If more than one reference exists, do nothing
}
+ }
};
diff --git a/src/XrdApps/XrdClJCachePlugin/cache/RbTree.hh b/src/XrdApps/XrdClJCachePlugin/cache/RbTree.hh
index 5d9514759b8..fa0043d0381 100644
--- a/src/XrdApps/XrdClJCachePlugin/cache/RbTree.hh
+++ b/src/XrdApps/XrdClJCachePlugin/cache/RbTree.hh
@@ -27,62 +27,47 @@
#include <memory>
#include <stdexcept>
-class rb_invariant_error : public std::exception
-{
+class rb_invariant_error : public std::exception {
public:
+ rb_invariant_error() {}
- rb_invariant_error() { }
-
- virtual const char* what() const throw()
- {
+ virtual const char *what() const throw() {
return "Red-black tree invariant violation!";
}
-
};
-enum colour_t {
- RED = true,
- BLACK = false
-};
+enum colour_t { RED = true, BLACK = false };
-template<typename K, typename V>
-class node_t
-{
- template<typename, typename, typename> friend class rbtree;
+template <typename K, typename V> class node_t {
+ template <typename, typename, typename> friend class rbtree;
friend class RBTreeTest;
public:
-
- node_t(const K& key, const V& value) : key(key), value(value), colour(RED),
- parent(nullptr) { }
+ node_t(const K &key, const V &value)
+ : key(key), value(value), colour(RED), parent(nullptr) {}
const K key;
V value;
private:
colour_t colour;
- node_t* parent;
+ node_t *parent;
std::unique_ptr<node_t> left;
std::unique_ptr<node_t> right;
};
-template<typename K, typename V, typename N = node_t<K, V> >
-class rbtree
-{
+template <typename K, typename V, typename N = node_t<K, V>> class rbtree {
friend class RBTreeTest;
friend class IntervalTreeTest;
protected:
-
- static std::unique_ptr<N> make_node(const K& key, const V& value)
- {
+ static std::unique_ptr<N> make_node(const K &key, const V &value) {
return std::unique_ptr<N>(new N(key, value));
}
- static void swap_right_child(std::unique_ptr<N>& node,
- std::unique_ptr<N>& successor)
- {
+ static void swap_right_child(std::unique_ptr<N> &node,
+ std::unique_ptr<N> &successor) {
std::swap(node->colour, successor->colour);
// first do the obvious
std::swap(node->left, successor->left);
@@ -96,10 +81,10 @@ protected:
}
// now gather remaining pointers
- N* p = node->parent;
- N* n = node.release();
- N* s = successor.release();
- N* s_right = s->right.release();
+ N *p = node->parent;
+ N *n = node.release();
+ N *s = successor.release();
+ N *s_right = s->right.release();
// and finally reassign those pointers
s->parent = p;
node.reset(s);
@@ -112,9 +97,8 @@ protected:
}
}
- static void swap_successor(std::unique_ptr<N>& node,
- std::unique_ptr<N>& successor)
- {
+ static void swap_successor(std::unique_ptr<N> &node,
+ std::unique_ptr<N> &successor) {
// first check if successor is a direct child of node,
// since it is the in-order successor it can be only
// the right child
@@ -160,77 +144,45 @@ protected:
struct leaf_node_t {
- leaf_node_t(N* parent) : colour(BLACK), parent(parent) { }
+ leaf_node_t(N *parent) : colour(BLACK), parent(parent) {}
- leaf_node_t(const leaf_node_t& leaf) : colour(leaf.colour),
- parent(leaf.parent) { }
+ leaf_node_t(const leaf_node_t &leaf)
+ : colour(leaf.colour), parent(leaf.parent) {}
- leaf_node_t& operator=(const leaf_node_t& leaf)
- {
+ leaf_node_t &operator=(const leaf_node_t &leaf) {
colour = leaf.colour;
parent = leaf.parent;
return *this;
}
- leaf_node_t* operator->()
- {
- return this;
- }
+ leaf_node_t *operator->() { return this; }
- leaf_node_t& operator*()
- {
- return *this;
- }
+ leaf_node_t &operator*() { return *this; }
- operator bool() const
- {
- return true;
- }
+ operator bool() const { return true; }
- bool operator==(N* node) const
- {
- return node == nullptr;
- }
+ bool operator==(N *node) const { return node == nullptr; }
colour_t colour;
- N* parent;
+ N *parent;
};
public:
-
- class iterator
- {
+ class iterator {
public:
+ iterator(N *node = 0) : node(node) {}
- iterator(N* node = 0) : node(node) { }
-
- N* operator->()
- {
- return node;
- }
+ N *operator->() { return node; }
- N& operator*()
- {
- return *node;
- }
+ N &operator*() { return *node; }
- const N* operator->() const
- {
- return node;
- }
+ const N *operator->() const { return node; }
- const N& operator*() const
- {
- return *node;
- }
+ const N &operator*() const { return *node; }
- operator bool() const
- {
- return bool(node);
- }
+ operator bool() const { return bool(node); }
- iterator& operator++()
- {
+ iterator &operator++() {
if (!node) {
return *this;
}
@@ -245,7 +197,7 @@ public:
return *this;
}
- N* parent = node->parent;
+ N *parent = node->parent;
while (parent && is_right(node)) {
node = parent;
@@ -256,62 +208,46 @@ public:
return *this;
}
- bool operator!=(const iterator& itr)
- {
- return node != itr.node;
- }
+ bool operator!=(const iterator &itr) { return node != itr.node; }
private:
-
- N* node;
+ N *node;
};
- rbtree() : tree_size(0) { }
+ rbtree() : tree_size(0) {}
- virtual ~rbtree() { }
+ virtual ~rbtree() {}
- void insert(const K& key, const V& value)
- {
+ void insert(const K &key, const V &value) {
insert_into(key, value, tree_root);
}
- void erase(const K& key)
- {
- std::unique_ptr<N>& node = find_in(key, tree_root);
+ void erase(const K &key) {
+ std::unique_ptr<N> &node = find_in(key, tree_root);
erase_node(node);
}
- void clear()
- {
+ void clear() {
tree_root.reset();
tree_size = 0;
}
- iterator find(const K& key)
- {
- const std::unique_ptr<N>& n = find_in(key, tree_root);
+ iterator find(const K &key) {
+ const std::unique_ptr<N> &n = find_in(key, tree_root);
return iterator(n.get());
}
- const iterator find(const K& key) const
- {
- const std::unique_ptr<N>& n = find_in(key, tree_root);
+ const iterator find(const K &key) const {
+ const std::unique_ptr<N> &n = find_in(key, tree_root);
return iterator(n.get());
}
- size_t size() const
- {
- return tree_size;
- }
+ size_t size() const { return tree_size; }
- bool empty() const
- {
- return !tree_root;
- }
+ bool empty() const { return !tree_root; }
- iterator begin()
- {
- N* node = tree_root.get();
+ iterator begin() {
+ N *node = tree_root.get();
if (!node) {
return iterator();
@@ -324,16 +260,11 @@ public:
return iterator(node);
}
- iterator end()
- {
- return iterator();
- }
+ iterator end() { return iterator(); }
protected:
-
- void insert_into(const K& key, const V& value, std::unique_ptr<N>& node,
- N* parent = nullptr)
- {
+ void insert_into(const K &key, const V &value, std::unique_ptr<N> &node,
+ N *parent = nullptr) {
if (!node) {
node = make_node(key, value);
node->parent = parent;
@@ -353,8 +284,7 @@ protected:
}
}
- void erase_node(std::unique_ptr<N>& node)
- {
+ void erase_node(std::unique_ptr<N> &node) {
if (!node) {
return;
}
@@ -364,20 +294,20 @@ protected:
// 1. look for the in-order successor
// 2. replace the node with the in-order successor
// 3. erase the in-order successor
- N* n = node.get();
- std::unique_ptr<N>& successor = find_successor(node);
+ N *n = node.get();
+ std::unique_ptr<N> &successor = find_successor(node);
swap_successor(node, successor);
// we swapped the node with successor and the
// 'successor' unique pointer holds now the node
if (successor.get() == n) {
erase_node(successor);
- }// otherwise the successor was the right child of node,
+ } // otherwise the successor was the right child of node,
// hence node should be now the right child of 'node'
// unique pointer
else if (node->right.get() == n) {
erase_node(node->right);
- }// there are no other cases so anything else is wrong
+ } // there are no other cases so anything else is wrong
else {
throw std::logic_error("Bad rbtree swap.");
}
@@ -388,8 +318,8 @@ protected:
// node has at most one child
// in this case simply replace the node with the
// single child or null if there are no children
- N* parent = node->parent;
- std::unique_ptr<N>& child = node->left ? node->left : node->right;
+ N *parent = node->parent;
+ std::unique_ptr<N> &child = node->left ? node->left : node->right;
colour_t old_colour = node->colour;
if (child) {
@@ -413,18 +343,18 @@ protected:
rb_erase_case1(leaf_node_t(parent));
}
} else if (node)
- // if the node was red it has to have two BLACK children
- // and since at most one of those children is a non-leaf
- // child actually both have to be leafs (null) in order
- // to satisfy the red-black tree invariant
+ // if the node was red it has to have two BLACK children
+ // and since at most one of those children is a non-leaf
+ // child actually both have to be leafs (null) in order
+ // to satisfy the red-black tree invariant
{
throw rb_invariant_error();
}
}
- template<typename PTR> // make it a template so it works both for constant and mutable pointers
- static PTR& find_in(const K& key, PTR& node)
- {
+ template <typename PTR> // make it a template so it works both for constant
+ // and mutable pointers
+ static PTR &find_in(const K &key, PTR &node) {
if (!node) {
return null_node;
}
@@ -440,9 +370,9 @@ protected:
}
}
- template<typename PTR> // make it a template so it works both for constant and mutable pointers
- static PTR& find_min(PTR& node)
- {
+ template <typename PTR> // make it a template so it works both for constant
+ // and mutable pointers
+ static PTR &find_min(PTR &node) {
if (!node) {
return null_node;
}
@@ -454,9 +384,9 @@ protected:
return node;
}
- template<typename PTR> // make it a template so it works both for constant and mutable pointers
- static PTR& find_successor(PTR& node)
- {
+ template <typename PTR> // make it a template so it works both for constant
+ // and mutable pointers
+ static PTR &find_successor(PTR &node) {
if (!node) {
return null_node;
}
@@ -464,27 +394,22 @@ protected:
return find_min(node->right);
}
- static bool has_two(const N* node)
- {
- return node->left && node->right;
- }
+ static bool has_two(const N *node) { return node->left && node->right; }
////////////////////////////////////////////////////////////////////////////////////////////////////////////
- static void replace(std::unique_ptr<N>& ptr, N* node)
- {
+ static void replace(std::unique_ptr<N> &ptr, N *node) {
ptr.release();
ptr.reset(node);
}
- virtual void right_rotation(N* node)
- {
+ virtual void right_rotation(N *node) {
if (!node) {
return;
}
- N* parent = node->parent;
- N* left_child = node->left.release();
+ N *parent = node->parent;
+ N *left_child = node->left.release();
bool is_left = (parent && parent->left.get() == node) ? true : false;
node->left.reset(left_child->right.release());
@@ -509,14 +434,13 @@ protected:
}
}
- virtual void left_rotation(N* node)
- {
+ virtual void left_rotation(N *node) {
if (!node) {
return;
}
- N* parent = node->parent;
- N* right_child = node->right.release();
+ N *parent = node->parent;
+ N *right_child = node->right.release();
bool is_left = (parent && parent->left.get() == node) ? true : false;
node->right.reset(right_child->left.release());
@@ -543,8 +467,7 @@ protected:
////////////////////////////////////////////////////////////////////////////////////////////////////////////
- N* get_grandparent(N* node)
- {
+ N *get_grandparent(N *node) {
if (!node || !node->parent) {
return nullptr;
}
@@ -552,9 +475,8 @@ protected:
return node->parent->parent;
}
- N* get_uncle(N* node)
- {
- N* grandparent = get_grandparent(node);
+ N *get_uncle(N *node) {
+ N *grandparent = get_grandparent(node);
if (!grandparent) {
return nullptr;
@@ -567,8 +489,7 @@ protected:
}
}
- void rb_insert_case1(N* node)
- {
+ void rb_insert_case1(N *node) {
if (node->parent == nullptr) { // it is the root
node->colour = BLACK;
} else {
@@ -576,8 +497,7 @@ protected:
}
}
- void rb_insert_case2(N* node)
- {
+ void rb_insert_case2(N *node) {
if (node->parent->colour == BLACK) {
return; // the invariant is OK
} else {
@@ -585,14 +505,13 @@ protected:
}
}
- void rb_insert_case3(N* node)
- {
- N* uncle = get_uncle(node);
+ void rb_insert_case3(N *node) {
+ N *uncle = get_uncle(node);
if (uncle && uncle->colour == RED) {
node->parent->colour = BLACK;
uncle->colour = BLACK;
- N* grandparent = get_grandparent(node);
+ N *grandparent = get_grandparent(node);
grandparent->colour = RED;
rb_insert_case1(grandparent);
} else {
@@ -600,9 +519,8 @@ protected:
}
}
- void rb_insert_case4(N* node)
- {
- N* grandparent = get_grandparent(node);
+ void rb_insert_case4(N *node) {
+ N *grandparent = get_grandparent(node);
if ((node == node->parent->right.get()) &&
(node->parent == grandparent->left.get())) {
@@ -617,9 +535,8 @@ protected:
rb_insert_case5(node);
}
- void rb_insert_case5(N* node)
- {
- N* grandparent = get_grandparent(node);
+ void rb_insert_case5(N *node) {
+ N *grandparent = get_grandparent(node);
node->parent->colour = BLACK;
grandparent->colour = RED;
@@ -632,21 +549,15 @@ protected:
////////////////////////////////////////////////////////////////////////////////////////////////////////////
- template<typename NODE>
- static bool is_left(NODE node)
- {
+ template <typename NODE> static bool is_left(NODE node) {
return node == node->parent->left.get();
}
- template<typename NODE>
- static bool is_right(NODE node)
- {
+ template <typename NODE> static bool is_right(NODE node) {
return node == node->parent->right.get();
}
- template<typename NODE>
- N* get_sibling(NODE node)
- {
+ template <typename NODE> N *get_sibling(NODE node) {
if (!node || !node->parent) {
return nullptr;
}
@@ -658,18 +569,14 @@ protected:
}
}
- template<typename NODE>
- void rb_erase_case1(NODE node)
- {
+ template <typename NODE> void rb_erase_case1(NODE node) {
if (node->parent != nullptr) {
rb_erase_case2(node);
}
}
- template<typename NODE>
- void rb_erase_case2(NODE node)
- {
- N* sibling = get_sibling(node);
+ template <typename NODE> void rb_erase_case2(NODE node) {
+ N *sibling = get_sibling(node);
if (!sibling) {
throw rb_invariant_error();
@@ -689,22 +596,20 @@ protected:
rb_erase_case3(node);
}
- template<typename NODE>
- void rb_erase_case3(NODE node)
- {
- N* sibling = get_sibling(node);
+ template <typename NODE> void rb_erase_case3(NODE node) {
+ N *sibling = get_sibling(node);
if (!sibling) {
throw rb_invariant_error();
}
- colour_t sibling_left_colour = sibling->left ? sibling->left->colour : BLACK;
- colour_t sibling_right_colour = sibling->right ? sibling->right->colour : BLACK;
+ colour_t sibling_left_colour =
+ sibling->left ? sibling->left->colour : BLACK;
+ colour_t sibling_right_colour =
+ sibling->right ? sibling->right->colour : BLACK;
- if (node->parent->colour == BLACK &&
- sibling->colour == BLACK &&
- sibling_left_colour == BLACK &&
- sibling_right_colour == BLACK) {
+ if (node->parent->colour == BLACK && sibling->colour == BLACK &&
+ sibling_left_colour == BLACK && sibling_right_colour == BLACK) {
sibling->colour = RED;
rb_erase_case1(node->parent);
} else {
@@ -712,22 +617,20 @@ protected:
}
}
- template<typename NODE>
- void rb_erase_case4(NODE node)
- {
- N* sibling = get_sibling(node);
+ template <typename NODE> void rb_erase_case4(NODE node) {
+ N *sibling = get_sibling(node);
if (!sibling) {
throw rb_invariant_error();
}
- colour_t sibling_left_colour = sibling->left ? sibling->left->colour : BLACK;
- colour_t sibling_right_colour = sibling->right ? sibling->right->colour : BLACK;
+ colour_t sibling_left_colour =
+ sibling->left ? sibling->left->colour : BLACK;
+ colour_t sibling_right_colour =
+ sibling->right ? sibling->right->colour : BLACK;
- if (node->parent->colour == RED &&
- sibling->colour == BLACK &&
- sibling_left_colour == BLACK &&
- sibling_right_colour == BLACK) {
+ if (node->parent->colour == RED && sibling->colour == BLACK &&
+ sibling_left_colour == BLACK && sibling_right_colour == BLACK) {
sibling->colour = RED;
node->parent->colour = BLACK;
} else {
@@ -735,21 +638,20 @@ protected:
}
}
- template<typename NODE>
- void rb_erase_case5(NODE node)
- {
- N* sibling = get_sibling(node);
+ template <typename NODE> void rb_erase_case5(NODE node) {
+ N *sibling = get_sibling(node);
if (!sibling) {
throw rb_invariant_error();
}
- colour_t sibling_left_colour = sibling->left ? sibling->left->colour : BLACK;
- colour_t sibling_right_colour = sibling->right ? sibling->right->colour : BLACK;
+ colour_t sibling_left_colour =
+ sibling->left ? sibling->left->colour : BLACK;
+ colour_t sibling_right_colour =
+ sibling->right ? sibling->right->colour : BLACK;
if (sibling->colour == BLACK) {
- if (is_left(node) &&
- sibling_right_colour == BLACK &&
+ if (is_left(node) && sibling_right_colour == BLACK &&
sibling_left_colour == RED) {
sibling->colour = RED;
@@ -758,8 +660,7 @@ protected:
}
right_rotation(sibling);
- } else if (is_right(node) &&
- sibling_left_colour == BLACK &&
+ } else if (is_right(node) && sibling_left_colour == BLACK &&
sibling_right_colour == RED) {
sibling->colour = RED;
@@ -774,10 +675,8 @@ protected:
rb_erase_case6(node);
}
- template<typename NODE>
- void rb_erase_case6(NODE node)
- {
- N* sibling = get_sibling(node);
+ template <typename NODE> void rb_erase_case6(NODE node) {
+ N *sibling = get_sibling(node);
if (!sibling) {
throw rb_invariant_error();
@@ -805,5 +704,5 @@ protected:
size_t tree_size;
};
-template<typename K, typename V, typename N>
+template <typename K, typename V, typename N>
std::unique_ptr<N> rbtree<K, V, N>::null_node;
diff --git a/src/XrdApps/XrdClJCachePlugin/file/Art.hh b/src/XrdApps/XrdClJCachePlugin/file/Art.hh
index e8ce0fbc760..342f08f21b5 100644
--- a/src/XrdApps/XrdClJCachePlugin/file/Art.hh
+++ b/src/XrdApps/XrdClJCachePlugin/file/Art.hh
@@ -24,82 +24,89 @@
#pragma once
/*----------------------------------------------------------------------------*/
-#include <iostream>
-#include <iomanip>
-#include <vector>
#include <cmath>
+#include <iomanip>
+#include <iostream>
#include <numeric>
+#include <vector>
/*----------------------------------------------------------------------------*/
namespace JCache {
- class Art {
- public:
- Art() {}
- virtual ~Art() {}
+class Art {
+public:
+ Art() {}
+ virtual ~Art() {}
- void drawCurve(const std::vector<double>& dataPoints, double runtime) {
- if (dataPoints.size() != 40) {
- std::cerr << "Error: Exactly 40 data points are required." << std::endl;
- return;
- }
-
- double maxValue = *std::max_element(dataPoints.begin(), dataPoints.end());
- double minValue = *std::min_element(dataPoints.begin(), dataPoints.end());
-
- const int plotHeight = 10; // Number of lines in the plot
- const int plotWidth = 40; // Width of the plot in characters
- const int yLegendWidth = 8; // Width of the Y legend in characters
-
- std::vector<std::string> plot(plotHeight, std::string(plotWidth, ' '));
-
- // Normalize data points to the plot height
- std::vector<int> normalizedDataPoints;
- for (double point : dataPoints) {
- int normalizedValue = static_cast<int>((point - minValue) / (maxValue - minValue) * (plotHeight - 1));
- if (normalizedValue<0){
- normalizedValue=0;
- }
- normalizedDataPoints.push_back(normalizedValue);
- }
+ void drawCurve(const std::vector<double> &dataPoints, double runtime) {
+ if (dataPoints.size() != 40) {
+ std::cerr << "Error: Exactly 40 data points are required." << std::endl;
+ return;
+ }
- // Draw the curve
- for (size_t i = 0; i < normalizedDataPoints.size(); ++i) {
- int y = plotHeight - 1 - normalizedDataPoints[i];
- plot[y][i * (plotWidth / (dataPoints.size() - 1))] = '*';
- }
-
- // Print the plot with Y legend
- for (int i = 0; i < plotHeight; ++i) {
- double yValue = minValue + (maxValue - minValue) * (plotHeight - 1 - i) / (plotHeight - 1);
- if (i==0) {
- std::cerr << "# " << std::setw(yLegendWidth) << std::fixed << std::setprecision(2) << yValue << " MB/s | ";
- } else {
- std::cerr << "# " << std::setw(yLegendWidth) << std::fixed << std::setprecision(2) << yValue << " | ";
- }
- std::cerr << plot[i] << std::endl;
- }
+ double maxValue = *std::max_element(dataPoints.begin(), dataPoints.end());
+ double minValue = *std::min_element(dataPoints.begin(), dataPoints.end());
+
+ const int plotHeight = 10; // Number of lines in the plot
+ const int plotWidth = 40; // Width of the plot in characters
+ const int yLegendWidth = 8; // Width of the Y legend in characters
- // Print the X axis
- std::cerr << "# " << std::string(yLegendWidth + 7, ' ') << std::string(plotWidth, '-') << std::endl;
- std::cerr << "# " << std::string(yLegendWidth + 7, ' ');
- for (size_t i = 0 ; i < dataPoints.size()/4; ++i) {
- std::cerr << std::fixed << std::setw(4) << std::left << (i*10);
+ std::vector<std::string> plot(plotHeight, std::string(plotWidth, ' '));
+
+ // Normalize data points to the plot height
+ std::vector<int> normalizedDataPoints;
+ for (double point : dataPoints) {
+ int normalizedValue = static_cast<int>(
+ (point - minValue) / (maxValue - minValue) * (plotHeight - 1));
+ if (normalizedValue < 0) {
+ normalizedValue = 0;
}
- std::cerr << "[ " << 100 << " % = " << std::fixed << std::setprecision(2) << runtime << "s ]"<< std::endl;
+ normalizedDataPoints.push_back(normalizedValue);
}
- void drawCurve(const std::vector<long unsigned int>& data, double interval, double runtime) {
- std::vector<double> newdata;
- if (interval == 0) {
- interval = 0.00001;
- }
- if (runtime == 0) {
- runtime = 0.00001;
- }
- for ( auto i:data ) {
- newdata.push_back(i/1000000.0 / interval);
+ // Draw the curve
+ for (size_t i = 0; i < normalizedDataPoints.size(); ++i) {
+ int y = plotHeight - 1 - normalizedDataPoints[i];
+ plot[y][i * (plotWidth / (dataPoints.size() - 1))] = '*';
+ }
+
+ // Print the plot with Y legend
+ for (int i = 0; i < plotHeight; ++i) {
+ double yValue = minValue + (maxValue - minValue) * (plotHeight - 1 - i) /
+ (plotHeight - 1);
+ if (i == 0) {
+ std::cerr << "# " << std::setw(yLegendWidth) << std::fixed
+ << std::setprecision(2) << yValue << " MB/s | ";
+ } else {
+ std::cerr << "# " << std::setw(yLegendWidth) << std::fixed
+ << std::setprecision(2) << yValue << " | ";
}
- return drawCurve(newdata, runtime);
+ std::cerr << plot[i] << std::endl;
+ }
+
+ // Print the X axis
+ std::cerr << "# " << std::string(yLegendWidth + 7, ' ')
+ << std::string(plotWidth, '-') << std::endl;
+ std::cerr << "# " << std::string(yLegendWidth + 7, ' ');
+ for (size_t i = 0; i < dataPoints.size() / 4; ++i) {
+ std::cerr << std::fixed << std::setw(4) << std::left << (i * 10);
+ }
+ std::cerr << "[ " << 100 << " % = " << std::fixed << std::setprecision(2)
+ << runtime << "s ]" << std::endl;
+ }
+
+ void drawCurve(const std::vector<long unsigned int> &data, double interval,
+ double runtime) {
+ std::vector<double> newdata;
+ if (interval == 0) {
+ interval = 0.00001;
+ }
+ if (runtime == 0) {
+ runtime = 0.00001;
+ }
+ for (auto i : data) {
+ newdata.push_back(i / 1000000.0 / interval);
}
- };
+ return drawCurve(newdata, runtime);
+ }
+};
} // namespace JCache
diff --git a/src/XrdApps/XrdClJCachePlugin/file/CacheStats.hh b/src/XrdApps/XrdClJCachePlugin/file/CacheStats.hh
index c8f4a80c578..b1d9164890a 100644
--- a/src/XrdApps/XrdClJCachePlugin/file/CacheStats.hh
+++ b/src/XrdApps/XrdClJCachePlugin/file/CacheStats.hh
@@ -33,257 +33,324 @@
#include <mutex>
#include <sstream>
+#include "file/XrdClJCacheFile.hh"
+#include <set>
#include <string>
+#include <sys/resource.h>
+#include <sys/time.h>
#include <thread>
#include <vector>
-#include <set>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include "file/XrdClJCacheFile.hh"
-
+namespace JCache {
+//! structure for cache hit statistics
+struct CacheStats {
+ CacheStats(bool doe = false)
+ : bytesRead(0), bytesReadV(0), bytesCached(0), bytesCachedV(0),
+ readOps(0), readVOps(0), readVreadOps(0), nreadfiles(0),
+ dumponexit(doe), peakrate(0) {
+ // Get the current real time
+ struct timeval now;
+ gettimeofday(&now, nullptr);
+ startTime = now.tv_sec + now.tv_usec / 1000000.0;
+ }
-namespace JCache
-{
- //! structure for cache hit statistics
- struct CacheStats {
- CacheStats(bool doe=false) :
- bytesRead(0),
- bytesReadV(0),
- bytesCached(0),
- bytesCachedV(0),
- readOps(0),
- readVOps(0),
- readVreadOps(0),
- nreadfiles(0),
- dumponexit(doe),
- peakrate(0)
- {
- // Get the current real time
- struct timeval now;
- gettimeofday(&now, nullptr);
- startTime = now.tv_sec + now.tv_usec / 1000000.0;
- }
-
- ~CacheStats() {
- if (dumponexit.load() && totaldatasize) {
- using namespace std::chrono;
- std::string jsonpath = XrdCl::JCacheFile::sJsonPath + "jcache.";
- std::string name = getenv("XRD_APPNAME")?getenv("XRD_APPNAME"):"none"+std::string(".")+std::to_string(getpid());
- jsonpath += name;
- jsonpath += ".json";
- XrdCl::JCacheFile::sStats.GetTimes();
+ ~CacheStats() {
+ if (dumponexit.load() && totaldatasize) {
+ using namespace std::chrono;
+ std::string jsonpath = XrdCl::JCacheFile::sJsonPath + "jcache.";
+ std::string name = getenv("XRD_APPNAME") ? getenv("XRD_APPNAME")
+ : "none" + std::string(".") +
+ std::to_string(getpid());
+ jsonpath += name;
+ jsonpath += ".json";
+ XrdCl::JCacheFile::sStats.GetTimes();
- XrdCl::JCacheFile::sStats.bytes_per_second = XrdCl::JCacheFile::sStats.bench.GetBins((int)(realTime));
- XrdCl::JCacheFile::sStats.peakrate = *(std::max_element(XrdCl::JCacheFile::sStats.bytes_per_second.begin(), XrdCl::JCacheFile::sStats.bytes_per_second.end()));
- if (realTime <1) {
- XrdCl::JCacheFile::sStats.peakrate = ReadBytes() / realTime;
- }
- if (XrdCl::JCacheFile::sJsonPath.length()) {
- XrdCl::JCacheFile::sStats.persistToJson(jsonpath, name);
- }
- if (XrdCl::JCacheFile::sEnableSummary) {
- std::cerr << CacheStats::GlobalStats(XrdCl::JCacheFile::sStats);
- }
- std::vector<uint64_t> bins = XrdCl::JCacheFile::sStats.bench.GetBins(40);
- JCache::Art art;
- if (XrdCl::JCacheFile::sEnableSummary) {
- std::cerr << "# IO Timeprofile " << std::endl;
- art.drawCurve(bins, XrdCl::JCacheFile::sStats.bench.GetTimePerBin().count() / 1000000.0, realTime);
- std::cerr << "# ----------------------------------------------------------------------- #" << std::endl;
- }
+ XrdCl::JCacheFile::sStats.bytes_per_second =
+ XrdCl::JCacheFile::sStats.bench.GetBins((int)(realTime));
+ XrdCl::JCacheFile::sStats.peakrate =
+ *(std::max_element(XrdCl::JCacheFile::sStats.bytes_per_second.begin(),
+ XrdCl::JCacheFile::sStats.bytes_per_second.end()));
+ if (realTime < 1) {
+ XrdCl::JCacheFile::sStats.peakrate = ReadBytes() / realTime;
}
- }
-
- static std::string bytesToHumanReadable(double bytes) {
- const char* suffixes[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
- const int numSuffixes = sizeof(suffixes) / sizeof(suffixes[0]);
-
- if (bytes == 0) return "0 B";
-
- int exp = std::min((int)(std::log(bytes) / std::log(1000)), numSuffixes - 1);
- double val = bytes / std::pow(1000, exp);
- std::ostringstream oss;
- oss << std::fixed << std::setprecision(2) << val << " " << suffixes[exp];
- return oss.str();
- }
-
- uint64_t ReadOpBytes() {
- return this->bytesCached.load()+this->bytesRead.load();
- }
-
- uint64_t ReadVOpBytes() {
- return this->bytesCachedV.load()+this->bytesReadV.load();
- }
- double HitRate() {
- auto n = this->bytesCached.load()+this->bytesRead.load();
- if (!n) return 100.0;
- return 100.0*(this->bytesCached.load()) / n;
- }
- double HitRateV() {
- auto n = this->bytesCachedV.load()+this->bytesReadV.load();
- if (!n) return 100.0;
- return 100.0*(this->bytesCachedV.load()) / n;
- }
- double CombinedHitRate() {
- auto n = (this->bytesCached.load()+this->bytesRead.load()+this->bytesCachedV.load()+this->bytesReadV.load());
- if (!n) return 100.0;
- return 100.0*(this->bytesCached.load()+this->bytesCachedV.load()) / n;
- }
- void AddUrl(const std::string& url) {
- std::lock_guard<std::mutex> guard(urlMutex);
- urls.insert(url);
- }
- bool HasUrl(const std::string& url) {
- std::lock_guard<std::mutex> guard(urlMutex);
- return urls.count(url);
- }
- double ReadBytes() {
- return (bytesRead.load()+bytesReadV.load() + bytesCached.load() + bytesCachedV.load());
- }
-
- double Used() {
- if (totaldatasize) {
- return 100.0*(bytesRead.load()+bytesReadV.load() + bytesCached.load() + bytesCachedV.load()) / totaldatasize;
- } else {
- return 100.0;
+ if (XrdCl::JCacheFile::sJsonPath.length()) {
+ XrdCl::JCacheFile::sStats.persistToJson(jsonpath, name);
+ }
+ if (XrdCl::JCacheFile::sEnableSummary) {
+ std::cerr << CacheStats::GlobalStats(XrdCl::JCacheFile::sStats);
+ }
+ std::vector<uint64_t> bins = XrdCl::JCacheFile::sStats.bench.GetBins(40);
+ JCache::Art art;
+ if (XrdCl::JCacheFile::sEnableSummary) {
+ std::cerr << "# IO Timeprofile " << std::endl;
+ art.drawCurve(bins,
+ XrdCl::JCacheFile::sStats.bench.GetTimePerBin().count() /
+ 1000000.0,
+ realTime);
+ std::cerr << "# "
+ "---------------------------------------------------------"
+ "-------------- #"
+ << std::endl;
}
}
+ }
- size_t UniqueUrls() {
- std::lock_guard<std::mutex> guard(urlMutex);
- return urls.size();
- }
+ static std::string bytesToHumanReadable(double bytes) {
+ const char *suffixes[] = {"B", "KB", "MB", "GB", "TB",
+ "PB", "EB", "ZB", "YB"};
+ const int numSuffixes = sizeof(suffixes) / sizeof(suffixes[0]);
+
+ if (bytes == 0)
+ return "0 B";
- void GetTimes() {
- struct rusage usage;
- struct timeval now;
+ int exp =
+ std::min((int)(std::log(bytes) / std::log(1000)), numSuffixes - 1);
+ double val = bytes / std::pow(1000, exp);
+ std::ostringstream oss;
+ oss << std::fixed << std::setprecision(2) << val << " " << suffixes[exp];
+ return oss.str();
+ }
- // Get the current real time
- gettimeofday(&now, nullptr);
- realTime = now.tv_sec + now.tv_usec / 1000000.0 - startTime;
+ uint64_t ReadOpBytes() {
+ return this->bytesCached.load() + this->bytesRead.load();
+ }
- // Get resource usage
- getrusage(RUSAGE_SELF, &usage);
+ uint64_t ReadVOpBytes() {
+ return this->bytesCachedV.load() + this->bytesReadV.load();
+ }
+ double HitRate() {
+ auto n = this->bytesCached.load() + this->bytesRead.load();
+ if (!n)
+ return 100.0;
+ return 100.0 * (this->bytesCached.load()) / n;
+ }
+ double HitRateV() {
+ auto n = this->bytesCachedV.load() + this->bytesReadV.load();
+ if (!n)
+ return 100.0;
+ return 100.0 * (this->bytesCachedV.load()) / n;
+ }
+ double CombinedHitRate() {
+ auto n = (this->bytesCached.load() + this->bytesRead.load() +
+ this->bytesCachedV.load() + this->bytesReadV.load());
+ if (!n)
+ return 100.0;
+ return 100.0 * (this->bytesCached.load() + this->bytesCachedV.load()) / n;
+ }
+ void AddUrl(const std::string &url) {
+ std::lock_guard<std::mutex> guard(urlMutex);
+ urls.insert(url);
+ }
+ bool HasUrl(const std::string &url) {
+ std::lock_guard<std::mutex> guard(urlMutex);
+ return urls.count(url);
+ }
+ double ReadBytes() {
+ return (bytesRead.load() + bytesReadV.load() + bytesCached.load() +
+ bytesCachedV.load());
+ }
- // Get user and system time
- userTime = usage.ru_utime.tv_sec + usage.ru_utime.tv_usec / 1000000.0;
- sysTime = usage.ru_stime.tv_sec + usage.ru_stime.tv_usec / 1000000.0;
+ double Used() {
+ if (totaldatasize) {
+ return 100.0 *
+ (bytesRead.load() + bytesReadV.load() + bytesCached.load() +
+ bytesCachedV.load()) /
+ totaldatasize;
+ } else {
+ return 100.0;
}
+ }
- void persistToJson(const std::string& path, const std::string& name) {
- std::ofstream outFile(path);
- if (!outFile.is_open()) {
- std::cerr << "error: failed to open JSON statistics file: " << path << std::endl;
- return;
- }
+ size_t UniqueUrls() {
+ std::lock_guard<std::mutex> guard(urlMutex);
+ return urls.size();
+ }
- outFile << "{\n";
- outFile << " \"appname\": \"" << name << "\",\n";
- outFile << " \"pid\": \"" << getpid() << "\",\n";
- outFile << " \"bytesRead\": " << bytesRead.load() << ",\n";
- outFile << " \"bytesReadV\": " << bytesReadV.load() << ",\n";
- outFile << " \"bytesCached\": " << bytesCached.load() << ",\n";
- outFile << " \"bytesCachedV\": " << bytesCachedV.load() << ",\n";
- outFile << " \"readOps\": " << readOps.load() << ",\n";
- outFile << " \"readVOps\": " << readVOps.load() << ",\n";
- outFile << " \"readVreadOps\": " << readVreadOps.load() << ",\n";
- outFile << " \"nreadfiles\": " << nreadfiles.load() << ",\n";
- outFile << " \"totaldatasize\": " << totaldatasize.load() << ",\n";
+ void GetTimes() {
+ struct rusage usage;
+ struct timeval now;
- std::lock_guard<std::mutex> lock(urlMutex);
- outFile << " \"urls\": [";
- for (auto it = urls.begin(); it != urls.end(); ++it) {
- if (it != urls.begin()) {
- outFile << ", ";
- }
- outFile << "\"" << *it << "\"";
- }
- outFile << "],\n";
+ // Get the current real time
+ gettimeofday(&now, nullptr);
+ realTime = now.tv_sec + now.tv_usec / 1000000.0 - startTime;
- outFile << " \"bytes_per_second\": [";
- for (size_t i = 0; i < bytes_per_second.size(); ++i) {
- if (i != 0) {
- outFile << ", ";
- }
- outFile << bytes_per_second[i];
- }
- outFile << "],\n";
+ // Get resource usage
+ getrusage(RUSAGE_SELF, &usage);
- outFile << std::fixed << std::setprecision(6); // Set precision for double values
+ // Get user and system time
+ userTime = usage.ru_utime.tv_sec + usage.ru_utime.tv_usec / 1000000.0;
+ sysTime = usage.ru_stime.tv_sec + usage.ru_stime.tv_usec / 1000000.0;
+ }
- outFile << " \"userTime\": " << userTime.load() << ",\n";
- outFile << " \"realTime\": " << realTime.load() << ",\n";
- outFile << " \"sysTime\": " << sysTime.load() << ",\n";
- outFile << " \"startTime\": " << startTime.load() << "\n";
- outFile << "}\n";
+ void persistToJson(const std::string &path, const std::string &name) {
+ std::ofstream outFile(path);
+ if (!outFile.is_open()) {
+ std::cerr << "error: failed to open JSON statistics file: " << path
+ << std::endl;
+ return;
+ }
+
+ outFile << "{\n";
+ outFile << " \"appname\": \"" << name << "\",\n";
+ outFile << " \"pid\": \"" << getpid() << "\",\n";
+ outFile << " \"bytesRead\": " << bytesRead.load() << ",\n";
+ outFile << " \"bytesReadV\": " << bytesReadV.load() << ",\n";
+ outFile << " \"bytesCached\": " << bytesCached.load() << ",\n";
+ outFile << " \"bytesCachedV\": " << bytesCachedV.load() << ",\n";
+ outFile << " \"readOps\": " << readOps.load() << ",\n";
+ outFile << " \"readVOps\": " << readVOps.load() << ",\n";
+ outFile << " \"readVreadOps\": " << readVreadOps.load() << ",\n";
+ outFile << " \"nreadfiles\": " << nreadfiles.load() << ",\n";
+ outFile << " \"totaldatasize\": " << totaldatasize.load() << ",\n";
- outFile.close();
+ std::lock_guard<std::mutex> lock(urlMutex);
+ outFile << " \"urls\": [";
+ for (auto it = urls.begin(); it != urls.end(); ++it) {
+ if (it != urls.begin()) {
+ outFile << ", ";
+ }
+ outFile << "\"" << *it << "\"";
}
+ outFile << "],\n";
- void AddToStats(CacheStats& gStats) {
- gStats.readOps += readOps.load();
- gStats.readVOps += readVOps.load();
- gStats.readVreadOps += readVreadOps.load();
- gStats.bytesRead += bytesRead.load();
- gStats.bytesReadV += bytesReadV.load();
- gStats.bytesCached += bytesCached.load();
- gStats.bytesCachedV += bytesCachedV.load();
- gStats.nreadfiles += 1;
+ outFile << " \"bytes_per_second\": [";
+ for (size_t i = 0; i < bytes_per_second.size(); ++i) {
+ if (i != 0) {
+ outFile << ", ";
+ }
+ outFile << bytes_per_second[i];
}
+ outFile << "],\n";
- static std::string GlobalStats(CacheStats& sStats) {
- std::ostringstream oss;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : 2024 CERN.EOS - Andreas-Joachim Peters #" << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
+ outFile << std::fixed
+ << std::setprecision(6); // Set precision for double values
- oss << "# JCache : cache combined hit rate : " << std::fixed << std::setprecision(2) << sStats.CombinedHitRate() << " %" << std::endl;
- oss << "# JCache : cache read hit rate : " << std::fixed << std::setprecision(2) << (!sStats.ReadOpBytes()?"\033[9m":"") << sStats.HitRate() << " %" << (!sStats.ReadOpBytes()?"\033[0m":"") << std::endl;
- oss << "# JCache : cache readv hit rate : " << std::fixed << std::setprecision(2) << (!sStats.ReadVOpBytes()?"\033[9m":"") <<sStats.HitRateV() << " %" << (!sStats.ReadOpBytes()?"\033[0m":"") << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : total bytes read : " << sStats.bytesRead.load()+sStats.bytesCached.load() << std::endl;
- oss << "# JCache : total bytes readv : " << sStats.bytesReadV.load()+sStats.bytesCachedV.load() << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : total iops read : " << sStats.readOps.load() << std::endl;
- oss << "# JCache : total iops readv : " << sStats.readVOps.load() << std::endl;
- oss << "# JCache : total iops readvread : " << sStats.readVreadOps.load() << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : open files read : " << sStats.nreadfiles.load() << std::endl;
- oss << "# JCache : open unique f. read : " << sStats.UniqueUrls() << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : total unique files bytes : " << sStats.totaldatasize << std::endl;
- oss << "# JCache : total unique files size : " << sStats.bytesToHumanReadable((double)sStats.totaldatasize) << std::endl;
- oss << "# JCache : percentage dataset read : " << std::fixed << std::setprecision(2) << sStats.Used() << " %" << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
- oss << "# JCache : app user time : " << std::fixed << std::setprecision(2) << sStats.userTime << " s" << std::endl;
- oss << "# JCache : app real time : " << std::fixed << std::setprecision(2) << sStats.realTime << " s" << std::endl;
- oss << "# JCache : app sys time : " << std::fixed << std::setprecision(2) << sStats.sysTime << " s" << std::endl;
- oss << "# JCache : app acceleration : " << std::fixed << std::setprecision(2) << sStats.userTime / sStats.realTime << "x" << std::endl;
- oss << "# JCache : app readrate : " << std::fixed << std::setprecision(2) << sStats.bytesToHumanReadable((sStats.ReadBytes()/sStats.realTime)) << "/s" << " [ peak (1s) " << sStats.bytesToHumanReadable(sStats.peakrate) << "/s ]" << std::endl;
- oss << "# ----------------------------------------------------------------------- #" << std::endl;
+ outFile << " \"userTime\": " << userTime.load() << ",\n";
+ outFile << " \"realTime\": " << realTime.load() << ",\n";
+ outFile << " \"sysTime\": " << sysTime.load() << ",\n";
+ outFile << " \"startTime\": " << startTime.load() << "\n";
+ outFile << "}\n";
- return oss.str();
- }
+ outFile.close();
+ }
+
+ void AddToStats(CacheStats &gStats) {
+ gStats.readOps += readOps.load();
+ gStats.readVOps += readVOps.load();
+ gStats.readVreadOps += readVreadOps.load();
+ gStats.bytesRead += bytesRead.load();
+ gStats.bytesReadV += bytesReadV.load();
+ gStats.bytesCached += bytesCached.load();
+ gStats.bytesCachedV += bytesCachedV.load();
+ gStats.nreadfiles += 1;
+ }
+
+ static std::string GlobalStats(CacheStats &sStats) {
+ std::ostringstream oss;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : 2024 CERN.EOS - Andreas-Joachim Peters "
+ " #"
+ << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+
+ oss << "# JCache : cache combined hit rate : " << std::fixed
+ << std::setprecision(2) << sStats.CombinedHitRate() << " %"
+ << std::endl;
+ oss << "# JCache : cache read hit rate : " << std::fixed
+ << std::setprecision(2) << (!sStats.ReadOpBytes() ? "\033[9m" : "")
+ << sStats.HitRate() << " %" << (!sStats.ReadOpBytes() ? "\033[0m" : "")
+ << std::endl;
+ oss << "# JCache : cache readv hit rate : " << std::fixed
+ << std::setprecision(2) << (!sStats.ReadVOpBytes() ? "\033[9m" : "")
+ << sStats.HitRateV() << " %" << (!sStats.ReadOpBytes() ? "\033[0m" : "")
+ << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : total bytes read : "
+ << sStats.bytesRead.load() + sStats.bytesCached.load() << std::endl;
+ oss << "# JCache : total bytes readv : "
+ << sStats.bytesReadV.load() + sStats.bytesCachedV.load() << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : total iops read : " << sStats.readOps.load()
+ << std::endl;
+ oss << "# JCache : total iops readv : " << sStats.readVOps.load()
+ << std::endl;
+ oss << "# JCache : total iops readvread : "
+ << sStats.readVreadOps.load() << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : open files read : " << sStats.nreadfiles.load()
+ << std::endl;
+ oss << "# JCache : open unique f. read : " << sStats.UniqueUrls()
+ << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : total unique files bytes : " << sStats.totaldatasize
+ << std::endl;
+ oss << "# JCache : total unique files size : "
+ << sStats.bytesToHumanReadable((double)sStats.totaldatasize)
+ << std::endl;
+ oss << "# JCache : percentage dataset read : " << std::fixed
+ << std::setprecision(2) << sStats.Used() << " %" << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+ oss << "# JCache : app user time : " << std::fixed
+ << std::setprecision(2) << sStats.userTime << " s" << std::endl;
+ oss << "# JCache : app real time : " << std::fixed
+ << std::setprecision(2) << sStats.realTime << " s" << std::endl;
+ oss << "# JCache : app sys time : " << std::fixed
+ << std::setprecision(2) << sStats.sysTime << " s" << std::endl;
+ oss << "# JCache : app acceleration : " << std::fixed
+ << std::setprecision(2) << sStats.userTime / sStats.realTime << "x"
+ << std::endl;
+ oss << "# JCache : app readrate : " << std::fixed
+ << std::setprecision(2)
+ << sStats.bytesToHumanReadable((sStats.ReadBytes() / sStats.realTime))
+ << "/s" << " [ peak (1s) "
+ << sStats.bytesToHumanReadable(sStats.peakrate) << "/s ]" << std::endl;
+ oss << "# "
+ "-------------------------------------------------------------------"
+ "---- #"
+ << std::endl;
+
+ return oss.str();
+ }
- std::atomic<uint64_t> bytesRead;
- std::atomic<uint64_t> bytesReadV;
- std::atomic<uint64_t> bytesCached;
- std::atomic<uint64_t> bytesCachedV;
- std::atomic<uint64_t> readOps;
- std::atomic<uint64_t> readVOps;
- std::atomic<uint64_t> readVreadOps;
- std::atomic<uint64_t> nreadfiles;
- std::atomic<uint64_t> totaldatasize;
- std::atomic<bool> dumponexit;
- std::set<std::string> urls;
- std::mutex urlMutex;
- std::atomic<double> userTime;
- std::atomic<double> realTime;
- std::atomic<double> sysTime;
- std::atomic<double> startTime;
- JCache::TimeBench bench;
- std::vector<uint64_t> bytes_per_second;
- std::atomic<double> peakrate;
- }; // class CacheStats
+ std::atomic<uint64_t> bytesRead;
+ std::atomic<uint64_t> bytesReadV;
+ std::atomic<uint64_t> bytesCached;
+ std::atomic<uint64_t> bytesCachedV;
+ std::atomic<uint64_t> readOps;
+ std::atomic<uint64_t> readVOps;
+ std::atomic<uint64_t> readVreadOps;
+ std::atomic<uint64_t> nreadfiles;
+ std::atomic<uint64_t> totaldatasize;
+ std::atomic<bool> dumponexit;
+ std::set<std::string> urls;
+ std::mutex urlMutex;
+ std::atomic<double> userTime;
+ std::atomic<double> realTime;
+ std::atomic<double> sysTime;
+ std::atomic<double> startTime;
+ JCache::TimeBench bench;
+ std::vector<uint64_t> bytes_per_second;
+ std::atomic<double> peakrate;
+}; // class CacheStats
} // namespace JCache
diff --git a/src/XrdApps/XrdClJCachePlugin/file/TimeBench.hh b/src/XrdApps/XrdClJCachePlugin/file/TimeBench.hh
index 09502a10699..6007559c41a 100644
--- a/src/XrdApps/XrdClJCachePlugin/file/TimeBench.hh
+++ b/src/XrdApps/XrdClJCachePlugin/file/TimeBench.hh
@@ -23,72 +23,71 @@
#pragma once
-#include <iostream>
-#include <vector>
+#include <algorithm>
#include <chrono>
+#include <iostream>
#include <mutex>
-#include <algorithm>
+#include <vector>
+
+namespace JCache {
+class TimeBench {
+private:
+ using Clock = std::chrono::high_resolution_clock;
+ using TimePoint = std::chrono::time_point<Clock>;
+ using Duration = std::chrono::microseconds;
-namespace JCache
-{
- class TimeBench {
- private:
- using Clock = std::chrono::high_resolution_clock;
- using TimePoint = std::chrono::time_point<Clock>;
- using Duration = std::chrono::microseconds;
+ std::vector<std::pair<TimePoint, uint64_t>> measurements;
+ std::vector<uint64_t> bins;
+ TimePoint start;
+ TimePoint end;
+ uint64_t totalBytes;
+ size_t nbins;
+ std::mutex mtx;
- std::vector<std::pair<TimePoint,uint64_t>> measurements;
- std::vector<uint64_t> bins;
- TimePoint start;
- TimePoint end;
- uint64_t totalBytes;
- size_t nbins;
- std::mutex mtx;
-
- public:
- TimeBench() : totalBytes(0), nbins(10) {}
+public:
+ TimeBench() : totalBytes(0), nbins(10) {}
- void AddMeasurement(uint64_t bytes) {
- std::lock_guard<std::mutex> guard(mtx);
- auto now = Clock::now();
- if (measurements.empty()) {
- start = now;
- }
- measurements.push_back(std::make_pair(now,bytes));
- totalBytes += bytes;
- end = now;
- }
+ void AddMeasurement(uint64_t bytes) {
+ std::lock_guard<std::mutex> guard(mtx);
+ auto now = Clock::now();
+ if (measurements.empty()) {
+ start = now;
+ }
+ measurements.push_back(std::make_pair(now, bytes));
+ totalBytes += bytes;
+ end = now;
+ }
- std::vector<uint64_t> GetBins(size_t bin = 10) {
- std::lock_guard<std::mutex> guard(mtx);
- nbins = bin?bin:1;
- Duration totalTime = std::chrono::duration_cast<Duration>(end - start);
- Duration binSize = totalTime / nbins;
- bins.clear();
- bins.resize(nbins, 0);
- std::fill(bins.begin(), bins.end(), 0);
- size_t binIndex = 0;
+ std::vector<uint64_t> GetBins(size_t bin = 10) {
+ std::lock_guard<std::mutex> guard(mtx);
+ nbins = bin ? bin : 1;
+ Duration totalTime = std::chrono::duration_cast<Duration>(end - start);
+ Duration binSize = totalTime / nbins;
+ bins.clear();
+ bins.resize(nbins, 0);
+ std::fill(bins.begin(), bins.end(), 0);
+ size_t binIndex = 0;
- for (auto i : measurements) {
- if (binSize.count()) {
- binIndex = (i.first - start)/ binSize;
- } else {
- binIndex = 0;
- }
- if (binIndex < nbins) {
- bins[binIndex] += i.second;
- } else {
- break; // Don't process future measurements
- }
- }
+ for (auto i : measurements) {
+ if (binSize.count()) {
+ binIndex = (i.first - start) / binSize;
+ } else {
+ binIndex = 0;
+ }
+ if (binIndex < nbins) {
+ bins[binIndex] += i.second;
+ } else {
+ break; // Don't process future measurements
+ }
+ }
- return bins;
- }
+ return bins;
+ }
- Duration GetTimePerBin() {
- Duration totalTime = std::chrono::duration_cast<Duration>(end - start);
- Duration binSize = totalTime / nbins;
- return binSize;
- }
- };
+ Duration GetTimePerBin() {
+ Duration totalTime = std::chrono::duration_cast<Duration>(end - start);
+ Duration binSize = totalTime / nbins;
+ return binSize;
+ }
+};
} // namespace JCache
diff --git a/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.cc b/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.cc
index a1b90805c41..0d7250cd9bf 100644
--- a/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.cc
+++ b/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.cc
@@ -28,8 +28,8 @@
#include "XrdCl/XrdClMessageUtils.hh"
/*----------------------------------------------------------------------------*/
-std::string XrdCl::JCacheFile::sCachePath="";
-std::string XrdCl::JCacheFile::sJsonPath="./";
+std::string XrdCl::JCacheFile::sCachePath = "";
+std::string XrdCl::JCacheFile::sJsonPath = "./";
bool XrdCl::JCacheFile::sEnableJournalCache = true;
bool XrdCl::JCacheFile::sEnableVectorCache = false;
bool XrdCl::JCacheFile::sEnableSummary = true;
@@ -37,37 +37,28 @@ JCache::CacheStats XrdCl::JCacheFile::sStats(true);
JournalManager XrdCl::JCacheFile::sJournalManager;
-namespace XrdCl
-{
+namespace XrdCl {
//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
-JCacheFile::JCacheFile(const std::string& url):
- mIsOpen(false),
- pFile(0)
-{
+JCacheFile::JCacheFile(const std::string &url) : mIsOpen(false), pFile(0) {
mAttachedForRead = false;
mLog = DefaultEnv::GetLog();
}
//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
-JCacheFile::JCacheFile():
- mIsOpen(false),
- pFile(0)
-{
+JCacheFile::JCacheFile() : mIsOpen(false), pFile(0) {
mAttachedForRead = false;
mLog = DefaultEnv::GetLog();
pStats = new JCache::CacheStats();
}
-
//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
-JCacheFile::~JCacheFile()
-{
+JCacheFile::~JCacheFile() {
LogStats();
pStats->AddToStats(sStats);
if (pFile) {
@@ -78,23 +69,18 @@ JCacheFile::~JCacheFile()
}
}
-
//------------------------------------------------------------------------------
// Open
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Open(const std::string& url,
- OpenFlags::Flags flags,
- Access::Mode mode,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Open(const std::string &url, OpenFlags::Flags flags,
+ Access::Mode mode, ResponseHandler *handler,
+ uint16_t timeout) {
XRootDStatus st;
mFlags = flags;
if (mIsOpen) {
st = XRootDStatus(stError, errInvalidOp);
- std::cerr << "error: file is already opened: " << pUrl << std::endl;
+ std::cerr << "error: file is already opened: " << pUrl << std::endl;
return st;
}
@@ -113,33 +99,31 @@ JCacheFile::Open(const std::string& url,
mIsOpen = true;
if (sEnableVectorCache || sEnableJournalCache) {
if ((flags & OpenFlags::Flags::Read) == OpenFlags::Flags::Read) {
- std::string JournalDir = sCachePath + "/" + VectorCache::computeSHA256(pUrl);
- pJournalPath = JournalDir + "/journal";
- // it can be that we cannot write the journal directory
- if (!VectorCache::ensureLastSubdirectoryExists(JournalDir)) {
- st = XRootDStatus(stError, errOSError);
- std::cerr << "error: unable to create cache directory: " << JournalDir << std::endl;
- return st;
- }
+ std::string JournalDir =
+ sCachePath + "/" + VectorCache::computeSHA256(pUrl);
+ pJournalPath = JournalDir + "/journal";
+ // it can be that we cannot write the journal directory
+ if (!VectorCache::ensureLastSubdirectoryExists(JournalDir)) {
+ st = XRootDStatus(stError, errOSError);
+ std::cerr << "error: unable to create cache directory: " << JournalDir
+ << std::endl;
+ return st;
+ }
}
}
}
return st;
}
-
//------------------------------------------------------------------------------
// Close
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Close(ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Close(ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (mIsOpen) {
mIsOpen = false;
- pUrl = "";
+ pUrl = "";
if (pFile) {
st = pFile->Close(handler, timeout);
} else {
@@ -155,15 +139,11 @@ JCacheFile::Close(ResponseHandler* handler,
return st;
}
-
//------------------------------------------------------------------------------
// Stat
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Stat(bool force,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Stat(bool force, ResponseHandler *handler,
+ uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -175,17 +155,11 @@ JCacheFile::Stat(bool force,
return st;
}
-
//------------------------------------------------------------------------------
// Read
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Read(uint64_t offset,
- uint32_t size,
- void* buffer,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Read(uint64_t offset, uint32_t size, void *buffer,
+ ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -193,13 +167,13 @@ JCacheFile::Read(uint64_t offset,
if (sEnableJournalCache && AttachForRead()) {
bool eof = false;
auto rb = pJournal->pread(buffer, size, offset, eof);
- if ((rb == size) || (eof && rb)) {
+ if ((rb == size) || (eof && rb)) {
pStats->bytesCached += rb;
- pStats->readOps++;
+ pStats->readOps++;
// we can only serve success full reads from the cache for now
- XRootDStatus* ret_st = new XRootDStatus(st);
- ChunkInfo* chunkInfo = new ChunkInfo(offset, rb, buffer);
- AnyObject* obj = new AnyObject();
+ XRootDStatus *ret_st = new XRootDStatus(st);
+ ChunkInfo *chunkInfo = new ChunkInfo(offset, rb, buffer);
+ AnyObject *obj = new AnyObject();
obj->Set(chunkInfo);
handler->HandleResponse(ret_st, obj);
st = XRootDStatus(stOK, 0);
@@ -207,26 +181,23 @@ JCacheFile::Read(uint64_t offset,
}
}
- auto jhandler = new JCacheReadHandler(handler, &pStats->bytesRead,sEnableJournalCache?pJournal.get():nullptr);
+ auto jhandler =
+ new JCacheReadHandler(handler, &pStats->bytesRead,
+ sEnableJournalCache ? pJournal.get() : nullptr);
pStats->readOps++;
- st = pFile->Read(offset, size, buffer, jhandler, timeout);
+ st = pFile->Read(offset, size, buffer, jhandler, timeout);
} else {
st = XRootDStatus(stError, errInvalidOp);
}
return st;
}
-
//------------------------------------------------------------------------------
// Write
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Write(uint64_t offset,
- uint32_t size,
- const void* buffer,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Write(uint64_t offset, uint32_t size,
+ const void *buffer, ResponseHandler *handler,
+ uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -241,26 +212,21 @@ JCacheFile::Write(uint64_t offset,
//------------------------------------------------------------------------
//! PgRead
//------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::PgRead( uint64_t offset,
- uint32_t size,
- void *buffer,
- ResponseHandler *handler,
- uint16_t timeout )
-{
+XRootDStatus JCacheFile::PgRead(uint64_t offset, uint32_t size, void *buffer,
+ ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
sStats.bench.AddMeasurement(size);
if (sEnableJournalCache && AttachForRead()) {
bool eof = false;
auto rb = pJournal->pread(buffer, size, offset, eof);
- if ((rb == size) || (eof && rb)) {
+ if ((rb == size) || (eof && rb)) {
pStats->bytesCached += rb;
- pStats->readOps++;
+ pStats->readOps++;
// we can only serve success full reads from the cache for now
- XRootDStatus* ret_st = new XRootDStatus(st);
- ChunkInfo* chunkInfo = new ChunkInfo(offset, rb, buffer);
- AnyObject* obj = new AnyObject();
+ XRootDStatus *ret_st = new XRootDStatus(st);
+ ChunkInfo *chunkInfo = new ChunkInfo(offset, rb, buffer);
+ AnyObject *obj = new AnyObject();
obj->Set(chunkInfo);
handler->HandleResponse(ret_st, obj);
st = XRootDStatus(stOK, 0);
@@ -268,27 +234,24 @@ JCacheFile::PgRead( uint64_t offset,
}
}
- auto jhandler = new JCachePgReadHandler(handler, &pStats->bytesRead,sEnableJournalCache?pJournal.get():nullptr);
+ auto jhandler =
+ new JCachePgReadHandler(handler, &pStats->bytesRead,
+ sEnableJournalCache ? pJournal.get() : nullptr);
pStats->readOps++;
- st = pFile->PgRead(offset, size, buffer, jhandler, timeout);
+ st = pFile->PgRead(offset, size, buffer, jhandler, timeout);
} else {
st = XRootDStatus(stError, errInvalidOp);
}
return st;
}
-
//------------------------------------------------------------------------
//! PgWrite
//------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::PgWrite( uint64_t offset,
- uint32_t nbpgs,
- const void *buffer,
- std::vector<uint32_t> &cksums,
- ResponseHandler *handler,
- uint16_t timeout )
-{
+XRootDStatus JCacheFile::PgWrite(uint64_t offset, uint32_t nbpgs,
+ const void *buffer,
+ std::vector<uint32_t> &cksums,
+ ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -303,10 +266,7 @@ JCacheFile::PgWrite( uint64_t offset,
//------------------------------------------------------------------------------
// Sync
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Sync(ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Sync(ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -318,15 +278,11 @@ JCacheFile::Sync(ResponseHandler* handler,
return st;
}
-
//------------------------------------------------------------------------------
// Truncate
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Truncate(uint64_t size,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Truncate(uint64_t size, ResponseHandler *handler,
+ uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -338,16 +294,12 @@ JCacheFile::Truncate(uint64_t size,
return st;
}
-
//------------------------------------------------------------------------------
// VectorRead
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::VectorRead(const ChunkList& chunks,
- void* buffer,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::VectorRead(const ChunkList &chunks, void *buffer,
+ ResponseHandler *handler,
+ uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -357,66 +309,72 @@ JCacheFile::VectorRead(const ChunkList& chunks,
}
sStats.bench.AddMeasurement(len);
-
+
if (sEnableVectorCache) {
- VectorCache cache(chunks, pUrl, buffer?(char*)buffer:(char*)(chunks.begin()->buffer), sCachePath);
+ VectorCache cache(chunks, pUrl,
+ buffer ? (char *)buffer
+ : (char *)(chunks.begin()->buffer),
+ sCachePath);
if (cache.retrieve()) {
- XRootDStatus* ret_st = new XRootDStatus(st);
- *ret_st = XRootDStatus(stOK, 0);
- AnyObject* obj = new AnyObject();
- VectorReadInfo* vReadInfo = new VectorReadInfo();
+ XRootDStatus *ret_st = new XRootDStatus(st);
+ *ret_st = XRootDStatus(stOK, 0);
+ AnyObject *obj = new AnyObject();
+ VectorReadInfo *vReadInfo = new VectorReadInfo();
vReadInfo->SetSize(len);
- ChunkList& vResp = vReadInfo->GetChunks();
+ ChunkList &vResp = vReadInfo->GetChunks();
vResp = chunks;
obj->Set(vReadInfo);
handler->HandleResponse(ret_st, obj);
- pStats->readVOps++;
- pStats->readVreadOps += chunks.size();
- pStats->bytesCachedV += len;
+ pStats->readVOps++;
+ pStats->readVreadOps += chunks.size();
+ pStats->bytesCachedV += len;
return st;
}
} else {
if (sEnableJournalCache) {
- bool inJournal = true;
- size_t len = 0;
- // try to get chunks from journal cache
- for (auto it = chunks.begin(); it != chunks.end(); ++it) {
- bool eof = false;
- auto rb = pJournal->pread(it->buffer, it->length, it->offset, eof);
- if (rb != it->length) {
- // interrupt if we miss a piece and go remote
- inJournal = false;
- break;
- } else {
- len += it->length;
- }
- }
- if (inJournal) {
- // we found everything in the journal
- pStats->readVOps++;
- pStats->readVreadOps += chunks.size();
- pStats->bytesCachedV += len;
- XRootDStatus* ret_st = new XRootDStatus(st);
- *ret_st = XRootDStatus(stOK, 0);
- AnyObject* obj = new AnyObject();
- VectorReadInfo* vReadInfo = new VectorReadInfo();
- vReadInfo->SetSize(len);
- ChunkList& vResp = vReadInfo->GetChunks();
- vResp = chunks;
- obj->Set(vReadInfo);
- handler->HandleResponse(ret_st, obj);
- return st;
- }
+ bool inJournal = true;
+ size_t len = 0;
+ // try to get chunks from journal cache
+ for (auto it = chunks.begin(); it != chunks.end(); ++it) {
+ bool eof = false;
+ auto rb = pJournal->pread(it->buffer, it->length, it->offset, eof);
+ if (rb != it->length) {
+ // interrupt if we miss a piece and go remote
+ inJournal = false;
+ break;
+ } else {
+ len += it->length;
+ }
+ }
+ if (inJournal) {
+ // we found everything in the journal
+ pStats->readVOps++;
+ pStats->readVreadOps += chunks.size();
+ pStats->bytesCachedV += len;
+ XRootDStatus *ret_st = new XRootDStatus(st);
+ *ret_st = XRootDStatus(stOK, 0);
+ AnyObject *obj = new AnyObject();
+ VectorReadInfo *vReadInfo = new VectorReadInfo();
+ vReadInfo->SetSize(len);
+ ChunkList &vResp = vReadInfo->GetChunks();
+ vResp = chunks;
+ obj->Set(vReadInfo);
+ handler->HandleResponse(ret_st, obj);
+ return st;
+ }
}
}
-
-
- auto jhandler = new JCacheReadVHandler(handler, &pStats->bytesReadV,sEnableJournalCache?pJournal.get():nullptr, buffer?(char*)buffer:(char*)(chunks.begin()->buffer), sEnableVectorCache?sCachePath:"", pUrl);
- pStats->readVOps++;
+
+ auto jhandler = new JCacheReadVHandler(
+ handler, &pStats->bytesReadV,
+ sEnableJournalCache ? pJournal.get() : nullptr,
+ buffer ? (char *)buffer : (char *)(chunks.begin()->buffer),
+ sEnableVectorCache ? sCachePath : "", pUrl);
+ pStats->readVOps++;
pStats->readVreadOps += chunks.size();
- st = pFile->VectorRead(chunks, buffer, jhandler, timeout);
+ st = pFile->VectorRead(chunks, buffer, jhandler, timeout);
} else {
st = XRootDStatus(stError, errInvalidOp);
@@ -425,15 +383,11 @@ JCacheFile::VectorRead(const ChunkList& chunks,
return st;
}
-
//------------------------------------------------------------------------------
// Fcntl
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Fcntl(const XrdCl::Buffer& arg,
- ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Fcntl(const XrdCl::Buffer &arg,
+ ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -445,14 +399,10 @@ JCacheFile::Fcntl(const XrdCl::Buffer& arg,
return st;
}
-
//------------------------------------------------------------------------------
// Visa
//------------------------------------------------------------------------------
-XRootDStatus
-JCacheFile::Visa(ResponseHandler* handler,
- uint16_t timeout)
-{
+XRootDStatus JCacheFile::Visa(ResponseHandler *handler, uint16_t timeout) {
XRootDStatus st;
if (pFile) {
@@ -464,24 +414,16 @@ JCacheFile::Visa(ResponseHandler* handler,
return st;
}
-
//------------------------------------------------------------------------------
// IsOpen
//------------------------------------------------------------------------------
-bool
-JCacheFile::IsOpen() const
-{
- return mIsOpen;
-}
-
+bool JCacheFile::IsOpen() const { return mIsOpen; }
//------------------------------------------------------------------------------
// @see XrdCl::File::SetProperty
//------------------------------------------------------------------------------
-bool
-JCacheFile::SetProperty(const std::string& name,
- const std::string& value)
-{
+bool JCacheFile::SetProperty(const std::string &name,
+ const std::string &value) {
if (pFile) {
return pFile->SetProperty(name, value);
} else {
@@ -489,14 +431,11 @@ JCacheFile::SetProperty(const std::string& name,
}
}
-
//------------------------------------------------------------------------------
// @see XrdCl::File::GetProperty
//------------------------------------------------------------------------------
-bool
-JCacheFile::GetProperty(const std::string& name,
- std::string& value) const
-{
+bool JCacheFile::GetProperty(const std::string &name,
+ std::string &value) const {
if (pFile) {
return pFile->GetProperty(name, value);
} else {
@@ -504,9 +443,7 @@ JCacheFile::GetProperty(const std::string& name,
}
}
-bool
-JCacheFile::AttachForRead()
-{
+bool JCacheFile::AttachForRead() {
std::lock_guard guard(mAttachMutex);
if (mAttachedForRead) {
return true;
@@ -514,46 +451,46 @@ JCacheFile::AttachForRead()
if ((mFlags & OpenFlags::Flags::Read) == OpenFlags::Flags::Read) {
// attach to a cache
if (sEnableJournalCache && pFile) {
- mLog->Info(1, "JCache : attaching via journalmanager to '%s'", pUrl.c_str());
+ mLog->Info(1, "JCache : attaching via journalmanager to '%s'",
+ pUrl.c_str());
pJournal = sJournalManager.attach(pUrl);
- StatInfo* sinfo = 0;
+ StatInfo *sinfo = 0;
auto st = pFile->Stat(false, sinfo);
if (sinfo) {
- // only add a file if it wasn't yet added
- if (!sStats.HasUrl(pUrl)) {
- sStats.totaldatasize+=sinfo->GetSize();
- }
- if (pJournal->attach(pJournalPath, sinfo->GetModTime(),0, sinfo->GetSize())) {
- mLog->Error(1, "JCache : failed to attach to cache directory: %s", pJournalPath.c_str());
+ // only add a file if it wasn't yet added
+ if (!sStats.HasUrl(pUrl)) {
+ sStats.totaldatasize += sinfo->GetSize();
+ }
+ if (pJournal->attach(pJournalPath, sinfo->GetModTime(), 0,
+ sinfo->GetSize())) {
+ mLog->Error(1, "JCache : failed to attach to cache directory: %s",
+ pJournalPath.c_str());
mAttachedForRead = true;
return false;
} else {
- mLog->Info(1, "JCache : attached to cache directory: %s", pJournalPath.c_str());
- }
+ mLog->Info(1, "JCache : attached to cache directory: %s",
+ pJournalPath.c_str());
+ }
}
}
}
- sStats.AddUrl(pUrl);
+ sStats.AddUrl(pUrl);
mAttachedForRead = true;
return true;
}
-
//----------------------------------------------------------------------------
//! @brief log cache hit statistics
//----------------------------------------------------------------------------
void JCacheFile::LogStats() {
- mLog->Info(1, "JCache : read:readv-ops:readv-read-ops: %lu:%lu:%lus hit-rate: total [read/readv]=%.02f%% [%.02f%%/%.02f%%] remote-bytes-read/readv: %lu / %lu cached-bytes-read/readv: %lu / %lu",
- pStats->readOps.load(),
- pStats->readVOps.load(),
- pStats->readVreadOps.load(),
- pStats->CombinedHitRate(),
- pStats->HitRate(),
- pStats->HitRateV(),
- pStats->bytesRead.load(),
- pStats->bytesReadV.load(),
- pStats->bytesCached.load(),
- pStats->bytesCachedV.load());
- }
-} // namespace XrdCl
-
+ mLog->Info(
+ 1,
+ "JCache : read:readv-ops:readv-read-ops: %lu:%lu:%lus hit-rate: total "
+ "[read/readv]=%.02f%% [%.02f%%/%.02f%%] remote-bytes-read/readv: %lu / "
+ "%lu cached-bytes-read/readv: %lu / %lu",
+ pStats->readOps.load(), pStats->readVOps.load(),
+ pStats->readVreadOps.load(), pStats->CombinedHitRate(), pStats->HitRate(),
+ pStats->HitRateV(), pStats->bytesRead.load(), pStats->bytesReadV.load(),
+ pStats->bytesCached.load(), pStats->bytesCachedV.load());
+}
+} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.hh b/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.hh
index 3eeac533553..343a1e89063 100644
--- a/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.hh
+++ b/src/XrdApps/XrdClJCachePlugin/file/XrdClJCacheFile.hh
@@ -24,33 +24,32 @@
#pragma once
/*----------------------------------------------------------------------------*/
-#include "XrdCl/XrdClPlugInInterface.hh"
#include "XrdCl/XrdClDefaultEnv.hh"
#include "XrdCl/XrdClLog.hh"
+#include "XrdCl/XrdClPlugInInterface.hh"
/*----------------------------------------------------------------------------*/
+#include "cache/Journal.hh"
#include "file/Art.hh"
#include "file/TimeBench.hh"
-#include "cache/Journal.hh"
-#include "vector/XrdClVectorCache.hh"
-#include "handler/XrdClJCacheReadHandler.hh"
#include "handler/XrdClJCachePgReadHandler.hh"
+#include "handler/XrdClJCacheReadHandler.hh"
#include "handler/XrdClJCacheReadVHandler.hh"
+#include "vector/XrdClVectorCache.hh"
/*----------------------------------------------------------------------------*/
#include <atomic>
-#include <sys/time.h>
#include <chrono>
+#include <cmath>
+#include <iomanip>
#include <iostream>
#include <string>
-#include <iomanip>
-#include <cmath>
+#include <sys/time.h>
/*----------------------------------------------------------------------------*/
namespace JCache {
- class CacheStats;
+class CacheStats;
}
-namespace XrdCl
-{
+namespace XrdCl {
//----------------------------------------------------------------------------
//! JCache file plugin
//! This XRootD Client Plugin provides a client side read cache.
@@ -58,22 +57,19 @@ namespace XrdCl
//! - Read Journal Cache (journalling)
//! - Vector Read Cache (vector read responses are stored in binary blobs)
//----------------------------------------------------------------------------
-class JCacheFile: public XrdCl::FilePlugIn
-{
+class JCacheFile : public XrdCl::FilePlugIn {
public:
-
//----------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------
JCacheFile();
- JCacheFile(const std::string& url);
+ JCacheFile(const std::string &url);
//----------------------------------------------------------------------------
//! Destructor
//----------------------------------------------------------------------------
virtual ~JCacheFile();
-
//----------------------------------------------------------------------------
//! @brief Open a file by URL
//! @param url URL of the file
@@ -82,21 +78,16 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Open(const std::string& url,
- OpenFlags::Flags flags,
- Access::Mode mode,
- ResponseHandler* handler,
+ virtual XRootDStatus Open(const std::string &url, OpenFlags::Flags flags,
+ Access::Mode mode, ResponseHandler *handler,
uint16_t timeout);
-
//----------------------------------------------------------------------------
//! @brief Close a file
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Close(ResponseHandler* handler,
- uint16_t timeout);
-
+ virtual XRootDStatus Close(ResponseHandler *handler, uint16_t timeout);
//----------------------------------------------------------------------------
//! @brief Stat a file
@@ -104,11 +95,9 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Stat(bool force,
- ResponseHandler* handler,
+ virtual XRootDStatus Stat(bool force, ResponseHandler *handler,
uint16_t timeout);
-
//----------------------------------------------------------------------------
//! @brief Read
//! @param offset Offset in bytes
@@ -117,12 +106,8 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Read(uint64_t offset,
- uint32_t size,
- void* buffer,
- ResponseHandler* handler,
- uint16_t timeout);
-
+ virtual XRootDStatus Read(uint64_t offset, uint32_t size, void *buffer,
+ ResponseHandler *handler, uint16_t timeout);
//----------------------------------------------------------------------------
//! @brief Write
@@ -132,21 +117,15 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Write(uint64_t offset,
- uint32_t size,
- const void* buffer,
- ResponseHandler* handler,
- uint16_t timeout);
-
+ virtual XRootDStatus Write(uint64_t offset, uint32_t size, const void *buffer,
+ ResponseHandler *handler, uint16_t timeout);
//----------------------------------------------------------------------------
//! @brief Sync
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Sync(ResponseHandler* handler,
- uint16_t timeout);
-
+ virtual XRootDStatus Sync(ResponseHandler *handler, uint16_t timeout);
//----------------------------------------------------------------------------
//! @brief Truncate
@@ -154,11 +133,9 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Truncate(uint64_t size,
- ResponseHandler* handler,
+ virtual XRootDStatus Truncate(uint64_t size, ResponseHandler *handler,
uint16_t timeout);
-
//----------------------------------------------------------------------------
//! @brief VectorRead
//! @param chunks Chunks to read
@@ -166,10 +143,8 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus VectorRead(const ChunkList& chunks,
- void* buffer,
- ResponseHandler* handler,
- uint16_t timeout);
+ virtual XRootDStatus VectorRead(const ChunkList &chunks, void *buffer,
+ ResponseHandler *handler, uint16_t timeout);
//------------------------------------------------------------------------
//! @brief PgRead
@@ -179,11 +154,9 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//------------------------------------------------------------------------
- virtual XRootDStatus PgRead( uint64_t offset,
- uint32_t size,
- void *buffer,
- ResponseHandler *handler,
- uint16_t timeout ) override;
+ virtual XRootDStatus PgRead(uint64_t offset, uint32_t size, void *buffer,
+ ResponseHandler *handler,
+ uint16_t timeout) override;
//------------------------------------------------------------------------
//! @brief PgWrite
@@ -193,13 +166,11 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//------------------------------------------------------------------------
- virtual XRootDStatus PgWrite( uint64_t offset,
- uint32_t nbpgs,
- const void *buffer,
- std::vector<uint32_t> &cksums,
- ResponseHandler *handler,
- uint16_t timeout ) override;
-
+ virtual XRootDStatus PgWrite(uint64_t offset, uint32_t nbpgs,
+ const void *buffer,
+ std::vector<uint32_t> &cksums,
+ ResponseHandler *handler,
+ uint16_t timeout) override;
//------------------------------------------------------------------------
//! @brief Fcntl
@@ -207,47 +178,35 @@ public:
//! @param handler Response handler
//! @param timeout Timeout in seconds
//------------------------------------------------------------------------
- virtual XRootDStatus Fcntl(const Buffer& arg,
- ResponseHandler* handler,
+ virtual XRootDStatus Fcntl(const Buffer &arg, ResponseHandler *handler,
uint16_t timeout);
-
//----------------------------------------------------------------------------
//! @brief Visa
//! @param handler Response handler
//! @param timeout Timeout in seconds
//----------------------------------------------------------------------------
- virtual XRootDStatus Visa(ResponseHandler* handler,
- uint16_t timeout);
-
+ virtual XRootDStatus Visa(ResponseHandler *handler, uint16_t timeout);
//----------------------------------------------------------------------------
//! @brief check if file is open
//----------------------------------------------------------------------------
virtual bool IsOpen() const;
-
//----------------------------------------------------------------------------
//! @see XrdCl::File::SetProperty
//----------------------------------------------------------------------------
- virtual bool SetProperty(const std::string& name,
- const std::string& value);
-
+ virtual bool SetProperty(const std::string &name, const std::string &value);
//----------------------------------------------------------------------------
//! @see XrdCl::File::GetProperty
//----------------------------------------------------------------------------
- virtual bool GetProperty(const std::string& name,
- std::string& value) const;
-
+ virtual bool GetProperty(const std::string &name, std::string &value) const;
//----------------------------------------------------------------------------
//! @brief validate the local cache
//----------------------------------------------------------------------------
- inline bool IsValid()
- {
- return true;
- }
+ inline bool IsValid() { return true; }
//----------------------------------------------------------------------------
//! @brief set the local cache path and enable/disable journal/vector caches
@@ -255,12 +214,12 @@ public:
//! @param journal Enable/disable journal cache
//! @param vector Enable/disable vector cache
//----------------------------------------------------------------------------
-
- static void SetCache(const std::string& path) { sCachePath = path; }
- static void SetJournal(const bool& value) { sEnableJournalCache = value; }
- static void SetVector(const bool& value) { sEnableVectorCache = value; }
- static void SetJsonPath(const std::string& path) { sJsonPath = path; }
- static void SetSummary(const bool& value) { sEnableSummary = value; }
+
+ static void SetCache(const std::string &path) { sCachePath = path; }
+ static void SetJournal(const bool &value) { sEnableJournalCache = value; }
+ static void SetVector(const bool &value) { sEnableVectorCache = value; }
+ static void SetJsonPath(const std::string &path) { sJsonPath = path; }
+ static void SetSummary(const bool &value) { sEnableSummary = value; }
//----------------------------------------------------------------------------
//! @brief static members pointing to cache settings
@@ -271,17 +230,16 @@ public:
static bool sEnableJournalCache;
static bool sEnableSummary;
static JournalManager sJournalManager;
-
+
//----------------------------------------------------------------------------
//! @brief log cache hit statistics
//----------------------------------------------------------------------------
void LogStats();
-
+
//! @brief global plugin cache hit statistics
static JCache::CacheStats sStats;
-
-private:
+private:
//! @brief attach for read
bool AttachForRead();
@@ -294,7 +252,7 @@ private:
//! @brief boolean to track if file is open
bool mIsOpen;
//! @brief pointer to the remote file
- XrdCl::File* pFile;
+ XrdCl::File *pFile;
//! @brief URL of the remote file
std::string pUrl;
//! @brief instance of a local journal for this file
@@ -302,10 +260,10 @@ private:
//! @brief path to the journal of this file
std::string pJournalPath;
//! @brief pointer to logging object
- Log* mLog;
+ Log *mLog;
//! @brief cache hit statistics
- JCache::CacheStats* pStats;
+ JCache::CacheStats *pStats;
};
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCachePgReadHandler.hh b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCachePgReadHandler.hh
index a5ae639461e..dd8060e7cf9 100644
--- a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCachePgReadHandler.hh
+++ b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCachePgReadHandler.hh
@@ -32,41 +32,42 @@
namespace XrdCl {
class JCachePgReadHandler : public XrdCl::ResponseHandler
- // ---------------------------------------------------------------------- //
+// ---------------------------------------------------------------------- //
{
public:
- JCachePgReadHandler() { }
+ JCachePgReadHandler() {}
- JCachePgReadHandler(JCacheReadHandler* other) {
- rbytes = other->rbytes;
- journal = other->journal;
- }
-
- JCachePgReadHandler(XrdCl::ResponseHandler* handler,
- std::atomic<uint64_t>* rbytes,
- Journal* journal) : handler(handler), rbytes(rbytes), journal(journal) {}
+ JCachePgReadHandler(JCacheReadHandler *other) {
+ rbytes = other->rbytes;
+ journal = other->journal;
+ }
- virtual ~JCachePgReadHandler() {}
+ JCachePgReadHandler(XrdCl::ResponseHandler *handler,
+ std::atomic<uint64_t> *rbytes, Journal *journal)
+ : handler(handler), rbytes(rbytes), journal(journal) {}
- virtual void HandleResponse(XrdCl::XRootDStatus* pStatus,
- XrdCl::AnyObject* pResponse) {
+ virtual ~JCachePgReadHandler() {}
- XrdCl::PageInfo* pageInfo;
- if (pStatus->IsOK()) {
- if (pResponse) {
- pResponse->Get(pageInfo);
- // store successfull reads in the journal
- if (journal) journal->pwrite(pageInfo->GetBuffer(), pageInfo->GetLength(), pageInfo->GetOffset());
- *rbytes+= pageInfo->GetLength();
- }
- }
- handler->HandleResponse(pStatus, pResponse);
- }
+ virtual void HandleResponse(XrdCl::XRootDStatus *pStatus,
+ XrdCl::AnyObject *pResponse) {
- XrdCl::ResponseHandler* handler;
- std::atomic<uint64_t>* rbytes;
- Journal* journal;
+ XrdCl::PageInfo *pageInfo;
+ if (pStatus->IsOK()) {
+ if (pResponse) {
+ pResponse->Get(pageInfo);
+ // store successfull reads in the journal
+ if (journal)
+ journal->pwrite(pageInfo->GetBuffer(), pageInfo->GetLength(),
+ pageInfo->GetOffset());
+ *rbytes += pageInfo->GetLength();
+ }
+ }
+ handler->HandleResponse(pStatus, pResponse);
+ }
+ XrdCl::ResponseHandler *handler;
+ std::atomic<uint64_t> *rbytes;
+ Journal *journal;
};
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadHandler.hh b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadHandler.hh
index dd6a3814b79..baaf9178619 100644
--- a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadHandler.hh
+++ b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadHandler.hh
@@ -32,41 +32,42 @@
namespace XrdCl {
class JCacheReadHandler : public XrdCl::ResponseHandler
- // ---------------------------------------------------------------------- //
+// ---------------------------------------------------------------------- //
{
public:
- JCacheReadHandler() { }
+ JCacheReadHandler() {}
- JCacheReadHandler(JCacheReadHandler* other) {
- rbytes = other->rbytes;
- journal = other->journal;
- }
-
- JCacheReadHandler(XrdCl::ResponseHandler* handler,
- std::atomic<uint64_t>* rbytes,
- Journal* journal) : handler(handler), rbytes(rbytes), journal(journal) {}
+ JCacheReadHandler(JCacheReadHandler *other) {
+ rbytes = other->rbytes;
+ journal = other->journal;
+ }
- virtual ~JCacheReadHandler() {}
+ JCacheReadHandler(XrdCl::ResponseHandler *handler,
+ std::atomic<uint64_t> *rbytes, Journal *journal)
+ : handler(handler), rbytes(rbytes), journal(journal) {}
- virtual void HandleResponse(XrdCl::XRootDStatus* pStatus,
- XrdCl::AnyObject* pResponse) {
+ virtual ~JCacheReadHandler() {}
- XrdCl::ChunkInfo* chunkInfo;
- if (pStatus->IsOK()) {
- if (pResponse) {
- pResponse->Get(chunkInfo);
- // store successfull reads in the journal
- if (journal) journal->pwrite(chunkInfo->GetBuffer(), chunkInfo->GetLength(), chunkInfo->GetOffset());
- *rbytes+= chunkInfo->GetLength();
- }
- }
- handler->HandleResponse(pStatus, pResponse);
- }
+ virtual void HandleResponse(XrdCl::XRootDStatus *pStatus,
+ XrdCl::AnyObject *pResponse) {
- XrdCl::ResponseHandler* handler;
- std::atomic<uint64_t>* rbytes;
- Journal* journal;
+ XrdCl::ChunkInfo *chunkInfo;
+ if (pStatus->IsOK()) {
+ if (pResponse) {
+ pResponse->Get(chunkInfo);
+ // store successfull reads in the journal
+ if (journal)
+ journal->pwrite(chunkInfo->GetBuffer(), chunkInfo->GetLength(),
+ chunkInfo->GetOffset());
+ *rbytes += chunkInfo->GetLength();
+ }
+ }
+ handler->HandleResponse(pStatus, pResponse);
+ }
+ XrdCl::ResponseHandler *handler;
+ std::atomic<uint64_t> *rbytes;
+ Journal *journal;
};
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadVHandler.hh b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadVHandler.hh
index 59552d03bdb..f377e7671ef 100644
--- a/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadVHandler.hh
+++ b/src/XrdApps/XrdClJCachePlugin/handler/XrdClJCacheReadVHandler.hh
@@ -33,61 +33,62 @@
namespace XrdCl {
class JCacheReadVHandler : public XrdCl::ResponseHandler
- // ---------------------------------------------------------------------- //
+// ---------------------------------------------------------------------- //
{
public:
- JCacheReadVHandler() { }
+ JCacheReadVHandler() {}
- JCacheReadVHandler(JCacheReadVHandler* other) {
-
- journal = other->journal;
- buffer = other->buffer;
- rvbytes = other->rvbytes;
- vcachepath = other->vcachepath;
- url = other->url;
- }
+ JCacheReadVHandler(JCacheReadVHandler *other) {
+
+ journal = other->journal;
+ buffer = other->buffer;
+ rvbytes = other->rvbytes;
+ vcachepath = other->vcachepath;
+ url = other->url;
+ }
- JCacheReadVHandler(XrdCl::ResponseHandler* handler,
- std::atomic<uint64_t>* rvbytes,
- Journal* journal,
- void* buffer,
- const std::string& vcachepath,
- const std::string& url) : handler(handler), rvbytes(rvbytes), journal(journal), buffer(buffer), vcachepath(vcachepath), url(url) {}
+ JCacheReadVHandler(XrdCl::ResponseHandler *handler,
+ std::atomic<uint64_t> *rvbytes, Journal *journal,
+ void *buffer, const std::string &vcachepath,
+ const std::string &url)
+ : handler(handler), rvbytes(rvbytes), journal(journal), buffer(buffer),
+ vcachepath(vcachepath), url(url) {}
- virtual ~JCacheReadVHandler() {}
+ virtual ~JCacheReadVHandler() {}
- virtual void HandleResponse(XrdCl::XRootDStatus* pStatus,
- XrdCl::AnyObject* pResponse) {
- if (pStatus->IsOK()) {
- if (pResponse) {
- VectorReadInfo* vReadInfo;
- pResponse->Get(vReadInfo);
- ChunkList* chunks = &(vReadInfo->GetChunks());
- // store successfull reads in the journal if there is no vector cache
- if (vcachepath.empty()) {
- if (journal) {
- for (auto it = chunks->begin(); it != chunks->end(); ++it) {
- journal->pwrite(it->GetBuffer(), it->GetLength(), it->GetOffset());
- }
- }
- } else {
- VectorCache cache(*chunks, url, (const char*)buffer, vcachepath);
- cache.store();
- }
- for (auto it = chunks->begin(); it != chunks->end(); ++it) {
- *rvbytes += it->GetLength();
- }
- }
- }
- handler->HandleResponse(pStatus, pResponse);
- }
+ virtual void HandleResponse(XrdCl::XRootDStatus *pStatus,
+ XrdCl::AnyObject *pResponse) {
+ if (pStatus->IsOK()) {
+ if (pResponse) {
+ VectorReadInfo *vReadInfo;
+ pResponse->Get(vReadInfo);
+ ChunkList *chunks = &(vReadInfo->GetChunks());
+ // store successfull reads in the journal if there is no vector cache
+ if (vcachepath.empty()) {
+ if (journal) {
+ for (auto it = chunks->begin(); it != chunks->end(); ++it) {
+ journal->pwrite(it->GetBuffer(), it->GetLength(),
+ it->GetOffset());
+ }
+ }
+ } else {
+ VectorCache cache(*chunks, url, (const char *)buffer, vcachepath);
+ cache.store();
+ }
+ for (auto it = chunks->begin(); it != chunks->end(); ++it) {
+ *rvbytes += it->GetLength();
+ }
+ }
+ }
+ handler->HandleResponse(pStatus, pResponse);
+ }
- XrdCl::ResponseHandler* handler;
- std::atomic<uint64_t>* rvbytes;
- Journal* journal;
- void* buffer;
- std::string vcachepath;
- std::string url;
+ XrdCl::ResponseHandler *handler;
+ std::atomic<uint64_t> *rvbytes;
+ Journal *journal;
+ void *buffer;
+ std::string vcachepath;
+ std::string url;
};
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.cc b/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.cc
index a065303b5f5..1a76dda24f2 100644
--- a/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.cc
+++ b/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.cc
@@ -26,13 +26,10 @@
XrdVERSIONINFO(XrdClGetPlugIn, XrdClGetPlugIn)
-extern "C"
-{
- void* XrdClGetPlugIn( const void* arg )
- {
- const std::map<std::string, std::string>* config =
- static_cast< const std::map<std::string, std::string>* >(arg);
- return static_cast<void*>(new XrdCl::JCacheFactory( config ) );
+ extern "C" {
+ void *XrdClGetPlugIn(const void *arg) {
+ const std::map<std::string, std::string> *config =
+ static_cast<const std::map<std::string, std::string> *>(arg);
+ return static_cast<void *>(new XrdCl::JCacheFactory(config));
}
}
-
diff --git a/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.hh b/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.hh
index a174e105b63..24775690f95 100644
--- a/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.hh
+++ b/src/XrdApps/XrdClJCachePlugin/plugin/XrdClJCachePlugin.hh
@@ -23,105 +23,107 @@
#pragma once
/*----------------------------------------------------------------------------*/
-#include "XrdCl/XrdClPlugInInterface.hh"
#include "XrdCl/XrdClDefaultEnv.hh"
#include "XrdCl/XrdClLog.hh"
+#include "XrdCl/XrdClPlugInInterface.hh"
/*----------------------------------------------------------------------------*/
#include "../file/XrdClJCacheFile.hh"
/*----------------------------------------------------------------------------*/
-#include <memory>
#include <map>
+#include <memory>
#include <string>
/*----------------------------------------------------------------------------*/
-namespace XrdCl
-{
+namespace XrdCl {
//------------------------------------------------------------------------------
//! XrdCl JCache plug-in factory
//------------------------------------------------------------------------------
-class JCacheFactory : public PlugInFactory
-{
- public:
- //----------------------------------------------------------------------------
- //! Constructor
- //!
- //! @param config map containing configuration parameters
- //----------------------------------------------------------------------------
- JCacheFactory( const std::map<std::string, std::string>* config )
- {
- if( config )
- {
- auto itc = config->find( "cache" );
- JCacheFile::SetCache( itc != config->end() ? itc->second : "" );
- auto itv = config->find( "vector" );
- JCacheFile::SetVector( itv != config->end() ? itv->second == "true": false );
- auto itj = config->find( "journal" );
- JCacheFile::SetJournal( itj != config->end() ? itj->second == "true": false );
- auto itjson = config->find( "json" );
- JCacheFile::SetJsonPath( itjson != config->end() ? itjson->second : "./" );
- auto its = config->find( "summary" );
- JCacheFile::SetSummary( its != config->end() ? its->second != "false": true );
+class JCacheFactory : public PlugInFactory {
+public:
+ //----------------------------------------------------------------------------
+ //! Constructor
+ //!
+ //! @param config map containing configuration parameters
+ //----------------------------------------------------------------------------
+ JCacheFactory(const std::map<std::string, std::string> *config) {
+ if (config) {
+ auto itc = config->find("cache");
+ JCacheFile::SetCache(itc != config->end() ? itc->second : "");
+ auto itv = config->find("vector");
+ JCacheFile::SetVector(itv != config->end() ? itv->second == "true"
+ : false);
+ auto itj = config->find("journal");
+ JCacheFile::SetJournal(itj != config->end() ? itj->second == "true"
+ : false);
+ auto itjson = config->find("json");
+ JCacheFile::SetJsonPath(itjson != config->end() ? itjson->second : "./");
+ auto its = config->find("summary");
+ JCacheFile::SetSummary(its != config->end() ? its->second != "false"
+ : true);
- if (const char *v = getenv("XRD_JCACHE_CACHE")) {
- JCacheFile::SetCache( (std::string(v).length()) ? std::string(v) : "");
- }
+ if (const char *v = getenv("XRD_JCACHE_CACHE")) {
+ JCacheFile::SetCache((std::string(v).length()) ? std::string(v) : "");
+ }
- if (const char *v = getenv("XRD_JCACHE_SUMMARY")) {
- JCacheFile::SetSummary( (std::string(v) == "true") ? true : false);
- }
+ if (const char *v = getenv("XRD_JCACHE_SUMMARY")) {
+ JCacheFile::SetSummary((std::string(v) == "true") ? true : false);
+ }
- if (const char *v = getenv("XRD_JCACHE_JOURNAL")) {
- JCacheFile::SetJournal( (std::string(v) == "true") ? true : false);
- }
+ if (const char *v = getenv("XRD_JCACHE_JOURNAL")) {
+ JCacheFile::SetJournal((std::string(v) == "true") ? true : false);
+ }
- if (const char *v = getenv("XRD_JCACHE_VECTOR")) {
- JCacheFile::SetVector( (std::string(v) == "true") ? true : false);
- }
+ if (const char *v = getenv("XRD_JCACHE_VECTOR")) {
+ JCacheFile::SetVector((std::string(v) == "true") ? true : false);
+ }
- if (const char *v = getenv("XRD_JCACHE_JSON")) {
- JCacheFile::SetJsonPath( (std::string(v).length()) ? std::string(v) : "");
- }
+ if (const char *v = getenv("XRD_JCACHE_JSON")) {
+ JCacheFile::SetJsonPath((std::string(v).length()) ? std::string(v)
+ : "");
+ }
- Log* log = DefaultEnv::GetLog();
- log->Info(1, "JCache : cache directory: %s", JCacheFile::sCachePath.c_str());
- log->Info(1, "JCache : caching readv in vector cache : %s", JCacheFile::sEnableVectorCache ? "true" : "false");
- log->Info(1, "JCache : caching reads in journal cache: %s", JCacheFile::sEnableJournalCache ? "true" : "false");
- log->Info(1, "JCache : summary output is: %s", JCacheFile::sEnableSummary ? "true" : "false");
- if (JCacheFile::sJsonPath.length()) {
- log->Info(1, "JCache : json output to prefix: %s", JCacheFile::sJsonPath.c_str());
- } else {
- log->Info(1, "JCache : json output is disabled", JCacheFile::sJsonPath.c_str());
- }
+ Log *log = DefaultEnv::GetLog();
+ log->Info(1, "JCache : cache directory: %s",
+ JCacheFile::sCachePath.c_str());
+ log->Info(1, "JCache : caching readv in vector cache : %s",
+ JCacheFile::sEnableVectorCache ? "true" : "false");
+ log->Info(1, "JCache : caching reads in journal cache: %s",
+ JCacheFile::sEnableJournalCache ? "true" : "false");
+ log->Info(1, "JCache : summary output is: %s",
+ JCacheFile::sEnableSummary ? "true" : "false");
+ if (JCacheFile::sJsonPath.length()) {
+ log->Info(1, "JCache : json output to prefix: %s",
+ JCacheFile::sJsonPath.c_str());
+ } else {
+ log->Info(1, "JCache : json output is disabled",
+ JCacheFile::sJsonPath.c_str());
}
}
+ }
- //----------------------------------------------------------------------------
- //! Destructor
- //----------------------------------------------------------------------------
- virtual ~JCacheFactory()
- {
- }
+ //----------------------------------------------------------------------------
+ //! Destructor
+ //----------------------------------------------------------------------------
+ virtual ~JCacheFactory() {}
- //----------------------------------------------------------------------------
- //! Create a file plug-in for the given URL
- //----------------------------------------------------------------------------
- virtual FilePlugIn* CreateFile(const std::string& url)
- {
- std::unique_ptr<JCacheFile> ptr( new JCacheFile() );
- if( !ptr->IsValid() )
- return nullptr;
- return static_cast<FilePlugIn*>( ptr.release() );
- }
+ //----------------------------------------------------------------------------
+ //! Create a file plug-in for the given URL
+ //----------------------------------------------------------------------------
+ virtual FilePlugIn *CreateFile(const std::string &url) {
+ std::unique_ptr<JCacheFile> ptr(new JCacheFile());
+ if (!ptr->IsValid())
+ return nullptr;
+ return static_cast<FilePlugIn *>(ptr.release());
+ }
- //----------------------------------------------------------------------------
- //! Create a file system plug-in for the given URL
- //----------------------------------------------------------------------------
- virtual FileSystemPlugIn* CreateFileSystem(const std::string& url)
- {
- Log* log = DefaultEnv::GetLog();
- log->Error(1, "FileSystem plugin implementation not supported");
- return static_cast<FileSystemPlugIn*>(0);
- }
+ //----------------------------------------------------------------------------
+ //! Create a file system plug-in for the given URL
+ //----------------------------------------------------------------------------
+ virtual FileSystemPlugIn *CreateFileSystem(const std::string &url) {
+ Log *log = DefaultEnv::GetLog();
+ log->Error(1, "FileSystem plugin implementation not supported");
+ return static_cast<FileSystemPlugIn *>(0);
+ }
};
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.cc b/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.cc
index 61b0180e394..d30fa3861fa 100644
--- a/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.cc
+++ b/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.cc
@@ -25,8 +25,8 @@
#include "vector/XrdClVectorCache.hh"
/*----------------------------------------------------------------------------*/
#include <filesystem>
-#include <openssl/evp.h>
#include <openssl/err.h>
+#include <openssl/evp.h>
/*----------------------------------------------------------------------------*/
namespace fs = std::filesystem;
@@ -37,237 +37,244 @@ namespace XrdCl {
//! serialize a vector into a buffer
//----------------------------------------------------------------------------
std::vector<unsigned char> VectorCache::serializeVector() const {
- std::vector<unsigned char> serializedData;
- for (const auto& i : chunks) {
- uint64_t o = i.GetOffset();
- uint64_t n = i.GetLength();
- unsigned char buffer[sizeof(uint64_t) + sizeof(size_t)];
- std::memcpy(buffer, &o, sizeof(uint64_t));
- std::memcpy(buffer + sizeof(uint64_t), &n, sizeof(size_t));
- serializedData.insert(serializedData.end(), buffer, buffer + sizeof(buffer));
- }
- return serializedData;
+ std::vector<unsigned char> serializedData;
+ for (const auto &i : chunks) {
+ uint64_t o = i.GetOffset();
+ uint64_t n = i.GetLength();
+ unsigned char buffer[sizeof(uint64_t) + sizeof(size_t)];
+ std::memcpy(buffer, &o, sizeof(uint64_t));
+ std::memcpy(buffer + sizeof(uint64_t), &n, sizeof(size_t));
+ serializedData.insert(serializedData.end(), buffer,
+ buffer + sizeof(buffer));
+ }
+ return serializedData;
}
//----------------------------------------------------------------------------
//! compute SHA256 signature for a given vector read
//----------------------------------------------------------------------------
-std::string VectorCache::computeSHA256(const std::vector<unsigned char>& data) {
- unsigned int length = 0;
+std::string VectorCache::computeSHA256(const std::vector<unsigned char> &data) {
+ unsigned int length = 0;
#if OPENSSL_VERSION_NUMBER < 0x30000000L
- length = SHA256_DIGEST_LENGTH;
- unsigned char hash[length];
- SHA256_CTX sha256;
- SHA256_Init(&sha256);
- SHA256_Update(&sha256, data.data(), data.size());
- SHA256_Final(hash, &sha256);
+ length = SHA256_DIGEST_LENGTH;
+ unsigned char hash[length];
+ SHA256_CTX sha256;
+ SHA256_Init(&sha256);
+ SHA256_Update(&sha256, data.data(), data.size());
+ SHA256_Final(hash, &sha256);
#else
- // things don't always get better ... we skip error handling
- EVP_MD_CTX* ctx = EVP_MD_CTX_new();
- const EVP_MD* md = EVP_sha256();
- EVP_DigestInit_ex(ctx, md, NULL);
- EVP_DigestUpdate(ctx, data.data(), data.size());
- length = EVP_MD_size(md);
- unsigned char hash[length];
- EVP_DigestFinal_ex(ctx, hash, &length);
- EVP_MD_CTX_free(ctx);
+ // things don't always get better ... we skip error handling
+ EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+ const EVP_MD *md = EVP_sha256();
+ EVP_DigestInit_ex(ctx, md, NULL);
+ EVP_DigestUpdate(ctx, data.data(), data.size());
+ length = EVP_MD_size(md);
+ unsigned char hash[length];
+ EVP_DigestFinal_ex(ctx, hash, &length);
+ EVP_MD_CTX_free(ctx);
#endif
- std::stringstream ss;
- for (unsigned int i = 0; i < length; ++i) {
- ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
- }
- return ss.str();
+ std::stringstream ss;
+ for (unsigned int i = 0; i < length; ++i) {
+ ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
+ }
+ return ss.str();
}
//----------------------------------------------------------------------------
//! compute SHA256 signature for a string
//----------------------------------------------------------------------------
-std::string VectorCache::computeSHA256(const std::string& data) {
- unsigned int length = 0;
+std::string VectorCache::computeSHA256(const std::string &data) {
+ unsigned int length = 0;
#if OPENSSL_VERSION_NUMBER < 0x30000000L
- length = SHA256_DIGEST_LENGTH;
- unsigned char hash[length];
- SHA256_CTX sha256;
- SHA256_Init(&sha256);
- SHA256_Update(&sha256, data.c_str(), data.size());
- SHA256_Final(hash, &sha256);
+ length = SHA256_DIGEST_LENGTH;
+ unsigned char hash[length];
+ SHA256_CTX sha256;
+ SHA256_Init(&sha256);
+ SHA256_Update(&sha256, data.c_str(), data.size());
+ SHA256_Final(hash, &sha256);
#else
- // things don't always get better ... we skip error handling
- EVP_MD_CTX* ctx = EVP_MD_CTX_new();
- const EVP_MD* md = EVP_sha256();
- EVP_DigestInit_ex(ctx, md, NULL);
- EVP_DigestUpdate(ctx, data.data(), data.size());
- length = EVP_MD_size(md);
- unsigned char hash[length];
- EVP_DigestFinal_ex(ctx, hash, &length);
- EVP_MD_CTX_free(ctx);
+ // things don't always get better ... we skip error handling
+ EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+ const EVP_MD *md = EVP_sha256();
+ EVP_DigestInit_ex(ctx, md, NULL);
+ EVP_DigestUpdate(ctx, data.data(), data.size());
+ length = EVP_MD_size(md);
+ unsigned char hash[length];
+ EVP_DigestFinal_ex(ctx, hash, &length);
+ EVP_MD_CTX_free(ctx);
#endif
- std::stringstream ss;
- for (unsigned int i = 0; i < length; ++i) {
- ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
- }
- return ss.str();
+ std::stringstream ss;
+ for (unsigned int i = 0; i < length; ++i) {
+ ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
+ }
+ return ss.str();
}
//----------------------------------------------------------------------------
//! compute SHA256 for vector read and name
//----------------------------------------------------------------------------
std::pair<std::string, std::string> VectorCache::computeHash() const {
- std::vector<unsigned char> serializedData = serializeVector();
- std::string vectorHash = computeSHA256(serializedData);
- std::string nameHash = computeSHA256(name);
- return {vectorHash, nameHash};
+ std::vector<unsigned char> serializedData = serializeVector();
+ std::string vectorHash = computeSHA256(serializedData);
+ std::string nameHash = computeSHA256(name);
+ return {vectorHash, nameHash};
}
//----------------------------------------------------------------------------
//! ensure that the last subdirectory directory exists
//----------------------------------------------------------------------------
-bool VectorCache::ensureLastSubdirectoryExists(const std::string& dirName) {
- fs::path dirPath(dirName);
-
- if (fs::exists(dirPath) && fs::is_directory(dirPath)) {
- return true;
- }
-
- // Extract the parent path
- fs::path parentPath = dirPath.parent_path();
-
- if (!fs::exists(parentPath)) {
- std::cerr << "error: parent directory does not exist. Cannot create subdirectory.\n";
- return false;
- }
-
- if (fs::create_directory(dirPath)) {
- return true;
- } else {
- std::cerr << "error: failed to create subdirectory.\n";
- return false;
- }
+bool VectorCache::ensureLastSubdirectoryExists(const std::string &dirName) {
+ fs::path dirPath(dirName);
+ if (fs::exists(dirPath) && fs::is_directory(dirPath)) {
+ return true;
+ }
+
+ // Extract the parent path
+ fs::path parentPath = dirPath.parent_path();
+
+ if (!fs::exists(parentPath)) {
+ std::cerr << "error: parent directory does not exist. Cannot create "
+ "subdirectory.\n";
return false;
+ }
+
+ if (fs::create_directory(dirPath)) {
+ return true;
+ } else {
+ std::cerr << "error: failed to create subdirectory.\n";
+ return false;
+ }
+
+ return false;
}
//----------------------------------------------------------------------------
//! store a vector read in the cache
//----------------------------------------------------------------------------
bool VectorCache::store() const {
- // Compute hashes
- auto [vectorHash, nameHash] = computeHash();
-
- // Compute the total expected length from the input vector
- size_t expectedLen = 0;
- for (const auto& chunk : chunks) {
- expectedLen += chunk.GetLength();
- }
+ // Compute hashes
+ auto [vectorHash, nameHash] = computeHash();
- // Try to have a cache toplevel directory
- if (!ensureLastSubdirectoryExists(prefix)) {
- return false;
- }
+ // Compute the total expected length from the input vector
+ size_t expectedLen = 0;
+ for (const auto &chunk : chunks) {
+ expectedLen += chunk.GetLength();
+ }
- // Generate the dir name using the prefix and the hash of the name
- std::string dirName = prefix + nameHash;
- std::string fileName = dirName + "/" + vectorHash;
- std::string tmpName = fileName + ".tmp";
+ // Try to have a cache toplevel directory
+ if (!ensureLastSubdirectoryExists(prefix)) {
+ return false;
+ }
- // Try to have a cache subdirectory for this file
- if (!ensureLastSubdirectoryExists(dirName)) {
- return false;
- }
+ // Generate the dir name using the prefix and the hash of the name
+ std::string dirName = prefix + nameHash;
+ std::string fileName = dirName + "/" + vectorHash;
+ std::string tmpName = fileName + ".tmp";
- // Open the file for writing (binary mode
- // Write specified segments of data to the file
- std::ofstream outFile(tmpName, std::ios::binary);
- if (outFile.is_open()) {
- std::error_code ec;
- outFile.write(data, expectedLen);
- if (outFile.fail()) {
- std::cerr << "error: failed writing to file: " << tmpName << std::endl;
- outFile.close();
- fs::remove(tmpName, ec);
- if (ec) {
- std::cerr << "error: failed cleanup of temporary file: " << tmpName << std::endl;
- }
- return false;
- }
- outFile.close();
- fs::rename(tmpName, fileName, ec);
- if (ec) {
- outFile.close();
- std::cerr << "error: failed atomic rename to file: " << fileName << std::endl;
- fs::remove(tmpName, ec);
- if (ec) {
- std::cerr << "error: failed cleanup of temporary file: " << tmpName << std::endl;
- }
- return false;
- }
- return true;
- } else {
- std::cerr << "error: failed to open file: " << tmpName << std::endl;
- return false;
+ // Try to have a cache subdirectory for this file
+ if (!ensureLastSubdirectoryExists(dirName)) {
+ return false;
+ }
+
+ // Open the file for writing (binary mode
+ // Write specified segments of data to the file
+ std::ofstream outFile(tmpName, std::ios::binary);
+ if (outFile.is_open()) {
+ std::error_code ec;
+ outFile.write(data, expectedLen);
+ if (outFile.fail()) {
+ std::cerr << "error: failed writing to file: " << tmpName << std::endl;
+ outFile.close();
+ fs::remove(tmpName, ec);
+ if (ec) {
+ std::cerr << "error: failed cleanup of temporary file: " << tmpName
+ << std::endl;
+ }
+ return false;
+ }
+ outFile.close();
+ fs::rename(tmpName, fileName, ec);
+ if (ec) {
+ outFile.close();
+ std::cerr << "error: failed atomic rename to file: " << fileName
+ << std::endl;
+ fs::remove(tmpName, ec);
+ if (ec) {
+ std::cerr << "error: failed cleanup of temporary file: " << tmpName
+ << std::endl;
+ }
+ return false;
}
+ return true;
+ } else {
+ std::cerr << "error: failed to open file: " << tmpName << std::endl;
+ return false;
+ }
}
//----------------------------------------------------------------------------
//! retrieve a vector read from the cache
//----------------------------------------------------------------------------
bool VectorCache::retrieve() const {
- // Compute the total expected length from the input vector
- size_t expectedLen = 0;
- for (const auto& chunk : chunks) {
- expectedLen += chunk.GetLength();
- }
+ // Compute the total expected length from the input vector
+ size_t expectedLen = 0;
+ for (const auto &chunk : chunks) {
+ expectedLen += chunk.GetLength();
+ }
- // Compute hashes
- auto [vectorHash, nameHash] = computeHash();
+ // Compute hashes
+ auto [vectorHash, nameHash] = computeHash();
- // Generate the dir name using the prefix and the hash of the name
- std::string dirName = prefix + nameHash;
- std::string fileName = dirName + "/" + vectorHash;
+ // Generate the dir name using the prefix and the hash of the name
+ std::string dirName = prefix + nameHash;
+ std::string fileName = dirName + "/" + vectorHash;
- // Check if the file exists
- struct stat fileInfo;
- if (stat(fileName.c_str(), &fileInfo) != 0) {
- if (verbose) {
- std::cerr << "error: file does not exist: " << fileName << std::endl;
- }
- return false;
+ // Check if the file exists
+ struct stat fileInfo;
+ if (stat(fileName.c_str(), &fileInfo) != 0) {
+ if (verbose) {
+ std::cerr << "error: file does not exist: " << fileName << std::endl;
}
+ return false;
+ }
- // Check if the file size matches the expected length
- if ((size_t)fileInfo.st_size != expectedLen) {
- if (verbose) {
- std::cerr << "error: file size mismatch. Expected: " << expectedLen << ", Actual: " << fileInfo.st_size << std::endl;
- }
- return false;
+ // Check if the file size matches the expected length
+ if ((size_t)fileInfo.st_size != expectedLen) {
+ if (verbose) {
+ std::cerr << "error: file size mismatch. Expected: " << expectedLen
+ << ", Actual: " << fileInfo.st_size << std::endl;
}
+ return false;
+ }
- // Open the file for reading
- std::ifstream inFile(fileName, std::ios::binary);
- if (inFile.is_open()) {
- inFile.read((char*)data, fileInfo.st_size);
- if (inFile.fail()) {
- if (verbose) {
- std::cerr << "error: failed to read cached data" << std::endl;
- }
- } else {
- std::streamsize bytesRead = inFile.gcount();
- if (bytesRead != fileInfo.st_size) {
- if (verbose) {
- std::cerr << "error: read only " << bytesRead << " bytes instead of " << fileInfo.st_size << " !"<< std::endl;
- }
- return false;
- }
- }
- inFile.close();
- return true;
+ // Open the file for reading
+ std::ifstream inFile(fileName, std::ios::binary);
+ if (inFile.is_open()) {
+ inFile.read((char *)data, fileInfo.st_size);
+ if (inFile.fail()) {
+ if (verbose) {
+ std::cerr << "error: failed to read cached data" << std::endl;
+ }
} else {
+ std::streamsize bytesRead = inFile.gcount();
+ if (bytesRead != fileInfo.st_size) {
if (verbose) {
- std::cerr << "error: failed to open file: " << fileName << std::endl;
+ std::cerr << "error: read only " << bytesRead << " bytes instead of "
+ << fileInfo.st_size << " !" << std::endl;
}
return false;
+ }
}
+ inFile.close();
+ return true;
+ } else {
+ if (verbose) {
+ std::cerr << "error: failed to open file: " << fileName << std::endl;
+ }
+ return false;
+ }
}
} // namespace XrdCl
diff --git a/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.hh b/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.hh
index 673eee32335..cccc09f78e7 100644
--- a/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.hh
+++ b/src/XrdApps/XrdClJCachePlugin/vector/XrdClVectorCache.hh
@@ -24,16 +24,16 @@
#pragma once
/*----------------------------------------------------------------------------*/
+#include <cstring> // For std::memcpy
+#include <fstream> // For file operations
+#include <iomanip>
#include <iostream>
-#include <vector>
-#include <utility>
-#include <openssl/sha.h> // For SHA-256
+#include <openssl/sha.h> // For SHA-256
#include <sstream>
-#include <iomanip>
-#include <cstring> // For std::memcpy
#include <string>
-#include <fstream> // For file operations
-#include <sys/stat.h> // For checking if file exists
+#include <sys/stat.h> // For checking if file exists
+#include <utility>
+#include <vector>
/*----------------------------------------------------------------------------*/
#include "XrdCl/XrdClXRootDResponses.hh"
//----------------------------------------------------------------------------
@@ -44,25 +44,27 @@ namespace XrdCl {
class VectorCache {
public:
- VectorCache(const XrdCl::ChunkList chunks, const std::string& name, const char* data, const std::string& prefix, bool verbose=false)
- : chunks(chunks), name(name), data(data), prefix(prefix), verbose(verbose) {}
-
- std::pair<std::string, std::string> computeHash() const;
- bool store() const;
- bool retrieve() const;
+ VectorCache(const XrdCl::ChunkList chunks, const std::string &name,
+ const char *data, const std::string &prefix, bool verbose = false)
+ : chunks(chunks), name(name), data(data), prefix(prefix),
+ verbose(verbose) {}
+
+ std::pair<std::string, std::string> computeHash() const;
+ bool store() const;
+ bool retrieve() const;
- static std::string computeSHA256(const std::vector<unsigned char>& data);
- static std::string computeSHA256(const std::string& data);
- static bool ensureLastSubdirectoryExists(const std::string& dirName);
+ static std::string computeSHA256(const std::vector<unsigned char> &data);
+ static std::string computeSHA256(const std::string &data);
+ static bool ensureLastSubdirectoryExists(const std::string &dirName);
private:
- XrdCl::ChunkList chunks;
- std::string name;
- const char* data;
- std::string prefix;
- bool verbose;
+ XrdCl::ChunkList chunks;
+ std::string name;
+ const char *data;
+ std::string prefix;
+ bool verbose;
- std::vector<unsigned char> serializeVector() const;
+ std::vector<unsigned char> serializeVector() const;
};
} // namespace XrdCl
\ No newline at end of file