Lustre (file system)

"Cluster File Systems" redirects here. For the generic term, see Clustered file system. For the programming language, see Lustre (programming language).
Initial release December 16, 2003 (2003-12-16)[1]
Stable release
2.5.3 (last public Intel maintenance release),[2]

2.8.0 (latest major release)[3]

/ March 16, 2016 (2016-03-16)
Preview release
2.8.59 / October 7, 2016 (2016-10-07)
Written in C
Operating system Linux kernel
Type Distributed file system
License GPL v2
Cluster File Systems, Inc.
Founded 2001
Founder Peter J. Braam
Headquarters Boulder, Colorado
Key people
Phil Schwan, Eric Barton, Andreas Dilger
Products Lustre file system
Introduced December, 2003 with Linux
Directory contents Hash, Interleaved Hash with DNE in 2.7+
Min. volume size 32 MB
Max. volume size 100 PB (production), over 16 EB (theoretical)
Max. file size 3.2 PB (ext4), 16 EB (ZFS)
File size granularity 4 KB
Max. number of files Per Metadata Target (MDT): 4 billion files (ldiskfs backend), 256 trillion files (ZFS backend),[4] up to 128 MDTs per filesystem
Max. filename length 255 bytes
Max. dirname length 255 bytes
Max. directory depth 4096 bytes
Allowed characters in filenames All bytes except NUL ('\0') and '/' and the special file names "." and ".."
Dates recorded modification (mtime), attribute modification (ctime), access (atime), delete (dtime), create (crtime)
Date range 2^34 bits (ext4), 2^64 bits (ZFS)
Date resolution 1 s
Forks n
Attributes 32bitapi, acl, checksum, flock, lazystatfs, localflock, lruresize, noacl, nochecksum, noflock, nolazystatfs, nolruresize, nouser_fid2path, nouser_xattr, user_fid2path, user_xattr
File system permissions POSIX
Transparent compression y (ZFS)
Transparent encryption n
Data deduplication y (ZFS)
Copy-on-write y (ZFS)
Supported operating systems Linux kernel

Lustre is a type of parallel distributed file system, generally used for large-scale cluster computing. The name Lustre is a portmanteau word derived from Linux and cluster.[5] Lustre file system software is available under the GNU General Public License (version 2 only) and provides high performance file systems for computer clusters ranging in size from small workgroup clusters to large-scale, multi-site clusters.

Because Lustre file systems have high performance capabilities and open licensing, it is often used in supercomputers. Since June 2005, it has consistently been used by at least half of the top ten, and more than 60 of the top 100 fastest supercomputers in the world,[6][7][8] including the world's No. 2 and No. 3 ranked TOP500 supercomputers in 2014, Titan and Sequoia.[9][10]

Lustre file systems are scalable and can be part of multiple computer clusters with tens of thousands of client nodes, tens of petabytes (PB) of storage on hundreds of servers, and more than a terabyte per second (TB/s) of aggregate I/O throughput.[11][12] This makes Lustre file systems a popular choice for businesses with large data centers, including those in industries such as meteorology, simulation, oil and gas, life science, rich media, and finance.[13]


The Lustre file system architecture was started as a research project in 1999 by Peter J. Braam, who was on the staff of Carnegie Mellon University (CMU) at the time. Braam went on to found his own company Cluster File Systems in 2001,[14] starting from work on the InterMezzo file system in the Coda project at CMU.[15] Lustre was developed under the Accelerated Strategic Computing Initiative Path Forward project funded by the United States Department of Energy, which included Hewlett-Packard and Intel.[16] In September 2007, Sun Microsystems acquired the assets of Cluster File Systems Inc. including its intellectual property.[17][18] Sun included Lustre with its high-performance computing hardware offerings, with the intent to bring Lustre technologies to Sun's ZFS file system and the Solaris operating system. In November 2008, Braam left Sun Microsystems, and Eric Barton and Andreas Dilger took control of the project. In 2010 Oracle Corporation, by way of its acquisition of Sun, began to manage and release Lustre.

