XRootD
XrdPfc.hh
Go to the documentation of this file.
1 #ifndef __XRDPFC_CACHE_HH__
2 #define __XRDPFC_CACHE_HH__
3 //----------------------------------------------------------------------------------
4 // Copyright (c) 2014 by Board of Trustees of the Leland Stanford, Jr., University
5 // Author: Alja Mrak-Tadel, Matevz Tadel, Brian Bockelman
6 //----------------------------------------------------------------------------------
7 // XRootD is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Lesser General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11 //
12 // XRootD is distributed in the hope that it will be useful,
13 // but WITHOUT ANY emacs WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU Lesser General Public License
18 // along with XRootD. If not, see <http://www.gnu.org/licenses/>.
19 //----------------------------------------------------------------------------------
20 #include <string>
21 #include <list>
22 #include <map>
23 #include <set>
24 
25 #include "Xrd/XrdScheduler.hh"
26 #include "XrdVersion.hh"
27 #include "XrdSys/XrdSysPthread.hh"
28 #include "XrdOuc/XrdOucCache.hh"
29 #include "XrdOuc/XrdOucCallBack.hh"
30 
31 #include "XrdPfcFile.hh"
32 #include "XrdPfcDecision.hh"
33 
34 class XrdOss;
35 class XrdOucStream;
36 class XrdSysError;
37 class XrdSysTrace;
38 class XrdXrootdGStream;
39 
40 namespace XrdPfc
41 {
42 class File;
43 class IO;
44 class PurgePin;
45 class ResourceMonitor;
46 
47 
48 template<class MOO>
49 struct MutexHolder {
50  MOO &mutex;
51  MutexHolder(MOO &m) : mutex(m) { mutex.Lock(); }
52  ~MutexHolder() { mutex.UnLock(); }
53 };
54 }
55 
56 
57 namespace XrdPfc
58 {
59 
60 //----------------------------------------------------------------------------
62 //----------------------------------------------------------------------------
64 {
65  Configuration();
66 
67  bool are_file_usage_limits_set() const { return m_fileUsageMax > 0; }
68  bool is_age_based_purge_in_effect() const { return m_purgeColdFilesAge > 0 ; }
69  bool is_uvkeep_purge_in_effect() const { return m_cs_UVKeep >= 0; }
70  bool is_dir_stat_reporting_on() const { return m_dirStatsMaxDepth >= 0 || ! m_dirStatsDirs.empty() || ! m_dirStatsDirGlobs.empty(); }
71  bool is_purge_plugin_set_up() const { return false; }
72 
74 
75  bool is_cschk_cache() const { return m_cs_Chk & CSChk_Cache; }
76  bool is_cschk_net() const { return m_cs_Chk & CSChk_Net; }
77  bool is_cschk_any() const { return m_cs_Chk & CSChk_Both; }
78  bool is_cschk_both() const { return (m_cs_Chk & CSChk_Both) == CSChk_Both; }
79 
80  bool does_cschk_have_missing_bits(CkSumCheck_e cks_on_file) const { return m_cs_Chk & ~cks_on_file; }
81 
82  bool should_uvkeep_purge(time_t delta) const { return m_cs_UVKeep >= 0 && delta > m_cs_UVKeep; }
83 
85  bool m_hdfsmode;
87 
88  std::string m_username;
89  std::string m_data_space;
90  std::string m_meta_space;
91 
92  long long m_diskTotalSpace;
93  long long m_diskUsageLWM;
94  long long m_diskUsageHWM;
95  long long m_fileUsageBaseline;
96  long long m_fileUsageNominal;
97  long long m_fileUsageMax;
102 
103  std::set<std::string> m_dirStatsDirs;
104  std::set<std::string> m_dirStatsDirGlobs;
108 
109  long long m_bufferSize;
110  long long m_RamAbsAvailable;
115 
116  long long m_hdfsbsize;
117  long long m_flushCnt;
118 
119  time_t m_cs_UVKeep;
120  int m_cs_Chk;
121  bool m_cs_ChkTLS;
122 
125 };
126 
127 //------------------------------------------------------------------------------
128 
130 {
131  std::string m_diskUsageLWM;
132  std::string m_diskUsageHWM;
133  std::string m_fileUsageBaseline;
134  std::string m_fileUsageNominal;
135  std::string m_fileUsageMax;
136  std::string m_flushRaw;
137  std::string m_writemodeRaw;
138 
140  m_diskUsageLWM("0.90"), m_diskUsageHWM("0.95"),
141  m_flushRaw("")
142  {}
143 };
144 
145 
146 //==============================================================================
147 // Cache
148 //==============================================================================
149 
150 //----------------------------------------------------------------------------
152 //----------------------------------------------------------------------------
153 class Cache : public XrdOucCache
154 {
155 public:
156  //---------------------------------------------------------------------
158  //---------------------------------------------------------------------
159  Cache(XrdSysLogger *logger, XrdOucEnv *env);
160 
161  //---------------------------------------------------------------------
163  //---------------------------------------------------------------------
164  using XrdOucCache::Attach;
165 
166  virtual XrdOucCacheIO *Attach(XrdOucCacheIO *, int Options = 0);
167 
168  //---------------------------------------------------------------------
169  // Virtual function of XrdOucCache. Used for redirection to a local
170  // file on a distributed FS.
171  virtual int LocalFilePath(const char *url, char *buff=0, int blen=0,
172  LFP_Reason why=ForAccess, bool forall=false);
173 
174  //---------------------------------------------------------------------
175  // Virtual function of XrdOucCache. Used for deferred open.
176  virtual int Prepare(const char *url, int oflags, mode_t mode);
177 
178  // virtual function of XrdOucCache.
179  virtual int Stat(const char *url, struct stat &sbuff);
180 
181  // virtual function of XrdOucCache.
182  virtual int Unlink(const char *url);
183 
184  //---------------------------------------------------------------------
185  // Used by PfcFstcl::Fsctl function.
186  // Test if file is cached taking in onlyifcached configuration parameters.
187  //---------------------------------------------------------------------
188  virtual int ConsiderCached(const char *url);
189 
190  bool DecideIfConsideredCached(long long file_size, long long bytes_on_disk);
191  void WriteFileSizeXAttr(int cinfo_fd, long long file_size);
192  long long DetermineFullFileSize(const std::string &cinfo_fname);
193 
194  //--------------------------------------------------------------------
200  //--------------------------------------------------------------------
201  bool Decide(XrdOucCacheIO*);
202 
203  //------------------------------------------------------------------------
205  //------------------------------------------------------------------------
206  const Configuration& RefConfiguration() const { return m_configuration; }
207 
208  //---------------------------------------------------------------------
215  //---------------------------------------------------------------------
216  bool Config(const char *config_filename, const char *parameters);
217 
218  //---------------------------------------------------------------------
220  //---------------------------------------------------------------------
221  static Cache &CreateInstance(XrdSysLogger *logger, XrdOucEnv *env);
222 
223  //---------------------------------------------------------------------
225  //---------------------------------------------------------------------
226  static Cache &GetInstance();
227  static const Cache &TheOne();
228  static const Configuration &Conf();
229 
230  static ResourceMonitor &ResMon();
231 
232  //---------------------------------------------------------------------
234  //---------------------------------------------------------------------
235  static bool VCheck(XrdVersionInfo &urVersion) { return true; }
236 
237  //---------------------------------------------------------------------
239  //---------------------------------------------------------------------
240  int UnlinkFile(const std::string& f_name, bool fail_if_open);
241 
242  //---------------------------------------------------------------------
244  //---------------------------------------------------------------------
245  void AddWriteTask(Block* b, bool from_read);
246 
247  //---------------------------------------------------------------------
250  //---------------------------------------------------------------------
251  void RemoveWriteQEntriesFor(File *f);
252 
253  //---------------------------------------------------------------------
255  //---------------------------------------------------------------------
256  void ProcessWriteTasks();
257 
258  long long WritesSinceLastCall();
259 
260  char* RequestRAM(long long size);
261  void ReleaseRAM(char* buf, long long size);
262 
263  void RegisterPrefetchFile(File*);
265 
267 
268  void Prefetch();
269 
270  XrdOss* GetOss() const { return m_oss; }
271 
272  bool IsFileActiveOrPurgeProtected(const std::string&) const;
273  void ClearPurgeProtectedSet();
274  PurgePin* GetPurgePin() const { return m_purge_pin; }
275 
276  File* GetFile(const std::string&, IO*, long long off = 0, long long filesize = 0);
277 
278  void ReleaseFile(File*, IO*);
279 
280  void ScheduleFileSync(File* f) { schedule_file_sync(f, false, false); }
281 
282  void FileSyncDone(File*, bool high_debug);
283 
284  XrdSysError* GetLog() { return &m_log; }
285  XrdSysTrace* GetTrace() { return m_trace; }
286 
287  ResourceMonitor& RefResMon() { return *m_res_mon; }
288  XrdXrootdGStream* GetGStream() { return m_gstream; }
289 
290  void ExecuteCommandUrl(const std::string& command_url);
291 
293 
294 private:
295  bool ConfigParameters(std::string, XrdOucStream&, TmpConfiguration &tmpc);
296  bool ConfigXeq(char *, XrdOucStream &);
297  bool xcschk(XrdOucStream &);
298  bool xdlib(XrdOucStream &);
299  bool xplib(XrdOucStream &);
300  bool xtrace(XrdOucStream &);
301  bool test_oss_basics_and_features();
302 
303  bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name);
304 
305  static Cache *m_instance;
306 
307  XrdOucEnv *m_env;
308  XrdSysError m_log;
309  XrdSysTrace *m_trace;
310  const char *m_traceID;
311 
312  XrdOss *m_oss;
313 
314  XrdXrootdGStream *m_gstream;
315 
316  ResourceMonitor *m_res_mon;
317 
318  std::vector<Decision*> m_decisionpoints;
319  PurgePin* m_purge_pin;
320 
321  Configuration m_configuration;
322 
323  XrdSysCondVar m_prefetch_condVar;
324  bool m_prefetch_enabled;
325 
326  XrdSysMutex m_RAM_mutex;
327  long long m_RAM_used;
328  long long m_RAM_write_queue;
329  std::list<char*> m_RAM_std_blocks;
330  int m_RAM_std_size;
331 
332  bool m_isClient;
333  bool m_dataXattr = false;
334  bool m_metaXattr = false;
335 
336  struct WriteQ
337  {
338  WriteQ() : condVar(0), writes_between_purges(0), size(0) {}
339 
340  XrdSysCondVar condVar;
341  std::list<Block*> queue;
342  long long writes_between_purges;
343  int size;
344  };
345 
346  WriteQ m_writeQ;
347 
348  // active map, purge delay set
349  typedef std::map<std::string, File*> ActiveMap_t;
350  typedef ActiveMap_t::iterator ActiveMap_i;
351  typedef std::set<std::string> FNameSet_t;
352 
353  ActiveMap_t m_active;
354  FNameSet_t m_purge_delay_set;
355  mutable XrdSysCondVar m_active_cond;
356 
357  void inc_ref_cnt(File*, bool lock, bool high_debug);
358  void dec_ref_cnt(File*, bool high_debug);
359 
360  void schedule_file_sync(File*, bool ref_cnt_already_set, bool high_debug);
361 
362  // prefetching
363  typedef std::vector<File*> PrefetchList;
364  PrefetchList m_prefetchList;
365 };
366 
367 }
368 
369 #endif
#define stat(a, b)
Definition: XrdPosix.hh:101
XrdOucString File
virtual XrdOucCacheIO * Attach(XrdOucCacheIO *ioP, int opts=0)=0
Attaches/creates and detaches/deletes cache-io objects for disk based cache.
Definition: XrdPfc.hh:154
PurgePin * GetPurgePin() const
Definition: XrdPfc.hh:274
long long DetermineFullFileSize(const std::string &cinfo_fname)
Definition: XrdPfc.cc:929
void FileSyncDone(File *, bool high_debug)
Definition: XrdPfc.cc:546
File * GetFile(const std::string &, IO *, long long off=0, long long filesize=0)
Definition: XrdPfc.cc:393
XrdOss * GetOss() const
Definition: XrdPfc.hh:270
static const Configuration & Conf()
Definition: XrdPfc.cc:134
bool Config(const char *config_filename, const char *parameters)
Parse configuration file.
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
Definition: XrdPfc.cc:797
virtual int Stat(const char *url, struct stat &sbuff)
Definition: XrdPfc.cc:1124
XrdSysTrace * GetTrace()
Definition: XrdPfc.hh:285
const Configuration & RefConfiguration() const
Reference XrdPfc configuration.
Definition: XrdPfc.hh:206
static ResourceMonitor & ResMon()
Definition: XrdPfc.cc:135
XrdXrootdGStream * GetGStream()
Definition: XrdPfc.hh:288
bool IsFileActiveOrPurgeProtected(const std::string &) const
Definition: XrdPfc.cc:680
void ClearPurgeProtectedSet()
Definition: XrdPfc.cc:688
XrdSysError * GetLog()
Definition: XrdPfc.hh:284
void ReleaseRAM(char *buf, long long size)
Definition: XrdPfc.cc:375
virtual int ConsiderCached(const char *url)
Definition: XrdPfc.cc:1003
static Cache & GetInstance()
Singleton access.
Definition: XrdPfc.cc:132
void DeRegisterPrefetchFile(File *)
Definition: XrdPfc.cc:714
void ExecuteCommandUrl(const std::string &command_url)
void RegisterPrefetchFile(File *)
Definition: XrdPfc.cc:698
void WriteFileSizeXAttr(int cinfo_fd, long long file_size)
Definition: XrdPfc.cc:914
void Prefetch()
Definition: XrdPfc.cc:755
void ReleaseFile(File *, IO *)
Definition: XrdPfc.cc:475
void AddWriteTask(Block *b, bool from_read)
Add downloaded block in write queue.
Definition: XrdPfc.cc:225
Cache(XrdSysLogger *logger, XrdOucEnv *env)
Constructor.
Definition: XrdPfc.cc:158
bool Decide(XrdOucCacheIO *)
Makes decision if the original XrdOucCacheIO should be cached.
Definition: XrdPfc.cc:137
int UnlinkFile(const std::string &f_name, bool fail_if_open)
Remove cinfo and data files from cache.
Definition: XrdPfc.cc:1195
virtual XrdOucCacheIO * Attach(XrdOucCacheIO *ioP, int opts=0)=0
Obtain a new IO object that fronts existing XrdOucCacheIO.
static XrdScheduler * schedP
Definition: XrdPfc.hh:292
File * GetNextFileToPrefetch()
Definition: XrdPfc.cc:736
ResourceMonitor & RefResMon()
Definition: XrdPfc.hh:287
long long WritesSinceLastCall()
Definition: XrdPfc.cc:324
void ProcessWriteTasks()
Separate task which writes blocks from ram to disk.
Definition: XrdPfc.cc:277
virtual int Unlink(const char *url)
Definition: XrdPfc.cc:1185
void RemoveWriteQEntriesFor(File *f)
Remove blocks from write queue which belong to given prefetch. This method is used at the time of Fil...
Definition: XrdPfc.cc:244
static const Cache & TheOne()
Definition: XrdPfc.cc:133
static bool VCheck(XrdVersionInfo &urVersion)
Version check.
Definition: XrdPfc.hh:235
char * RequestRAM(long long size)
Definition: XrdPfc.cc:335
virtual int Prepare(const char *url, int oflags, mode_t mode)
Definition: XrdPfc.cc:1069
bool DecideIfConsideredCached(long long file_size, long long bytes_on_disk)
Definition: XrdPfc.cc:970
static Cache & CreateInstance(XrdSysLogger *logger, XrdOucEnv *env)
Singleton creation.
Definition: XrdPfc.cc:125
void ScheduleFileSync(File *f)
Definition: XrdPfc.hh:280
Base cache-io class that implements some XrdOucCacheIO abstract methods.
Definition: XrdPfcIO.hh:16
Base class for reguesting directory space to obtain.
Definition: XrdPfc.hh:41
@ CSChk_Both
Definition: XrdPfcTypes.hh:27
@ CSChk_Net
Definition: XrdPfcTypes.hh:27
@ CSChk_Cache
Definition: XrdPfcTypes.hh:27
Contains parameters configurable from the xrootd config file.
Definition: XrdPfc.hh:64
long long m_hdfsbsize
used with m_hdfsmode, default 128MB
Definition: XrdPfc.hh:116
long long m_RamAbsAvailable
available from configuration
Definition: XrdPfc.hh:110
long long m_flushCnt
nuber of unsynced blcoks on disk before flush is called
Definition: XrdPfc.hh:117
int m_accHistorySize
max number of entries in access history part of cinfo file
Definition: XrdPfc.hh:101
bool does_cschk_have_missing_bits(CkSumCheck_e cks_on_file) const
Definition: XrdPfc.hh:80
int m_wqueue_threads
number of threads writing blocks to disk
Definition: XrdPfc.hh:113
bool m_write_through
flag indicating write-through mode is enabled
Definition: XrdPfc.hh:84
long long m_diskTotalSpace
total disk space on configured partition or oss space
Definition: XrdPfc.hh:92
long long m_fileUsageMax
cache purge - files usage maximum
Definition: XrdPfc.hh:97
long long m_fileUsageBaseline
cache purge - files usage baseline
Definition: XrdPfc.hh:95
int m_dirStatsStoreDepth
depth to which statistics should be collected
Definition: XrdPfc.hh:107
bool m_allow_xrdpfc_command
flag for enabling access to /xrdpfc-command/ functionality.
Definition: XrdPfc.hh:86
bool is_purge_plugin_set_up() const
Definition: XrdPfc.hh:71
long long m_diskUsageHWM
cache purge - disk usage high water mark
Definition: XrdPfc.hh:94
bool is_cschk_cache() const
Definition: XrdPfc.hh:75
std::set< std::string > m_dirStatsDirGlobs
directory globs for which stat reporting was requested
Definition: XrdPfc.hh:104
CkSumCheck_e get_cs_Chk() const
Definition: XrdPfc.hh:73
bool is_uvkeep_purge_in_effect() const
Definition: XrdPfc.hh:69
int m_prefetch_max_blocks
maximum number of blocks to prefetch per file
Definition: XrdPfc.hh:114
bool are_file_usage_limits_set() const
Definition: XrdPfc.hh:67
bool is_cschk_any() const
Definition: XrdPfc.hh:77
bool m_cs_ChkTLS
Allow TLS.
Definition: XrdPfc.hh:121
long long m_fileUsageNominal
cache purge - files usage nominal
Definition: XrdPfc.hh:96
int m_cs_Chk
Checksum check.
Definition: XrdPfc.hh:120
bool should_uvkeep_purge(time_t delta) const
Definition: XrdPfc.hh:82
int m_purgeAgeBasedPeriod
peform cold file / uvkeep purge every this many purge cycles
Definition: XrdPfc.hh:100
bool m_hdfsmode
flag for enabling block-level operation
Definition: XrdPfc.hh:85
int m_purgeColdFilesAge
purge files older than this age
Definition: XrdPfc.hh:99
std::string m_data_space
oss space for data files
Definition: XrdPfc.hh:89
bool is_cschk_both() const
Definition: XrdPfc.hh:78
std::set< std::string > m_dirStatsDirs
directories for which stat reporting was requested
Definition: XrdPfc.hh:103
long long m_diskUsageLWM
cache purge - disk usage low water mark
Definition: XrdPfc.hh:93
int m_RamKeepStdBlocks
number of standard-sized blocks kept after release
Definition: XrdPfc.hh:111
long long m_bufferSize
prefetch buffer size, default 1MB
Definition: XrdPfc.hh:109
int m_dirStatsInterval
time between resource monitor statistics dump in seconds
Definition: XrdPfc.hh:105
std::string m_meta_space
oss space for metadata files (cinfo)
Definition: XrdPfc.hh:90
int m_wqueue_blocks
maximum number of blocks written per write-queue loop
Definition: XrdPfc.hh:112
bool is_age_based_purge_in_effect() const
Definition: XrdPfc.hh:68
std::string m_username
username passed to oss plugin
Definition: XrdPfc.hh:88
bool is_cschk_net() const
Definition: XrdPfc.hh:76
double m_onlyIfCachedMinFrac
minimum fraction of downloaded file, used by only-if-cached CGI option
Definition: XrdPfc.hh:124
time_t m_cs_UVKeep
unverified checksum cache keep
Definition: XrdPfc.hh:119
int m_dirStatsMaxDepth
maximum depth for statistics write out
Definition: XrdPfc.hh:106
int m_purgeInterval
sleep interval between cache purges
Definition: XrdPfc.hh:98
long long m_onlyIfCachedMinSize
minumum size of downloaded file, used by only-if-cached CGI option
Definition: XrdPfc.hh:123
bool is_dir_stat_reporting_on() const
Definition: XrdPfc.hh:70
MutexHolder(MOO &m)
Definition: XrdPfc.hh:51
std::string m_writemodeRaw
Definition: XrdPfc.hh:137
std::string m_diskUsageLWM
Definition: XrdPfc.hh:131
std::string m_diskUsageHWM
Definition: XrdPfc.hh:132
std::string m_fileUsageBaseline
Definition: XrdPfc.hh:133
std::string m_fileUsageNominal
Definition: XrdPfc.hh:134
std::string m_flushRaw
Definition: XrdPfc.hh:136
std::string m_fileUsageMax
Definition: XrdPfc.hh:135