imagecache: remove redundant ImageSpec from ImageCache internals (AcademySoftwareFoundation#4664)

Backend changes for issue
AcademySoftwareFoundation#4436.

## Description

- add `ImageDims` struct to store only a subset of `ImageSpec` or use it
as a view on an existing ImageSpec.
- move `ImageDims` and `ImageSpec` ownership to `ImageCacheFile` and use
them as a pool
- add `ImageSpec* m_spec` in `SubimageInfo` to access the descriptors
that are common across all mip level
- add `ImageDims* m_dims` in `LevelInfo` to access the despcriptors that
differ per mip level
- add functions to access to mip level dimensions:
```c++
const Dimensions& SubimageInfo::leveldims(int miplevel) const;
```
- do the plumbing across all `libtexture` to use the new interface

## Tests

I performed a batch of testing to compare the memory usage and
performance of different strategies using 17 `ptex` files from the PTex
library samples (some from the Moana Island dataset, so they are quite
heavy). The baseline numbers are approximates but gives a good estimate
of the memory usage.

Baseline | Total (MB) | Specs (MB) (%) | # specs | Subimages (MB) (%)
-- | -- | -- | -- | -- 
OIIO 3.0 main | 1500 | 1200 (80%) | 4936364 | 300 (20%)


Method | Total (MB) | Specs (MB) (%) | # specs | Subimages (MB) (%)
-- | -- | -- | -- | -- 
No reuse | 787,2 | 454,3 (58%) | 4936381 | 332,5 (42%)
Reuse dist=1 | 442,2 | 109,3 (25%) | 1193485 | 332,5 (75%)
Reuse dist=10 | 368,5 | 35,6 (10%) | 380506 | 332,5 (90%)
Reuse dist=inf | 333,2 | 0,292 (<1%) | 3020 | 332,5 (>99%)

These numbers shows that the memory is now bounded by the `SubimageInfo`
+ `LevelInfo` structure sizes, and not from the descriptors `ImageSpec`
+ `Dimensions`  with the right amount of reuse across subimages and mip
levels.

---------

Signed-off-by: Basile Fraboni <basile.fraboni@gmail.com>

Author: bfraboni

src/include/OpenImageIO/memory.h

@@ -48,7 +48,7 @@ template<typename T>
 inline size_t
 footprint(const T* t)
 {
-    return sizeof(T) + (t ? footprint(*t) : 0);
+    return sizeof(T*) + (t ? footprint(*t) : 0);
 }
 
 /// Specializations for common STL types
@@ -68,16 +68,6 @@ heapsize<std::string>(const std::string& s)
     return is_small ? 0 : s.capacity();
 }
 
-// heapsize specialization for std::vector
-template<typename T>
-inline size_t
-heapsize(const std::vector<T>& vec)
-{
-    size_t size = 0;
-    for (const T& elem : vec)
-        size += footprint(elem);
-    return size;
-}
 
 // heapsize specialization for std::shared_ptr
 template<typename T>
@@ -111,6 +101,29 @@ footprint(const std::unique_ptr<T>& ref)
     return sizeof(std::unique_ptr<T>) + heapsize(ref);
 }
 
+// heapsize specialization for std::vector
+template<typename T>
+inline size_t
+heapsize(const std::vector<T>& vec)
+{
+    size_t size = 0;
+    // account for used allocated memory
+    for (const T& elem : vec)
+        size += footprint(elem);
+    // account for unused allocated memory
+    size += (vec.capacity() - vec.size()) * sizeof(T);
+    return size;
+}
+
+// footprint specialization for std::vector
+template<typename T>
+inline size_t
+footprint(const std::vector<T>& vec)
+{
+    return sizeof(std::vector<T>) + heapsize<T>(vec);
+}
+
+
 }  // namespace pvt
 
 

src/libtexture/environment.cpp

@@ -202,7 +202,8 @@ convention is dictated by OpenEXR.
 OIIO_NAMESPACE_BEGIN
 using namespace pvt;
 using namespace simd;
-
+using SubimageInfo = ImageCacheFile::SubimageInfo;
+using ImageDims    = ImageCacheFile::ImageDims;
 
 bool
 TextureSystem::environment(ustring filename, TextureOpt& options, V3fParam R,
@@ -352,7 +353,7 @@ TextureSystemImpl::environment(TextureHandle* texture_handle_,
         return missing_texture(options, nchannels, result, dresultds,
                                dresultdt);
     }
-    const ImageSpec& spec(texturefile->spec(options.subimage, 0));
+    const ImageSpec& spec(texturefile->spec(options.subimage));
 
     // Environment maps dictate particular wrap modes
     options.swrap = texturefile->m_sample_border
@@ -455,9 +456,8 @@ TextureSystemImpl::environment(TextureHandle* texture_handle_,
         invsamples = 1.0f;
     }
 
-    ImageCacheFile::SubimageInfo& subinfo(
-        texturefile->subimageinfo(options.subimage));
-    int min_mip_level = subinfo.min_mip_level;
+    const SubimageInfo& si(texturefile->subimageinfo(options.subimage));
+    int min_mip_level = si.min_mip_level;
 
     // FIXME -- assuming latlong
     bool ok   = true;
@@ -472,14 +472,14 @@ TextureSystemImpl::environment(TextureHandle* texture_handle_,
         int miplevel[2]  = { -1, -1 };
         float levelblend = 0;
 
-        int nmiplevels = (int)subinfo.levels.size();
+        int nmiplevels = (int)si.levels.size();
         for (int m = min_mip_level; m < nmiplevels; ++m) {
             // Compute the filter size in raster space at this MIP level.
             // Filters are in radians, and the vertical resolution of a
             // latlong map is PI radians.  So to compute the raster size of
             // our filter width...
-            float filtwidth_ras = subinfo.spec(m).full_height * filtwidth
-                                  * M_1_PI;
+            const ImageDims& dims(si.leveldims(m));
+            float filtwidth_ras = dims.full_height * filtwidth * M_1_PI;
             // Once the filter width is smaller than one texel at this level,
             // we've gone too far, so we know that we want to interpolate the
             // previous level and the current level.  Note that filtwidth_ras
@@ -524,8 +524,7 @@ TextureSystemImpl::environment(TextureHandle* texture_handle_,
             int lev = miplevel[level];
             if (options.interpmode == TextureOpt::InterpSmartBicubic) {
                 if (lev == 0
-                    || (texturefile->spec(options.subimage, lev).full_height
-                        < naturalres / 2)) {
+                    || (si.leveldims(lev).full_height < naturalres / 2)) {
                     sampler = &TextureSystemImpl::sample_bicubic;
                     ++stats.cubic_interps;
                 } else {