In December 2010, Oracle announced they would cease Lustre 2.x development and place Lustre 1.8 into maintenance-only support creating uncertainty around the future development of the file system.[19] Following this announcement, several new organizations sprang up to provide support and development in an open community development model, including Whamcloud,[20] Open Scalable File Systems, Inc. (OpenSFS), EUROPEAN Open File Systems (EOFS) and others. By the end of 2010, most Lustre developers had left Oracle. Braam and several associates joined the hardware-oriented Xyratex when it acquired the assets of ClusterStor,[21][22] while Barton, Dilger, and others formed software startup Whamcloud, where they continued to work on Lustre.[23]

In August 2011, OpenSFS awarded a contract for Lustre feature development to Whamcloud.[24] This contract covered the completion of features, including improved Single Server Metadata Performance scaling, which allows Lustre to better take advantage of many-core metadata server; online Lustre distributed filesystem checking (LFSCK), which allows verification of the distributed filesystem state between data and metadata servers while the filesystem is mounted and in use; and Distributed Namespace (DNE), formerly Clustered Metadata (CMD), which allows the Lustre metadata to be distributed across multiple servers. Development also continued on ZFS-based back-end object storage at Lawrence Livermore National Laboratory.[10] These features were in the Lustre 2.2 through 2.4 community release roadmap.[25] In November 2011, a separate contract was awarded to Whamcloud for the maintenance of the Lustre 2.x source code to ensure that the Lustre code would receive sufficient testing and bug fixing while new features were being developed.[26]

In July 2012 Whamcloud was acquired by Intel,[27][28] after Whamcloud won the FastForward DOE contract to extend Lustre for exascale computing systems in the 2018 timeframe.[29] OpenSFS then transitioned contracts for Lustre development to Intel.

In February 2013, Xyratex Ltd., announced it acquired the original Lustre trademark, logo, website and associated intellectual property from Oracle.[21] In June 2013, Intel began expanding Lustre usage beyond traditional HPC, such as within Hadoop.[30] For 2013 as a whole, OpenSFS announced request for proposals (RFP) to cover Lustre feature development, parallel file system tools, addressing Lustre technical debt, and parallel file system incubators.[31] OpenSFS also established the Lustre Community Portal, a technical site that provides a collection of information and documentation in one area for reference and guidance to support the Lustre open source community. On April 8, 2014, Ken Claffey announced that Xyratex/Seagate is donating the domain back to the user community,[32] and was completed in March, 2015.

Release history

A Lustre file system was first installed for production use in March 2003 on the MCR Linux Cluster at Lawrence Livermore National Laboratory,[33] one of the largest supercomputers at the time.[34]

Lustre 1.0.0 was released in December 2003,[1] and provided basic Lustre filesystem functionality, including server failover and recovery.

Lustre 1.2.0, released in March 2004, worked on Linux kernel 2.6, and had a "size glimpse" feature to avoid lock revocation on files undergoing write, and client side data write-back cache accounting (grant).

Lustre 1.4.0, released in November 2004, provided protocol compatibility between versions, could use InfiniBand networks, and could exploit extents/mballoc in the ldiskfs on-disk filesystem.

Lustre 1.6.0, released in April 2007, allowed mount configuration (“mountconf”) allowing servers to be configured with "mkfs" and "mount", allowed dynamic addition of object storage targets (OSTs), enabled Lustre distributed lock manager (LDLM) scalability on symmetric multiprocessing (SMP) servers, and provided free space management for object allocations.

Lustre 1.8.0, released in May 2009, provided OSS Read Cache, improved recovery in the face of multiple failures, added basic heterogeneous storage management via OST Pools, adaptive network timeouts, and version-based recovery. It was a transition release, being interoperable with both Lustre 1.6 and Lustre 2.0.[35]

