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 #include "XrdCl/XrdClDefaultEnv.hh"
31 
32 #include "XrdPfcFile.hh"
33 #include "XrdPfcDecision.hh"
34 
35 class XrdOucStream;
36 class XrdSysError;
37 class XrdSysTrace;
38 class XrdXrootdGStream;
39 
40 namespace XrdCl
41 {
42 class Log;
43 }
44 
45 namespace XrdPfc
46 {
47 class File;
48 class IO;
49 
50 class DataFsState;
51 }
52 
53 
54 namespace XrdPfc
55 {
56 
57 //----------------------------------------------------------------------------
59 //----------------------------------------------------------------------------
61 {
63  m_hdfsmode(false),
65  m_data_space("public"),
66  m_meta_space("public"),
67  m_diskTotalSpace(-1),
68  m_diskUsageLWM(-1),
69  m_diskUsageHWM(-1),
72  m_fileUsageMax(-1),
73  m_purgeInterval(300),
76  m_accHistorySize(20),
79  m_dirStats(false),
80  m_bufferSize(1024*1024),
83  m_wqueue_blocks(16),
86  m_hdfsbsize(128*1024*1024),
87  m_flushCnt(2000)
88  {}
89 
90  bool are_file_usage_limits_set() const { return m_fileUsageMax > 0; }
92  bool is_purge_plugin_set_up() const { return false; }
93 
94  void calculate_fractional_usages(long long du, long long fu, double &frac_du, double &frac_fu);
95 
96  // This might become more complicated with per-dir purge policy
97  bool are_dirstats_enabled() const { return m_dirStats; }
98 
99  bool m_hdfsmode;
101 
102  std::string m_username;
103  std::string m_data_space;
104  std::string m_meta_space;
105 
106  long long m_diskTotalSpace;
107  long long m_diskUsageLWM;
108  long long m_diskUsageHWM;
110  long long m_fileUsageNominal;
111  long long m_fileUsageMax;
116 
117  std::set<std::string> m_dirStatsDirs;
118  std::set<std::string> m_dirStatsDirGlobs;
121  bool m_dirStats;
122 
123  long long m_bufferSize;
124  long long m_RamAbsAvailable;
129 
130  long long m_hdfsbsize;
131  long long m_flushCnt;
132 };
133 
134 //------------------------------------------------------------------------------
135 
137 {
138  std::string m_diskUsageLWM;
139  std::string m_diskUsageHWM;
140  std::string m_fileUsageBaseline;
141  std::string m_fileUsageNominal;
142  std::string m_fileUsageMax;
143  std::string m_flushRaw;
144 
146  m_diskUsageLWM("0.90"), m_diskUsageHWM("0.95"),
147  m_flushRaw("")
148  {}
149 };
150 
151 //==============================================================================
152 
154 {
155  char *str;
156  const char *delim;
157  char *state;
158  bool first;
159 
160  SplitParser(const std::string &s, const char *d) :
161  str(strdup(s.c_str())), delim(d), state(0), first(true)
162  {}
163  ~SplitParser() { free(str); }
164 
165  char* get_token()
166  {
167  if (first) { first = false; return strtok_r(str, delim, &state); }
168  else { return strtok_r(0, delim, &state); }
169  }
170 
172  {
173  if (first) { return str; }
174  else { *(state - 1) = delim[0]; return state - 1; }
175  }
176 
177  char *get_reminder()
178  {
179  return first ? str : state;
180  }
181 
182  int fill_argv(std::vector<char*> &argv)
183  {
184  if (!first) return 0;
185  int dcnt = 0; { char *p = str; while (*p) { if (*(p++) == delim[0]) ++dcnt; } }
186  argv.reserve(dcnt + 1);
187  int argc = 0;
188  char *i = strtok_r(str, delim, &state);
189  while (i)
190  {
191  ++argc;
192  argv.push_back(i);
193  // printf(" arg %d : '%s'\n", argc, i);
194  i = strtok_r(0, delim, &state);
195  }
196  return argc;
197  }
198 };
199 
200 struct PathTokenizer : private SplitParser
201 {
202  std::vector<const char*> m_dirs;
203  const char *m_reminder;
204  int m_n_dirs;
205 
206  PathTokenizer(const std::string &path, int max_depth, bool parse_as_lfn) :
207  SplitParser(path, "/"),
208  m_reminder (0)
209  {
210  // If parse_as_lfn is true store final token into reminder, regardless of maxdepth.
211  // This assumes the last token is a file name (and full path if lfn, including the file name).
212 
213  m_dirs.reserve(max_depth);
214 
215  char *t = 0;
216  for (int i = 0; i < max_depth; ++i)
217  {
218  t = get_token();
219  if (t == 0) break;
220  m_dirs.emplace_back(t);
221  }
222  if (parse_as_lfn && (t == 0 || * get_reminder() == 0))
223  {
224  m_reminder = m_dirs.back();
225  m_dirs.pop_back();
226  }
227  else
228  {
230  }
231  m_n_dirs = (int) m_dirs.size();
232  }
233 
235  {
236  return m_n_dirs;
237  }
238 
239  const char *get_dir(int pos)
240  {
241  if (pos >= m_n_dirs) return 0;
242  return m_dirs[pos];
243  }
244 
245  std::string make_path()
246  {
247  std::string res;
248  for (std::vector<const char*>::iterator i = m_dirs.begin(); i != m_dirs.end(); ++i)
249  {
250  res += "/";
251  res += *i;
252  }
253  if (m_reminder != 0)
254  {
255  res += "/";
256  res += m_reminder;
257  }
258  return res;
259  }
260 
261  void deboog()
262  {
263  printf("PathTokenizer::deboog size=%d\n", m_n_dirs);
264  for (int i = 0; i < m_n_dirs; ++i)
265  {
266  printf(" %2d: %s\n", i, m_dirs[i]);
267  }
268  printf(" rem: %s\n", m_reminder);
269  }
270 };
271 
272 
273 //==============================================================================
274 // Cache
275 //==============================================================================
276 
277 //----------------------------------------------------------------------------
279 //----------------------------------------------------------------------------
280 class Cache : public XrdOucCache
281 {
282 public:
283  //---------------------------------------------------------------------
285  //---------------------------------------------------------------------
286  Cache(XrdSysLogger *logger, XrdOucEnv *env);
287 
288  //---------------------------------------------------------------------
290  //---------------------------------------------------------------------
291  using XrdOucCache::Attach;
292 
293  virtual XrdOucCacheIO *Attach(XrdOucCacheIO *, int Options = 0);
294 
295  //---------------------------------------------------------------------
296  // Virtual function of XrdOucCache. Used for redirection to a local
297  // file on a distributed FS.
298  virtual int LocalFilePath(const char *url, char *buff=0, int blen=0,
299  LFP_Reason why=ForAccess, bool forall=false);
300 
301  //---------------------------------------------------------------------
302  // Virtual function of XrdOucCache. Used for deferred open.
303  virtual int Prepare(const char *url, int oflags, mode_t mode);
304 
305  // virtual function of XrdOucCache.
306  virtual int Stat(const char *url, struct stat &sbuff);
307 
308  // virtual function of XrdOucCache.
309  virtual int Unlink(const char *url);
310 
311  //--------------------------------------------------------------------
317  //--------------------------------------------------------------------
319 
320  //------------------------------------------------------------------------
322  //------------------------------------------------------------------------
323  const Configuration& RefConfiguration() const { return m_configuration; }
324 
325  //---------------------------------------------------------------------
332  //---------------------------------------------------------------------
333  bool Config(const char *config_filename, const char *parameters);
334 
335  //---------------------------------------------------------------------
337  //---------------------------------------------------------------------
338  static Cache &CreateInstance(XrdSysLogger *logger, XrdOucEnv *env);
339 
340  //---------------------------------------------------------------------
342  //---------------------------------------------------------------------
343  static Cache &GetInstance();
344 
345  //---------------------------------------------------------------------
347  //---------------------------------------------------------------------
348  static bool VCheck(XrdVersionInfo &urVersion) { return true; }
349 
350  //---------------------------------------------------------------------
352  //---------------------------------------------------------------------
354 
355  //---------------------------------------------------------------------
357  //---------------------------------------------------------------------
358  void Purge();
359 
360  //---------------------------------------------------------------------
362  //---------------------------------------------------------------------
363  int UnlinkUnlessOpen(const std::string& f_name);
364 
365  //---------------------------------------------------------------------
367  //---------------------------------------------------------------------
368  void AddWriteTask(Block* b, bool from_read);
369 
370  //---------------------------------------------------------------------
373  //---------------------------------------------------------------------
375 
376  //---------------------------------------------------------------------
378  //---------------------------------------------------------------------
380 
381  char* RequestRAM(long long size);
382  void ReleaseRAM(char* buf, long long size);
383 
386 
388 
389  void Prefetch();
390 
391  XrdOss* GetOss() const { return m_oss; }
392 
393  bool IsFileActiveOrPurgeProtected(const std::string&);
394 
395  File* GetFile(const std::string&, IO*, long long off = 0, long long filesize = 0);
396 
397  void ReleaseFile(File*, IO*);
398 
399  void ScheduleFileSync(File* f) { schedule_file_sync(f, false, false); }
400 
401  void FileSyncDone(File*, bool high_debug);
402 
403  XrdSysError* GetLog() { return &m_log; }
404  XrdSysTrace* GetTrace() { return m_trace; }
405 
407 
408  void ExecuteCommandUrl(const std::string& command_url);
409 
411 
412 private:
413  bool ConfigParameters(std::string, XrdOucStream&, TmpConfiguration &tmpc);
414  bool ConfigXeq(char *, XrdOucStream &);
417 
418  bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name);
419 
420  int UnlinkCommon(const std::string& f_name, bool fail_if_open);
421 
422  static Cache *m_instance;
423 
427  const char *m_traceID;
428 
431 
433 
434  std::vector<XrdPfc::Decision*> m_decisionpoints;
435 
437 
440 
442  long long m_RAM_used;
443  long long m_RAM_write_queue;
444  std::list<char*> m_RAM_std_blocks;
446 
447  bool m_isClient;
448 
449  struct WriteQ
450  {
452 
454  std::list<Block*> queue;
456  int size;
457  };
458 
460 
461  // active map, purge delay set
462  typedef std::map<std::string, File*> ActiveMap_t;
463  typedef ActiveMap_t::iterator ActiveMap_i;
464  typedef std::multimap<std::string, XrdPfc::Stats> StatsMMap_t;
465  typedef StatsMMap_t::iterator StatsMMap_i;
466  typedef std::set<std::string> FNameSet_t;
467 
473 
474  void inc_ref_cnt(File*, bool lock, bool high_debug);
475  void dec_ref_cnt(File*, bool high_debug);
476 
477  void schedule_file_sync(File*, bool ref_cnt_already_set, bool high_debug);
478 
479  // prefetching
480  typedef std::vector<File*> PrefetchList;
482 
483  //---------------------------------------------------------------------------
484  // Statistics, heart-beat, scan-and-purge
485 
487 
489 
490  DataFsState *m_fs_state;
491 
495 
497 };
498 
499 }
500 
501 #endif
#define stat(a, b)
Definition: XrdPosix.hh:96
Definition: XrdOss.hh:488
Definition: XrdOucCache.hh:103
Definition: XrdOucCacheStats.hh:44
Definition: XrdOucCache.hh:494
LFP_Reason
Definition: XrdOucCache.hh:569
@ ForAccess
Definition: XrdOucCache.hh:569
virtual XrdOucCacheIO * Attach(XrdOucCacheIO *ioP, int opts=0)=0
Definition: XrdOucEnv.hh:42
Definition: XrdOucStream.hh:47
Definition: XrdPfcFile.hh:61
Attaches/creates and detaches/deletes cache-io objects for disk based cache.
Definition: XrdPfc.hh:281
bool ConfigXeq(char *, XrdOucStream &)
void RegisterPrefetchFile(File *)
Configuration m_configuration
configurable parameters
Definition: XrdPfc.hh:436
long long m_RAM_used
Definition: XrdPfc.hh:442
static XrdScheduler * schedP
Definition: XrdPfc.hh:410
ActiveMap_t m_active
Map of currently active / open files.
Definition: XrdPfc.hh:468
XrdOss * GetOss() const
Definition: XrdPfc.hh:391
ScanAndPurgeThreadState_e
Definition: XrdPfc.hh:486
@ SPTS_Idle
Definition: XrdPfc.hh:486
@ SPTS_Done
Definition: XrdPfc.hh:486
@ SPTS_Purge
Definition: XrdPfc.hh:486
@ SPTS_Scan
Definition: XrdPfc.hh:486
static Cache & GetInstance()
Singleton access.
StatsMMap_t m_closed_files_stats
Definition: XrdPfc.hh:469
bool ConfigParameters(std::string, XrdOucStream &, TmpConfiguration &tmpc)
File * GetNextFileToPrefetch()
std::map< std::string, File * > ActiveMap_t
Definition: XrdPfc.hh:462
XrdSysTrace * GetTrace()
Definition: XrdPfc.hh:404
void FileSyncDone(File *, bool high_debug)
void inc_ref_cnt(File *, bool lock, bool high_debug)
const Configuration & RefConfiguration() const
Reference XrdPfc configuration.
Definition: XrdPfc.hh:323
WriteQ m_writeQ
Definition: XrdPfc.hh:459
std::vector< XrdPfc::Decision * > m_decisionpoints
decision plugins
Definition: XrdPfc.hh:434
void DeRegisterPrefetchFile(File *)
void Purge()
Thread function invoked to scan and purge files from disk when needed.
int UnlinkUnlessOpen(const std::string &f_name)
Remove file from cache unless it is currently open.
int m_last_scan_duration
Definition: XrdPfc.hh:492
int m_RAM_std_size
Definition: XrdPfc.hh:445
int m_last_purge_duration
Definition: XrdPfc.hh:493
XrdXrootdGStream * GetGStream()
Definition: XrdPfc.hh:406
bool m_isClient
True if running as client.
Definition: XrdPfc.hh:447
void copy_out_active_stats_and_update_data_fs_state()
void RemoveWriteQEntriesFor(File *f)
Remove blocks from write queue which belong to given prefetch. This method is used at the time of Fil...
StatsMMap_t::iterator StatsMMap_i
Definition: XrdPfc.hh:465
XrdSysMutex m_RAM_mutex
lock for allcoation of RAM blocks
Definition: XrdPfc.hh:441
DataFsState * m_fs_state
directory state for access / usage info and quotas
Definition: XrdPfc.hh:490
int UnlinkCommon(const std::string &f_name, bool fail_if_open)
XrdOss * m_oss
disk cache file system
Definition: XrdPfc.hh:430
virtual int LocalFilePath(const char *url, char *buff=0, int blen=0, LFP_Reason why=ForAccess, bool forall=false)
ActiveMap_t::iterator ActiveMap_i
Definition: XrdPfc.hh:463
void schedule_file_sync(File *, bool ref_cnt_already_set, bool high_debug)
XrdSysError * GetLog()
Definition: XrdPfc.hh:403
PrefetchList m_prefetchList
Definition: XrdPfc.hh:481
bool cfg2bytes(const std::string &str, long long &store, long long totalSpace, const char *name)
bool xdlib(XrdOucStream &)
void ProcessWriteTasks()
Separate task which writes blocks from ram to disk.
std::vector< File * > PrefetchList
Definition: XrdPfc.hh:480
const char * m_traceID
Definition: XrdPfc.hh:427
void ResourceMonitorHeartBeat()
Thread function checking resource usage periodically.
bool Config(const char *config_filename, const char *parameters)
Parse configuration file.
void ExecuteCommandUrl(const std::string &command_url)
virtual int Prepare(const char *url, int oflags, mode_t mode)
virtual int Stat(const char *url, struct stat &sbuff)
void ReleaseRAM(char *buf, long long size)
virtual int Unlink(const char *url)
File * GetFile(const std::string &, IO *, long long off=0, long long filesize=0)
virtual XrdOucCacheIO * Attach(XrdOucCacheIO *, int Options=0)
XrdXrootdGStream * m_gstream
Definition: XrdPfc.hh:432
std::multimap< std::string, XrdPfc::Stats > StatsMMap_t
Definition: XrdPfc.hh:464
XrdOucEnv * m_env
environment passed in at creation
Definition: XrdPfc.hh:424
ScanAndPurgeThreadState_e m_spt_state
Definition: XrdPfc.hh:494
XrdSysCondVar m_prefetch_condVar
lock for vector of prefetching files
Definition: XrdPfc.hh:438
long long m_RAM_write_queue
Definition: XrdPfc.hh:443
XrdSysTrace * m_trace
Definition: XrdPfc.hh:426
std::list< char * > m_RAM_std_blocks
A list of blocks of standard size, to be reused.
Definition: XrdPfc.hh:444
bool xtrace(XrdOucStream &)
char * RequestRAM(long long size)
void dec_ref_cnt(File *, bool high_debug)
XrdSysError m_log
XrdPfc namespace logger.
Definition: XrdPfc.hh:425
bool m_in_purge
Definition: XrdPfc.hh:471
void ReleaseFile(File *, IO *)
bool m_prefetch_enabled
set to true when prefetching is enabled
Definition: XrdPfc.hh:439
FNameSet_t m_purge_delay_set
Definition: XrdPfc.hh:470
Cache(XrdSysLogger *logger, XrdOucEnv *env)
Constructor.
void AddWriteTask(Block *b, bool from_read)
Add downloaded block in write queue.
static Cache & CreateInstance(XrdSysLogger *logger, XrdOucEnv *env)
Singleton creation.
bool IsFileActiveOrPurgeProtected(const std::string &)
static Cache * m_instance
this object
Definition: XrdPfc.hh:422
static bool VCheck(XrdVersionInfo &urVersion)
Version check.
Definition: XrdPfc.hh:348
std::set< std::string > FNameSet_t
Definition: XrdPfc.hh:466
XrdOucCacheStats m_ouc_stats
Definition: XrdPfc.hh:429
XrdSysCondVar m_stats_n_purge_cond
communication between heart-beat and scan-purge threads
Definition: XrdPfc.hh:488
bool Decide(XrdOucCacheIO *)
Makes decision if the original XrdOucCacheIO should be cached.
void ScheduleFileSync(File *f)
Definition: XrdPfc.hh:399
XrdSysCondVar m_active_cond
Cond-var protecting active file data structures.
Definition: XrdPfc.hh:472
Definition: XrdPfcFile.hh:134
Base cache-io class that implements XrdOucCacheIO abstract methods.
Definition: XrdPfcIO.hh:17
Definition: XrdScheduler.hh:45
Definition: XrdSysPthread.hh:79
Definition: XrdSysError.hh:90
Definition: XrdSysLogger.hh:53
Definition: XrdSysPthread.hh:166
Definition: XrdSysTrace.hh:49
Definition: XrdXrootdGStream.hh:44
Definition: XrdClAnyObject.hh:26
Definition: XrdPfc.hh:46
Definition: XrdPfc.hh:450
long long writes_between_purges
upper bound on amount of bytes written between two purge passes
Definition: XrdPfc.hh:455
XrdSysCondVar condVar
write list condVar
Definition: XrdPfc.hh:453
int size
current size of write queue
Definition: XrdPfc.hh:456
WriteQ()
Definition: XrdPfc.hh:451
std::list< Block * > queue
container
Definition: XrdPfc.hh:454
Contains parameters configurable from the xrootd config file.
Definition: XrdPfc.hh:61
long long m_hdfsbsize
used with m_hdfsmode, default 128MB
Definition: XrdPfc.hh:130
long long m_RamAbsAvailable
available from configuration
Definition: XrdPfc.hh:124
long long m_flushCnt
nuber of unsynced blcoks on disk before flush is called
Definition: XrdPfc.hh:131
int m_accHistorySize
max number of entries in access history part of cinfo file
Definition: XrdPfc.hh:115
int m_wqueue_threads
number of threads writing blocks to disk
Definition: XrdPfc.hh:127
long long m_diskTotalSpace
total disk space on configured partition or oss space
Definition: XrdPfc.hh:106
long long m_fileUsageMax
cache purge - files usage maximum
Definition: XrdPfc.hh:111
long long m_fileUsageBaseline
cache purge - files usage baseline
Definition: XrdPfc.hh:109
int m_dirStatsStoreDepth
depth to which statistics should be collected
Definition: XrdPfc.hh:120
Configuration()
Definition: XrdPfc.hh:62
bool m_allow_xrdpfc_command
flag for enabling access to /xrdpfc-command/ functionality.
Definition: XrdPfc.hh:100
bool is_purge_plugin_set_up() const
Definition: XrdPfc.hh:92
long long m_diskUsageHWM
cache purge - disk usage high water mark
Definition: XrdPfc.hh:108
std::set< std::string > m_dirStatsDirGlobs
directory globs for which stat reporting was requested
Definition: XrdPfc.hh:118
int m_prefetch_max_blocks
maximum number of blocks to prefetch per file
Definition: XrdPfc.hh:128
bool are_file_usage_limits_set() const
Definition: XrdPfc.hh:90
void calculate_fractional_usages(long long du, long long fu, double &frac_du, double &frac_fu)
long long m_fileUsageNominal
cache purge - files usage nominal
Definition: XrdPfc.hh:110
bool m_hdfsmode
flag for enabling block-level operation
Definition: XrdPfc.hh:99
int m_purgeColdFilesAge
purge files older than this age
Definition: XrdPfc.hh:113
std::string m_data_space
oss space for data files
Definition: XrdPfc.hh:103
std::set< std::string > m_dirStatsDirs
directories for which stat reporting was requested
Definition: XrdPfc.hh:117
long long m_diskUsageLWM
cache purge - disk usage low water mark
Definition: XrdPfc.hh:107
int m_RamKeepStdBlocks
number of standard-sized blocks kept after release
Definition: XrdPfc.hh:125
bool m_dirStats
is directory access / usage statistics enabled
Definition: XrdPfc.hh:121
int m_purgeColdFilesPeriod
peform cold file purge every this many purge cycles
Definition: XrdPfc.hh:114
long long m_bufferSize
prefetch buffer size, default 1MB
Definition: XrdPfc.hh:123
std::string m_meta_space
oss space for metadata files (cinfo)
Definition: XrdPfc.hh:104
int m_wqueue_blocks
maximum number of blocks written per write-queue loop
Definition: XrdPfc.hh:126
bool is_age_based_purge_in_effect() const
Definition: XrdPfc.hh:91
bool are_dirstats_enabled() const
Definition: XrdPfc.hh:97
std::string m_username
username passed to oss plugin
Definition: XrdPfc.hh:102
int m_dirStatsMaxDepth
maximum depth for statistics write out
Definition: XrdPfc.hh:119
int m_purgeInterval
sleep interval between cache purges
Definition: XrdPfc.hh:112
Definition: XrdPfc.hh:201
std::string make_path()
Definition: XrdPfc.hh:245
const char * m_reminder
Definition: XrdPfc.hh:203
PathTokenizer(const std::string &path, int max_depth, bool parse_as_lfn)
Definition: XrdPfc.hh:206
void deboog()
Definition: XrdPfc.hh:261
int get_n_dirs()
Definition: XrdPfc.hh:234
std::vector< const char * > m_dirs
Definition: XrdPfc.hh:202
int m_n_dirs
Definition: XrdPfc.hh:204
const char * get_dir(int pos)
Definition: XrdPfc.hh:239
Definition: XrdPfc.hh:154
bool first
Definition: XrdPfc.hh:158
SplitParser(const std::string &s, const char *d)
Definition: XrdPfc.hh:160
char * get_reminder()
Definition: XrdPfc.hh:177
~SplitParser()
Definition: XrdPfc.hh:163
char * get_token()
Definition: XrdPfc.hh:165
const char * delim
Definition: XrdPfc.hh:156
char * state
Definition: XrdPfc.hh:157
char * str
Definition: XrdPfc.hh:155
int fill_argv(std::vector< char * > &argv)
Definition: XrdPfc.hh:182
char * get_reminder_with_delim()
Definition: XrdPfc.hh:171
Definition: XrdPfc.hh:137
std::string m_diskUsageLWM
Definition: XrdPfc.hh:138
std::string m_diskUsageHWM
Definition: XrdPfc.hh:139
std::string m_fileUsageBaseline
Definition: XrdPfc.hh:140
TmpConfiguration()
Definition: XrdPfc.hh:145
std::string m_fileUsageNominal
Definition: XrdPfc.hh:141
std::string m_flushRaw
Definition: XrdPfc.hh:143
std::string m_fileUsageMax
Definition: XrdPfc.hh:142