xrootd
XrdFileCacheFile.hh
Go to the documentation of this file.
1 #ifndef __XRDFILECACHE_FILE_HH__
2 #define __XRDFILECACHE_FILE_HH__
3 //----------------------------------------------------------------------------------
4 // Copyright (c) 2014 by Board of Trustees of the Leland Stanford, Jr., University
5 // Author: Alja Mrak-Tadel, Matevz Tadel
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 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 
22 #include "XrdCl/XrdClDefaultEnv.hh"
23 
24 #include "XrdOuc/XrdOucCache2.hh"
25 #include "XrdOuc/XrdOucIOVec.hh"
26 
27 #include "XrdFileCacheInfo.hh"
28 #include "XrdFileCacheStats.hh"
29 
30 #include <string>
31 #include <map>
32 
33 class XrdJob;
34 class XrdOucIOVec;
35 
36 namespace XrdCl
37 {
38 class Log;
39 }
40 
41 namespace XrdFileCache
42 {
43 class BlockResponseHandler;
44 class DirectResponseHandler;
45 class IO;
46 
47 struct ReadVBlockListRAM;
48 struct ReadVChunkListRAM;
49 struct ReadVBlockListDisk;
50 struct ReadVChunkListDisk;
51 }
52 
53 
54 namespace XrdFileCache
55 {
56 
57 class File;
58 
59 class Block
60 {
61 public:
62  std::vector<char> m_buff;
63  long long m_offset;
65  IO *m_io; // IO that handled current request, used for == / != comparisons only
66 
67  int m_refcnt;
68  int m_errno; // stores negative errno
70  bool m_prefetch;
71 
72  Block(File *f, IO *io, long long off, int size, bool m_prefetch) :
73  m_offset(off), m_file(f), m_io(io), m_refcnt(0),
75  {
76  m_buff.resize(size);
77  }
78 
79  char* get_buff(long long pos = 0) { return &m_buff[pos]; }
80  int get_size() { return (int) m_buff.size(); }
81  long long get_offset() { return m_offset; }
82 
83  IO* get_io() const { return m_io; }
84 
85  bool is_finished() { return m_downloaded || m_errno != 0; }
86  bool is_ok() { return m_downloaded; }
87  bool is_failed() { return m_errno != 0; }
88 
89  void set_downloaded() { m_downloaded = true; }
90  void set_error(int err) { m_errno = err; }
91 
93  {
94  m_errno = 0;
95  m_io = io;
96  }
97 };
98 
99 // ================================================================
100 
102 {
103 public:
106 
107  BlockResponseHandler(Block *b, bool prefetch) :
108  m_block(b), m_for_prefetch(prefetch) {}
109 
110  virtual void Done(int result);
111 };
112 
113 // ================================================================
114 
116 {
117 public:
120  int m_errno;
121 
122  DirectResponseHandler(int to_wait) : m_cond(0), m_to_wait(to_wait), m_errno(0) {}
123 
124  bool is_finished() { XrdSysCondVarHelper _lck(m_cond); return m_to_wait == 0; }
125  bool is_ok() { XrdSysCondVarHelper _lck(m_cond); return m_to_wait == 0 && m_errno == 0; }
126  bool is_failed() { XrdSysCondVarHelper _lck(m_cond); return m_errno != 0; }
127 
128  virtual void Done(int result);
129 };
130 
131 // ================================================================
132 
133 class File
134 {
135 public:
136  //------------------------------------------------------------------------
138  //------------------------------------------------------------------------
139  File(const std::string &path, long long offset, long long fileSize);
140 
141  //------------------------------------------------------------------------
143  //------------------------------------------------------------------------
144  static File* FileOpen(const std::string &path, long long offset, long long fileSize);
145 
146  //------------------------------------------------------------------------
148  //------------------------------------------------------------------------
149  ~File();
150 
153 
155  void BlocksRemovedFromWriteQ(std::list<Block*>&);
156 
158  bool Open();
159 
161  int ReadV(IO *io, const XrdOucIOVec *readV, int n);
162 
164  int Read (IO *io, char* buff, long long offset, int size);
165 
166  //----------------------------------------------------------------------
168  //----------------------------------------------------------------------
169  bool isOpen() const { return m_is_open; }
170 
171  //----------------------------------------------------------------------
174  //----------------------------------------------------------------------
175  bool ioActive(IO *io);
176 
177  //----------------------------------------------------------------------
180  //----------------------------------------------------------------------
182 
183  //----------------------------------------------------------------------
186  //----------------------------------------------------------------------
188 
189  //----------------------------------------------------------------------
191  //----------------------------------------------------------------------
192  void Sync();
193 
194  //----------------------------------------------------------------------
196  //----------------------------------------------------------------------
197  Stats& GetStats() { return m_stats; }
198 
201 
202  void Prefetch();
203 
204  float GetPrefetchScore() const;
205 
207  const char* lPath() const;
208 
209  std::string& GetLocalPath() { return m_filename; }
210 
213 
214  long long GetFileSize() { return m_fileSize; }
215 
216  void AddIO(IO *io);
219  void RemoveIO(IO *io);
220 
221  //========================================================================
222  // The following methods are called under Cache's m_active lock
223  //========================================================================
224 
225  int get_ref_cnt() { return m_ref_cnt; }
226  int inc_ref_cnt() { return ++m_ref_cnt; }
227  int dec_ref_cnt() { return --m_ref_cnt; }
228 
231 
232 private:
234 
235  int m_ref_cnt;
236 
237  bool m_is_open;
239 
243 
244  std::string m_filename;
245  long long m_offset;
246  long long m_fileSize;
247 
248  // IO objects attached to this file.
249 
250  struct IODetails
251  {
255 
257  };
258 
259  typedef std::map<IO*, IODetails> IoMap_t;
260  typedef IoMap_t::iterator IoMap_i;
261 
265 
266  // fsync
267  std::vector<int> m_writes_during_sync;
269  bool m_in_sync;
270 
271  typedef std::list<int> IntList_t;
272  typedef IntList_t::iterator IntList_i;
273 
274  typedef std::list<Block*> BlockList_t;
275  typedef BlockList_t::iterator BlockList_i;
276 
277  typedef std::map<int, Block*> BlockMap_t;
278  typedef BlockMap_t::iterator BlockMap_i;
279 
280 
282 
284 
286 
288 
291  float m_prefetchScore; // cached
292 
294 
295  static const char *m_traceID;
296  bool overlap(int blk, // block to query
297  long long blk_size, //
298  long long req_off, // offset of user request
299  int req_size, // size of user request
300  // output:
301  long long &off, // offset in user buffer
302  long long &blk_off, // offset in block
303  long long &size);
304 
305  // Read
306  Block* PrepareBlockRequest(int i, IO *io, bool prefetch);
307 
308  void ProcessBlockRequest (Block *b, bool prefetch);
309  void ProcessBlockRequests(BlockList_t& blks, bool prefetch);
310 
312  char* buff, long long req_off, long long req_size);
313 
315  char* req_buf, long long req_off, long long req_size);
316 
317  // VRead
318  bool VReadValidate (const XrdOucIOVec *readV, int n);
319  void VReadPreProcess (IO *io, const XrdOucIOVec *readV, int n,
320  BlockList_t& blks_to_request,
321  ReadVBlockListRAM& blks_to_process,
322  ReadVBlockListDisk& blks_on_disk,
323  std::vector<XrdOucIOVec>& chunkVec);
324  int VReadFromDisk (const XrdOucIOVec *readV, int n,
325  ReadVBlockListDisk& blks_on_disk);
326  int VReadProcessBlocks(IO *io, const XrdOucIOVec *readV, int n,
327  std::vector<ReadVChunkListRAM>& blks_to_process,
328  std::vector<ReadVChunkListRAM>& blks_rocessed);
329 
330  long long BufferSize();
331 
335 
337 
338  int offsetIdx(int idx);
339 };
340 
341 }
342 
343 #endif
XrdClXRootDResponses.hh
XrdFileCache::File::IoMap_t
std::map< IO *, IODetails > IoMap_t
Definition: XrdFileCacheFile.hh:259
XrdFileCache::File::m_filename
std::string m_filename
filename of data file on disk
Definition: XrdFileCacheFile.hh:244
XrdOucCache2.hh
XrdFileCache::Block::set_error
void set_error(int err)
Definition: XrdFileCacheFile.hh:90
XrdFileCache::File::IntList_i
IntList_t::iterator IntList_i
Definition: XrdFileCacheFile.hh:272
XrdFileCache::File::Prefetch
void Prefetch()
XrdFileCache::BlockResponseHandler::BlockResponseHandler
BlockResponseHandler(Block *b, bool prefetch)
Definition: XrdFileCacheFile.hh:107
XrdFileCache::File::IODetails::m_allow_prefetching
bool m_allow_prefetching
Definition: XrdFileCacheFile.hh:253
XrdFileCache::Info
Status of cached file. Can be read from and written into a binary file.
Definition: XrdFileCacheInfo.hh:49
XrdFileCache::File::m_downloadCond
XrdSysCondVar m_downloadCond
Definition: XrdFileCacheFile.hh:283
XrdFileCache::File::ReadV
int ReadV(IO *io, const XrdOucIOVec *readV, int n)
Vector read from disk if block is already downloaded, else ReadV from client.
XrdFileCache::Block::Block
Block(File *f, IO *io, long long off, int size, bool m_prefetch)
Definition: XrdFileCacheFile.hh:72
XrdFileCache::File::kHold
@ kHold
Definition: XrdFileCacheFile.hh:233
XrdSysCondVarHelper
Definition: XrdSysPthread.hh:130
XrdFileCache::Block::get_size
int get_size()
Definition: XrdFileCacheFile.hh:80
XrdFileCache::File::GetPrefetchScore
float GetPrefetchScore() const
XrdFileCache::File::GetTrace
XrdSysTrace * GetTrace()
XrdFileCache::Block
Definition: XrdFileCacheFile.hh:60
XrdFileCache::File::VReadPreProcess
void VReadPreProcess(IO *io, const XrdOucIOVec *readV, int n, BlockList_t &blks_to_request, ReadVBlockListRAM &blks_to_process, ReadVBlockListDisk &blks_on_disk, std::vector< XrdOucIOVec > &chunkVec)
XrdFileCache::File::inc_ref_count
void inc_ref_count(Block *)
XrdFileCache::File::select_current_io_or_disable_prefetching
bool select_current_io_or_disable_prefetching(bool skip_current)
XrdFileCache::File::IoMap_i
IoMap_t::iterator IoMap_i
Definition: XrdFileCacheFile.hh:260
XrdFileCache::File::m_offset
long long m_offset
offset of cached file for block-based / hdfs operation
Definition: XrdFileCacheFile.hh:245
XrdFileCache::DirectResponseHandler::is_ok
bool is_ok()
Definition: XrdFileCacheFile.hh:125
XrdFileCache::File::m_current_io
IoMap_i m_current_io
IO object to be used for prefetching.
Definition: XrdFileCacheFile.hh:263
XrdFileCache::File::offsetIdx
int offsetIdx(int idx)
XrdFileCache::BlockResponseHandler::Done
virtual void Done(int result)
XrdFileCache::Block::m_io
IO * m_io
Definition: XrdFileCacheFile.hh:65
XrdFileCache::File::RequestBlocksDirect
int RequestBlocksDirect(IO *io, DirectResponseHandler *handler, IntList_t &blocks, char *buff, long long req_off, long long req_size)
XrdFileCache::File::m_fileSize
long long m_fileSize
size of cached disk file for block-based operation
Definition: XrdFileCacheFile.hh:246
XrdFileCache::File::ProcessBlockResponse
void ProcessBlockResponse(BlockResponseHandler *brh, int res)
XrdFileCache::File
Definition: XrdFileCacheFile.hh:134
XrdFileCache::File::RemoveIO
void RemoveIO(IO *io)
XrdOssDF
Definition: XrdOss.hh:60
XrdFileCache::BlockResponseHandler::m_for_prefetch
bool m_for_prefetch
Definition: XrdFileCacheFile.hh:105
XrdFileCache::Stats
Statistics of disk cache utilisation.
Definition: XrdFileCacheStats.hh:31
XrdFileCache::File::ioActive
bool ioActive(IO *io)
Initiate close. Return true if still IO active. Used in XrdPosixXrootd::Close()
XrdFileCache::DirectResponseHandler::m_errno
int m_errno
Definition: XrdFileCacheFile.hh:120
XrdFileCache::File::VReadFromDisk
int VReadFromDisk(const XrdOucIOVec *readV, int n, ReadVBlockListDisk &blks_on_disk)
XrdFileCache::File::AddIO
void AddIO(IO *io)
XrdFileCache::File::PrefetchState_e
PrefetchState_e
Definition: XrdFileCacheFile.hh:233
XrdFileCache::File::IODetails::m_ioactive_false_reported
bool m_ioactive_false_reported
Definition: XrdFileCacheFile.hh:254
XrdFileCache::IO
Base cache-io class that implements XrdOucCacheIO abstract methods.
Definition: XrdFileCacheIO.hh:17
XrdFileCache::File::File
File(const std::string &path, long long offset, long long fileSize)
Constructor.
XrdFileCache::Block::is_failed
bool is_failed()
Definition: XrdFileCacheFile.hh:87
XrdFileCache::DirectResponseHandler::is_failed
bool is_failed()
Definition: XrdFileCacheFile.hh:126
XrdOucIOVec
Definition: XrdOucIOVec.hh:41
XrdFileCache::File::Open
bool Open()
Open file handle for data file and info file on local disk.
XrdFileCache::File::ProcessBlockRequests
void ProcessBlockRequests(BlockList_t &blks, bool prefetch)
XrdFileCache::Block::m_errno
int m_errno
Definition: XrdFileCacheFile.hh:68
XrdFileCache::File::m_output
XrdOssDF * m_output
file handle for data file on disk
Definition: XrdFileCacheFile.hh:240
XrdFileCache::File::dec_ref_count
void dec_ref_count(Block *)
XrdFileCache::File::VReadValidate
bool VReadValidate(const XrdOucIOVec *readV, int n)
XrdFileCache::File::initiate_emergency_shutdown
void initiate_emergency_shutdown()
XrdFileCache::File::m_non_flushed_cnt
int m_non_flushed_cnt
Definition: XrdFileCacheFile.hh:268
XrdFileCache::File::m_is_open
bool m_is_open
open state (presumably not needed anymore)
Definition: XrdFileCacheFile.hh:237
XrdFileCache::File::GetPrefetchCountOnIO
int GetPrefetchCountOnIO(IO *io)
XrdFileCache::File::m_prefetchState
PrefetchState_e m_prefetchState
Definition: XrdFileCacheFile.hh:287
XrdFileCache::File::BlockMap_i
BlockMap_t::iterator BlockMap_i
Definition: XrdFileCacheFile.hh:278
XrdFileCache::File::IntList_t
std::list< int > IntList_t
Definition: XrdFileCacheFile.hh:271
XrdFileCache::File::kStopped
@ kStopped
Definition: XrdFileCacheFile.hh:233
XrdFileCache::File::inc_ref_cnt
int inc_ref_cnt()
Definition: XrdFileCacheFile.hh:226
XrdFileCacheStats.hh
XrdFileCache::File::PrepareBlockRequest
Block * PrepareBlockRequest(int i, IO *io, bool prefetch)
XrdSysCondVar
Definition: XrdSysPthread.hh:79
XrdFileCache::File::isOpen
bool isOpen() const
Data and cinfo files are open.
Definition: XrdFileCacheFile.hh:169
XrdFileCache::File::get_ref_cnt
int get_ref_cnt()
Definition: XrdFileCacheFile.hh:225
XrdFileCache::File::m_block_map
BlockMap_t m_block_map
Definition: XrdFileCacheFile.hh:281
XrdFileCache::File::GetFileSize
long long GetFileSize()
Definition: XrdFileCacheFile.hh:214
XrdFileCache::File::IODetails::m_active_prefetches
int m_active_prefetches
Definition: XrdFileCacheFile.hh:252
XrdFileCacheInfo.hh
XrdFileCache::File::GetLocalPath
std::string & GetLocalPath()
Definition: XrdFileCacheFile.hh:209
XrdFileCache::Block::m_buff
std::vector< char > m_buff
Definition: XrdFileCacheFile.hh:62
XrdFileCache::Block::get_offset
long long get_offset()
Definition: XrdFileCacheFile.hh:81
XrdFileCache::File::m_ref_cnt
int m_ref_cnt
number of references from IO or sync
Definition: XrdFileCacheFile.hh:235
XrdFileCache
Definition: XrdFileCache.hh:40
XrdFileCache::File::RequestSyncOfDetachStats
void RequestSyncOfDetachStats()
Flags that detach stats should be written out in final sync. Called from CacheIO upon Detach.
XrdFileCache::File::~File
~File()
Destructor.
XrdFileCache::File::kOn
@ kOn
Definition: XrdFileCacheFile.hh:233
XrdOucIOVec.hh
XrdFileCache::File::m_in_shutdown
bool m_in_shutdown
file is in emergency shutdown due to irrecoverable error or unlink request
Definition: XrdFileCacheFile.hh:238
XrdFileCache::DirectResponseHandler
Definition: XrdFileCacheFile.hh:116
XrdFileCache::Block::m_offset
long long m_offset
Definition: XrdFileCacheFile.hh:63
XrdFileCache::File::overlap
bool overlap(int blk, long long blk_size, long long req_off, int req_size, long long &off, long long &blk_off, long long &size)
XrdFileCache::File::IODetails::IODetails
IODetails()
Definition: XrdFileCacheFile.hh:256
XrdFileCache::BlockResponseHandler
Definition: XrdFileCacheFile.hh:102
XrdFileCache::File::m_ios_in_detach
int m_ios_in_detach
Number of IO objects to which we replied false to ioActive() and will be removed soon.
Definition: XrdFileCacheFile.hh:264
XrdFileCache::Block::m_downloaded
bool m_downloaded
Definition: XrdFileCacheFile.hh:69
XrdFileCache::File::BlocksRemovedFromWriteQ
void BlocksRemovedFromWriteQ(std::list< Block * > &)
Handle removal of a set of blocks from Cache's write queue.
XrdFileCache::File::kComplete
@ kComplete
Definition: XrdFileCacheFile.hh:233
XrdFileCache::DirectResponseHandler::Done
virtual void Done(int result)
XrdJob
Definition: XrdJob.hh:43
XrdFileCache::File::WriteBlockToDisk
void WriteBlockToDisk(Block *b)
XrdFileCache::File::m_in_sync
bool m_in_sync
Definition: XrdFileCacheFile.hh:269
XrdFileCache::File::StopPrefetchingOnIO
void StopPrefetchingOnIO(IO *io)
XrdFileCache::File::Read
int Read(IO *io, char *buff, long long offset, int size)
Normal read.
XrdFileCache::File::free_block
void free_block(Block *)
XrdFileCache::File::ReadBlocksFromDisk
int ReadBlocksFromDisk(IntList_t &blocks, char *req_buf, long long req_off, long long req_size)
XrdFileCache::File::is_in_emergency_shutdown
bool is_in_emergency_shutdown()
Definition: XrdFileCacheFile.hh:230
XrdFileCache::File::GetStats
Stats & GetStats()
Reference to prefetch statistics.
Definition: XrdFileCacheFile.hh:197
XrdFileCache::Block::m_prefetch
bool m_prefetch
Definition: XrdFileCacheFile.hh:70
XrdFileCache::File::VReadProcessBlocks
int VReadProcessBlocks(IO *io, const XrdOucIOVec *readV, int n, std::vector< ReadVChunkListRAM > &blks_to_process, std::vector< ReadVChunkListRAM > &blks_rocessed)
XrdFileCache::Block::set_downloaded
void set_downloaded()
Definition: XrdFileCacheFile.hh:89
XrdCl
Definition: XrdClAnyObject.hh:26
XrdFileCache::File::FinalizeSyncBeforeExit
bool FinalizeSyncBeforeExit()
Returns true if any of blocks need sync. Called from Cache::dec_ref_cnt on zero ref cnt.
XrdFileCache::Block::reset_error_and_set_io
void reset_error_and_set_io(IO *io)
Definition: XrdFileCacheFile.hh:92
XrdFileCache::File::BlockList_i
BlockList_t::iterator BlockList_i
Definition: XrdFileCacheFile.hh:275
XrdFileCache::File::lPath
const char * lPath() const
Log path.
XrdClDefaultEnv.hh
XrdFileCache::File::Sync
void Sync()
Sync file cache inf o and output data with disk.
XrdFileCache::Block::m_file
File * m_file
Definition: XrdFileCacheFile.hh:64
XrdFileCache::File::m_cfi
Info m_cfi
download status of file blocks and access statistics
Definition: XrdFileCacheFile.hh:242
XrdFileCache::File::m_writes_during_sync
std::vector< int > m_writes_during_sync
Definition: XrdFileCacheFile.hh:267
XrdFileCache::File::m_infoFile
XrdOssDF * m_infoFile
file handle for data-info file on disk
Definition: XrdFileCacheFile.hh:241
XrdFileCache::File::m_detachTimeIsLogged
bool m_detachTimeIsLogged
Definition: XrdFileCacheFile.hh:293
XrdFileCache::File::GetLog
XrdSysError * GetLog()
XrdFileCache::DirectResponseHandler::m_cond
XrdSysCondVar m_cond
Definition: XrdFileCacheFile.hh:118
XrdFileCache::File::ProcessBlockRequest
void ProcessBlockRequest(Block *b, bool prefetch)
XrdFileCache::File::BlockRemovedFromWriteQ
void BlockRemovedFromWriteQ(Block *)
Handle removal of a block from Cache's write queue.
XrdFileCache::Block::is_ok
bool is_ok()
Definition: XrdFileCacheFile.hh:86
XrdFileCache::Block::is_finished
bool is_finished()
Definition: XrdFileCacheFile.hh:85
XrdFileCache::File::FileOpen
static File * FileOpen(const std::string &path, long long offset, long long fileSize)
Static constructor that also does Open. Returns null ptr if Open fails.
XrdFileCache::File::BlockList_t
std::list< Block * > BlockList_t
Definition: XrdFileCacheFile.hh:274
XrdFileCache::Block::m_refcnt
int m_refcnt
Definition: XrdFileCacheFile.hh:67
XrdFileCache::DirectResponseHandler::is_finished
bool is_finished()
Definition: XrdFileCacheFile.hh:124
XrdFileCache::File::m_io_map
IoMap_t m_io_map
Definition: XrdFileCacheFile.hh:262
XrdOucCacheIOCB
Definition: XrdOucCache.hh:94
XrdFileCache::File::m_prefetchHitCnt
int m_prefetchHitCnt
Definition: XrdFileCacheFile.hh:290
XrdFileCache::File::BufferSize
long long BufferSize()
XrdFileCache::File::m_traceID
static const char * m_traceID
Definition: XrdFileCacheFile.hh:295
XrdFileCache::File::kOff
@ kOff
Definition: XrdFileCacheFile.hh:233
XrdFileCache::File::dec_ref_cnt
int dec_ref_cnt()
Definition: XrdFileCacheFile.hh:227
XrdSysError
Definition: XrdSysError.hh:90
XrdSysTrace
Definition: XrdSysTrace.hh:49
XrdFileCache::File::m_prefetchScore
float m_prefetchScore
Definition: XrdFileCacheFile.hh:291
XrdFileCache::Block::get_io
IO * get_io() const
Definition: XrdFileCacheFile.hh:83
XrdFileCache::BlockResponseHandler::m_block
Block * m_block
Definition: XrdFileCacheFile.hh:104
XrdFileCache::File::m_prefetchReadCnt
int m_prefetchReadCnt
Definition: XrdFileCacheFile.hh:289
XrdFileCache::File::BlockMap_t
std::map< int, Block * > BlockMap_t
Definition: XrdFileCacheFile.hh:277
XrdFileCache::File::m_stats
Stats m_stats
cache statistics, used in IO detach
Definition: XrdFileCacheFile.hh:285
XrdFileCache::DirectResponseHandler::DirectResponseHandler
DirectResponseHandler(int to_wait)
Definition: XrdFileCacheFile.hh:122
XrdFileCache::Block::get_buff
char * get_buff(long long pos=0)
Definition: XrdFileCacheFile.hh:79
XrdFileCache::File::IODetails
Definition: XrdFileCacheFile.hh:251
XrdFileCache::DirectResponseHandler::m_to_wait
int m_to_wait
Definition: XrdFileCacheFile.hh:119