Lustre 2.0, released in August 2010, was based on significant internally restructured code to prepare for major architectural advancements. Lustre 2.x clients cannot interoperate with 1.8 or earlier servers. However, Lustre 1.8.6 and later clients can interoperate with Lustre 2.0 and later servers. The Metadata Target (MDT) and OST on-disk format from 1.8 can be upgraded to 2.0 and later without the need to reformat the filesystem.

Lustre 2.1, released in September 2011, was a community-wide initiative in response to Oracle suspending development on Lustre 2.x releases.[36] It adds the ability to run servers on Red Hat Linux 6 and increases the maximum ext4-based OST size from 24 TB to 128 TB,[37] as well as a number of performance and stability improvements. Lustre 2.1 servers remain interoperable with 1.8.6 and later clients, and is the new long-term maintenance release for Lustre.

Lustre 2.2, released in March 2012, focused on providing metadata performance improvements and new features.[38] It adds parallel directory operations allowing multiple clients to traverse and modify a single large directory concurrently, faster recovery from server failures, increased stripe counts for a single file (across up to 2000 OSTs), and improved single-client directory traversal (ls -l, find, du) performance.

Lustre 2.3, released in October 2012, continued to optimize the metadata server code to remove internal locking bottlenecks on nodes with many CPU cores (over 16). The object store added a preliminary ability to use ZFS as the backing file system. The Lustre File System ChecK (LFSCK) feature can verify and repair the MDS Object Index (OI) while the file system is in use, after a file-level backup/restore or in case of MDS corruption. The server-side IO statistics were enhanced to allow integration with batch job schedulers such as SLURM to track per-job statistics. Client-side software was updated to work with Linux kernels up to version 3.0.

Lustre 2.4, released in May 2013, added a considerable number of major features, many funded directly through OpenSFS. Distributed Namespace (DNE) allows horizontal metadata capacity and performance scaling for 2.4 clients, by allowing subdirectory trees of a single namespace to be located on separate MDTs. ZFS can now be used as the backing filesystem for both MDT and OST storage. The LFSCK feature added the ability to scan and verify the internal consistency of the MDT FID and LinkEA attributes. The Network Request Scheduler (NRS) adds policies to optimize client request processing for disk ordering or fairness. Clients can optionally send bulk RPCs up to 4 MB in size. Client-side software was updated to work with Linux kernels up to version 3.6, and is still interoperable with 1.8 clients.

Lustre 2.5, released in October 2013, added the highly anticipated feature, Hierarchical Storage Management (HSM). A core requirement in enterprise environments, HSM allows customers to easily implement tiered storage solutions in their operational environment. This release is the current OpenSFS-designated Maintenance Release branch of Lustre.[39][40][41][42] The most recent maintenance version is 2.5.3 and was released in September 2014.[2]

Lustre 2.6, released in July 2014,[43] was a more modest release feature wise, adding LFSCK functionality to do local consistency checks on the OST as well as consistency checks between MDT and OST objects. Single-client IO performance was improved over the previous releases.[44] This release also added a preview of DNE striped directories, allowing single large directories to be stored on multiple MDTs to improve performance and scalability.

Lustre 2.7, released in March 2015,[45] added LFSCK functionality to verify DNE consistency of remote and striped directories between multiple MDTs. Dynamic LNet Config adds the ability to configure and modify LNet network interfaces, routes, and routers at runtime. A new evaluation feature was added for UID/GID mapping for clients with different administrative domains, along with improvements to the DNE striped directory functionality.

Lustre 2.8, released in March 2016,[3] finished the DNE striped directory feature, including support for migrating directories between MDTs, and cross-MDT hard link and rename. As well, it included improved support for Security-Enhanced Linux (SELinux) on the client, Kerberos authentication and RPC encryption over the network, and performance improvements for LFSCK.


A Lustre file system has three major functional units:

