From d98208cf23ccbd057f40fd3507d097fb5536b398 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Mon, 6 May 2019 10:09:03 -0700 Subject: [PATCH 01/16] Propose an RFC for filesystem plugins under modular TensorFlow --- ...06-filesystem-plugin-modular-tensorflow.md | 1082 +++++++++++++++++ .../big_picture.png | Bin 0 -> 279758 bytes .../env.png | Bin 0 -> 76730 bytes .../filesystem.png | Bin 0 -> 138217 bytes 4 files changed, 1082 insertions(+) create mode 100644 rfcs/20190506-filesystem-plugin-modular-tensorflow.md create mode 100644 rfcs/20190506-filesystem-plugin-modular-tensorflow/big_picture.png create mode 100644 rfcs/20190506-filesystem-plugin-modular-tensorflow/env.png create mode 100644 rfcs/20190506-filesystem-plugin-modular-tensorflow/filesystem.png diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md new file mode 100644 index 000000000..e064790fd --- /dev/null +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -0,0 +1,1082 @@ +# Modular Filesystems C API + +| Status | Proposed | +:-------------- |:---------------------------------------------------- | +| **Author(s)** | Mihai Maruseac (mihaimaruseac@google.com) | +| **Sponsor** | Gunhan Gulsoy (gunan@google.com) | +| **Updated** | 2019-05-06 | + +## Abstract + +TensorFlow has grown large since its introduction and we are currently working +on ensuring a better development workflow by a team-wide effort designed to make +TensorFlow more modular according to the [current RFC][modular_rfc]. + +A major module of the modular TensorFlow involves all operations regarding files +and the filesystem. Saving models, checkpointing, reading files as input to +models (i.e. images, audio, etc.), and many other file manipulations are all +tasks that TensorFlow has to support. + +While users can use the underlying operating system’s API (such as calling fopen +and friends on Posix environments, for example), it is definitely better to have +a cross-platform, cross-environment API that can be used everywhere. TensorFlow +provides such an API at the moment but it results in compiling code for all +known filesystems in the final binary. We propose a new design where all +filesystems are implemented as plugins and only the required ones are added at +runtime. To do so, we will first need to design a C API for the filesystems and +then integrate this with the rest of the modularization effort. + +In a nutshell, the proposed API uses several data structures of function +pointers to mimic the current class-based API. Every plugin will fill in the +appropriate fields of these data structures during registration. When doing a +filesystem operation, core TensorFlow identifies the plugin/filesystem needed to +implement the operation, reads the function pointer from the corresponding table +and executes it. This way, we are able to offer support for all kinds of files, +including memory mapped files, remote files, compressed files or filesystem with +specific rules. + +The rest of the document presents a set of requirements that this design tries +to satisfy, a (somewhat very detailed) overview of the existing implementation, +the proposed changes and estimates on the amount of work needed to integrate +this design with TensorFlow code. + +## Requirements + +Moving to a modular design adds several new requirements to the design, as we +want to prevent code from one plugin to interfere with code from another plugin +or the core TensorFlow. As such, here are a few requirements that we think are +needed: + +1. Once a plugin is registered, the function pointer to plugin provided + implementation should never change. Since unloading shared libraries after + code from them has been run can lead to bad behavior (resource leaks, copies + of pointers to functions within the library, object size mismatches, etc.) we + will not attempt to deregister/unload plugins. + +1. Interface between TensorFlow and plugins must be as simple as possible as + well as thoroughly tested. It is better to localize errors in either + TensorFlow core or the plugin providing the filesystem functionality than in + the glue code between the two. + +1. Plugin registration should support mandatory metadata such as version + numbers, checks for backwards and forwards compatibility as well as optional + fields such as author information, bug reporting URL, etc. + +1. The mandatory metadata must guarantee _binary compatibility_: allow plugins + built at one version of TensorFlow core to be loaded by a range of TensorFlow + core versions, provided tests for API compatibility based on version metadata + pass. + +1. Furthermore, it is ideal to have compilation failures when trying to compile + plugins against an old API interface which will surely fail the version + metadata tests. When that is not possible we should give users good error + messages at runtime. In other words, _source compatibility_ is guaranteed + only as best effort. + +1. We should minimize the number of times we need to cross module boundaries to + implement a filesystem functionality. Each time the boundary is crossed we + have to do conversions from C++ types to C types and back and that incurs + some performance costs. + +1. The API should provide some _type safety_, to ensure that plugin operations + only act upon data structures that they should work on. Thus, instead of + using opaque `void*` pointers, we will need to differentiate between the + structures being operated on. We do this by having data structures which just + wrap around these opaque pointers. These structures will only have one + `void*` field. + +1. We should provide a way for plugins to register that they don’t support some + functionality, either because it doesn’t make sense for the specific plugin + or because of compatibility reasons. + +1. We should have a minimal amount of allocation at the boundary between plugins + and core TensorFlow. Most of the memory should either be owned by TensorFlow + or by the plugin and the only transfer between these should happen when + reading/writing files as well as in converting from C++ types to C types + (e.g. marshalling from `string` to `char*`) + +1. The proposed API should minimize the amount of sweeping changes that need to + happen on TensorFlow code. Ideally, we should allow some period of time when + both plugins and the existing filesystem implementation will be present in + the code, allowing users to gradually shift towards the new design. + Fortunately, the proposed design allows for transparently rewriting the + current C++ APIs, causing minimal disruption. + +1. Although this design is mostly about C++ implementation, we should ensure + Python code and other language bindings will be able to continue working with + the modular design. + +## Existing implementation + +The existing implementation of a filesystem support in TensorFlow is hairy, due +to the complexity of operations that needs to be provided. This section is an +overview of the existing architecture. + +In short summary, TensorFlow’s support for filesystems can be decomposed into 3 +types of API: + +* Low level API mainly focused on offering interfaces to hide complexity and + provide cross-platform compatibility; +* Convenience API providing functions to read/write files in a generic way as + well as providing support for compressed data and for buffered I/O; +* High level API which offers functionality needed by the kernels, ops and other + utilities. + +Furthermore, the codebase has some additional methods to access the filesystem. +These are used sporadically in some kernels and ops or for special cases such as +very special filesystems or test environments. We can translate these additional +APIs to use the design presented here, unifying API all across the codebase. + +![Filesystem layers](20190502-filesystem-plugin-modular-tensorflow/big_picture.png "Overview of filesystem support") + +This diagram illustrates this decomposition. Classes are full gray rectangles, +interfaces are blue shaded ones and functions are rectangles with a dashed +border. Arrows represent inheritance and the line between `Env` and `FileSystem` +illustrates the coupling between these two structures as will be described in +the next subsection. + +### Low level filesystem API + +The low-level filesystem API in TensorFlow guarantees the same interface both +across multiple operating systems as well as across multiple filesystems hiding +the complexities arising from the differences between these platforms. Thus, +there are two different things that need consideration: implementing a new +filesystem and making it accessible for each operating system (i.e. +registering). + +#### The filesystem implementation + +A new filesystem is currently implemented by subclassing 4 interfaces: one for +the filesystem operation ([`FileSystem`][class FileSystem]), two for the file +operations ([`RandomAccessFile`][class RandomAccessFile], [`WritableFile`][class +WritableFile]) and one for read only memory mapped files +([`ReadOnlyMemoryRegion`][class ReadOnlyMemoryRegion]). + +The `Filesystem` interface is needed to define common functionality to create or +delete files and directories as well as manipulating directory contents and +getting information about files present on a filesystem: listing directory +contents, getting statistics about files and finding paths matching a globbing +pattern. + +```cpp +class Filesystem { + // File creation + virtual Status NewRandomAccessFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewWritableFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewAppendableFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewReadOnlyMemoryRegionFromFile(const string& fname, std::unique_ptr* result) = 0; + + // Creating directories + virtual Status CreateDir(const string& dirname) = 0; + virtual Status RecursivelyCreateDir(const string& dirname); + + // Deleting + virtual Status DeleteFile(const string& fname) = 0; + virtual Status DeleteDir(const string& dirname) = 0; + virtual Status DeleteRecursively(const string& dirname, int64* undeleted_files, int64* undeleted_dirs); + + // Changing directory contents + virtual Status RenameFile(const string& src, const string& target) = 0; + virtual Status CopyFile(const string& src, const string& target); + + // Filesystem information + virtual Status FileExists(const string& fname) = 0; + virtual bool FilesExist(const std::vector& files, std::vector* status); + virtual Status GetChildren(const string& dir, std::vector* result) = 0; + virtual Status Stat(const string& fname, FileStatistics* stat) = 0; + virtual Status IsDirectory(const string& fname); + virtual Status GetFileSize(const string& fname, uint65* file_size) = 0; + + // Globbing + virtual Status GetMatchingPaths(const string& pattern, std::vector* results) = 0; + + // Misc + virtual void FlushCaches(); + virtual string TranslateName(const string& name) const; +}; +``` + +In TensorFlow, files are identified by a URI of form +`[://[]]`. Because sometimes we only need the filename +part, the FileSystem API defines `TranslateName()` which also ensures that paths +are canonical, properly resolving `.` and `..` entries that might be present in +the path. Although filesystems can reimplement this, by default +[`tensorflow::lib::io::CleanPath()`][CleanPath] is used. + +The default `CopyFile()` implementation just calls the +[`FileSystemCopyFile()`][FileSystemCopyFile] helper method using the same +`FileSystem` argument for both source and target. + +The [`FileStatistics`][class FileStatistics] class is just a value class +containing information related to a dentry: + +```cpp +class FileStatistics { + int64 length = -1; + int64 mtime_nsec = 0; + bool is_directory = false; +}; +``` + +There is also a [`TF_FileStatistics`][struct TF_FileStatistics] data structure +used by the C API. Both have the same values but the `TF_FileStatistics` +structure doesn’t have constructors/destructors as it has to be pure C. + +The other 3 interfaces that need to be subclassed to get a functional filesystem +are simple: + +```cpp +class RandomAccessFile { + virtual Status Name(StringPiece* result) const; + virtual Status Read(uint64 offset, size_t n, StringPiece* result, char* scratch) const = 0; +}; + +class WritableFile { + virtual Status Name(StringPiece* result) const; + virtual Status Append(StringPiece data) = 0; + virtual Status Append(const absl::Cord& cord); + virtual Status Tell(int64* position); + virtual Status Close() = 0; + virtual Status Flush() = 0; + virtual Status Sync() = 0; +}; + +class ReadOnlyMemoryRegion { + virtual const void* data() = 0; + virtual uint64 length() = 0; +}; +``` + +Once these 4 interfaces are implemented, we have a fully functioning filesystem +at the lowest API level. Each such filesystem can be tested in isolation from +the rest of TensorFlow. + +If a filesystem doesn’t support one of the file types, then we don’t need to +implement the corresponding interface. Instead, the method creating the file of +that type can just error, as in this +[HadoopFileSystem][HadoopFileSystem] example. + +There are multiple filesystems supported by TensorFlow, some of which are +present in the next diagram: + +![Example filesystems](20190502-filesystem-plugin-modular-tensorflow/filesystem.png "Example filesystems") + +#### Cross operating system compatibility + +The operating system compatibility is ensured by the [`Env`][class Env] +interface. This contains API calls used to access functionality that depends on +the platform the process runs on: threading, clock information, loading dynamic +libraries and filesystem methods. We will focus only on the latter in this +document. As the number of environments is usually very small, we can achieve +minimal code by using preprocessor guards and compiling only for one platform. +Alternatively, we can have a similar design as this one and create plugins for +each operating system, although this will require additional work in defining +interfaces and versioning and won’t bring much benefit over the preprocessor +macros approach. + +Restricting only to the filesystem related API, the `Env` interface looks like +the following code snippet: + +```cpp +class Env { + // Filesystem registration + virtual Status GetFileSystemForFile(const string& fname, FileSystem** result); + virtual Status GetRegisteredFileSystemSchemes(std::vector* schemes); + virtual Status RegisterFileSystem(const string& scheme, FileSystemRegistry::Factory factory); + + // Creating files, including memory mapped + Status NewRandomAccessFile(const string& fname, std::unique_ptr* result); + Status NewWritableFile(const string& fname, std::unique_ptr* result); + Status NewAppendableFile(const string& fname, std::unique_ptr* result); + Status NewReadOnlyMemoryRegionFromFile(const string& fname, std::unique_ptr* result); + + // Creating directories + Status CreateDir(const string& dirname); + Status RecursivelyCreateDir(const string& dirname); + + // Deleting + Status DeleteFile(const string& fname); + Status DeleteDir(const string& dirname); + Status DeleteRecursively(const string& dirname, int64* undeleted_files, int64* undeleted_dirs); + + // Changing directory contents + Status RenameFile(const string& src, const string& target); + Status CopyFile(const string& src, const string& target); + + // Filesystem information + Status FileExists(const string& fname); + bool FilesExist(const std::vector& files, std::vector* status); + Status GetChildren(const string& dir, std::vector* result); + Status Stat(const string& fname, FileStatistics* stat); + Status IsDirectory(const string& fname); + Status GetFileSize(const string& fname, uint64* file_size); + + // Globbing + virtual bool MatchPath(const string& path, const string& pattern) = 0; + virtual Status GetMatchingPaths(const string& pattern, std::vector* results); + + // Misc + Status FlushFileSystemCaches(); + string GetExecutablePath(); + virtual string GetRunfilesDir() = 0; + bool LocalTempFilename(string* filename); + bool CreateUniqueFileName(string* prefix, const string& suffix); + virtual void GetLocalTempDirectories(std::vector* list) = 0; + static Env* Default(); + + // Other methods of the class, not relevant here +}; +``` + +Each process accesses the environment by calling the static `Env::Default()` +method and then gains access to all the functionality that depends on the +operating system. Then, to operate on the filesystem, any process will either +use the methods provided by the `Env` API or those of the `FileSystem` object +obtained from `GetFileSystemForFile()`. In fact, most of the default +implementations of the methods above use `GetFileSystemForFile()` and then +delegate to the filesystem. + +Note that in the case of `RenameFile()` and `CopyFile()` the target and the +source files might be in a different filesystem. Renaming results in an error +(as it is currently not implemented), whereas copying is done via the +`FileSystemCopyFile()` helper introduced in the previous section. + +The `GetMatchingPaths()` call can be used to identify all paths in the current +filesystem that match a specific pattern. The default implementation uses +[`GetMatchingPaths()`][GetMatchingPaths]: + +The following diagram shows several of the implementations of the `Env` +interface: + +![Example environments](20190502-filesystem-plugin-modular-tensorflow/env.png "Example environments") + +#### Registering a filesystem to the environment + +In order to access a filesystem via `GetFileSystemForFile()`, first it has to be +registered to the environment. This can be done via `RegisterFileSystem()` but +it is preferable to use the [`REGISTER_FILE_SYSTEM(scheme, +factory)`][REGISTER_FILE_SYSTEM] macro instead, where `factory` is an empty +constructor of a subclass of `FileSystem` and `scheme` is the URI scheme needed +to access the file. Any filesystem call using `scheme` in the URI will then get +handled by the subclass used for registration. + +Filesystems are registered into a [`FileSystemRegistry`][class +FileSystemRegistry], which is semantically equivalent to a map from file scheme +to filesystem. Since this has to be unique over the lifetime of the program, the +interface is [opaque outside of Env][FileSystemRegistry init]. + +```cpp +class FileSystemRegistry { + typedef std::function Factory; + virtual Status Register(const string& scheme, Factory factory) = 0; + virtual FileSystem* Lookup(const string& scheme) = 0; + virtual Status GetRegisteredFileSystemSchemes(std::vector* schemes) = 0; +}; +``` + +### Convenience API + +All the functionality presented until this point is enough to transparently +operate with files across filesystems and operating systems. However, each such +operation requires getting the environment via Env::Default() then accessing the +needed functionality from a method of that class. This quickly becomes +repetitive, so TensorFlow has some convenience API that can be used. For +example, there are these helper methods: + +```cpp +Status ReadFileToString(Env* env, const string& fname, string* data); +Status ReadBinaryProto(Env* env, const string& fname, MessageLite* proto); +Status ReadTextProto(Env* env, const string& fname, protobuf::Message* proto); + +Status WriteStringToFile(Env* env, const string& fname, const StringPiece& data); +Status WriteBinaryProto(Env* env, const string& fname, const protobuf::MessageLite& proto); +Status WriteTextProto(Env* env, const string& fname, const protobuf::Message& proto); +``` + +#### Buffered (streaming) support + +Furthermore, as some files can be large, we need a way to stream the data from +them. There are several options that we can use: + +An [`InputBuffer`][class InputBuffer] is a buffer on top of a RandomAccessFile +passed to the constructor. Its API is simple: + +```cpp +class InputBuffer { + Status ReadLine(string* result); + Status ReadNBytes(int64 bytes_to_read, string* result); + Status ReadNBytes(int64 bytes_to_read, char* result, size_t* read); + Status ReadVarint32(uint32* result); + Status ReadVarint64(uint64* result); + Status SkipNBytes(int64 bytes_to_skip); + Status Seek(int64 position); + int64 Tell() const; +}; +``` + +However, the `InputBuffer` interface is too tied to a `RandomAccessFile` and +thus it is only being used in one place, by the `TextLineReaderOp` kernel. + +A replacement method is provided by [`InputStreamInterface`][class +InputStreamInterface]: + +```cpp +class InputStreamInterface { + virtual Status ReadNBytes(int64 bytes_to_read, string* result) = 0; + virtual Status SkipNBytes(int64 bytes_to_skip); + virtual int64 Tell() const = 0; + virtual Status Reset() = 0; +}; +``` + +A [`RandomAccessInputStream`][class RandomAccessInputStream] object is an +`InputStreamInterface` object which wraps a `RandomAccessFile`. To provide more +functionality (e.g., `ReadLine()`, `Seek()`), this can be wrapped by a +[`BufferedInputStream`][class BufferedInputStream]. + +#### File compression APIs + +Another descendant of `InputStreamInterface` is [`MemoryInputStream`][class +MemoryInputStream] which wraps a memory buffer and is used in +`DecodeCompressedOp`. This doesn’t use filesystem operations, although it can be +implemented in terms of `ReadOnlyMemoryRegion` if needed. + +There are two more relevant compression APIs built from `InputStreamInterface`. +First, [`SnappyInputBuffer`][class SnappyInputBuffer] provides access to files +compressed using Snappy and represented as `RandomAccessFile` objects. There is +also a [`SnappyOutputBuffer`][class SnappyOutputBuffer] class to write +compressed input, but there is no `OutputStreamInterface`. + +The second compression API is given by [`ZlibInputStream`][class +ZlibInputStream]. Similar to the `RandomAccessInputStream` case, this just wraps +an `InputStreamInterface`. To write to compressed zlib files, we can use +[`ZlibOutputBuffer`][class ZlibOutputBuffer] to wrap around a `WritableFile`. + +### High level filesystem API + +Building on top of the convenience API, TensorFlow code has several custom +classes and helpers to provide high level access to the filesystem. + +For example `tf.data` uses `TFRecord` support provided by [`RecordReader`][class +RecordReader], [`RecordWriter`][class RecordWriter] and +[`SequentialRecordReader`][class SequentialRecordReader] to build the +[`FileDataset`][class FileDataset] and [`FileIterator`][class FileIterator] +abstractions (and subclasses such as [`FileWriterIterator`][class +FileWriterIterator], [`FileReaderIterator`][class FileReaderIterator]). Then, +kernels and ops such as [`TextLineDatasetOp`][class TextLineDatasetOp] and +[`TFRecordDatasetOp`][class TFRecordDatasetOp] are built and then used in Python +APIs. + +Other examples include: + +* [`DumpGraphDefToFile`][DumpGraphDefToFile], + [`DumpGraphToFile`][DumpGraphToFile], + [`DumpFunctionDefToFile`][DumpFunctionDefToFile]; +* [`Table`][class Table] - immutable mapping from strings to strings backed up + by a file; +* [`BundleWriter`][class BundleWriter], [`BundleReader`][class BundleReader] - + checkpointing; +* [`TensorSliceWriter`][class TensorSliceWriter], [`TensorSliceReader`][class + TensorSliceReader] - checkpointing partitioned variables; +* [`LoadSavedModel`][LoadSavedModel] - `SavedModel` loading; +* [`EventsWriter`][class EventsWriter]; +* [`DebugFileIO`][class DebugFileIO]; +* API generation tools inside TensorFlow. + +### Additional APIs + +For some special cases or due to historical reasons, TensorFlow has a set of +filesystem APIs which cannot be directly mapped on the hierarchy described so +far. We will mention them here for completeness, but it turns out we can either +ignore them for the rest of the design as they don’t require many changes. + +#### `FileBlockCache` + +The [`FileBlockCache`][class FileBlockCache] class can be used by filesystems to +cache files at the block level. Each entry in the cache is keyed by the filename +and the offset of the block in the file. Filesystem implementations are free to +ignore this class, but we’re mentioning it in this document as it is being used +by the cloud filesystems. + +In the new filesystem design, filesystems needing this functionality can just +import the corresponding targets. Since this is an implementation detail, the +caching information doesn’t need to cross the module boundary. + +#### `ReaderInterface` + +The [`ReaderInterface`][class ReaderInterface] and its subclasses provides an +alternative method of reading records from files in a TensorFlow graph. It has +the following API: + +```cpp +class ReaderInterface : public ResourceBase { + // Reads one single record + virtual void Read(QueueInterface* queue, string* key, string* value, OpKernelContext* context) = 0; + // Reads up to num_records + virtual int64 ReadUpTo(const int64 num_records, QueueInterface* queue, std::vector* keys, std::vector* values, OpKernelContext* context) = 0; + + // Misc + virtual Status Reset() = 0; + virtual int64 NumRecordsProduced() = 0; + virtual Status SerializeState(string* state) = 0; + virtual Status RestoreState(const string& state) = 0; +}; +``` + +The only subclass in TensorFlow is [`ReaderBase`][class ReaderBase], which adds +API entry-points for reading while a mutex is being held: + +```cpp +class ReaderBase : public ReaderInterface { + virtual Status ReadLocked(string* key, string* value, bool* produced, bool* at_end) = 0; + virtual Status ReadUpToLocked(int64 num_records, std::vector* keys, std::vector* values, int64* num_read, bool* at_end); +}; +``` + +In this subclass, the `Read()` and `ReadUpTo()` methods are implemented in terms +of their corresponding locked methods. Furthermore, descendants of this class +only need to implement `ReadLocked()`, the only pure virtual member of the API. + +Currently, there are 7 descendants of `ReaderBase` and they are used to +implement kernels and ops. All of these kernels inherit from +[`ReaderOpKernel`][class ReaderOpKernel] which handles access to the source to +be read from. Whereas [`TextLineReader`][class TextLineReader], +[`TFRecordReader`][class TFRecordReader] and [`WholeFileReader`][class +WholeFileReader] access the filesystem using the environment approach +illustrated above, the other subclasses either work with in-memory data +([`IdentityReader`][class IdentityReader], [`LMDBReader`][class LMDBReader]), +with data obtained from a remote call ([`BigQueryReader`][class BigQueryReader]) +or with data that is read using the `InputStreamInterface` mechanism described +previously ([`FixedLengthRecordReader`][class FixedLengthRecordReader]). + +In the modular design, most of these descendants will be converted for free. The +only class that might not be trivial to transfer to the new API might be +`BigQueryReader`. But, since currently it completely ignores the filesystem +APIs, we can continue with this design ignoring it for now and converting it in +the future. + +#### `SummaryWriterInterface` + +A [`SummaryWriterInterface`][class SummaryWriterInterface] allows writing +TensorFlow resources to a summary file, being a subclass of `ResourceBase`, just +like `ReaderInterface`. + +```cpp +class SummaryWriterInterface : public ResourceBase { + virtual Status Flush() = 0; + virtual Status WriteTensor(int64 global_step, Tensor t, const string& tag, const string& serialized_metadata) = 0; + virtual Status WriteScalar(int64 global_step, Tensor t, const string& tag) = 0; + virtual Status WriteHistogram(int64 global_step, Tensor t, const string& tag) = 0; + virtual Status WriteImage(int64 global_step, Tensor t, const string& tag, int max_images, Tensor bad_color) = 0; + virtual Status WriteAudio(int64 global_step, Tensor t, const string& tag, int max_outputs_, float sample_rate) = 0; + virtual Status WriteGraph(int64 global_step, std::unique_ptr graph) = 0; + virtual Status WriteEvent(std::unique_ptr e) = 0; +}; +``` + +When writing to files, we use the [`SummaryFileWriter`][class SummaryFileWriter] +subclass which uses the `Env` method. However, the other subclass, +[`SummaryDbWriter`][class SummaryDbWriter], uses an `Sqlite` object to talk to a +SQL database. Similar to the `BigQueryReader` case from the previous section, we +can postpone converting this to the new filesystem API until a later time. + +### IO from external libraries or other languages + +To provide functionality to read/write image/audio files, TensorFlow uses some +external libraries. Although they can do their own IO, there is glue code for +[gif][gif io], [jpeg][jpeg io], [png][png io] and [wav][wav io] files. This glue +ensures that the calls into the library use strings representing file contents +instead of letting the library do its own IO. This way, the filesystem support +that TensorFlow does is the only one accessing files on disk. + +However, there is nothing stopping future code development from directly reading +from a file on the disk (for example), either in the C/C++ code or in the Python +code. Preventing this is out of scope for the current design document. + +### Existing C API implementation + +There is an [existing C API for filesystems][c api] which we might reuse in this +design. We cannot build on top of this API as it only offers C entry points +which then call the existing C++ API functions. But, it gives us an indication +on what API we should provide, at the minimum: + +```cpp +typedef struct TF_FileStatistics { + int64_t length; + int64_t mtime_nsec; + bool is_directory; +} TF_FileStatistics; + +// filesystem manipulation +TF_CAPI_EXPORT extern void TF_CreateDir(const char* dirname, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteDir(const char* dirname, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteRecursively(const char* dirname, int64_t* undeleted_file_count, int64_t* undeleted_dir_count, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteFile(const char* filename, TF_Status* status); +TF_CAPI_EXPORT extern void TF_FileStat(const char* filename, TF_FileStatistics* stats, TF_Status* status); + +// writable files API +TF_CAPI_EXPORT extern void TF_NewWritableFile(const char* filename, TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_CloseWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_SyncWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_FlushWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_AppendWritableFile(TF_WritableFileHandle** handle, const char* data, size_t length, TF_Status* status); +``` + +This API is very incomplete, for example it lacks support for random access +files and memory mapped files. Furthermore, the `TF_WritableFileHandle` object +is just an opaque struct (in C-land) which maps over a `WritableFile` pointer +from the C++ implementation. + +Since this has to be pure C, Status objects are replaced by pointers to a +`TF_Status` structure. There is code to convert from one to the other. Moreover, +these APIs assume that the `TF_Status` object is created and managed from the +calling code, instead of returning the status from every function call. We will +follow a similar design in this proposal. + +## Proposed implementation + +Since the existing implementation is layered, as described above, we can focus +this design on the low level API part. Everything else can be incorporated into +the core of TensorFlow in the modular world and it should support any filesystem +in a transparent way (as long as the plugin is loaded). + +### Filesystem interface + +In this section, we present the interface that all filesystem plugins must +implement before they can be loaded and used. + +Across core-plugin boundary, we can represent open files and a filesystem as +opaque pointers (`void*`) but this results in a loss of type safety. It is easy +to imagine passing a pointer to a read only file to a method expecting to write +to such a file. To prevent this from happening, we propose the following 4 data +structures which just incorporate the `void*` pointer: + +```cpp +typedef struct TF_RandomAccessFile { + void* plugin_file; +} TF_RandomAccessFile; + +typedef struct TF_WritableFile { + void* plugin_file; +} TF_WritableFile; + +typedef struct TF_ReadOnlyMemoryRegion { + void* plugin_memory_region; +} TF_ReadOnlyMemoryRegion; + +typedef struct TF_Filesystem { + void* plugin_filesystem; +} TF_Filesystem; +``` + +The glue code between the core TensorFlow and the plugin will +allocate/deallocate these structures but they can also be allocated/deallocated +by plugins during testing, for example: + +```cpp +class PluginFilesystemIOTest : public ::testing::Test { + protected: + void SetUp() override { + filesystem_ = new TF_Filesystem; + Init(filesystem_); + status = TF_NewStatus(); + } + + void TearDown() override { + TF_DeleteStatus(status); + Cleanup(filesystem_); + delete filesystem_; + } + + TF_Filesystem* filesystem_; + TF_Status* status; +}; + +TEST_F(PluginFilesystemIOTest, TestIO) { + // ... +} +``` + +These structures are useless without operations to operate on them. We could +incorporate function pointer in the structures themselves but that will result +in a lot of duplication and object size changes when one functionality gets +added/removed. This, in turn results in compatibility being harder to maintain, +which is something we don’t want. + +Instead, we provide 3 different data structures to act as function tables, to +hold function pointers for files and the filesystem. Currently, these structures +are filled with the functionality already present in the existing filesystem +API: + +```cpp +// Operations on a TF_RandomAccessFile +typedef struct TF_RandomAccessFileOps { + size_t (*const Read)(const TF_RandomAccessFile*, uint64, size_t, char*, TF_Status*); + void (*const Cleanup)(TF_RandomAccessFile*); +} TF_RandomAccessFileOps; + +// Operations on a TF_WritableFile +typedef struct TF_WritableFileOps { + void (*const Append)(const TF_WritableFile*, const char*, size_t, TF_Status*); + void (*const Close)(TF_WritableFile*, TF_Status*); + void (*const Cleanup)(TF_WritableFile*); + // optional + int64 (*const Tell)(const TF_WritableFile*, TF_Status*); + void (*const Flush)(const TF_WritableFile*, TF_Status*); + void (*const Sync)(const TF_WritableFile*, TF_Status*); +} TF_WritableFileOps; + +// Operations on a TF_ReadOnlyMemoryRegion +typedef struct TF_ReadOnlyMemoryRegionOps { + const void* (*const Data)(const TF_ReadOnlyMemoryRegion*); + uint64 (*const Length)(const TF_ReadOnlyMemoryRegion*); + void (*const Cleanup)(TF_ReadOnlyMemoryRegion*); +} TF_ReadOnlyMemoryRegionOps; + + +// Operations on a TF_Filesystem +typedef struct TF_FilesystemOps { + void (*const NewRandomAccessFile)(const TF_Filesystem*, const char*, TF_RandomAccessFile*, TF_Status*); + void (*const NewWritableFile)(const TF_Filesystem*, const char*, TF_WritableFile*, TF_Status*); + void (*const NewAppendableFile)(const TF_Filesystem*, const char*, TF_WritableFile*, TF_Status*); + void (*const NewReadOnlyMemoryRegionFromFile)(const TF_Filesystem*, const char*, TF_ReadOnlyMemoryRegion*, TF_Status*); + + void (*const CreateDir)(const TF_Filesystem*, const char*, TF_Status*); + void (*const RecursivelyCreateDir)(const TF_Filesystem*, const char*, TF_Status*); + + void (*const DeleteFile)(const TF_Filesystem*, const char*, TF_Status*); + void (*const DeleteDir)(const TF_Filesystem*, const char*, TF_Status*); + void (*const DeleteRecursively)(const TF_Filesystem*, const char*, int64*, int64*, TF_Status*); + + void (*const RenameFile)(const TF_Filesystem*, const char*, const char*, TF_Status*); + void (*const CopyFile)(const TF_Filesystem*, const char*, const char*, TF_Status*); + + void (*const FileExists)(const TF_Filesystem*, const char*, TF_Status*); + bool (*const FilesExist)(const TF_Filesystem*, const char**, int, TF_Status**); + int (*const GetChildren)(const TF_Filesystem*, const char*, char***, TF_Status*); + + void (*const Stat)(const TF_Filesystem*, const char*, TF_FileStatistics*, TF_Status*); + void (*const IsDirectory)(const TF_Filesystem*, const char*, TF_Status*); + uint64 (*const GetFileSize)(const TF_Filesystem*, const char*, TF_Status*); + int (*const GetMatchingPaths)(const TF_Filesystem*, const char*, char***, TF_Status*); + + void (*const FlushCaches)(const TF_Filesystem*); + const char* (*const TranslateName)(const TF_Filesystem*, const char*); + + void (*const Init)(TF_Filesystem*); + void (*const Cleanup)(TF_Filesystem*); +} TF_FilesystemOps; +``` + +We also provide some convenience calls that plugins can use to fill in these +function tables, for example: + +```cpp +void FlushCaches_NoOp(const TF_Filesystem* fs); +const char* TranslateName_Identity(const TF_Filesystem* fs, const char* name); +``` + +As another benefit, having separate function tables can be checked at plugin +registration to ensure that all required functionality is present. This makes it +easier to guarantee compatibility between versions. This will be the focus of +the next section. + +### Plugin initialization and registration + +When the shared object containing the plugin is loaded the `TF_InitPlugin` +symbol is called to register the plugin: + +```cpp +TF_CAPI_EXPORT extern void TF_InitPlugin(TF_Status* status); +``` + +This function must allocate all of the above tables and then call a function +provided by the core TensorFlow to register plugin filesystems: + +```cpp +TF_CAPI_EXPORT extern void RegisterFileSystemPlugin( + const string& plugin, const string& scheme, + const TF_Filesystem_Plugin_Metadata* metadata, + const TF_FilesystemOps* filesystemOps, + const TF_RandomAccessFileOps* randomAccessFileOps, + const TF_WritableFileOps* writableFileOps, + const TF_ReadOnlyMemoryRegionOps* readOnlyMemoryRegionOps, + TF_Status* status); +``` + +The `RegisterFileSystemPlugin` call is the one place where we can check that all +required functionality is implemented, that the provided version number is +compatible with the current version of TensorFlow core, etc. Once everything is +validated, we register the new filesystem and it becomes available to the +runtime: + +```cpp +void RegisterFileSystemPlugin( + const string& plugin, const string& scheme, + const TF_Filesystem_Plugin_Metadata* metadata, + const TF_FilesystemOps* filesystemOps, + const TF_RandomAccessFileOps* randomAccessFileOps, + const TF_WritableFileOps* writableFileOps, + const TF_ReadOnlyMemoryRegionOps* readOnlyMemoryRegionOps, + TF_Status* status) { + if (!ValidateMetadata(metadata, status)) return; + if (!ValidateFilesystemOps(filesystemOps, status)) return; + if (!ValidateRandomAccessFileOps(randomAccessFileOps, status)) return; + if (!ValidateWritableFileOps(writableFileOps, status)) return; + if (!ValidateReadOnlyMemoryOps(readOnlyMemoryRegionOps, status)) return; + + // ... rest of initialization and registration +} +``` + +### Incorporating C API into filesystem classes + +To incorporate this new filesystem mechanism, we will provide new instances for +`RandomAccessFile`, `WritableFile` and `ReadOnlyMemoryRegion` classes: they need +to allocate the corresponding `TF_*` object (e.g., `TF_RandomAccessFile` for +`RandomAccessFile`). Furthermore, each of these classes will incorporate the +corresponding function table (e.g., `TF_RandomAccessFileOps` for +`RandomAccessFile`). Then, methods of these classes will just load the +corresponding function from the table and call it, marshalling arguments and +return values. For example, here is the implementation of +`ModularRandomAccessFile`: + +```cpp +class ModularRandomAccessFile : public RandomAccessFile { + public: + ModularRandomAccessFile(const string& filename, + const TF_RandomAccessFile* file, + const TF_RandomAccessFileOps* ops) + : filename_(filename), file_(file), ops_(ops) {} + virtual ~ModularRandomAccessFile() { + ops_->Cleanup(const_cast(file_)); + delete file_; + } + + Status Read(uint64 offset, size_t n, StringPiece* result, char* scratch) const; + Status Name(StringPiece* result) const; + + private: + string filename_; + const TF_RandomAccessFile* file_; + const TF_RandomAccessFileOps* ops_; + TF_DISALLOW_COPY_AND_ASSIGN(ModularRandomAccessFile); +}; + +Status ModularRandomAccessFile::Read(uint64 offset, size_t n, StringPiece* result, char* scratch) const { + TF_Status* plugin_status = TF_NewStatus(); + size_t read = ops_->Read(file_, offset, n, scratch, plugin_status); + *result = StringPiece(scratch, read); + Status status = StatusFromTF_Status(plugin_status); + TF_DeleteStatus(plugin_status); + return status; +} + +Status ModularRandomAccessFile::Name(StringPiece* result) const { + *result = filename_; + return Status::OK(); +} +``` + +Similarly, we will have to implement a subclass of the `FileSystem` class, +`ModularFileSystem`, in the same vein. + +Another change we have to do is to `FileSystemRegistry`: the `Register()` call +now uses a `unique_ptr` argument instead of the existing +`Factory`-based implementation since the constructor of `ModularFileSystem` +needs to take as argument the function tables for the operations supported by +the filesystem. + +Because of this change, we also need a new subclass of `Env`, as each instance +of `Env` has the `FileSystemRegistry` baked in at construction time. Actually, +since most of the functionality calls `Env::Default()` to obtain the static +instance of `Env` and then extract the filesystem from there, we can get rid of +the level of indirection via `Env` and create a static instance of +`ModularFileSystem`. This will be possible only after all filesystems use the +modular approach, after the changes mentioned in the next section. + +Since the function tables in the filesystem interface mention this, we will have +to move `TF_FileStatistics` from `tensorflow/c/env.h` to the same location as +the filesystem plugin interface. Then, the outer level C API can just include +this header and the structure will still be visible there. + +Once these changes are in place, the rest of the TensorFlow code can use the +modular filesystem API transparently, with no change. + +### Optional additional changes to TensorFlow C/C++ core + +Something we might elect to do is to force all future filesystem implementations +to use the plugin design suggested above. To do that, we will have to convert +all code that uses additional APIs to use this proposed API. Furthermore, we +might want to mark all filesystem classes as `final`, deprecating and removing +the current subclasses that are present in the source code, after converting +them to the modular world. This process should happen in two steps: first we +have to add deprecation warnings to the classes (printed at compile time) and +release a TensorFlow release. After that release we can convert the classes to +`final` and remove subclasses. This step will also allow us to avoid +indirections via `Env` class. + +Optionally, to not have to always translate from `TF_FileStatistics` to +`FileStatistics`, we might implement a mechanism to convert from one to the +other within as few CPU cycles as possible. + +### Python considerations + +Since these changes only happen at the very low level of the C++ TensorFlow +core, Python and other language bindings should continue to behave the same way +without any changes to the code. + +A user having a custom filesystem implementation can use it from Python by +calling [`load_library`][load_library]. When the shared library is loaded, the +plugin initialization starts, as mentioned before. Once the filesystem +implementation is available to TensorFlow core, it can also be accessed from +Python. + +## Versioning + +Since the code of a plugin can develop at a different velocity than the code of +core TensorFlow, we need to ensure backwards and forwards compatibility. Any +change in a method’s signature or reordering the methods in the `TF_*Ops` data +structures needs a new version as plugins compiled against one signature will +either crash or not load properly if core has a different interface. + +Thus, the `TF_*Ops` data structures need to record version information which is +checked at plugin loading time. For example, this is a potential implementation +of `TF_RandomAccessFileOps`, including versioning fields: + +```cpp +typedef struct TF_RandomAccessFileOps { + // these fields must always be at the beginning + const int version = 1; + // alternatively: const int size = sizeof(TF_RandomAccessFileOps); + const int num_ops = 2; + + // the real ops in the table + size_t (*const Read)(const TF_RandomAccessFile*, uint64, size_t, char*, TF_Status*); + void (*const Cleanup)(TF_RandomAccessFile*); +} TF_RandomAccessFileOps; +``` + +We will allow each structure to evolve independently. That is, the `version` +field in each one can be increased independently of the value of the field in +the other structures. + +To increase the range of compatibility, we will give a guarantee that, except on +new major versions, new methods will only be added to the end of each of these +structures and that no method will be deleted from the table. Changing the +signature of a method will be handled by adding the method with the new +signature to the end of the table and marking the old method as deprecated. + +Deprecation of a method will be done in two parts. First, we will add compiler +pragmas to warn the users compiling against the interface and relying on +deprecated methods. Second, at plugin’s registration, TensorFlow code can check +the function pointers sent by the plugin to see which ones are for deprecated +methods. In case there is any, a warning message should be printed. + +To allow both the core and the plugin to know which methods from the tables are +supported, we also add the `num_ops` field, counting how many methods are +defined in the table. This field can be used to determine the amount of +available API calls, as it is guaranteed to only increase during minor releases. +We provide a `NUM_OPS_IN_TABLE` macro to allow the compiler to set the value of +`num_ops` automatically. + +Alternatively, instead of `num_ops` field we can have a size field which is the +size of the entire structure and can be obtained via `sizeof`. The benefits of +using the `size` field is that we don’t need an additional macro but this comes +at the downside that it will be harder to determine how many methods are +available in the function table. + +Major versions of TensorFlow core allow breaking changes so we can completely +change the `TF_*Ops` data structures to remove fields which are no longer used. +We will still increase the `version` field but `num_ops` can be allowed to +decrease. + +Similar changes are needed for the metadata information of a plugin, for +example: + +```cpp +typedef struct TF_Filesystem_Plugin_Metadata { + const int version = 1; + const int num_fields = 2; + + const char* plugin_version_string; + const char* author; +} TF_Filesystem_Plugin_Metadata; +``` + +During registration we can check all of the fields and store some for later use +(e.g., for displaying better error message, localizing the plugin in error). + + + +[modular_rfc]: https://github.com/tensorflow/community/pull/77 "RFC: Modular TensorFlow" + +[class FileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L46 "class FileSystem" +[class RandomAccessFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L232 "class RandomAccessFile" +[class WritableFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L271 "class WritableFile" +[class ReadOnlyMemoryRegion]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L342 "class ReadOnlyMemoryRegion" +[class Env]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L48 "class Env" +[class FileSystemRegistry]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L360 "class FileSystemRegistry" +[class FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_statistics.h#L23 "class FileStatistics" +[struct TF_FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h#L36 "struct TF_FileStatistics" +[class InputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputbuffer.h#L32 "class InputBuffer" +[class InputStreamInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputstream_interface.h#L27 "class InputStreamInterface" +[class RandomAccessInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/random_inputstream.h#L27 "class RandomAccessInputStream" +[class BufferedInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/buffered_inputstream.h#L27 "class BufferedInputStream" +[class MemoryInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/decode_compressed_op.cc#L30 "class MemoryInputStream" +[class SnappyInputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_inputbuffer.h#L35 "class SnappyInputBuffer" +[class SnappyOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_outputbuffer.h#L46 "class SnappyOutputBuffer" +[class ZlibInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_inputstream.h#L40 "class ZlibInputStream" +[class ZlibOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_outputbuffer.h#L38i "class ZlibOutputBuffer" +[class RecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L59 "class RecordReader" +[class RecordWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_writer.h#L50 "class RecordWriter" +[class SequentialRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L120 "class SequentialRecordReader" +[class FileDataset]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L50 "class FileDataset" +[class FileIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L112 "class FileIterator" +[class FileWriterIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L195 "class FileWriterIterator" +[class FileReaderIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L439 "class FileReaderIterator" +[class TextLineDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L35 "class TextLineDatasetOp" +[class TFRecordDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L740 "class TFRecordDatasetOp" +[class Table]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/table.h#L34 "class Table" +[class BundleWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L108 "class BundleWriter" +[class BundleReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L182 "class BundleReader" +[class TensorSliceWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_writer.h#L43 "class TensorSliceWriter" +[class TensorSliceReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_reader.h#L54 "class TensorSliceReader" +[class EventsWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/events_writer.h#L31 "class EventsWriter" +[class DebugFileIO]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/debug/debug_io_utils.h#L147 "class DebugFileIO" +[class FileBlockCache]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/cloud/file_block_cache.h#L39 "class FileBlockCache" +[class ReaderInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_interface.h#L44 "class ReaderInterface" +[class ReaderBase]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_base.h#L30 "class ReaderBase" +[class ReaderOpKernel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_op_kernel.h#L35 "class ReaderOpKernel" +[class TextLineReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/text_line_reader_op.cc#L28 "class TextLineReader" +[class TFRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/tf_record_reader_op.cc#L28 "class TFRecordReader" +[class WholeFileReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/whole_file_read_ops.cc#L45 "class WholeFileReader" +[class IdentityReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/identity_reader_op.cc#L29 "class IdentityReader" +[class LMDBReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/lmdb_reader_op.cc#L27 "class LMDBReader" +[class BigQueryReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/contrib/cloud/kernels/bigquery_reader_ops.cc#L52 "class BigQueryReader" +[class FixedLengthRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/fixed_length_record_reader_op.cc#L33 "class FixedLengthRecordReader" +[class SummaryWriterInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/summary_interface.h#L30 "class SummaryWriterInterface" +[class SummaryFileWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_file_writer.cc#L30 "class SummaryFileWriter" +[class SummaryDbWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_db_writer.cc#L875 "class SummaryDbWriter" + +[CleanPath]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/path.h#L74 "tensorflow::lib::io::CleanPath()" +[FileSystemCopyFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L430 "FileSystemCopyFile()" +[GetMatchingPaths]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system_helper.h#L45 "GetMatchingPaths()" +[DumpGraphDeftoFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L36 "DumpGraphDefToFile()" +[DumpGraphToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L41 "DumpGraphToFile()" +[DumpFunctionDefToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L47 "DumpFunctionDefToFile()" +[LoadSavedModel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/cc/saved_model/loader.h#L50 "LoadSaveDModel()" + +[HadoopFileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/hadoop/hadoop_file_system.cc#L368-L377 "HadoopFileSystem::NewReadOnlyMemoryRegionFromFile()" +[FileSystemRegistry init]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.cc#L93 "initialization of FileSystemRegistry" + +[REGISTER_FILE_SYSTEM]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L480 "REGISTER_FILE_SYSTEM(scheme, factory)" + +[gif io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/gif +[jpeg io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/jpeg +[png io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/png +[wav io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/wav + +[c api]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h + +[load_library]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/python/framework/load_library.py#L132 diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow/big_picture.png b/rfcs/20190506-filesystem-plugin-modular-tensorflow/big_picture.png new file mode 100644 index 0000000000000000000000000000000000000000..c5e60c568ff75e82fcdf930bcba94a4e12d7716d GIT binary patch literal 279758 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 z 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

