LLVM 17.0.0git
Caching.h
Go to the documentation of this file.
1//===- Caching.h - LLVM Local File Cache ------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the CachedFileStream and the localCache function, which
10// simplifies caching files on the local filesystem in a directory whose
11// contents are managed by a CachePruningPolicy.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_SUPPORT_CACHING_H
16#define LLVM_SUPPORT_CACHING_H
17
18#include "llvm/Support/Error.h"
19
20namespace llvm {
21
22class MemoryBuffer;
23
24/// This class wraps an output stream for a file. Most clients should just be
25/// able to return an instance of this base class from the stream callback, but
26/// if a client needs to perform some action after the stream is written to,
27/// that can be done by deriving from this class and overriding the destructor.
29public:
30 CachedFileStream(std::unique_ptr<raw_pwrite_stream> OS,
31 std::string OSPath = "")
32 : OS(std::move(OS)), ObjectPathName(OSPath) {}
33 std::unique_ptr<raw_pwrite_stream> OS;
34 std::string ObjectPathName;
35 virtual ~CachedFileStream() = default;
36};
37
38/// This type defines the callback to add a file that is generated on the fly.
39///
40/// Stream callbacks must be thread safe.
41using AddStreamFn = std::function<Expected<std::unique_ptr<CachedFileStream>>(
42 unsigned Task, const Twine &ModuleName)>;
43
44/// This is the type of a file cache. To request an item from the cache, pass a
45/// unique string as the Key. For hits, the cached file will be added to the
46/// link and this function will return AddStreamFn(). For misses, the cache will
47/// return a stream callback which must be called at most once to produce
48/// content for the stream. The file stream produced by the stream callback will
49/// add the file to the link after the stream is written to. ModuleName is the
50/// unique module identifier for the bitcode module the cache is being checked
51/// for.
52///
53/// Clients generally look like this:
54///
55/// if (AddStreamFn AddStream = Cache(Task, Key, ModuleName))
56/// ProduceContent(AddStream);
57using FileCache = std::function<Expected<AddStreamFn>(
58 unsigned Task, StringRef Key, const Twine &ModuleName)>;
59
60/// This type defines the callback to add a pre-existing file (e.g. in a cache).
61///
62/// Buffer callbacks must be thread safe.
63using AddBufferFn = std::function<void(unsigned Task, const Twine &ModuleName,
64 std::unique_ptr<MemoryBuffer> MB)>;
65
66/// Create a local file system cache which uses the given cache name, temporary
67/// file prefix, cache directory and file callback. This function does not
68/// immediately create the cache directory if it does not yet exist; this is
69/// done lazily the first time a file is added. The cache name appears in error
70/// messages for errors during caching. The temporary file prefix is used in the
71/// temporary file naming scheme used when writing files atomically.
73 const Twine &CacheNameRef, const Twine &TempFilePrefixRef,
74 const Twine &CacheDirectoryPathRef,
75 AddBufferFn AddBuffer = [](size_t Task, const Twine &ModuleName,
76 std::unique_ptr<MemoryBuffer> MB) {});
77} // namespace llvm
78
79#endif
This class wraps an output stream for a file.
Definition: Caching.h:28
CachedFileStream(std::unique_ptr< raw_pwrite_stream > OS, std::string OSPath="")
Definition: Caching.h:30
std::string ObjectPathName
Definition: Caching.h:34
virtual ~CachedFileStream()=default
std::unique_ptr< raw_pwrite_stream > OS
Definition: Caching.h:33
Tagged union holding either a T or a Error.
Definition: Error.h:470
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::function< void(unsigned Task, const Twine &ModuleName, std::unique_ptr< MemoryBuffer > MB)> AddBufferFn
This type defines the callback to add a pre-existing file (e.g.
Definition: Caching.h:64
std::function< Expected< std::unique_ptr< CachedFileStream > >(unsigned Task, const Twine &ModuleName)> AddStreamFn
This type defines the callback to add a file that is generated on the fly.
Definition: Caching.h:42
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1862
std::function< Expected< AddStreamFn >(unsigned Task, StringRef Key, const Twine &ModuleName)> FileCache
This is the type of a file cache.
Definition: Caching.h:58
Expected< FileCache > localCache(const Twine &CacheNameRef, const Twine &TempFilePrefixRef, const Twine &CacheDirectoryPathRef, AddBufferFn AddBuffer=[](size_t Task, const Twine &ModuleName, std::unique_ptr< MemoryBuffer > MB) {})
Create a local file system cache which uses the given cache name, temporary file prefix,...
Definition: Caching.cpp:29
Definition: BitVector.h:851