The MDT, OST, and client may be on the same node (usually for testing purposes), but in typical production installations these devices are on separate nodes communicating over a network. Each MDT and OST may be part of only a single filesystem, though it is possible to have multiple MDTs or OSTs on a single node that are part of different filesystems. The Lustre Network (LNet) layer can use several types of network interconnects, including native InfiniBand verbs, TCP/IP on Ethernet, Omni-Path, and other proprietary network technologies such as the Cray Gemini interconnect. In Lustre 2.3 and earlier, Myrinet, Quadrics, Cray SeaStar and RapidArray networks were also supported, but these network drivers were deprecated when these networks were no longer commercially available, and support was removed completely in Lustre 2.8. Lustre will take advantage of remote direct memory access (RDMA) transfers, when available, to improve throughput and reduce CPU usage.

The storage used for the MDT and OST backing filesystems is normally provided by hardware RAID devices, though will work with any block devices. Since Lustre 2.4, the MDT and OST can also use ZFS for the backing filesystem, allowing them to effectively use JBOD storage instead of hardware RAID devices. The Lustre OSS and MDS servers read, write, and modify data in the format imposed by the backing filesystem and return this data to the clients. This allows Lustre to take advantage of improvements and features in the underlying filesystem, such as compression and data checksums in ZFS. Clients do not have any direct access to the underlying storage.

An OST is a dedicated filesystem that exports an interface to byte ranges of file objects for read/write operations. An MDT is a dedicated filesystem that stores inodes, attributes, and directories; controls file access, and tells clients the layout of the object(s) that make up each regular file. MDTs and OSTs currently use either an enhanced version of ext4 called ldiskfs, or ZFS/DMU for back-end data storage to store files/objects[46] using the open source ZFS-on-Linux port.[47]

When a client accesses a file, it performs a filename lookup on the MDS. When the MDS filename lookup is complete, either the layout of an existing file is returned to the client or a new file is created on behalf of the client, if requested. For read or write operations, the client then interprets the file layout in the logical object volume (LOV) layer, which maps the file offset and size to one or more objects, each residing on a separate OST. The client then locks the file range being operated on and executes one or more parallel read or write operations directly to the OSS nodes. With this approach, bottlenecks for client-to-OSS communications are eliminated, so the total bandwidth available for the clients to read and write data scales almost linearly with the number of OSTs in the filesystem.

After the initial lookup of the file layout, the MDS is not involved in file IO operations since all block allocation is managed internally by the OST. Clients do not directly modify the objects on the OST filesystems, but instead delegate this task to OSS nodes. This approach ensures scalability for large-scale clusters and supercomputers, as well as improved security and reliability. In contrast, shared block-based filesystems such as Global File System and OCFS must allow direct access to all of the underlying storage by all of the clients in the filesystem, which requires a large back-end SAN attached to all clients, and increases the risk of filesystem corruption from misbehaving/defective clients.


In a typical Lustre installation on a Linux client, a Lustre filesystem driver module is loaded into the kernel and the filesystem is mounted like any other local or network filesystem. Client applications see a single, unified filesystem even though it may be composed of tens to thousands of individual servers and MDT/OST filesystems.

On some massively parallel processor (MPP) installations, computational processors can access a Lustre file system by redirecting their I/O requests to a dedicated I/O node configured as a Lustre client. This approach is used in the Blue Gene installation[48] at Lawrence Livermore National Laboratory.

Another approach used in the early years of Lustre is the liblustre library on the Cray XT3 using the Catamount operating system on systems such as Sandia Red Storm,[49] which provided userspace applications with direct filesystem access. Liblustre was a user-level library that allows computational processors to mount and use the Lustre file system as a client. Using liblustre, the computational processors could access a Lustre file system even if the service node on which the job was launched is not a Linux client. Liblustre allowed data movement directly between application space and the Lustre OSSs without requiring an intervening data copy through the kernel, thus providing access from computational processors to the Lustre file system directly in a constrained operating environment. The liblustre functionality was deleted from Lustre 2.7.0 after having been disabled since Lustre 2.6.0, and was untested since Lustre 2.3.0.

Data objects and file striping

