Reduce stack memory usage

[Kurt Schwehr]

In multi-threaded programs, stack usage is particularly important. GDAL currently uses large amount of memory on the stack. I plan to gradually work towards reducing this usage. Some strategies:

• Move local variables into the scope they are used
• Allocate large structures on the heap when possible

[Even Rouault]

I'm not sure what stack consumers you've spotted, but one thing to be aware of is that some places can be performance critical and heap allocation with malloc() could slow down things.

[Kurt Schwehr]

Even, Agreed. It's going to take a while to work through this and some it matters more when running with the compiler in debug / no-optimize mode where the compiler can't reorder things. My first patch is coming in a few minutes. I haven't yet started profiling where a lot of the memory usage is coming from.

[Kurt Schwehr]

Proposed first patch for reducing large stacks. Because vectors are required to dynamically allocate their storage, that means they must use the heap. The storage is required to be contiguous and pointer to the first element can be used as a C array as long as the size of the vector is not changed. By using the fill constructor, we can start off with the required size and replace the memset.

• ​http://www.cplusplus.com/reference/vector/vector/vector/
• ​http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69
• ​https://isocpp.org/wiki/faq/containers#vector-is-contiguous
• ​http://stackoverflow.com/questions/1733143/converting-between-c-stdvector-and-c-array-without-copying

frmts/netcdf/netcdfdataset.cpp

@@ -35 +35 @@
 #include "gdal_frmts.h"
 #include "netcdfdataset.h"
 
-#include <map> //for NCDFWriteProjAttribs()
 #include <limits>
+#include <map> //for NCDFWriteProjAttribs()
+#include <vector>
+
+using std::vector;
 
 CPL_CVSID("$Id: netcdfdataset.cpp 32423 2015-12-21 12:33:17Z rouault $");
 
@@ -432 +435 @@
 /* -------------------------------------------------------------------- */
 #ifdef NETCDF_HAS_NC4
     int nTmpFormat = 0;
