[Python-checkins] coalesce GILless sections in new_buffersize (#5059)

[Benjamin Peterson]

https://github.com/python/cpython/commit/eb08a9290f28e602ba035acfe8c2d3cd2b9965b0
commit: eb08a9290f28e602ba035acfe8c2d3cd2b9965b0
branch: 2.7
author: Benjamin Peterson <benjamin at python.org>
committer: GitHub <noreply at github.com>
date: 2018-01-02T15:52:42-08:00
summary:

coalesce GILless sections in new_buffersize (#5059)

830daae1c82ed33deef0086b7b6323e5be0b0cc8 added some new GIL-releasing to new_buffersize. This is fine, but it's better to avoid reacquiring the GIL for as long as possible. Also, it should use FILE_(BEGIN|END)_ALLOW_THREADS to avoid having the file closed from under it.

files:
M Objects/fileobject.c

diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 270b28264a8..b524f09e0a3 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -1015,10 +1015,10 @@ new_buffersize(PyFileObject *f, size_t currentsize)
     off_t pos, end;
     struct stat st;
     int res;
+    size_t bufsize = 0;
 
-    Py_BEGIN_ALLOW_THREADS
+    FILE_BEGIN_ALLOW_THREADS(f)
     res = fstat(fileno(f->f_fp), &st);
-    Py_END_ALLOW_THREADS
 
     if (res == 0) {
         end = st.st_size;
@@ -1032,9 +1032,7 @@ new_buffersize(PyFileObject *f, size_t currentsize)
            need to take the amount of buffered data into account.
            (Yet another reason why stdio stinks. :-) */
 
-        Py_BEGIN_ALLOW_THREADS
         pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR);
-        Py_END_ALLOW_THREADS
 
         if (pos >= 0) {
             pos = ftell(f->f_fp);
@@ -1042,9 +1040,12 @@ new_buffersize(PyFileObject *f, size_t currentsize)
         if (pos < 0)
             clearerr(f->f_fp);
         if (end > pos && pos >= 0)
-            return currentsize + end - pos + 1;
+            bufsize = currentsize + end - pos + 1;
         /* Add 1 so if the file were to grow we'd notice. */
     }
+    FILE_END_ALLOW_THREADS(f)
+    if (bufsize != 0)
+        return bufsize;
 #endif
     /* Expand the buffer by an amount proportional to the current size,
        giving us amortized linear-time behavior. Use a less-than-double