In a traditional Unix disk file system, an inode data structure contains basic information about each file, such as where the data contained in the file is stored. The Lustre file system also uses inodes, but inodes on MDTs point to one or more OST objects associated with the file rather than to data blocks. These objects are implemented as files on the OSTs. When a client opens a file, the file open operation transfers a set of object identifiers and their layout from the MDS to the client, so that the client can directly interact with the OSS node where the object is stored. This allows the client to perform I/O in parallel across all of the OST objects in the file without further communication with the MDS.

If only one OST object is associated with an MDT inode, that object contains all the data in the Lustre file. When more than one object is associated with a file, data in the file is "striped" in chunks in a round-robin manner across the OST objects similar to RAID 0. Striping a file over multiple OST objects provides significant performance benefits if there is a need for high bandwidth access to a single large file. When striping is used, the maximum file size is not limited by the size of a single target. Capacity and aggregate I/O bandwidth scale with the number of OSTs a file is striped over. Also, since the locking of each object is managed independently for each OST, adding more stripes (one per OST) scales the file I/O locking capacity of the file proportionately. Each file created in the filesystem may specify different layout parameters, such as the stripe count (number of OST objects making up that file), stripe size (unit of data stored on each OST before moving to the next), and OST selection, so that performance and capacity can be tuned optimally for each file. When many application threads are reading or writing to separate files in parallel, it is optimal to have a single stripe per file, since the application is providing its own parallelism. When there are many threads reading or writing a single large file concurrently, then it is optimal to have one stripe on each OST to maximize the performance and capacity of that file.

Metadata objects and DNE remote or striped directories

When multiple MDTs are configured for a filesystem, the client determines on which MDT a given filename resides on by looking up the 128-bit Lustre File Identifier (FID, composed of the Sequence number and Object ID) of the parent directory in the FID Location Database (FLDB), which maps the Sequence to a specific MDT. Once the MDT of the parent directory is determined, further directory operations (for non-striped directories) take place exclusively on that MDT, avoiding contention between MDTs. For striped directories, the per-directory layout stored on the parent directory provides a hash function and list of MDT objects across which the directory is distributed. The filename is hashed and mapped to a specific MDT shard, which will handle further operations on that file in an identical manner to a non-striped directory. For readdir() operations, the entries from each directory shard are returned interleaved in hash order so that a single 64-bit cookie can be used to determine the current offset within the directory.


The Lustre distributed lock manager (LDLM), implemented in the OpenVMS style, protects the integrity of each file's data and metadata. Access and modification of a Lustre file is completely cache coherent among all of the clients. Metadata locks are managed by the MDT that stores the inode for the file, using FID as the resource name. The metadata locks are split into separate bits that protect the lookup of the file (file owner and group, permission and mode, and access control list (ACL)), the state of the inode (directory size, directory contents, link count, timestamps), layout (file striping, since Lustre 2.4), and extended attributes (xattrs, since Lustre 2.5). A client can fetch multiple metadata lock bits for a single inode with a single RPC request, but currently they are only ever granted a read lock for the inode. The MDS manages all modifications to the inode in order to avoid lock resource contention and is currently the only node that gets write locks on inodes.

File data locks are managed by the OST on which each object of the file is striped, using byte-range extent locks. Clients can be granted overlapping read extent locks for part or all of the file, allowing multiple concurrent readers of the same file, and/or non-overlapping write extent locks for independent regions of the file. This allows many Lustre clients to access a single file concurrently for both read and write, avoiding bottlenecks during file I/O. In practice, because Linux clients manage their data cache in units of pages, the clients will request locks that are always an integer multiple of the page size (4096 bytes on most clients). When a client is requesting an extent lock the OST may grant a lock for a larger extent than originally requested, in order to reduce the number of lock requests that the client makes. The actual size of the granted lock depends on several factors, including the number of currently-granted locks on that object, whether there are conflicting write locks for the requested lock extent, and the number of pending lock requests on that object. The granted lock is never smaller than the originally-requested extent. OST extent locks use the Lustre FID of the object as the resource name for the lock. Since the number of extent lock servers scales with the number of OSTs in the filesystem, this also scales the aggregate locking performance of the filesystem, and of a single file if it is striped over multiple OSTs.