-    size_t chunksize[ MAX_NC_DIMS ];
+    vector<size_t> chunksizeStorage(MAX_NC_DIMS, 0);
+    size_t * const chunksize = &chunksizeStorage[0];
+
     status = nc_inq_format( cdfid, &nTmpFormat);
     NetCDFFormatEnum eTmpFormat = static_cast<NetCDFFormatEnum>(nTmpFormat);
     if( ( status == NC_NOERR ) && ( ( eTmpFormat == NCDF_FORMAT_NC4 ) ||
@@ -1016 +1021 @@
         int nDims = 0;
         /* status = */ nc_inq_varndims( cdfid, nVarID, &nDims );
 
-        char szMetaTemp[256];
+        vector<char> szMetaTempStorage(256, 0);
+        char * const szMetaTemp = &szMetaTempStorage[0];
         if( nDims == 1 ) {
             size_t count[1] = {1};
             size_t start[1] = {static_cast<size_t>(result)};
@@ -1196 +1202 @@
 /*      Locate X, Y and Z position in the array                         */
 /* -------------------------------------------------------------------- */
 
-    size_t start[ MAX_NC_DIMS ];
-    memset( start, 0, sizeof( start ) );
+    vector<size_t> startStorage(MAX_NC_DIMS, 0);
+    size_t * const start = &startStorage[0];
+
     start[nBandXPos] = nBlockXOff * nBlockXSize;
 
     // check y order
@@ -1223 +1230 @@
       start[nBandYPos] = nBlockYOff * nBlockYSize;
     }
 
-    size_t edge[ MAX_NC_DIMS ];
-    memset( edge,  0, sizeof( edge )  );
+    vector<size_t> edgeStorage(MAX_NC_DIMS, 0);
+    size_t * const edge = &edgeStorage[0];
 
     edge[nBandXPos] = nBlockXSize;
     if ( ( start[nBandXPos] + edge[nBandXPos] ) > (size_t)nRasterXSize )
@@ -1380 +1387 @@
 /*      Locate X, Y and Z position in the array                         */
 /* -------------------------------------------------------------------- */
 
-    size_t start[ MAX_NC_DIMS];
-    memset( start, 0, sizeof( start ) );
+    vector<size_t> startStorage(MAX_NC_DIMS, 0);
+    size_t * const start = &startStorage[0];
 
     start[nBandXPos] = 0;          // x dim can move around in array
     // check y order
@@ -1391 +1398 @@
         start[nBandYPos] = nBlockYOff; // y
     }
 
-    size_t edge[ MAX_NC_DIMS ];
-    memset( edge,  0, sizeof( edge )  );
+    vector<size_t> edgeStorage(MAX_NC_DIMS, 0);
+    size_t * const edge = &edgeStorage[0];
 
-    edge[nBandXPos] = nBlockXSize; 
+    edge[nBandXPos] = nBlockXSize;
     edge[nBandYPos] = 1;
 
     if( nd == 3 ) {
@@ -1701 +1708 @@
                                      const char *pszParm, double dfDefault )
 
 {
-    char szTemp[ 256 ];
-    snprintf(szTemp, sizeof(szTemp), "%s#%s", pszGridMappingValue, pszParm);
+    const int szTempSize = 256;
+    vector<char> szTempStorage(szTempSize, 0);
+    char * const szTemp = &szTempStorage[0];
+
+    snprintf(szTemp, szTempSize, "%s#%s", pszGridMappingValue, pszParm);
     const char *pszValue = CSLFetchNameValue(papszMetadata, szTemp);
 
     if( pszValue )
@@ -1719 +1729 @@
 
 char** netCDFDataset::FetchStandardParallels( const char *pszGridMappingValue )
 {
-    char         szTemp[256 ];
-    //cf-1.0 tags
-    snprintf(szTemp, sizeof(szTemp), "%s#%s", pszGridMappingValue, CF_PP_STD_PARALLEL);
+    const int szTempSize = 256;
+    vector<char> szTempStorage(szTempSize, 0);
+    char * const szTemp = &szTempStorage[0];
+
+    // cf-1.0 tags
+    snprintf( szTemp, szTempSize, "%s#%s", pszGridMappingValue,
+              CF_PP_STD_PARALLEL);
     const char *pszValue = CSLFetchNameValue( papszMetadata, szTemp );
 
     char **papszValues = NULL;
@@ -5757 +5771 @@
     if ( eCompress == NCDF_COMPRESS_DEFLATE ) {
         // Must set chunk size to avoid huge performance hit (set bChunkingArg=TRUE)
         // perhaps another solution it to change the chunk cache?
-        // http://www.unidata.ucar.edu/software/netcdf/docs/netcdf.html#Chunk-Cache   
+        // http://www.unidata.ucar.edu/software/netcdf/docs/netcdf.html#Chunk-Cache
         // TODO: make sure this is okay.
         CPLDebug( "GDAL_netCDF",
                   "DefVarDeflate( %d, %d ) nZlevel=%d",
@@ -5770 +5784 @@
 
             // set chunking to be 1 for all dims, except X dim
             // size_t chunksize[] = { 1, (size_t)nRasterXSize };
-            size_t chunksize[ MAX_NC_DIMS ];
+            vector<size_t> chunksizeStorage(MAX_NC_DIMS, 0);
+            size_t * const chunksize = &chunksizeStorage[0];
+
             int nd;
             nc_inq_varndims( cdfid, nVarId, &nd );
             chunksize[0] = (size_t)1;
@@ -5778 +5794 @@
             for( int i=2; i<nd; i++ ) chunksize[i] = (size_t)1;
             chunksize[nd-1] = (size_t)nRasterXSize;
 
-            CPLDebug( "GDAL_netCDF", 
+            CPLDebug( "GDAL_netCDF",
                       "DefVarDeflate() chunksize={%ld, %ld} chunkX=%ld nd=%d",
                       (long)chunksize[0], (long)chunksize[1], (long)chunksize[nd-1], nd );
 #ifdef NCDF_DEBUG
-            for( int i=0; i<nd; i++ ) 
+            for( int i=0; i<nd; i++ )
                 CPLDebug( "GDAL_netCDF","DefVarDeflate() chunk[%d]=%ld", i, chunksize[i] );
 #endif
 
-            status = nc_def_var_chunking( cdfid, nVarId,          
+            status = nc_def_var_chunking( cdfid, nVarId,
                                           NC_CHUNKED, chunksize );
             NCDF_ERR(status);
         }
@@ -6295 +6311 @@
 
     double dfValue = 0.0;
     size_t m;
-    char szTemp[ 256 ];
+
+    const int szTempSize = 256;
+    vector<char> szTempStorage(szTempSize, 0);
+    char * const szTemp = &szTempStorage[0];
 
     switch (nAttrType) {
         case NC_CHAR:
@@ -6311 +6330 @@
             nc_get_att_schar( nCdfId, nVarId, pszAttrName, pscTemp );
             dfValue = static_cast<double>( pscTemp[0] );
             for(m=0; m < nAttrLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%d,", pscTemp[m] );
+                snprintf( szTemp, szTempSize, "%d,", pscTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
             snprintf( szTemp, sizeof(szTemp), "%d", pscTemp[m] );
@@ -6328 +6347 @@
             nc_get_att_uchar( nCdfId, nVarId, pszAttrName, pucTemp );
             dfValue = static_cast<double>( pucTemp[0] );
             for(m=0; m < nAttrLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%d,", pucTemp[m] );
+                snprintf( szTemp, szTempSize, "%d,", pucTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
-            snprintf( szTemp, sizeof(szTemp), "%d", pucTemp[m] );
+            snprintf( szTemp, szTempSize, "%d", pucTemp[m] );
             NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             CPLFree(pucTemp);
             break;
@@ -6345 +6364 @@
             nc_get_att_short( nCdfId, nVarId, pszAttrName, psTemp );
             dfValue = static_cast<double>( psTemp[0] );
             for(m=0; m < nAttrLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%hd,", psTemp[m] );
+                snprintf( szTemp, szTempSize, "%hd,", psTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
-            snprintf( szTemp, sizeof(szTemp), "%hd", psTemp[m] );
+            snprintf( szTemp, szTempSize, "%hd", psTemp[m] );
             NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             CPLFree(psTemp);
             break;
@@ -6360 +6379 @@
             nc_get_att_int( nCdfId, nVarId, pszAttrName, pnTemp );
             dfValue = static_cast<double>( pnTemp[0] );
             for(m=0; m < nAttrLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%d,", pnTemp[m] );
+                snprintf( szTemp, szTempSize, "%d,", pnTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
-            snprintf( szTemp, sizeof(szTemp), "%d", pnTemp[m] );
+            snprintf( szTemp, szTempSize, "%d", pnTemp[m] );
             NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             CPLFree(pnTemp);
             break;
@@ -6376 +6395 @@
             nc_get_att_float( nCdfId, nVarId, pszAttrName, pfTemp );
             dfValue = static_cast<double>( pfTemp[0] );
             for(m=0; m < nAttrLen-1; m++) {
-                CPLsnprintf( szTemp, sizeof(szTemp), "%.8g,", pfTemp[m] );
+                CPLsnprintf( szTemp, szTempSize, "%.8g,", pfTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
-            CPLsnprintf( szTemp, sizeof(szTemp), "%.8g", pfTemp[m] );
+            CPLsnprintf( szTemp, szTempSize, "%.8g", pfTemp[m] );
             NCDFSafeStrcat(&pszAttrValue,szTemp, &nAttrValueSize);
             CPLFree(pfTemp);
             break;
@@ -6392 +6411 @@
             nc_get_att_double( nCdfId, nVarId, pszAttrName, pdfTemp );
             dfValue = pdfTemp[0];
             for(m=0; m < nAttrLen-1; m++) {
-                CPLsnprintf( szTemp, sizeof(szTemp), "%.16g,", pdfTemp[m] );
+                CPLsnprintf( szTemp, szTempSize, "%.16g,", pdfTemp[m] );
                 NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             }
-            CPLsnprintf( szTemp, sizeof(szTemp), "%.16g", pdfTemp[m] );
+            CPLsnprintf( szTemp, szTempSize, "%.16g", pdfTemp[m] );
             NCDFSafeStrcat(&pszAttrValue, szTemp, &nAttrValueSize);
             CPLFree(pdfTemp);
             break;
@@ -6468 +6487 @@
                 /* strtof() is C89, which is not available in MSVC */
                 /* see if we loose precision if we cast to float and write to char* */
                 float fValue = float(dfValue);
-                char    szTemp[ 256 ];
-                CPLsnprintf( szTemp, sizeof(szTemp), "%.8g",fValue);
+                const int szTempSize = 256;
+                vector<char> szTempStorage(szTempSize, 0);
+                char * const szTemp = &szTempStorage[0];
+
+                CPLsnprintf( szTemp, szTempSize, "%.8g",fValue);
                 if ( EQUAL(szTemp, papszValues[i] ) )
                     nTmpAttrType = NC_FLOAT;
                 else
@@ -6573 +6595 @@
     if ( nVarLen > 1 && nVarType != NC_CHAR )    
         NCDFSafeStrcat(&pszVarValue, "{", &nVarValueSize);
 
+    const int szTempSize = 256;
+    vector<char> szTempStorage(szTempSize, 0);
+    char * const szTemp = &szTempStorage[0];
+
     switch (nVarType) {
         case NC_CHAR:
             nc_get_vara_text( nCdfId, nVarId, start, count, pszVarValue );
@@ -6584 +6610 @@
             signed char *pscTemp = reinterpret_cast<signed char *> (
                 CPLCalloc( nVarLen, sizeof( signed char ) ) );
             nc_get_vara_schar( nCdfId, nVarId, start, count, pscTemp );
-            char szTemp[ 256 ];
             size_t m = 0;
             for( ; m < nVarLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%d,", pscTemp[m] );
+                snprintf( szTemp, szTempSize, "%d,", pscTemp[m] );
                 NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             }
             snprintf( szTemp, sizeof(szTemp), "%d", pscTemp[m] );
@@ -6600 +6625 @@
             short *psTemp = reinterpret_cast<short *> (
                 CPLCalloc( nVarLen, sizeof( short ) ) );
             nc_get_vara_short( nCdfId, nVarId, start, count, psTemp );
-            char szTemp[ 256 ];
             size_t m = 0;
             for( ; m < nVarLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%hd,", psTemp[m] );
+                snprintf( szTemp, szTempSize, "%hd,", psTemp[m] );
                 NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             }
             snprintf( szTemp, sizeof(szTemp),  "%hd", psTemp[m] );
@@ -6616 +6640 @@
             int *pnTemp = reinterpret_cast<int *> (
                 CPLCalloc( nVarLen, sizeof( int ) ) );
             nc_get_vara_int( nCdfId, nVarId, start, count, pnTemp );
-            char szTemp[ 256 ];
             size_t m = 0;
             for( ; m < nVarLen-1; m++) {
-                snprintf( szTemp, sizeof(szTemp), "%d,", pnTemp[m] );
+                snprintf( szTemp, szTempSize, "%d,", pnTemp[m] );
                 NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             }
             snprintf( szTemp, sizeof(szTemp), "%d", pnTemp[m] );
@@ -6632 +6655 @@
             float *pfTemp = reinterpret_cast<float *> (
                 CPLCalloc( nVarLen, sizeof( float ) ) );
             nc_get_vara_float( nCdfId, nVarId, start, count, pfTemp );
-            char szTemp[ 256 ];
             size_t m = 0;
             for( ; m < nVarLen-1; m++) {
-                CPLsnprintf( szTemp, sizeof(szTemp), "%.8g,", pfTemp[m] );
+                CPLsnprintf( szTemp, szTempSize, "%.8g,", pfTemp[m] );
                 NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             }
-            CPLsnprintf( szTemp, sizeof(szTemp), "%.8g", pfTemp[m] );
+            CPLsnprintf( szTemp, szTempSize, "%.8g", pfTemp[m] );
             NCDFSafeStrcat(&pszVarValue,szTemp, &nVarValueSize);
             CPLFree(pfTemp);
             break;
@@ -6648 +6673 @@
             double *pdfTemp = reinterpret_cast<double *> (
                 CPLCalloc( nVarLen, sizeof(double) ) );
             nc_get_vara_double( nCdfId, nVarId, start, count, pdfTemp );
-            char szTemp[ 256 ];
             size_t m = 0;
             for( ; m < nVarLen-1; m++) {
-                CPLsnprintf( szTemp, sizeof(szTemp), "%.16g,", pdfTemp[m] );
+                CPLsnprintf( szTemp, szTempSize, "%.16g,", pdfTemp[m] );
                 NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             }
-            CPLsnprintf( szTemp, sizeof(szTemp), "%.16g", pdfTemp[m] );
+            CPLsnprintf( szTemp, szTempSize, "%.16g", pdfTemp[m] );
             NCDFSafeStrcat(&pszVarValue, szTemp, &nVarValueSize);
             CPLFree(pdfTemp);
             break;

[Even Rouault]

Looks reasonable, but I think that patterns like

char szTemp[ 256 ];
snprintf(szTemp, sizeof(szTemp), "%s#%s", pszGridMappingValue, pszParm);

would be better simplified as (one line instead of 4):

CPLString osTemp(pszGridMappingValue + CPLString("#") + pszParm);

[Kurt Schwehr]

Thanks! I was thinking that those could be simplified with C++ strings. I'll give it a try.

[Kurt Schwehr]

r33176 r33175 r33179 For gdalexif EXIFExtractMetadata() char szTemp[MAXSTRINGLENGTH+1];

[Kurt Schwehr]

r33191 for hdf5dataset.cpp

[Even Rouault]

This ticket has been automatically closed because Trac is no longer used for GDAL bug tracking, since the project has migrated to GitHub. If you believe this ticket is still valid, you may file it to ​https://github.com/OSGeo/gdal/issues if it is not already reported there.