ho7!ZHy*By?5&toU>IcMA%ou2-hB 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∨9P?w&OfG|C+mIZ7F#U$!pK(rU|xh$1^-+)Du{?fsY1yPw>d>h z3R)>Jelr{xx+U#XHv~oqU|Zn~9+Sm-xwU_`H{vuV-pw~#7XS4H2Ya|)502Ll?ULX` zrJjnj>0=(M%c;|&d9aAgYuxCdcT7%_W~;#$@82RKu^%jij;iioi!^@y&yy6EOgJg( z72s!JUk0DFz6EQ812%GZ#Mg_hz|4 ze8KiIhPx|uQ(B~S&~(65G|q2$fxZFDB${mu3J>VJ;5>0Mzpe*ga-!}{2Zw^bJ3z95 zuD!C-2yD&<9Ft(!4c`Eq(c^87nC>?)&>7g4H-yq?Z>_J6Z}x{-R_*U`)z20Z;a))F zBwExPmdwAwKp1{Z*=sv;uJ2&FXT|gK-?9jQ{J-u5exD=%ey8xq-->^ZMo%8rt=*~A Qz<4E2Rr^w*ih0og11`*}FaQ7m literal 0 HcmV?d00001 diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow/env.png b/rfcs/20190506-filesystem-plugin-modular-tensorflow/env.png new file mode 100644 index 0000000000000000000000000000000000000000..f2097117c32a019aba908dbf3540c40236e605a8 GIT binary patch literal 76730 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