In a cluster with a Lustre file system, the system network connecting the servers and the clients is implemented using Lustre Networking (LNet), which provides the communication infrastructure required by the Lustre file system. Disk storage is connected to the Lustre MDS and OSS server nodes using direct attached storage (SAS, FC, iSCSI) or traditional storage area network (SAN) technologies.

LNet can use many commonly-used network types, such as InfiniBand and TCP (commonly Ethernet) networks, and allows simultaneous availability across multiple network types with routing between them. Remote Direct Memory Access (RDMA) is permitted when available on the underlying networks such as InfiniBand, RoCE, iWARP, and Omni-Path. High availability and recovery features enable transparent recovery in conjunction with failover servers.

LNet provides end-to-end throughput over Gigabit Ethernet networks in excess of 100 MB/s,[50] throughput up to 3 GB/s using InfiniBand quad data rate (QDR) links, and throughput over 1 GB/s across 10 Gigabit Ethernet interfaces.

High availability

Lustre file system high availability features include a robust failover and recovery mechanism, making server failures and reboots transparent. Version interoperability between successive minor versions of the Lustre software enables a server to be upgraded by taking it offline (or failing it over to a standby server), performing the upgrade, and restarting it, while all active jobs continue to run, experiencing a delay while the backup server takes over the storage.

Lustre MDSes are configured as an active/passive pair, while OSSes are typically deployed in an active/active configuration that provides redundancy without extra overhead. Often the standby MDS for one filesystem is the active MDS for another file system, so no nodes are idle in the cluster.


Lustre is used by many of the TOP500 supercomputers and large multi-cluster sites. Six of the top 10 and more than 60 of the top 100 supercomputers use Lustre file systems. These include: K computer at the RIKEN Advanced Institute for Computational Science,[10] the Tianhe-1A at the National Supercomputing Center in Tianjin, China, the Jaguar and Titan at Oak Ridge National Laboratory (ORNL), Blue Waters at the University of Illinois, and Sequoia and Blue Gene/L at Lawrence Livermore National Laboratory (LLNL).

There are also large Lustre filesystems at the National Energy Research Scientific Computing Center, Pacific Northwest National Laboratory, Texas Advanced Computing Center, Brazilian National Laboratory of Scientific Computing,[51] and NASA[52] in North America, in Asia at Tokyo Institute of Technology,[53] in Europe at CEA,[54][55] and others.

Commercial technical support

Commercial technical support for Lustre is available. In most cases, this support is bundled along with the computing system or storage hardware sold by the vendor. Some vendors selling bundled computing and Lustre storage systems include Cray,[56] Dell,[57] Hewlett-Packard, Groupe Bull, Silicon Graphics International,[58][59] Fujitsu.[60] Vendors selling storage hardware with bundled Lustre support include Hitachi Data Systems,[61] DataDirect Networks (DDN),[62] NetApp, Seagate,[63] and many others. It is also possible to get software-only support for Lustre file systems from some vendors, including Intel's High Performance Data Division.[64]

