Internal methods introduced to reduce the usage of FileHandle.readData() in order to avoid calling fstat, alloc and dealloc while reading a file

* New internal init method introduced to init with fileSystemRepresentation UnsafeMutablePointer<Int8>
* New internal method _readBytes() introduced for continuous iteration of reading a file without allocating and deallocating buffer memory.

Author: karthikkeyan

Foundation/FileHandle.swift

@@ -342,6 +342,14 @@ open class FileHandle : NSObject, NSSecureCoding {
         }
 #endif
     }
+    
+    internal func _readBytes(into buffer: UnsafeMutablePointer<UInt8>, length: Int) throws -> Int {
+        let amtRead = _read(_fd, buffer, length)
+        if amtRead < 0 {
+            throw _NSErrorWithErrno(errno, reading: true)
+        }
+        return amtRead
+    }
 
     internal func _writeBytes(buf: UnsafeRawPointer, length: Int) throws {
 #if os(Windows)
@@ -425,6 +433,15 @@ open class FileHandle : NSObject, NSSecureCoding {
         }
     }
 #endif
+    
+    internal init?(fileSystemRepresentation: UnsafePointer<Int8>, flags: Int32, createMode: Int) {
+        _fd = _CFOpenFileWithMode(fileSystemRepresentation, flags, mode_t(createMode))
+        _closeOnDealloc = true
+        super.init()
+        if _fd < 0 {
+            return nil
+        }
+    }
 
     deinit {
         // .close() tries to wait after operations in flight on the handle queue, if one exists, and then close. It does so by sending .sync { … } work to it.

Foundation/FileManager.swift

@@ -1720,25 +1720,29 @@ open class FileManager : NSObject {
 #if os(Windows)
         NSUnimplemented()
 #else
-        guard let file1 = FileHandle(forReadingAtPath: String(cString: file1Rep)) else {
-            return false
-        }
-        
-        defer { try? file1.close() }
+        guard let file1 = FileHandle(fileSystemRepresentation: file1Rep, flags: O_RDONLY, createMode: 0) else { return false }
+        guard let file2 = FileHandle(fileSystemRepresentation: file2Rep, flags: O_RDONLY, createMode: 0) else { return false }
 
-        guard let file2 = FileHandle(forReadingAtPath: String(cString: file2Rep)) else {
-            return false
+        var buffer1 = UnsafeMutablePointer<UInt8>.allocate(capacity: bufSize)
+        var buffer2 = UnsafeMutablePointer<UInt8>.allocate(capacity: bufSize)
+        defer {
+            buffer1.deallocate()
+            buffer2.deallocate()
         }
 
-        defer { try? file2.close() }
-        
         var bytesLeft = size
         while bytesLeft > 0 {
             let bytesToRead = Int(min(Int64(bufSize), bytesLeft))
-            let file1Data = file1.readData(ofLength: bytesToRead)
-            let file2Data = file2.readData(ofLength: bytesToRead)
 
-            guard file1Data.count == bytesToRead, file2Data.count == bytesToRead, file1Data == file2Data else {
+            guard let file1BytesRead = try? file1._readBytes(into: buffer1, length: bytesToRead), file1BytesRead == bytesToRead else {
+                return false
+            }
+            
+            guard let file2BytesRead = try? file2._readBytes(into: buffer2, length: bytesToRead), file2BytesRead == bytesToRead else {
+                return false
+            }
+            
+            guard memcmp(buffer1, buffer2, bytesToRead) == 0 else {
                 return false
             }