Refactor PythonPointTable

Author: gsakkis

pdal/StreamableExecutor.cpp

@@ -48,60 +48,46 @@ namespace python
 // PythonPointTable
 
 PythonPointTable::PythonPointTable(point_count_t limit, int prefetch) :
-    StreamPointTable(m_layout, limit), m_limit(limit), m_prefetch(prefetch),
+    StreamPointTable(m_layout, limit), m_prefetch(prefetch),
     m_curArray(nullptr), m_dtype(nullptr)
 {}
 
 PythonPointTable::~PythonPointTable()
-{
-    py_destroy();
-}
-
-void PythonPointTable::finalize()
-{
-    BasePointTable::finalize();
-    py_createDescriptor();
-    m_curArray = py_createArray();
-}
-
-void PythonPointTable::py_destroy()
 {
     auto gil = PyGILState_Ensure();
-
     Py_XDECREF(m_dtype);
     Py_XDECREF(m_curArray);
-
     PyGILState_Release(gil);
 }
 
-PyArrayObject *PythonPointTable::py_createArray() const
+void PythonPointTable::finalize()
 {
-    auto gil = PyGILState_Ensure();
-
-    npy_intp size = (npy_intp)m_limit;
-    Py_INCREF(m_dtype);
-    PyArrayObject *arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, m_dtype,
-        1, &size, 0, nullptr, NPY_ARRAY_CARRAY, nullptr);
-
-    PyGILState_Release(gil);
-    return arr;
-}
+    BasePointTable::finalize();
 
-void PythonPointTable::py_createDescriptor()
-{
+    // create dtype
     auto gil = PyGILState_Ensure();
-
     if (_import_array() < 0)
         std::cerr << "Could not import array!\n";
     PyObject *dtype_dict = py_buildNumpyDescriptor();
     if (PyArray_DescrConverter(dtype_dict, &m_dtype) == NPY_FAIL)
-        m_dtype = nullptr;
+        throw pdal_error("Unable to create numpy dtype");
     Py_XDECREF(dtype_dict);
+    PyGILState_Release(gil);
+
+    py_createArray();
+}
 
+void PythonPointTable::py_createArray()
+{
+    auto gil = PyGILState_Ensure();
+    npy_intp size = capacity();
+    Py_INCREF(m_dtype);
+    m_curArray = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, m_dtype,
+        1, &size, 0, nullptr, NPY_ARRAY_CARRAY, nullptr);
     PyGILState_Release(gil);
 }
 
-void PythonPointTable::py_resizeArray(int np)
+void PythonPointTable::py_resizeArray(point_count_t np)
 {
     npy_intp sizes[1];
     sizes[0] = np;
@@ -187,7 +173,7 @@ void PythonPointTable::reset()
         if (!skip(idx))
             np++;
 
-    if (np && np != m_limit)
+    if (np && np != capacity())
         py_resizeArray(np);
 
     // This will keep putting arrays on the list until done, whether or not the consumer
@@ -199,7 +185,7 @@ void PythonPointTable::reset()
         if (np)
         {
             m_arrays.push(m_curArray);
-            m_curArray = py_createArray();
+            py_createArray();
             m_producedCv.notify_one();
         }
         while (m_arrays.size() > m_prefetch)
@@ -236,7 +222,7 @@ PyArrayObject *PythonPointTable::fetchArray()
 
 char *PythonPointTable::getPoint(PointId idx)
 {
-    return (char *)PyArray_GETPTR1(m_curArray, (npy_intp)idx);
+    return (char *)PyArray_GETPTR1(m_curArray, idx);
 }
 
 

pdal/StreamableExecutor.hpp

@@ -68,13 +68,10 @@ class PythonPointTable : public StreamPointTable
 
 private:
     // All functions starting with py_ call Python things that need the GIL locked.
-    void py_destroy();
-    PyArrayObject *py_createArray() const;
-    void py_createDescriptor();
-    void py_resizeArray(int np);
+    void py_createArray();
+    void py_resizeArray(point_count_t np);
     PyObject *py_buildNumpyDescriptor() const;
 
-    point_count_t m_limit;
     int m_prefetch;
     PointLayout m_layout;
     PyArrayObject *m_curArray;
@@ -94,7 +91,6 @@ class StreamableExecutor : public PipelineExecutor
     PyArrayObject* executeNext();
 
 private:
-    int m_prefetch;
     PythonPointTable m_table;
     std::unique_ptr<std::thread> m_thread;
 };