See also


  1. 1 2 Corbet, Jonathon (December 17, 2003). "Lustre 1.0 released". Linux Weekly News. Retrieved March 15, 2015.
  2. 1 2 Jones, Peter (September 9, 2014). "Lustre 2.5.3 released". HPDD-discuss mailing list archive. Retrieved October 21, 2014. Morrone, Chris (May 20, 2015). "Retired Release Terminology". Lustre Wiki. Retrieved January 18, 2016.
  3. 1 2 Jones, Peter (March 16, 2016). "Lustre 2.8.0 released". Lustre-announce mailing list archive. Retrieved March 28, 2016.
  4. Oracle Corporation / Intel Corporation (August 4, 2002). "Lustre* Software Release 2.x Operations Manual" (PDF). Instruction Manual. Intel. Retrieved May 19, 2015.
  5. "Lustre Home". Archived from the original on March 31, 2001. Retrieved September 23, 2013.
  6. "Lustre File System, Version 2.4 Released". Open Scalable File Systems. Retrieved 2014-10-18.
  7. "Open-source Lustre gets supercomputing nod". Retrieved 2014-10-18.
  8. "Xyratex Captures Oracle's Lustre". HPCWire. Retrieved 2014-10-18.
  9. "Titan System Overview". Oak Ridge National Laboratory. Retrieved 2013-09-19.
  10. 1 2 3 Brian Behlendorf. "ZFS on Linux for Lustre" (PDF). Lawrence Livermore National Laboratory. Retrieved 2014-10-18.
  11. "Spider Center-Wide File System". Oak Ridge Leadership Computing Facility. Retrieved 2012-02-02.
  12. "Rock-Hard Lustre: Trends in Scalability and Quality" (PDF). Nathan Rutman, Xyratex. Retrieved 2012-02-02.
  13. Lustre File System presentation, November 2007 on YouTube By Peter Braam, November 10, 2007
  14. "Company". old web site. Cluster File Systems, Inc. Archived from the original on August 12, 2007.
  15. Peter J. Braam (August 4, 2002). "Lustre, The Inter-Galactic File System" (PDF). Presentation slides. Lawrence Livermore National Laboratory. Retrieved September 23, 2013.
  16. R. Kent Koeninger (June 2003). "The Ultra-Scalable HPTC Lustre Filesystem" (PDF). Slides for presentation at Cluster World 2003. Retrieved September 23, 2013.
  17. Britta Wülfing (September 13, 2007). "Sun Assimilates Lustre Filesystem". Linux Magazine. Retrieved September 23, 2013.
  18. "Sun Microsystems Expands High Performance Computing Portfolio with Definitive Agreement to Acquire Assets of Cluster File Systems, Including the Lustre File System". Press release. Sun Microsystems. September 12, 2007. Archived from the original on October 2, 2007. Retrieved September 23, 2013.
  19. "Oracle has Kicked Lustre to the Curb". Inside HPC. 2011-01-10.
  20. J. Leidel (August 20, 2010). "Whamcloud aims to make sure Lustre has a future in HPC". Inside HPC. Retrieved September 23, 2013.
  21. 1 2 "Xyratex Advances Lustre® Initiative, Assumes Ownership of Related Assets". Press release. Xyratex. February 19, 2013. Retrieved September 18, 2013.
  22. Rich Brueckner (November 9, 2010). "Bojanic & Braam Getting Lustre Band Back Together at Xyratex". Inside HPC. Retrieved September 23, 2013.
  23. Rich Brueckner (January 4, 2011). "Whamcloud Staffs up for Brighter Lustre". Inside HPC. Retrieved September 18, 2013.
  24. "Whamcloud Signs Multi-Year Lustre Development Contract With OpenSFS". Press release. HPC Wire. August 16, 2011. Retrieved September 23, 2013.
  25. Galen Shipman (November 18, 2011). "OpenSFS Update" (PDF). Slides for Supercomputing 2011 presentation. Open Scalable File Systems. Retrieved September 23, 2013.
  26. Whamcloud (November 15, 2011). "OpenSFS and Whamcloud Sign Lustre Community Tree Development Agreement". Press release. Retrieved September 23, 2013.
  27. Joab Jackson (2012-07-16). "Intel Purchases Lustre Purveyor Whamcloud". PC World.
  28. Timothy Prickett Morgan (2012-07-16). "Intel gobbles Lustre file system expert Whamcloud". The Register.
  29. Timothy Prickett Morgan (2012-07-11). "DOE doles out cash to AMD, Whamcloud for exascale research". The Register.
  30. Nicole Hemsoth (June 12, 2013). "Intel Carves Mainstream Highway for Lustre". HPC Wire. Retrieved September 23, 2013.
  31. Brueckner, Rich. "With New RFP, OpenSFS to Invest in Critical Open Source Technologies for HPC". insideHPC. Retrieved 1 October 2013.
  32. "Seagate Donates Back to the User Community". Retrieved 9 September 2014.
  33. "Lustre Helps Power Third Fastest Supercomputer". DSStar.
  34. "MCR Linux Cluster Xeon 2.4 GHz – Quadrics". Top500.Org.
  35. Peter Bojanic (June 15, 2008). "Lustre Roadmap and Future Plans" (PDF). Presentation to Sun HPC Consortium. Sun Microsystems. Retrieved September 23, 2013.
  36. Whamcloud "OpenSFS Announces Collaborative Effort to Support Lustre 2.1 Community Distribution" Check |url= value (help). Open Scalable File Systems. Retrieved 2012-02-02.
  37. "Lustre 2.1 Released". Retrieved 2012-02-02.
  38. "Lustre 2.2 Released". Yahoo! Finance. Retrieved 2012-05-08.
  39. Prickett Morgan, Timothy. "OpenSFS Announces Availability of Lustre 2.5". EnterpriseTech.
  40. Brueckner, Rich. "Video: New Lustre 2.5 Release Offers HSM Capabilities". Inside Big Data. Retrieved 11 December 2013.
  41. Hemsoth, Nicole. "Lustre Gets Business Class Upgrade with HSM". HPCwire. Retrieved 11 December 2013.
  42. "Lustre 2.5". Scientific Computing World. Retrieved 11 December 2013.
  43. "Lustre 2.6.0 released". HPDD-discuss mailing list archive. July 30, 2014. Retrieved October 21, 2014.
  44. Uselton, Andrew. "Demonstrating the Improvement in the Performance of a Single Lustre Client from Version 1.8 to Version 2.6" (PDF). Retrieved 2014-10-18.
  45. Jones, Peter (March 13, 2015). "Lustre 2.7.0 released". HPDD-discuss mailing list archive. Retrieved March 15, 2015.
  46. "Lustre to run on ZFS". Government Computer News. 2008-10-26.
  47. "ZFS on Lustre". 2011-05-10.
  48. "DataDirect Selected As Storage Tech Powering BlueGene/L". HPC Wire. October 15, 2004.
  49. Suzanne M. Kelly (2006). "Catamount Software Architecture with Dual Core Extensions" (PDF). Retrieved 2016-02-16.
  50. Lafoucrière, Jacques-Charles. "Lustre Experience at CEA/DIF" (PDF). HEPiX Forum, April 2007.
  51. "LNCC – Laboratório Nacional de Computação Científica". Retrieved 2015-05-27.
  52. "Pleiades Supercomputer". 2008-08-18.
  53. "TOP500 List – November 2006". TOP500.Org.
  54. "TOP500 List – June 2006". TOP500.Org.
  55. "French Atomic Energy Group Expands HPC File System to 11 Petabytes". 2012-06-15.
  56. "Sonexion Scale-out Lustre Storage System". 2015-04-14.
  57. "Dell HPC Solutions". 2015-04-14.
  58. "SGI – Products: Storage: Lustre Solutions". 2015-04-14.
  59. "File management consulting". SGI Professional Services web site.
  60. "Fujitsu Releases World's Highest-Performance File System – FEFS scalable file system software for advanced x86 HPC cluster systems". 2015-06-13.
  61. "High Throughput Storage Solutions with Lustre". 2015-04-14.
  62. "Exascaler: Massively Scalable, High Performance, Lustre File System Appliance". 2015-04-14.
  63. "ClusterStor Parallel Storage System". 2015-04-14.
  64. "Intel Solutions for Lustre Software". 2016-03-28.

Information wikis

Community foundations

Hardware/software vendors

This article is issued from Wikipedia - version of the 11/22/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.