{%B<^ 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�*?Z%>d!t5xdX{fA?FO=}OF$vQejM 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 Date: Mon, 6 May 2019 13:38:37 -0700 Subject: [PATCH 02/16] Update path to image files The RFC files got moved to a new directory but text was still using the old path. --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index e064790fd..3f3356efa 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -127,7 +127,7 @@ These are used sporadically in some kernels and ops or for special cases such as very special filesystems or test environments. We can translate these additional APIs to use the design presented here, unifying API all across the codebase. -![Filesystem layers](20190502-filesystem-plugin-modular-tensorflow/big_picture.png "Overview of filesystem support") +![Filesystem layers](20190506-filesystem-plugin-modular-tensorflow/big_picture.png "Overview of filesystem support") This diagram illustrates this decomposition. Classes are full gray rectangles, interfaces are blue shaded ones and functions are rectangles with a dashed @@ -259,7 +259,7 @@ that type can just error, as in this There are multiple filesystems supported by TensorFlow, some of which are present in the next diagram: -![Example filesystems](20190502-filesystem-plugin-modular-tensorflow/filesystem.png "Example filesystems") +![Example filesystems](20190506-filesystem-plugin-modular-tensorflow/filesystem.png "Example filesystems") #### Cross operating system compatibility @@ -348,7 +348,7 @@ filesystem that match a specific pattern. The default implementation uses The following diagram shows several of the implementations of the `Env` interface: -![Example environments](20190502-filesystem-plugin-modular-tensorflow/env.png "Example environments") +![Example environments](20190506-filesystem-plugin-modular-tensorflow/env.png "Example environments") #### Registering a filesystem to the environment From 897623349118e29e01ed144146d5f6e0583c9c66 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 08:30:28 -0700 Subject: [PATCH 03/16] Add mention of cloud environments --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 3f3356efa..f9b7d2259 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -19,9 +19,13 @@ tasks that TensorFlow has to support. While users can use the underlying operating system’s API (such as calling fopen and friends on Posix environments, for example), it is definitely better to have -a cross-platform, cross-environment API that can be used everywhere. TensorFlow -provides such an API at the moment but it results in compiling code for all -known filesystems in the final binary. We propose a new design where all +a cross-platform, cross-environment API that can be used everywhere. This +becomes more evident when we consider cloud environments: a user of TensorFlow +should not have to compile support for all existing cloud environments if the +program only touches local files. + +TensorFlow provides such an API at the moment but it results in compiling code +for all known filesystems in the final binary. We propose a new design where all filesystems are implemented as plugins and only the required ones are added at runtime. To do so, we will first need to design a C API for the filesystems and then integrate this with the rest of the modularization effort. From 93b3eae27b9d4566db1d654f989b8c084d0ffdec Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 08:47:40 -0700 Subject: [PATCH 04/16] Expand compatibility defintion/requirements --- ...06-filesystem-plugin-modular-tensorflow.md | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index f9b7d2259..e61fa3cd2 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -68,14 +68,24 @@ needed: 1. The mandatory metadata must guarantee _binary compatibility_: allow plugins built at one version of TensorFlow core to be loaded by a range of TensorFlow - core versions, provided tests for API compatibility based on version metadata - pass. + core versions. If integration tests for API compatibility between version A + of the plugin and version Z of TensorFlow core pass, as detailed on [modular + TensorFlow RFC][modular_rfc], then version A of the plugin should be allowed + to work with version Z of TensorFlow core and mandatory metadata should allow + this. If integration tests between version B of plugin and version Y of core + fail then the metadata must forbid this combination. 1. Furthermore, it is ideal to have compilation failures when trying to compile plugins against an old API interface which will surely fail the version - metadata tests. When that is not possible we should give users good error - messages at runtime. In other words, _source compatibility_ is guaranteed - only as best effort. + metadata tests. For example, if a method's signature changes this will break + integration tests but will also be caught during compilation of plugin. + However, something that might not be caught at compile time is when an + optional method becomes required or a new method is added. We can maintain + _source compatibility_ by always increasing version numbers when a method + changes from being optional to being required and by always adding new + methods as optionals. But since version changes might be mistakenly + forgotten, we only guarantee it as best effort, providing users with clear + runtime error messages when compatibility is accidentally broken. 1. We should minimize the number of times we need to cross module boundaries to implement a filesystem functionality. Each time the boundary is crossed we From 71e48d8a8f17991e674cd48baf23bdea5a614642 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 09:03:39 -0700 Subject: [PATCH 05/16] Better time based qualifiers --- ...06-filesystem-plugin-modular-tensorflow.md | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index e61fa3cd2..92bbe2f74 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -10,7 +10,7 @@ TensorFlow has grown large since its introduction and we are currently working on ensuring a better development workflow by a team-wide effort designed to make -TensorFlow more modular according to the [current RFC][modular_rfc]. +TensorFlow more modular according to the [current proposal][modular_rfc]. A major module of the modular TensorFlow involves all operations regarding files and the filesystem. Saving models, checkpointing, reading files as input to @@ -70,7 +70,7 @@ needed: built at one version of TensorFlow core to be loaded by a range of TensorFlow core versions. If integration tests for API compatibility between version A of the plugin and version Z of TensorFlow core pass, as detailed on [modular - TensorFlow RFC][modular_rfc], then version A of the plugin should be allowed + TensorFlow proposal][modular_rfc], then version A of the plugin should be allowed to work with version Z of TensorFlow core and mandatory metadata should allow this. If integration tests between version B of plugin and version Y of core fail then the metadata must forbid this combination. @@ -160,11 +160,11 @@ registering). #### The filesystem implementation -A new filesystem is currently implemented by subclassing 4 interfaces: one for -the filesystem operation ([`FileSystem`][class FileSystem]), two for the file -operations ([`RandomAccessFile`][class RandomAccessFile], [`WritableFile`][class -WritableFile]) and one for read only memory mapped files -([`ReadOnlyMemoryRegion`][class ReadOnlyMemoryRegion]). +In the world before this proposal, a new filesystem is implemented by +subclassing 4 interfaces: one for the filesystem operation ([`FileSystem`][class +FileSystem]), two for the file operations ([`RandomAccessFile`][class +RandomAccessFile], [`WritableFile`][class WritableFile]) and one for read only +memory mapped files ([`ReadOnlyMemoryRegion`][class ReadOnlyMemoryRegion]). The `Filesystem` interface is needed to define common functionality to create or delete files and directories as well as manipulating directory contents and @@ -551,7 +551,7 @@ In this subclass, the `Read()` and `ReadUpTo()` methods are implemented in terms of their corresponding locked methods. Furthermore, descendants of this class only need to implement `ReadLocked()`, the only pure virtual member of the API. -Currently, there are 7 descendants of `ReaderBase` and they are used to +Before this proposal, there are 7 descendants of `ReaderBase` and they are used to implement kernels and ops. All of these kernels inherit from [`ReaderOpKernel`][class ReaderOpKernel] which handles access to the source to be read from. Whereas [`TextLineReader`][class TextLineReader], @@ -565,9 +565,9 @@ previously ([`FixedLengthRecordReader`][class FixedLengthRecordReader]). In the modular design, most of these descendants will be converted for free. The only class that might not be trivial to transfer to the new API might be -`BigQueryReader`. But, since currently it completely ignores the filesystem -APIs, we can continue with this design ignoring it for now and converting it in -the future. +`BigQueryReader`. But, since before this proposal this class completely +ignores the filesystem APIs, we can continue with this design ignoring it for +the moment. #### `SummaryWriterInterface` @@ -718,9 +718,9 @@ added/removed. This, in turn results in compatibility being harder to maintain, which is something we don’t want. Instead, we provide 3 different data structures to act as function tables, to -hold function pointers for files and the filesystem. Currently, these structures -are filled with the functionality already present in the existing filesystem -API: +hold function pointers for files and the filesystem. For this proposal, these +structures are filled with the functionality already present in the existing +filesystem API, but we can expand them as the review progresses: ```cpp // Operations on a TF_RandomAccessFile @@ -896,10 +896,10 @@ Similarly, we will have to implement a subclass of the `FileSystem` class, `ModularFileSystem`, in the same vein. Another change we have to do is to `FileSystemRegistry`: the `Register()` call -now uses a `unique_ptr` argument instead of the existing -`Factory`-based implementation since the constructor of `ModularFileSystem` -needs to take as argument the function tables for the operations supported by -the filesystem. +after this proposal will use a `unique_ptr` argument instead of the +existing `Factory`-based implementation since the constructor of +`ModularFileSystem` needs to take as argument the function tables for the +operations supported by the filesystem. Because of this change, we also need a new subclass of `Env`, as each instance of `Env` has the `FileSystemRegistry` baked in at construction time. Actually, From af8125bb63c44b87881004dbbe0492c5f0852e78 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 09:10:28 -0700 Subject: [PATCH 06/16] Specify that scheme uniquely identifies filesystem implementation --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 92bbe2f74..4334d06e3 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -211,7 +211,11 @@ class Filesystem { ``` In TensorFlow, files are identified by a URI of form -`[://[]]`. Because sometimes we only need the filename +`[://[]]` and `scheme` is always used to identify which +implementation to use for accessing them (for example, a path specified as +`hdfs:///path/to/file` will use the Hadoop filesystem implementation). + +Because sometimes we only need the filename part, the FileSystem API defines `TranslateName()` which also ensures that paths are canonical, properly resolving `.` and `..` entries that might be present in the path. Although filesystems can reimplement this, by default From e920d7f35294171da4985c0a5badfa00a634a2c8 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 09:44:33 -0700 Subject: [PATCH 07/16] Separate higher level APIs into appendix --- ...06-filesystem-plugin-modular-tensorflow.md | 357 +--------- .../existing_filesystem_review.md | 609 ++++++++++++++++++ 2 files changed, 625 insertions(+), 341 deletions(-) create mode 100644 rfcs/20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.md diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 4334d06e3..08cdc5739 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -70,10 +70,10 @@ needed: built at one version of TensorFlow core to be loaded by a range of TensorFlow core versions. If integration tests for API compatibility between version A of the plugin and version Z of TensorFlow core pass, as detailed on [modular - TensorFlow proposal][modular_rfc], then version A of the plugin should be allowed - to work with version Z of TensorFlow core and mandatory metadata should allow - this. If integration tests between version B of plugin and version Y of core - fail then the metadata must forbid this combination. + TensorFlow proposal][modular_rfc], then version A of the plugin should be + allowed to work with version Z of TensorFlow core and mandatory metadata + should allow this. If integration tests between version B of plugin and + version Y of core fail then the metadata must forbid this combination. 1. Furthermore, it is ideal to have compilation failures when trying to compile plugins against an old API interface which will surely fail the version @@ -122,9 +122,9 @@ needed: ## Existing implementation -The existing implementation of a filesystem support in TensorFlow is hairy, due -to the complexity of operations that needs to be provided. This section is an -overview of the existing architecture. +The implementation of a filesystem support in TensorFlow is hairy, due to the +complexity of operations that needs to be provided. This section is an overview +of the architecture. In short summary, TensorFlow’s support for filesystems can be decomposed into 3 types of API: @@ -149,6 +149,10 @@ border. Arrows represent inheritance and the line between `Env` and `FileSystem` illustrates the coupling between these two structures as will be described in the next subsection. +For a better understanding of this proposal, we will present only the low level +details here as these are the ones that we propose to change. The rest of the +filesystem implementation is moved to [the appendix][filesystem appendix]. + ### Low level filesystem API The low-level filesystem API in TensorFlow guarantees the same interface both @@ -215,16 +219,6 @@ In TensorFlow, files are identified by a URI of form implementation to use for accessing them (for example, a path specified as `hdfs:///path/to/file` will use the Hadoop filesystem implementation). -Because sometimes we only need the filename -part, the FileSystem API defines `TranslateName()` which also ensures that paths -are canonical, properly resolving `.` and `..` entries that might be present in -the path. Although filesystems can reimplement this, by default -[`tensorflow::lib::io::CleanPath()`][CleanPath] is used. - -The default `CopyFile()` implementation just calls the -[`FileSystemCopyFile()`][FileSystemCopyFile] helper method using the same -`FileSystem` argument for both source and target. - The [`FileStatistics`][class FileStatistics] class is just a value class containing information related to a dentry: @@ -271,8 +265,8 @@ the rest of TensorFlow. If a filesystem doesn’t support one of the file types, then we don’t need to implement the corresponding interface. Instead, the method creating the file of -that type can just error, as in this -[HadoopFileSystem][HadoopFileSystem] example. +that type can just error, as in this [HadoopFileSystem][HadoopFileSystem] +example. There are multiple filesystems supported by TensorFlow, some of which are present in the next diagram: @@ -354,15 +348,6 @@ obtained from `GetFileSystemForFile()`. In fact, most of the default implementations of the methods above use `GetFileSystemForFile()` and then delegate to the filesystem. -Note that in the case of `RenameFile()` and `CopyFile()` the target and the -source files might be in a different filesystem. Renaming results in an error -(as it is currently not implemented), whereas copying is done via the -`FileSystemCopyFile()` helper introduced in the previous section. - -The `GetMatchingPaths()` call can be used to identify all paths in the current -filesystem that match a specific pattern. The default implementation uses -[`GetMatchingPaths()`][GetMatchingPaths]: - The following diagram shows several of the implementations of the `Env` interface: @@ -392,264 +377,8 @@ class FileSystemRegistry { }; ``` -### Convenience API - -All the functionality presented until this point is enough to transparently -operate with files across filesystems and operating systems. However, each such -operation requires getting the environment via Env::Default() then accessing the -needed functionality from a method of that class. This quickly becomes -repetitive, so TensorFlow has some convenience API that can be used. For -example, there are these helper methods: - -```cpp -Status ReadFileToString(Env* env, const string& fname, string* data); -Status ReadBinaryProto(Env* env, const string& fname, MessageLite* proto); -Status ReadTextProto(Env* env, const string& fname, protobuf::Message* proto); - -Status WriteStringToFile(Env* env, const string& fname, const StringPiece& data); -Status WriteBinaryProto(Env* env, const string& fname, const protobuf::MessageLite& proto); -Status WriteTextProto(Env* env, const string& fname, const protobuf::Message& proto); -``` - -#### Buffered (streaming) support - -Furthermore, as some files can be large, we need a way to stream the data from -them. There are several options that we can use: - -An [`InputBuffer`][class InputBuffer] is a buffer on top of a RandomAccessFile -passed to the constructor. Its API is simple: - -```cpp -class InputBuffer { - Status ReadLine(string* result); - Status ReadNBytes(int64 bytes_to_read, string* result); - Status ReadNBytes(int64 bytes_to_read, char* result, size_t* read); - Status ReadVarint32(uint32* result); - Status ReadVarint64(uint64* result); - Status SkipNBytes(int64 bytes_to_skip); - Status Seek(int64 position); - int64 Tell() const; -}; -``` - -However, the `InputBuffer` interface is too tied to a `RandomAccessFile` and -thus it is only being used in one place, by the `TextLineReaderOp` kernel. - -A replacement method is provided by [`InputStreamInterface`][class -InputStreamInterface]: - -```cpp -class InputStreamInterface { - virtual Status ReadNBytes(int64 bytes_to_read, string* result) = 0; - virtual Status SkipNBytes(int64 bytes_to_skip); - virtual int64 Tell() const = 0; - virtual Status Reset() = 0; -}; -``` - -A [`RandomAccessInputStream`][class RandomAccessInputStream] object is an -`InputStreamInterface` object which wraps a `RandomAccessFile`. To provide more -functionality (e.g., `ReadLine()`, `Seek()`), this can be wrapped by a -[`BufferedInputStream`][class BufferedInputStream]. - -#### File compression APIs - -Another descendant of `InputStreamInterface` is [`MemoryInputStream`][class -MemoryInputStream] which wraps a memory buffer and is used in -`DecodeCompressedOp`. This doesn’t use filesystem operations, although it can be -implemented in terms of `ReadOnlyMemoryRegion` if needed. - -There are two more relevant compression APIs built from `InputStreamInterface`. -First, [`SnappyInputBuffer`][class SnappyInputBuffer] provides access to files -compressed using Snappy and represented as `RandomAccessFile` objects. There is -also a [`SnappyOutputBuffer`][class SnappyOutputBuffer] class to write -compressed input, but there is no `OutputStreamInterface`. - -The second compression API is given by [`ZlibInputStream`][class -ZlibInputStream]. Similar to the `RandomAccessInputStream` case, this just wraps -an `InputStreamInterface`. To write to compressed zlib files, we can use -[`ZlibOutputBuffer`][class ZlibOutputBuffer] to wrap around a `WritableFile`. - -### High level filesystem API - -Building on top of the convenience API, TensorFlow code has several custom -classes and helpers to provide high level access to the filesystem. - -For example `tf.data` uses `TFRecord` support provided by [`RecordReader`][class -RecordReader], [`RecordWriter`][class RecordWriter] and -[`SequentialRecordReader`][class SequentialRecordReader] to build the -[`FileDataset`][class FileDataset] and [`FileIterator`][class FileIterator] -abstractions (and subclasses such as [`FileWriterIterator`][class -FileWriterIterator], [`FileReaderIterator`][class FileReaderIterator]). Then, -kernels and ops such as [`TextLineDatasetOp`][class TextLineDatasetOp] and -[`TFRecordDatasetOp`][class TFRecordDatasetOp] are built and then used in Python -APIs. - -Other examples include: - -* [`DumpGraphDefToFile`][DumpGraphDefToFile], - [`DumpGraphToFile`][DumpGraphToFile], - [`DumpFunctionDefToFile`][DumpFunctionDefToFile]; -* [`Table`][class Table] - immutable mapping from strings to strings backed up - by a file; -* [`BundleWriter`][class BundleWriter], [`BundleReader`][class BundleReader] - - checkpointing; -* [`TensorSliceWriter`][class TensorSliceWriter], [`TensorSliceReader`][class - TensorSliceReader] - checkpointing partitioned variables; -* [`LoadSavedModel`][LoadSavedModel] - `SavedModel` loading; -* [`EventsWriter`][class EventsWriter]; -* [`DebugFileIO`][class DebugFileIO]; -* API generation tools inside TensorFlow. - -### Additional APIs - -For some special cases or due to historical reasons, TensorFlow has a set of -filesystem APIs which cannot be directly mapped on the hierarchy described so -far. We will mention them here for completeness, but it turns out we can either -ignore them for the rest of the design as they don’t require many changes. - -#### `FileBlockCache` - -The [`FileBlockCache`][class FileBlockCache] class can be used by filesystems to -cache files at the block level. Each entry in the cache is keyed by the filename -and the offset of the block in the file. Filesystem implementations are free to -ignore this class, but we’re mentioning it in this document as it is being used -by the cloud filesystems. - -In the new filesystem design, filesystems needing this functionality can just -import the corresponding targets. Since this is an implementation detail, the -caching information doesn’t need to cross the module boundary. - -#### `ReaderInterface` - -The [`ReaderInterface`][class ReaderInterface] and its subclasses provides an -alternative method of reading records from files in a TensorFlow graph. It has -the following API: - -```cpp -class ReaderInterface : public ResourceBase { - // Reads one single record - virtual void Read(QueueInterface* queue, string* key, string* value, OpKernelContext* context) = 0; - // Reads up to num_records - virtual int64 ReadUpTo(const int64 num_records, QueueInterface* queue, std::vector* keys, std::vector* values, OpKernelContext* context) = 0; - - // Misc - virtual Status Reset() = 0; - virtual int64 NumRecordsProduced() = 0; - virtual Status SerializeState(string* state) = 0; - virtual Status RestoreState(const string& state) = 0; -}; -``` - -The only subclass in TensorFlow is [`ReaderBase`][class ReaderBase], which adds -API entry-points for reading while a mutex is being held: - -```cpp -class ReaderBase : public ReaderInterface { - virtual Status ReadLocked(string* key, string* value, bool* produced, bool* at_end) = 0; - virtual Status ReadUpToLocked(int64 num_records, std::vector* keys, std::vector* values, int64* num_read, bool* at_end); -}; -``` - -In this subclass, the `Read()` and `ReadUpTo()` methods are implemented in terms -of their corresponding locked methods. Furthermore, descendants of this class -only need to implement `ReadLocked()`, the only pure virtual member of the API. - -Before this proposal, there are 7 descendants of `ReaderBase` and they are used to -implement kernels and ops. All of these kernels inherit from -[`ReaderOpKernel`][class ReaderOpKernel] which handles access to the source to -be read from. Whereas [`TextLineReader`][class TextLineReader], -[`TFRecordReader`][class TFRecordReader] and [`WholeFileReader`][class -WholeFileReader] access the filesystem using the environment approach -illustrated above, the other subclasses either work with in-memory data -([`IdentityReader`][class IdentityReader], [`LMDBReader`][class LMDBReader]), -with data obtained from a remote call ([`BigQueryReader`][class BigQueryReader]) -or with data that is read using the `InputStreamInterface` mechanism described -previously ([`FixedLengthRecordReader`][class FixedLengthRecordReader]). - -In the modular design, most of these descendants will be converted for free. The -only class that might not be trivial to transfer to the new API might be -`BigQueryReader`. But, since before this proposal this class completely -ignores the filesystem APIs, we can continue with this design ignoring it for -the moment. - -#### `SummaryWriterInterface` - -A [`SummaryWriterInterface`][class SummaryWriterInterface] allows writing -TensorFlow resources to a summary file, being a subclass of `ResourceBase`, just -like `ReaderInterface`. - -```cpp -class SummaryWriterInterface : public ResourceBase { - virtual Status Flush() = 0; - virtual Status WriteTensor(int64 global_step, Tensor t, const string& tag, const string& serialized_metadata) = 0; - virtual Status WriteScalar(int64 global_step, Tensor t, const string& tag) = 0; - virtual Status WriteHistogram(int64 global_step, Tensor t, const string& tag) = 0; - virtual Status WriteImage(int64 global_step, Tensor t, const string& tag, int max_images, Tensor bad_color) = 0; - virtual Status WriteAudio(int64 global_step, Tensor t, const string& tag, int max_outputs_, float sample_rate) = 0; - virtual Status WriteGraph(int64 global_step, std::unique_ptr graph) = 0; - virtual Status WriteEvent(std::unique_ptr e) = 0; -}; -``` - -When writing to files, we use the [`SummaryFileWriter`][class SummaryFileWriter] -subclass which uses the `Env` method. However, the other subclass, -[`SummaryDbWriter`][class SummaryDbWriter], uses an `Sqlite` object to talk to a -SQL database. Similar to the `BigQueryReader` case from the previous section, we -can postpone converting this to the new filesystem API until a later time. - -### IO from external libraries or other languages - -To provide functionality to read/write image/audio files, TensorFlow uses some -external libraries. Although they can do their own IO, there is glue code for -[gif][gif io], [jpeg][jpeg io], [png][png io] and [wav][wav io] files. This glue -ensures that the calls into the library use strings representing file contents -instead of letting the library do its own IO. This way, the filesystem support -that TensorFlow does is the only one accessing files on disk. - -However, there is nothing stopping future code development from directly reading -from a file on the disk (for example), either in the C/C++ code or in the Python -code. Preventing this is out of scope for the current design document. - -### Existing C API implementation - -There is an [existing C API for filesystems][c api] which we might reuse in this -design. We cannot build on top of this API as it only offers C entry points -which then call the existing C++ API functions. But, it gives us an indication -on what API we should provide, at the minimum: - -```cpp -typedef struct TF_FileStatistics { - int64_t length; - int64_t mtime_nsec; - bool is_directory; -} TF_FileStatistics; - -// filesystem manipulation -TF_CAPI_EXPORT extern void TF_CreateDir(const char* dirname, TF_Status* status); -TF_CAPI_EXPORT extern void TF_DeleteDir(const char* dirname, TF_Status* status); -TF_CAPI_EXPORT extern void TF_DeleteRecursively(const char* dirname, int64_t* undeleted_file_count, int64_t* undeleted_dir_count, TF_Status* status); -TF_CAPI_EXPORT extern void TF_DeleteFile(const char* filename, TF_Status* status); -TF_CAPI_EXPORT extern void TF_FileStat(const char* filename, TF_FileStatistics* stats, TF_Status* status); - -// writable files API -TF_CAPI_EXPORT extern void TF_NewWritableFile(const char* filename, TF_WritableFileHandle** handle, TF_Status* status); -TF_CAPI_EXPORT extern void TF_CloseWritableFile(TF_WritableFileHandle** handle, TF_Status* status); -TF_CAPI_EXPORT extern void TF_SyncWritableFile(TF_WritableFileHandle** handle, TF_Status* status); -TF_CAPI_EXPORT extern void TF_FlushWritableFile(TF_WritableFileHandle** handle, TF_Status* status); -TF_CAPI_EXPORT extern void TF_AppendWritableFile(TF_WritableFileHandle** handle, const char* data, size_t length, TF_Status* status); -``` - -This API is very incomplete, for example it lacks support for random access -files and memory mapped files. Furthermore, the `TF_WritableFileHandle` object -is just an opaque struct (in C-land) which maps over a `WritableFile` pointer -from the C++ implementation. - -Since this has to be pure C, Status objects are replaced by pointers to a -`TF_Status` structure. There is code to convert from one to the other. Moreover, -these APIs assume that the `TF_Status` object is created and managed from the -calling code, instead of returning the status from every function call. We will -follow a similar design in this proposal. +For the rest of the filesystem related implementations that TensorFlow offers, +consult [the appendix][filesystem appendix]. ## Proposed implementation @@ -1026,8 +755,8 @@ During registration we can check all of the fields and store some for later use (e.g., for displaying better error message, localizing the plugin in error). - [modular_rfc]: https://github.com/tensorflow/community/pull/77 "RFC: Modular TensorFlow" +[filesystem appendix]: 20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.png "A detailed presentation of TensorFlow's filesystem support" [class FileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L46 "class FileSystem" [class RandomAccessFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L232 "class RandomAccessFile" @@ -1037,64 +766,10 @@ During registration we can check all of the fields and store some for later use [class FileSystemRegistry]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L360 "class FileSystemRegistry" [class FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_statistics.h#L23 "class FileStatistics" [struct TF_FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h#L36 "struct TF_FileStatistics" -[class InputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputbuffer.h#L32 "class InputBuffer" -[class InputStreamInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputstream_interface.h#L27 "class InputStreamInterface" -[class RandomAccessInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/random_inputstream.h#L27 "class RandomAccessInputStream" -[class BufferedInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/buffered_inputstream.h#L27 "class BufferedInputStream" -[class MemoryInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/decode_compressed_op.cc#L30 "class MemoryInputStream" -[class SnappyInputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_inputbuffer.h#L35 "class SnappyInputBuffer" -[class SnappyOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_outputbuffer.h#L46 "class SnappyOutputBuffer" -[class ZlibInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_inputstream.h#L40 "class ZlibInputStream" -[class ZlibOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_outputbuffer.h#L38i "class ZlibOutputBuffer" -[class RecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L59 "class RecordReader" -[class RecordWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_writer.h#L50 "class RecordWriter" -[class SequentialRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L120 "class SequentialRecordReader" -[class FileDataset]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L50 "class FileDataset" -[class FileIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L112 "class FileIterator" -[class FileWriterIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L195 "class FileWriterIterator" -[class FileReaderIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L439 "class FileReaderIterator" -[class TextLineDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L35 "class TextLineDatasetOp" -[class TFRecordDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L740 "class TFRecordDatasetOp" -[class Table]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/table.h#L34 "class Table" -[class BundleWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L108 "class BundleWriter" -[class BundleReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L182 "class BundleReader" -[class TensorSliceWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_writer.h#L43 "class TensorSliceWriter" -[class TensorSliceReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_reader.h#L54 "class TensorSliceReader" -[class EventsWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/events_writer.h#L31 "class EventsWriter" -[class DebugFileIO]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/debug/debug_io_utils.h#L147 "class DebugFileIO" -[class FileBlockCache]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/cloud/file_block_cache.h#L39 "class FileBlockCache" -[class ReaderInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_interface.h#L44 "class ReaderInterface" -[class ReaderBase]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_base.h#L30 "class ReaderBase" -[class ReaderOpKernel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_op_kernel.h#L35 "class ReaderOpKernel" -[class TextLineReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/text_line_reader_op.cc#L28 "class TextLineReader" -[class TFRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/tf_record_reader_op.cc#L28 "class TFRecordReader" -[class WholeFileReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/whole_file_read_ops.cc#L45 "class WholeFileReader" -[class IdentityReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/identity_reader_op.cc#L29 "class IdentityReader" -[class LMDBReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/lmdb_reader_op.cc#L27 "class LMDBReader" -[class BigQueryReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/contrib/cloud/kernels/bigquery_reader_ops.cc#L52 "class BigQueryReader" -[class FixedLengthRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/fixed_length_record_reader_op.cc#L33 "class FixedLengthRecordReader" -[class SummaryWriterInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/summary_interface.h#L30 "class SummaryWriterInterface" -[class SummaryFileWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_file_writer.cc#L30 "class SummaryFileWriter" -[class SummaryDbWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_db_writer.cc#L875 "class SummaryDbWriter" - -[CleanPath]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/path.h#L74 "tensorflow::lib::io::CleanPath()" -[FileSystemCopyFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L430 "FileSystemCopyFile()" -[GetMatchingPaths]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system_helper.h#L45 "GetMatchingPaths()" -[DumpGraphDeftoFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L36 "DumpGraphDefToFile()" -[DumpGraphToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L41 "DumpGraphToFile()" -[DumpFunctionDefToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L47 "DumpFunctionDefToFile()" -[LoadSavedModel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/cc/saved_model/loader.h#L50 "LoadSaveDModel()" [HadoopFileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/hadoop/hadoop_file_system.cc#L368-L377 "HadoopFileSystem::NewReadOnlyMemoryRegionFromFile()" [FileSystemRegistry init]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.cc#L93 "initialization of FileSystemRegistry" [REGISTER_FILE_SYSTEM]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L480 "REGISTER_FILE_SYSTEM(scheme, factory)" -[gif io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/gif -[jpeg io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/jpeg -[png io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/png -[wav io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/wav - -[c api]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h - [load_library]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/python/framework/load_library.py#L132 diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.md new file mode 100644 index 000000000..60d54fd36 --- /dev/null +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.md @@ -0,0 +1,609 @@ +# Filesystem operations in TensorFlow + +This document accompanies the [modular filesystem plugin][filesystem_rfc] RFC +and describes in full details how TensorFlow accesses filesystems at various +levels of implementation. + +The implementation of a filesystem support in TensorFlow is hairy, due to the +complexity of operations that needs to be provided. This section is a full +overview of the architecture. + +TensorFlow’s support for filesystems can be decomposed into 3 types of API: + +* Low level API mainly focused on offering interfaces to hide complexity and + provide cross-platform compatibility; +* Convenience API providing functions to read/write files in a generic way as + well as providing support for compressed data and for buffered I/O; +* High level API which offers functionality needed by the kernels, ops and other + utilities. + +Furthermore, the codebase has some additional methods to access the filesystem. +These are used sporadically in some kernels and ops or for special cases such as +very special filesystems or test environments. We can translate these additional +APIs to use the design presented here, unifying API all across the codebase. + +![Filesystem layers](20190506-filesystem-plugin-modular-tensorflow/big_picture.png "Overview of filesystem support") + +This diagram illustrates this decomposition. Classes are full gray rectangles, +interfaces are blue shaded ones and functions are rectangles with a dashed +border. Arrows represent inheritance and the line between `Env` and `FileSystem` +illustrates the coupling between these two structures as will be described in +the next subsection. + +## Low level filesystem API + +This subsection is present in the main document too, but it is included here +with some additional contents. + +The low-level filesystem API in TensorFlow guarantees the same interface both +across multiple operating systems as well as across multiple filesystems hiding +the complexities arising from the differences between these platforms. Thus, +there are two different things that need consideration: implementing a new +filesystem and making it accessible for each operating system (i.e. +registering). + +### The filesystem implementation + +In the world before this proposal, a new filesystem is implemented by +subclassing 4 interfaces: one for the filesystem operation ([`FileSystem`][class +FileSystem]), two for the file operations ([`RandomAccessFile`][class +RandomAccessFile], [`WritableFile`][class WritableFile]) and one for read only +memory mapped files ([`ReadOnlyMemoryRegion`][class ReadOnlyMemoryRegion]). + +The `Filesystem` interface is needed to define common functionality to create or +delete files and directories as well as manipulating directory contents and +getting information about files present on a filesystem: listing directory +contents, getting statistics about files and finding paths matching a globbing +pattern. + +```cpp +class Filesystem { + // File creation + virtual Status NewRandomAccessFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewWritableFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewAppendableFile(const string& fname, std::unique_ptr* result) = 0; + virtual Status NewReadOnlyMemoryRegionFromFile(const string& fname, std::unique_ptr* result) = 0; + + // Creating directories + virtual Status CreateDir(const string& dirname) = 0; + virtual Status RecursivelyCreateDir(const string& dirname); + + // Deleting + virtual Status DeleteFile(const string& fname) = 0; + virtual Status DeleteDir(const string& dirname) = 0; + virtual Status DeleteRecursively(const string& dirname, int64* undeleted_files, int64* undeleted_dirs); + + // Changing directory contents + virtual Status RenameFile(const string& src, const string& target) = 0; + virtual Status CopyFile(const string& src, const string& target); + + // Filesystem information + virtual Status FileExists(const string& fname) = 0; + virtual bool FilesExist(const std::vector& files, std::vector* status); + virtual Status GetChildren(const string& dir, std::vector* result) = 0; + virtual Status Stat(const string& fname, FileStatistics* stat) = 0; + virtual Status IsDirectory(const string& fname); + virtual Status GetFileSize(const string& fname, uint65* file_size) = 0; + + // Globbing + virtual Status GetMatchingPaths(const string& pattern, std::vector* results) = 0; + + // Misc + virtual void FlushCaches(); + virtual string TranslateName(const string& name) const; +}; +``` + +In TensorFlow, files are identified by a URI of form +`[://[]]` and `scheme` is always used to identify which +implementation to use for accessing them (for example, a path specified as +`hdfs:///path/to/file` will use the Hadoop filesystem implementation). + +Because sometimes we only need the filename part, the FileSystem API defines +`TranslateName()` which also ensures that paths are canonical, properly +resolving `.` and `..` entries that might be present in the path. Although +filesystems can reimplement this, by default +[`tensorflow::lib::io::CleanPath()`][CleanPath] is used. + +The default `CopyFile()` implementation just calls the +[`FileSystemCopyFile()`][FileSystemCopyFile] helper method using the same +`FileSystem` argument for both source and target. + +The [`FileStatistics`][class FileStatistics] class is just a value class +containing information related to a dentry: + +```cpp +class FileStatistics { + int64 length = -1; + int64 mtime_nsec = 0; + bool is_directory = false; +}; +``` + +There is also a [`TF_FileStatistics`][struct TF_FileStatistics] data structure +used by the C API. Both have the same values but the `TF_FileStatistics` +structure doesn’t have constructors/destructors as it has to be pure C. + +The other 3 interfaces that need to be subclassed to get a functional filesystem +are simple: + +```cpp +class RandomAccessFile { + virtual Status Name(StringPiece* result) const; + virtual Status Read(uint64 offset, size_t n, StringPiece* result, char* scratch) const = 0; +}; + +class WritableFile { + virtual Status Name(StringPiece* result) const; + virtual Status Append(StringPiece data) = 0; + virtual Status Append(const absl::Cord& cord); + virtual Status Tell(int64* position); + virtual Status Close() = 0; + virtual Status Flush() = 0; + virtual Status Sync() = 0; +}; + +class ReadOnlyMemoryRegion { + virtual const void* data() = 0; + virtual uint64 length() = 0; +}; +``` + +Once these 4 interfaces are implemented, we have a fully functioning filesystem +at the lowest API level. Each such filesystem can be tested in isolation from +the rest of TensorFlow. + +If a filesystem doesn’t support one of the file types, then we don’t need to +implement the corresponding interface. Instead, the method creating the file of +that type can just error, as in this [HadoopFileSystem][HadoopFileSystem] +example. + +There are multiple filesystems supported by TensorFlow, some of which are +present in the next diagram: + +![Example filesystems](20190506-filesystem-plugin-modular-tensorflow/filesystem.png "Example filesystems") + +### Cross operating system compatibility + +The operating system compatibility is ensured by the [`Env`][class Env] +interface. This contains API calls used to access functionality that depends on +the platform the process runs on: threading, clock information, loading dynamic +libraries and filesystem methods. We will focus only on the latter in this +document. As the number of environments is usually very small, we can achieve +minimal code by using preprocessor guards and compiling only for one platform. +Alternatively, we can have a similar design as this one and create plugins for +each operating system, although this will require additional work in defining +interfaces and versioning and won’t bring much benefit over the preprocessor +macros approach. + +Restricting only to the filesystem related API, the `Env` interface looks like +the following code snippet: + +```cpp +class Env { + // Filesystem registration + virtual Status GetFileSystemForFile(const string& fname, FileSystem** result); + virtual Status GetRegisteredFileSystemSchemes(std::vector* schemes); + virtual Status RegisterFileSystem(const string& scheme, FileSystemRegistry::Factory factory); + + // Creating files, including memory mapped + Status NewRandomAccessFile(const string& fname, std::unique_ptr* result); + Status NewWritableFile(const string& fname, std::unique_ptr* result); + Status NewAppendableFile(const string& fname, std::unique_ptr* result); + Status NewReadOnlyMemoryRegionFromFile(const string& fname, std::unique_ptr* result); + + // Creating directories + Status CreateDir(const string& dirname); + Status RecursivelyCreateDir(const string& dirname); + + // Deleting + Status DeleteFile(const string& fname); + Status DeleteDir(const string& dirname); + Status DeleteRecursively(const string& dirname, int64* undeleted_files, int64* undeleted_dirs); + + // Changing directory contents + Status RenameFile(const string& src, const string& target); + Status CopyFile(const string& src, const string& target); + + // Filesystem information + Status FileExists(const string& fname); + bool FilesExist(const std::vector& files, std::vector* status); + Status GetChildren(const string& dir, std::vector* result); + Status Stat(const string& fname, FileStatistics* stat); + Status IsDirectory(const string& fname); + Status GetFileSize(const string& fname, uint64* file_size); + + // Globbing + virtual bool MatchPath(const string& path, const string& pattern) = 0; + virtual Status GetMatchingPaths(const string& pattern, std::vector* results); + + // Misc + Status FlushFileSystemCaches(); + string GetExecutablePath(); + virtual string GetRunfilesDir() = 0; + bool LocalTempFilename(string* filename); + bool CreateUniqueFileName(string* prefix, const string& suffix); + virtual void GetLocalTempDirectories(std::vector* list) = 0; + static Env* Default(); + + // Other methods of the class, not relevant here +}; +``` + +Each process accesses the environment by calling the static `Env::Default()` +method and then gains access to all the functionality that depends on the +operating system. Then, to operate on the filesystem, any process will either +use the methods provided by the `Env` API or those of the `FileSystem` object +obtained from `GetFileSystemForFile()`. In fact, most of the default +implementations of the methods above use `GetFileSystemForFile()` and then +delegate to the filesystem. + +Note that in the case of `RenameFile()` and `CopyFile()` the target and the +source files might be in a different filesystem. Renaming results in an error +(as it is currently not implemented), whereas copying is done via the +`FileSystemCopyFile()` helper introduced in the previous section. + +The `GetMatchingPaths()` call can be used to identify all paths in the current +filesystem that match a specific pattern. The default implementation uses +[`GetMatchingPaths()`][GetMatchingPaths]: + +The following diagram shows several of the implementations of the `Env` +interface: + +![Example environments](20190506-filesystem-plugin-modular-tensorflow/env.png "Example environments") + +### Registering a filesystem to the environment + +In order to access a filesystem via `GetFileSystemForFile()`, first it has to be +registered to the environment. This can be done via `RegisterFileSystem()` but +it is preferable to use the [`REGISTER_FILE_SYSTEM(scheme, +factory)`][REGISTER_FILE_SYSTEM] macro instead, where `factory` is an empty +constructor of a subclass of `FileSystem` and `scheme` is the URI scheme needed +to access the file. Any filesystem call using `scheme` in the URI will then get +handled by the subclass used for registration. + +Filesystems are registered into a [`FileSystemRegistry`][class +FileSystemRegistry], which is semantically equivalent to a map from file scheme +to filesystem. Since this has to be unique over the lifetime of the program, the +interface is [opaque outside of Env][FileSystemRegistry init]. + +```cpp +class FileSystemRegistry { + typedef std::function Factory; + virtual Status Register(const string& scheme, Factory factory) = 0; + virtual FileSystem* Lookup(const string& scheme) = 0; + virtual Status GetRegisteredFileSystemSchemes(std::vector* schemes) = 0; +}; +``` + +## Convenience API + +All the functionality presented until this point is enough to transparently +operate with files across filesystems and operating systems. However, each such +operation requires getting the environment via Env::Default() then accessing the +needed functionality from a method of that class. This quickly becomes +repetitive, so TensorFlow has some convenience API that can be used. For +example, there are these helper methods: + +```cpp +Status ReadFileToString(Env* env, const string& fname, string* data); +Status ReadBinaryProto(Env* env, const string& fname, MessageLite* proto); +Status ReadTextProto(Env* env, const string& fname, protobuf::Message* proto); + +Status WriteStringToFile(Env* env, const string& fname, const StringPiece& data); +Status WriteBinaryProto(Env* env, const string& fname, const protobuf::MessageLite& proto); +Status WriteTextProto(Env* env, const string& fname, const protobuf::Message& proto); +``` + +### Buffered (streaming) support + +Furthermore, as some files can be large, we need a way to stream the data from +them. There are several options that we can use: + +An [`InputBuffer`][class InputBuffer] is a buffer on top of a RandomAccessFile +passed to the constructor. Its API is simple: + +```cpp +class InputBuffer { + Status ReadLine(string* result); + Status ReadNBytes(int64 bytes_to_read, string* result); + Status ReadNBytes(int64 bytes_to_read, char* result, size_t* read); + Status ReadVarint32(uint32* result); + Status ReadVarint64(uint64* result); + Status SkipNBytes(int64 bytes_to_skip); + Status Seek(int64 position); + int64 Tell() const; +}; +``` + +However, the `InputBuffer` interface is too tied to a `RandomAccessFile` and +thus it is only being used in one place, by the `TextLineReaderOp` kernel. + +A replacement method is provided by [`InputStreamInterface`][class +InputStreamInterface]: + +```cpp +class InputStreamInterface { + virtual Status ReadNBytes(int64 bytes_to_read, string* result) = 0; + virtual Status SkipNBytes(int64 bytes_to_skip); + virtual int64 Tell() const = 0; + virtual Status Reset() = 0; +}; +``` + +A [`RandomAccessInputStream`][class RandomAccessInputStream] object is an +`InputStreamInterface` object which wraps a `RandomAccessFile`. To provide more +functionality (e.g., `ReadLine()`, `Seek()`), this can be wrapped by a +[`BufferedInputStream`][class BufferedInputStream]. + +### File compression APIs + +Another descendant of `InputStreamInterface` is [`MemoryInputStream`][class +MemoryInputStream] which wraps a memory buffer and is used in +`DecodeCompressedOp`. This doesn’t use filesystem operations, although it can be +implemented in terms of `ReadOnlyMemoryRegion` if needed. + +There are two more relevant compression APIs built from `InputStreamInterface`. +First, [`SnappyInputBuffer`][class SnappyInputBuffer] provides access to files +compressed using Snappy and represented as `RandomAccessFile` objects. There is +also a [`SnappyOutputBuffer`][class SnappyOutputBuffer] class to write +compressed input, but there is no `OutputStreamInterface`. + +The second compression API is given by [`ZlibInputStream`][class +ZlibInputStream]. Similar to the `RandomAccessInputStream` case, this just wraps +an `InputStreamInterface`. To write to compressed zlib files, we can use +[`ZlibOutputBuffer`][class ZlibOutputBuffer] to wrap around a `WritableFile`. + +## High level filesystem API + +Building on top of the convenience API, TensorFlow code has several custom +classes and helpers to provide high level access to the filesystem. + +For example `tf.data` uses `TFRecord` support provided by [`RecordReader`][class +RecordReader], [`RecordWriter`][class RecordWriter] and +[`SequentialRecordReader`][class SequentialRecordReader] to build the +[`FileDataset`][class FileDataset] and [`FileIterator`][class FileIterator] +abstractions (and subclasses such as [`FileWriterIterator`][class +FileWriterIterator], [`FileReaderIterator`][class FileReaderIterator]). Then, +kernels and ops such as [`TextLineDatasetOp`][class TextLineDatasetOp] and +[`TFRecordDatasetOp`][class TFRecordDatasetOp] are built and then used in Python +APIs. + +Other examples include: + +* [`DumpGraphDefToFile`][DumpGraphDefToFile], + [`DumpGraphToFile`][DumpGraphToFile], + [`DumpFunctionDefToFile`][DumpFunctionDefToFile]; +* [`Table`][class Table] - immutable mapping from strings to strings backed up + by a file; +* [`BundleWriter`][class BundleWriter], [`BundleReader`][class BundleReader] - + checkpointing; +* [`TensorSliceWriter`][class TensorSliceWriter], [`TensorSliceReader`][class + TensorSliceReader] - checkpointing partitioned variables; +* [`LoadSavedModel`][LoadSavedModel] - `SavedModel` loading; +* [`EventsWriter`][class EventsWriter]; +* [`DebugFileIO`][class DebugFileIO]; +* API generation tools inside TensorFlow. + +## Additional APIs + +For some special cases or due to historical reasons, TensorFlow has a set of +filesystem APIs which cannot be directly mapped on the hierarchy described so +far. We will mention them here for completeness, but it turns out we can either +ignore them for the rest of the design as they don’t require many changes. + +### `FileBlockCache` + +The [`FileBlockCache`][class FileBlockCache] class can be used by filesystems to +cache files at the block level. Each entry in the cache is keyed by the filename +and the offset of the block in the file. Filesystem implementations are free to +ignore this class, but we’re mentioning it in this document as it is being used +by the cloud filesystems. + +In the new filesystem design, filesystems needing this functionality can just +import the corresponding targets. Since this is an implementation detail, the +caching information doesn’t need to cross the module boundary. + +### `ReaderInterface` + +The [`ReaderInterface`][class ReaderInterface] and its subclasses provides an +alternative method of reading records from files in a TensorFlow graph. It has +the following API: + +```cpp +class ReaderInterface : public ResourceBase { + // Reads one single record + virtual void Read(QueueInterface* queue, string* key, string* value, OpKernelContext* context) = 0; + // Reads up to num_records + virtual int64 ReadUpTo(const int64 num_records, QueueInterface* queue, std::vector* keys, std::vector* values, OpKernelContext* context) = 0; + + // Misc + virtual Status Reset() = 0; + virtual int64 NumRecordsProduced() = 0; + virtual Status SerializeState(string* state) = 0; + virtual Status RestoreState(const string& state) = 0; +}; +``` + +The only subclass in TensorFlow is [`ReaderBase`][class ReaderBase], which adds +API entry-points for reading while a mutex is being held: + +```cpp +class ReaderBase : public ReaderInterface { + virtual Status ReadLocked(string* key, string* value, bool* produced, bool* at_end) = 0; + virtual Status ReadUpToLocked(int64 num_records, std::vector* keys, std::vector* values, int64* num_read, bool* at_end); +}; +``` + +In this subclass, the `Read()` and `ReadUpTo()` methods are implemented in terms +of their corresponding locked methods. Furthermore, descendants of this class +only need to implement `ReadLocked()`, the only pure virtual member of the API. + +Before this proposal, there are 7 descendants of `ReaderBase` and they are used +to implement kernels and ops. All of these kernels inherit from +[`ReaderOpKernel`][class ReaderOpKernel] which handles access to the source to +be read from. Whereas [`TextLineReader`][class TextLineReader], +[`TFRecordReader`][class TFRecordReader] and [`WholeFileReader`][class +WholeFileReader] access the filesystem using the environment approach +illustrated above, the other subclasses either work with in-memory data +([`IdentityReader`][class IdentityReader], [`LMDBReader`][class LMDBReader]), +with data obtained from a remote call ([`BigQueryReader`][class BigQueryReader]) +or with data that is read using the `InputStreamInterface` mechanism described +previously ([`FixedLengthRecordReader`][class FixedLengthRecordReader]). + +In the modular design, most of these descendants will be converted for free. The +only class that might not be trivial to transfer to the new API might be +`BigQueryReader`. But, since before this proposal this class completely ignores +the filesystem APIs, we can continue with this design ignoring it for the +moment. + +### `SummaryWriterInterface` + +A [`SummaryWriterInterface`][class SummaryWriterInterface] allows writing +TensorFlow resources to a summary file, being a subclass of `ResourceBase`, just +like `ReaderInterface`. + +```cpp +class SummaryWriterInterface : public ResourceBase { + virtual Status Flush() = 0; + virtual Status WriteTensor(int64 global_step, Tensor t, const string& tag, const string& serialized_metadata) = 0; + virtual Status WriteScalar(int64 global_step, Tensor t, const string& tag) = 0; + virtual Status WriteHistogram(int64 global_step, Tensor t, const string& tag) = 0; + virtual Status WriteImage(int64 global_step, Tensor t, const string& tag, int max_images, Tensor bad_color) = 0; + virtual Status WriteAudio(int64 global_step, Tensor t, const string& tag, int max_outputs_, float sample_rate) = 0; + virtual Status WriteGraph(int64 global_step, std::unique_ptr graph) = 0; + virtual Status WriteEvent(std::unique_ptr e) = 0; +}; +``` + +When writing to files, we use the [`SummaryFileWriter`][class SummaryFileWriter] +subclass which uses the `Env` method. However, the other subclass, +[`SummaryDbWriter`][class SummaryDbWriter], uses an `Sqlite` object to talk to a +SQL database. Similar to the `BigQueryReader` case from the previous section, we +can postpone converting this to the new filesystem API until a later time. + +## IO from external libraries or other languages + +To provide functionality to read/write image/audio files, TensorFlow uses some +external libraries. Although they can do their own IO, there is glue code for +[gif][gif io], [jpeg][jpeg io], [png][png io] and [wav][wav io] files. This glue +ensures that the calls into the library use strings representing file contents +instead of letting the library do its own IO. This way, the filesystem support +that TensorFlow does is the only one accessing files on disk. + +However, there is nothing stopping future code development from directly reading +from a file on the disk (for example), either in the C/C++ code or in the Python +code. Preventing this is out of scope for the current design document. + +## Existing C API implementation + +There is an [existing C API for filesystems][c api] which we might reuse in this +design. We cannot build on top of this API as it only offers C entry points +which then call the existing C++ API functions. But, it gives us an indication +on what API we should provide, at the minimum: + +```cpp +typedef struct TF_FileStatistics { + int64_t length; + int64_t mtime_nsec; + bool is_directory; +} TF_FileStatistics; + +// filesystem manipulation +TF_CAPI_EXPORT extern void TF_CreateDir(const char* dirname, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteDir(const char* dirname, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteRecursively(const char* dirname, int64_t* undeleted_file_count, int64_t* undeleted_dir_count, TF_Status* status); +TF_CAPI_EXPORT extern void TF_DeleteFile(const char* filename, TF_Status* status); +TF_CAPI_EXPORT extern void TF_FileStat(const char* filename, TF_FileStatistics* stats, TF_Status* status); + +// writable files API +TF_CAPI_EXPORT extern void TF_NewWritableFile(const char* filename, TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_CloseWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_SyncWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_FlushWritableFile(TF_WritableFileHandle** handle, TF_Status* status); +TF_CAPI_EXPORT extern void TF_AppendWritableFile(TF_WritableFileHandle** handle, const char* data, size_t length, TF_Status* status); +``` + +This API is very incomplete, for example it lacks support for random access +files and memory mapped files. Furthermore, the `TF_WritableFileHandle` object +is just an opaque struct (in C-land) which maps over a `WritableFile` pointer +from the C++ implementation. + +Since this has to be pure C, Status objects are replaced by pointers to a +`TF_Status` structure. There is code to convert from one to the other. Moreover, +these APIs assume that the `TF_Status` object is created and managed from the +calling code, instead of returning the status from every function call. We will +follow a similar design in this proposal. + + +[filesystem_rfc]: https://github.com/tensorflow/community/pull/101 "RFC: Modular Filesystems C API" + +[class FileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L46 "class FileSystem" +[class RandomAccessFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L232 "class RandomAccessFile" +[class WritableFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L271 "class WritableFile" +[class ReadOnlyMemoryRegion]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L342 "class ReadOnlyMemoryRegion" +[class Env]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L48 "class Env" +[class FileSystemRegistry]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L360 "class FileSystemRegistry" +[class FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_statistics.h#L23 "class FileStatistics" +[struct TF_FileStatistics]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h#L36 "struct TF_FileStatistics" +[class InputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputbuffer.h#L32 "class InputBuffer" +[class InputStreamInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/inputstream_interface.h#L27 "class InputStreamInterface" +[class RandomAccessInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/random_inputstream.h#L27 "class RandomAccessInputStream" +[class BufferedInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/buffered_inputstream.h#L27 "class BufferedInputStream" +[class MemoryInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/decode_compressed_op.cc#L30 "class MemoryInputStream" +[class SnappyInputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_inputbuffer.h#L35 "class SnappyInputBuffer" +[class SnappyOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/snappy/snappy_outputbuffer.h#L46 "class SnappyOutputBuffer" +[class ZlibInputStream]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_inputstream.h#L40 "class ZlibInputStream" +[class ZlibOutputBuffer]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/zlib_outputbuffer.h#L38i "class ZlibOutputBuffer" +[class RecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L59 "class RecordReader" +[class RecordWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_writer.h#L50 "class RecordWriter" +[class SequentialRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/record_reader.h#L120 "class SequentialRecordReader" +[class FileDataset]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L50 "class FileDataset" +[class FileIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L112 "class FileIterator" +[class FileWriterIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L195 "class FileWriterIterator" +[class FileReaderIterator]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/cache_dataset_ops.cc#L439 "class FileReaderIterator" +[class TextLineDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L35 "class TextLineDatasetOp" +[class TFRecordDatasetOp]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/data/reader_dataset_ops.cc#L740 "class TFRecordDatasetOp" +[class Table]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/table.h#L34 "class Table" +[class BundleWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L108 "class BundleWriter" +[class BundleReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_bundle/tensor_bundle.h#L182 "class BundleReader" +[class TensorSliceWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_writer.h#L43 "class TensorSliceWriter" +[class TensorSliceReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/tensor_slice_reader.h#L54 "class TensorSliceReader" +[class EventsWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/events_writer.h#L31 "class EventsWriter" +[class DebugFileIO]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/debug/debug_io_utils.h#L147 "class DebugFileIO" +[class FileBlockCache]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/cloud/file_block_cache.h#L39 "class FileBlockCache" +[class ReaderInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_interface.h#L44 "class ReaderInterface" +[class ReaderBase]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_base.h#L30 "class ReaderBase" +[class ReaderOpKernel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/framework/reader_op_kernel.h#L35 "class ReaderOpKernel" +[class TextLineReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/text_line_reader_op.cc#L28 "class TextLineReader" +[class TFRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/tf_record_reader_op.cc#L28 "class TFRecordReader" +[class WholeFileReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/whole_file_read_ops.cc#L45 "class WholeFileReader" +[class IdentityReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/identity_reader_op.cc#L29 "class IdentityReader" +[class LMDBReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/lmdb_reader_op.cc#L27 "class LMDBReader" +[class BigQueryReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/contrib/cloud/kernels/bigquery_reader_ops.cc#L52 "class BigQueryReader" +[class FixedLengthRecordReader]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/fixed_length_record_reader_op.cc#L33 "class FixedLengthRecordReader" +[class SummaryWriterInterface]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/kernels/summary_interface.h#L30 "class SummaryWriterInterface" +[class SummaryFileWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_file_writer.cc#L30 "class SummaryFileWriter" +[class SummaryDbWriter]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/summary/summary_db_writer.cc#L875 "class SummaryDbWriter" + +[CleanPath]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/io/path.h#L74 "tensorflow::lib::io::CleanPath()" +[FileSystemCopyFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L430 "FileSystemCopyFile()" +[GetMatchingPaths]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system_helper.h#L45 "GetMatchingPaths()" +[DumpGraphDeftoFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L36 "DumpGraphDefToFile()" +[DumpGraphToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L41 "DumpGraphToFile()" +[DumpFunctionDefToFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/util/dump_graph.h#L47 "DumpFunctionDefToFile()" +[LoadSavedModel]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/cc/saved_model/loader.h#L50 "LoadSaveDModel()" + +[HadoopFileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/hadoop/hadoop_file_system.cc#L368-L377 "HadoopFileSystem::NewReadOnlyMemoryRegionFromFile()" +[FileSystemRegistry init]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.cc#L93 "initialization of FileSystemRegistry" + +[REGISTER_FILE_SYSTEM]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/env.h#L480 "REGISTER_FILE_SYSTEM(scheme, factory)" + +[gif io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/gif +[jpeg io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/jpeg +[png io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/png +[wav io]: https://github.com/tensorflow/tensorflow/tree/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/lib/wav + +[c api]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/c/env.h + +[load_library]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/python/framework/load_library.py#L132 From 0ee29880447918277f89b12cb3dc1fad94693149 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 09:51:41 -0700 Subject: [PATCH 08/16] Specify that new method will call the old one when only signature changes --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 08cdc5739..4f344e758 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -712,7 +712,8 @@ To increase the range of compatibility, we will give a guarantee that, except on new major versions, new methods will only be added to the end of each of these structures and that no method will be deleted from the table. Changing the signature of a method will be handled by adding the method with the new -signature to the end of the table and marking the old method as deprecated. +signature to the end of the table and marking the old method as deprecated as +well as ensuring that the new method will call the old one where needed. Deprecation of a method will be done in two parts. First, we will add compiler pragmas to warn the users compiling against the interface and relying on From 84184167cd623ba74d7014866e54b01c9a82798e Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 09:55:29 -0700 Subject: [PATCH 09/16] Specify that versioning information is ellided when presenting API --- .../20190506-filesystem-plugin-modular-tensorflow.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 4f344e758..08b90942e 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -458,12 +458,18 @@ filesystem API, but we can expand them as the review progresses: ```cpp // Operations on a TF_RandomAccessFile typedef struct TF_RandomAccessFileOps { + // versioning information ellided for now + // ... + // API information below size_t (*const Read)(const TF_RandomAccessFile*, uint64, size_t, char*, TF_Status*); void (*const Cleanup)(TF_RandomAccessFile*); } TF_RandomAccessFileOps; // Operations on a TF_WritableFile typedef struct TF_WritableFileOps { + // versioning information ellided for now + // ... + // API information below void (*const Append)(const TF_WritableFile*, const char*, size_t, TF_Status*); void (*const Close)(TF_WritableFile*, TF_Status*); void (*const Cleanup)(TF_WritableFile*); @@ -475,6 +481,9 @@ typedef struct TF_WritableFileOps { // Operations on a TF_ReadOnlyMemoryRegion typedef struct TF_ReadOnlyMemoryRegionOps { + // versioning information ellided for now + // ... + // API information below const void* (*const Data)(const TF_ReadOnlyMemoryRegion*); uint64 (*const Length)(const TF_ReadOnlyMemoryRegion*); void (*const Cleanup)(TF_ReadOnlyMemoryRegion*); @@ -483,6 +492,9 @@ typedef struct TF_ReadOnlyMemoryRegionOps { // Operations on a TF_Filesystem typedef struct TF_FilesystemOps { + // versioning information ellided for now + // ... + // API information below void (*const NewRandomAccessFile)(const TF_Filesystem*, const char*, TF_RandomAccessFile*, TF_Status*); void (*const NewWritableFile)(const TF_Filesystem*, const char*, TF_WritableFile*, TF_Status*); void (*const NewAppendableFile)(const TF_Filesystem*, const char*, TF_WritableFile*, TF_Status*); From 0e08da2b845fd23527d1f10a5459e149c213a5e7 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:14:36 -0700 Subject: [PATCH 10/16] Env class can be just extended with a new lookup layer instead of subclassing --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 08b90942e..1dba09619 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -647,10 +647,13 @@ existing `Factory`-based implementation since the constructor of operations supported by the filesystem. Because of this change, we also need a new subclass of `Env`, as each instance -of `Env` has the `FileSystemRegistry` baked in at construction time. Actually, -since most of the functionality calls `Env::Default()` to obtain the static -instance of `Env` and then extract the filesystem from there, we can get rid of -the level of indirection via `Env` and create a static instance of +of `Env` has the `FileSystemRegistry` baked in at construction time. In fact, we +can just change the existing class to have two lookup layers for the two +registries. + +Furthermore, since most of the functionality calls `Env::Default()` to obtain +the static instance of `Env` and then extract the filesystem from there, we can +get rid of the level of indirection via `Env` and create a static instance of `ModularFileSystem`. This will be possible only after all filesystems use the modular approach, after the changes mentioned in the next section. From 32ec6e1b5730e71c7cb8e2fe1d662cdeada44592 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:14:48 -0700 Subject: [PATCH 11/16] Add questions, cost and leaning --- ...06-filesystem-plugin-modular-tensorflow.md | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 1dba09619..562bba361 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -771,6 +771,44 @@ During registration we can check all of the fields and store some for later use (e.g., for displaying better error message, localizing the plugin in error). +## Questions and comments raised during review + +1. **Should we make the function tables public or hide them and only offer + allocate/free/set/get methods??** The proposed API above uses public + structures for simplicity but both can be implemented. A benefit of using + private structures is that we get some extra memory safety guarantees as + plugin code won't be able to directly access fields of the structure and + won't be required to keep track of structure size during + allocation/deallocation. The downside of having private structures is that + there is slightly more code needed at plugin initialization both on the + plugin side (calling all the setters instead of just filling in a structure + using initializer lists) as well as on core side (ensuring that once a + pointer has been set it won't be set again). Having structures public serves + as a quick documentation of the API that needs to be provided, documentation + which is much clearer than reading through several setters of function + pointers. After analyzing the cost/benefits, we're leaning towards + **private**. + +1. **Should we use the size of the structures or the number of methods in the + structures as versioning information?** If the structures are private, we can + do either. If the structures are public storing the size helps in memory + safety. Leaning towards **size**. + +1. **Should we enforce file ops to also take a pointer to the filesystem?** (for + example `Read` in `TF_RandomAccessFileOps` should take both a pointer to + `TF_RandomAccessFile` and a pointer to `TF_Filesystem` or only the first + pointer? Having a direct pointer to `TF_Filesystem` allows storing the state + of the filesystem but we argue that this is not needed for all filesystem + implementations and in the cases where is needed the plugin can store a + pointer to the filesystem inside of the memory pointed to by the + `TF_RandomAccessFile` pointer. Leaning towards **NO**. + +1. **Should we pass plugin structs by value during registration?** Doing so + makes ownership clear and prevents memory allocation bugs. Passing them by + value results in a copy but we need a copy for security reasons anyway. We're + leaning towards **YES**. + + [modular_rfc]: https://github.com/tensorflow/community/pull/77 "RFC: Modular TensorFlow" [filesystem appendix]: 20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.png "A detailed presentation of TensorFlow's filesystem support" From b590412bf49a2cd57aba6617b5e6e47645c7a8b3 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:26:45 -0700 Subject: [PATCH 12/16] Fix appendix link --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 562bba361..09235d643 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -810,7 +810,7 @@ During registration we can check all of the fields and store some for later use [modular_rfc]: https://github.com/tensorflow/community/pull/77 "RFC: Modular TensorFlow" -[filesystem appendix]: 20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.png "A detailed presentation of TensorFlow's filesystem support" +[filesystem appendix]: 20190506-filesystem-plugin-modular-tensorflow/existing_filesystem_review.md "A detailed presentation of TensorFlow's filesystem support" [class FileSystem]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L46 "class FileSystem" [class RandomAccessFile]: https://github.com/tensorflow/tensorflow/blob/69bd23af10506b0adae9b9795a00d4dc05b8a7fd/tensorflow/core/platform/file_system.h#L232 "class RandomAccessFile" From 96b33661acd7ec2a53bcc1adb5ff5ded7baf46ef Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:52:10 -0700 Subject: [PATCH 13/16] Fix spelling of elided --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 09235d643..72ba54144 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -458,7 +458,7 @@ filesystem API, but we can expand them as the review progresses: ```cpp // Operations on a TF_RandomAccessFile typedef struct TF_RandomAccessFileOps { - // versioning information ellided for now + // versioning information elided for now // ... // API information below size_t (*const Read)(const TF_RandomAccessFile*, uint64, size_t, char*, TF_Status*); @@ -467,7 +467,7 @@ typedef struct TF_RandomAccessFileOps { // Operations on a TF_WritableFile typedef struct TF_WritableFileOps { - // versioning information ellided for now + // versioning information elided for now // ... // API information below void (*const Append)(const TF_WritableFile*, const char*, size_t, TF_Status*); @@ -481,7 +481,7 @@ typedef struct TF_WritableFileOps { // Operations on a TF_ReadOnlyMemoryRegion typedef struct TF_ReadOnlyMemoryRegionOps { - // versioning information ellided for now + // versioning information elided for now // ... // API information below const void* (*const Data)(const TF_ReadOnlyMemoryRegion*); @@ -492,7 +492,7 @@ typedef struct TF_ReadOnlyMemoryRegionOps { // Operations on a TF_Filesystem typedef struct TF_FilesystemOps { - // versioning information ellided for now + // versioning information elided for now // ... // API information below void (*const NewRandomAccessFile)(const TF_Filesystem*, const char*, TF_RandomAccessFile*, TF_Status*); From 5e009caebb532f34271e31819537316506ed3be9 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:56:34 -0700 Subject: [PATCH 14/16] Remove duplicated character typo --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 72ba54144..2e7af1bf8 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -774,7 +774,7 @@ During registration we can check all of the fields and store some for later use ## Questions and comments raised during review 1. **Should we make the function tables public or hide them and only offer - allocate/free/set/get methods??** The proposed API above uses public + allocate/free/set/get methods?** The proposed API above uses public structures for simplicity but both can be implemented. A benefit of using private structures is that we get some extra memory safety guarantees as plugin code won't be able to directly access fields of the structure and From b0886bcf80398d2e66cdfd11485a411f1848dcf8 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Tue, 7 May 2019 10:58:33 -0700 Subject: [PATCH 15/16] Remove needless capitalization --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index 2e7af1bf8..de1f38573 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -801,12 +801,12 @@ During registration we can check all of the fields and store some for later use of the filesystem but we argue that this is not needed for all filesystem implementations and in the cases where is needed the plugin can store a pointer to the filesystem inside of the memory pointed to by the - `TF_RandomAccessFile` pointer. Leaning towards **NO**. + `TF_RandomAccessFile` pointer. Leaning towards **No**. 1. **Should we pass plugin structs by value during registration?** Doing so makes ownership clear and prevents memory allocation bugs. Passing them by value results in a copy but we need a copy for security reasons anyway. We're - leaning towards **YES**. + leaning towards **Yes**. [modular_rfc]: https://github.com/tensorflow/community/pull/77 "RFC: Modular TensorFlow" From 23e1fa210f8963b0d79f1493cb912a1e5b835055 Mon Sep 17 00:00:00 2001 From: Mihai Maruseac Date: Thu, 30 May 2019 14:41:22 -0700 Subject: [PATCH 16/16] Change status to accepted --- rfcs/20190506-filesystem-plugin-modular-tensorflow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md index de1f38573..faf936026 100644 --- a/rfcs/20190506-filesystem-plugin-modular-tensorflow.md +++ b/rfcs/20190506-filesystem-plugin-modular-tensorflow.md @@ -1,6 +1,6 @@ # Modular Filesystems C API -| Status | Proposed | +| Status | Accepted | :-------------- |:---------------------------------------------------- | | **Author(s)** | Mihai Maruseac (mihaimaruseac@google.com) | | **Sponsor** | Gunhan Gulsoy (gunan@google.com) |