rabernat
commented
7 years ago cc: @geosciz, who is helping with this project.
Open rabernat opened 7 years ago
rabernat
commented
7 years ago cc: @geosciz, who is helping with this project.
shoyer
commented
7 years ago For example, can I give a hint to xarray that this reindex_variables step is not necessary
Yes, adding an boolean argument prealigned which defaults to False to concat seems like a very reasonable optimization here.
But more generally, I am a little surprised by how slow pandas.Index.get_indexer and pandas.Index.is_unique are. This suggests we should add a fast-path optimization to skip these steps in reindex_variables:
https://github.com/pydata/xarray/blob/ab4ffee919d4abe9f6c0cf6399a5827c38b9eb5d/xarray/core/alignment.py#L302-L306
Basically, if index.equals(target), we should just set indexer = np.arange(target.size). Although, if we have duplicate values in the index, the operation should arguably fail for correctness.
rabernat
commented
6 years ago An update on this long-standing issue.
I have learned that open_mfdataset can be blazingly fast if decode_cf=False but extremely slow with decode_cf=True.
As an example, I am loading a POP datataset on cheyenne. Anyone with access can try this example.
base_dir = '/glade/scratch/rpa/'
prefix = 'BRCP85C5CN_ne120_t12_pop62.c13b17.asdphys.001'
code = 'pop.h.nday1.SST'
glob_pattern = os.path.join(base_dir, prefix, '%s.%s.*.nc' % (prefix, code))
def non_time_coords(ds):
return [v for v in ds.data_vars
if 'time' not in ds[v].dims]
def drop_non_essential_vars_pop(ds):
return ds.drop(non_time_coords(ds))
# this runs almost instantly
ds = xr.open_mfdataset(glob_pattern, decode_times=False, chunks={'time': 1},
preprocess=drop_non_essential_vars_pop, decode_cf=False)And returns this
<xarray.Dataset>
Dimensions: (d2: 2, nlat: 2400, nlon: 3600, time: 16401, z_t: 62, z_t_150m: 15, z_w: 62, z_w_bot: 62, z_w_top: 62)
Coordinates:
* z_w_top (z_w_top) float32 0.0 1000.0 2000.0 3000.0 4000.0 5000.0 ...
* z_t (z_t) float32 500.0 1500.0 2500.0 3500.0 4500.0 5500.0 ...
* z_w (z_w) float32 0.0 1000.0 2000.0 3000.0 4000.0 5000.0 6000.0 ...
* z_t_150m (z_t_150m) float32 500.0 1500.0 2500.0 3500.0 4500.0 5500.0 ...
* z_w_bot (z_w_bot) float32 1000.0 2000.0 3000.0 4000.0 5000.0 6000.0 ...
* time (time) float64 7.322e+05 7.322e+05 7.322e+05 7.322e+05 ...
Dimensions without coordinates: d2, nlat, nlon
Data variables:
time_bound (time, d2) float64 dask.array<shape=(16401, 2), chunksize=(1, 2)>
SST (time, nlat, nlon) float32 dask.array<shape=(16401, 2400, 3600), chunksize=(1, 2400, 3600)>
Attributes:
nsteps_total: 480
tavg_sum: 64800.0
title: BRCP85C5CN_ne120_t12_pop62.c13b17.asdphys.001
start_time: This dataset was created on 2016-03-14 at 05:32:30.3
Conventions: CF-1.0; http://www.cgd.ucar.edu/cms/eaton/netcdf/CF-curren...
source: CCSM POP2, the CCSM Ocean Component
cell_methods: cell_methods = time: mean ==> the variable values are aver...
calendar: All years have exactly 365 days.
history: none
contents: Diagnostic and Prognostic Variables
revision: $Id: tavg.F90 56176 2013-12-20 18:35:46Z mlevy@ucar.edu $This is roughly 45 years of daily data, one file per year.
Instead, if I just change decode_cf=True (the default), it takes forever. I can monitor what is happening via the distributed dashboard. It looks like this:
There are more of these open_dataset tasks then there are number of files (45), so I can only presume there are 16401 individual tasks (one for each timestep), which each takes about 1 s in serial.
This is a real failure of lazy decoding. Maybe it can be fixed by #1725, possibly related to #1372.
cc Pangeo folks: @jhamman, @mrocklin
shoyer
commented
6 years ago @rabernat How does performance compare if you call xarray.decode_cf() on the opened dataset? The adjustments I recently did to lazy decoding should only help once the data is already loaded into dask.
rabernat
commented
6 years ago Calling ds = xr.decode_cf(ds, decode_times=False) on the dataset returns instantly. However, the variable data is wrapped in the adaptors, effectively destroying the chunks
>>> ds.SST.variable._data
LazilyIndexedArray(array=DaskIndexingAdapter(array=dask.array<_apply_mask, shape=(16401, 2400, 3600), dtype=float32, chunksize=(1, 2400, 3600)>), key=BasicIndexer((slice(None, None, None), slice(None, None, None), slice(None, None, None))))Calling getitem on this array triggers the whole dask array to be computed, which would takes forever and would completely blow out the notebook memory. This is because of #1372, which would be fixed by #1725.
This has actually become a major showstopper for me. I need to work with this dataset in decoded form.
Versions
shoyer
commented
6 years ago OK, so it seems that we need a change to disable wrapping dask arrays with LazilyIndexedArray. Dask arrays are already lazy!
shoyer
commented
5 years ago Was this fixed by https://github.com/pydata/xarray/pull/2047?
chuaxr
commented
5 years ago I can confirm that
ds = xr.open_mfdataset(data_fnames,chunks={'lat':20,'time':50,'lon':24,'pfull':11},\
decode_cf=False)
ds = xr.decode_cf(ds)is much faster (seconds vs minutes) than
ds = xr.open_mfdataset(data_fnames,chunks={'lat':20,'time':50,'lon':24,'pfull':11})
. For reference, data_fnames is a list of 5 files, each of which is ~75 GB.
shoyer
commented
5 years ago @chuaxr I assume you're testing this with xarray 0.11?
It would be good to do some profiling to figure out what is going wrong here.
chuaxr
commented
5 years ago Yes, I'm on 0.11.
Nothing displays on the task stream/ progress bar when using open_mfdataset, although I can monitor progress when, say, computing the mean.
The output from %time using decode_cf = False is
CPU times: user 4.42 s, sys: 392 ms, total: 4.82 s
Wall time: 4.74 sand for decode_cf = True:
CPU times: user 11.6 s, sys: 1.61 s, total: 13.2 s
Wall time: 3min 28sUsing xr.set_options(file_cache_maxsize=1) doesn't make any noticeable difference.
If I repeat the open_mfdataset for another 5 files (after opening the first 5), I occasionally get this warning:
distributed.utils_perf - WARNING - full garbage collections took 24% CPU time recently (threshold: 10%)
I only began using the dashboard recently; please let me know if there's something basic I'm missing.
shoyer
commented
5 years ago @chuaxr What do you see when you use %prun when opening the dataset? This might point to the bottleneck.
One way to fix this would be to move our call to decode_cf() in open_dataset() to after applying chunking, i.e., to switch up the order of operations on these lines:
https://github.com/pydata/xarray/blob/f547ed0b379ef70a3bda5e77f66de95ec2332ddf/xarray/backends/api.py#L270-L296
In practice, is the difference between using xarray's internal lazy array classes for decoding and dask for decoding. I would expect to see small differences in performance between these approaches (especially when actually computing data), but for constructing the computation graph I would expect them to have similar performance. It is puzzling that dask is orders of magnitude faster -- that suggests that something else is going wrong in the normal code path for decode_cf(). It would certainly be good to understand this before trying to apply any fixes.
chuaxr
commented
5 years ago Sorry, I think the speedup had to do with accessing a file that had previously been loaded rather than due to decode_cf. Here's the output of prun using two different files of approximately the same size (~75 GB), run from a notebook without using distributed (which doesn't lead to any speedup):
Output of %prun ds = xr.open_mfdataset('/work/xrc/AM4_skc/atmos_level.1999010100-2000123123.sphum.nc',chunks={'lat':20,'time':50,'lon':12,'pfull':11})
780980 function calls (780741 primitive calls) in 55.374 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
7 54.448 7.778 54.448 7.778 {built-in method _operator.getitem}
764838 0.473 0.000 0.473 0.000 core.py:169(<genexpr>)
3 0.285 0.095 0.758 0.253 core.py:169(<listcomp>)
2 0.041 0.020 0.041 0.020 {cftime._cftime.num2date}
3 0.040 0.013 0.821 0.274 core.py:173(getem)
1 0.027 0.027 55.374 55.374 <string>:1(<module>)
Output of %prun ds = xr.open_mfdataset('/work/xrc/AM4_skc/atmos_level.2001010100-2002123123.temp.nc',chunks={'lat':20,'time':50,'lon':12,'pfull':11},\ decode_cf=False)
772212 function calls (772026 primitive calls) in 56.000 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
5 55.213 11.043 55.214 11.043 {built-in method _operator.getitem}
764838 0.486 0.000 0.486 0.000 core.py:169(<genexpr>)
3 0.185 0.062 0.671 0.224 core.py:169(<listcomp>)
3 0.041 0.014 0.735 0.245 core.py:173(getem)
1 0.027 0.027 56.001 56.001 <string>:1(<module>)/work isn't a remote archive, so it surprises me that this should happen.
shoyer
commented
5 years ago Does it take 10 seconds even to open a single file? The big mystery is what that top line ("_operator.getitem") is but my guess is it's netCDF4-python. h5netcdf might also give different results... On Fri, Nov 16, 2018 at 8:20 AM chuaxr notifications@github.com wrote:
Sorry, I think the speedup had to do with accessing a file that had previously been loaded rather than due to decode_cf. Here's the output of prun using two different files of approximately the same size (~75 GB), run from a notebook without using distributed (which doesn't lead to any speedup):
Output of %prun ds = xr.open_mfdataset('/work/xrc/AM4_skc/ atmos_level.1999010100-2000123123.sphum.nc ',chunks={'lat':20,'time':50,'lon':12,'pfull':11})
780980 function calls (780741 primitive calls) in 55.374 seconds Ordered by: internal time ncalls tottime percall cumtime percall filename:lineno(function) 7 54.448 7.778 54.448 7.778 {built-in method _operator.getitem} 764838 0.473 0.000 0.473 0.000 core.py:169(<genexpr>) 3 0.285 0.095 0.758 0.253 core.py:169(<listcomp>) 2 0.041 0.020 0.041 0.020 {cftime._cftime.num2date} 3 0.040 0.013 0.821 0.274 core.py:173(getem) 1 0.027 0.027 55.374 55.374 <string>:1(<module>)Output of %prun ds = xr.open_mfdataset('/work/xrc/AM4_skc/ atmos_level.2001010100-2002123123.temp.nc ',chunks={'lat':20,'time':50,'lon':12,'pfull':11}, decode_cf=False)
772212 function calls (772026 primitive calls) in 56.000 seconds Ordered by: internal time ncalls tottime percall cumtime percall filename:lineno(function) 5 55.213 11.043 55.214 11.043 {built-in method _operator.getitem} 764838 0.486 0.000 0.486 0.000 core.py:169(<genexpr>) 3 0.185 0.062 0.671 0.224 core.py:169(<listcomp>) 3 0.041 0.014 0.735 0.245 core.py:173(getem) 1 0.027 0.027 56.001 56.001 <string>:1(<module>)/work isn't a remote archive, so it surprises me that this should happen.
— You are receiving this because you commented. Reply to this email directly, view it on GitHub https://github.com/pydata/xarray/issues/1385#issuecomment-439445695, or mute the thread https://github.com/notifications/unsubscribe-auth/ABKS1jmFqfe9_dIgHAMYlVOh7WKhzO8Kks5uvuXKgaJpZM4NJOcQ .
chuaxr
commented
5 years ago h5netcdf fails with the following error (presumably the file is not compatible):
/nbhome/xrc/anaconda2/envs/py361/lib/python3.6/site-packages/h5py/_hl/files.py in make_fid(name, mode, userblock_size, fapl, fcpl, swmr)
97 if swmr and swmr_support:
98 flags |= h5f.ACC_SWMR_READ
---> 99 fid = h5f.open(name, flags, fapl=fapl)
100 elif mode == 'r+':
101 fid = h5f.open(name, h5f.ACC_RDWR, fapl=fapl)
h5py/_objects.pyx in h5py._objects.with_phil.wrapper()
h5py/_objects.pyx in h5py._objects.with_phil.wrapper()
h5py/h5f.pyx in h5py.h5f.open()
OSError: Unable to open file (file signature not found)Using scipy:
ncalls tottime percall cumtime percall filename:lineno(function)
65/42 80.448 1.238 80.489 1.916 {built-in method numpy.core.multiarray.array}
764838 0.548 0.000 0.548 0.000 core.py:169(<genexpr>)
3 0.169 0.056 0.717 0.239 core.py:169(<listcomp>)
2 0.041 0.021 0.041 0.021 {cftime._cftime.num2date}
3 0.038 0.013 0.775 0.258 core.py:173(getem)
1 0.024 0.024 81.313 81.313 <string>:1(<module>)
sbiner
commented
5 years ago I have the same problem. open_mfdatasset is 10X slower than nc.MFDataset. I used the following code to get some timing on opening 456 local netcdf files located in a nc_local directory (of total size of 532MB)
clef = 'nc_local/*.nc'
t00 = time.time()
l_fichiers_nc = sorted(glob.glob(clef))
print ('timing glob: {:6.2f}s'.format(time.time()-t00))
# netcdf4
t00 = time.time()
ds1 = nc.MFDataset(l_fichiers_nc)
#dates1 = ouralib.netcdf.calcule_dates(ds1)
print ('timing netcdf4: {:6.2f}s'.format(time.time()-t00))
# xarray
t00 = time.time()
ds2 = xr.open_mfdataset(l_fichiers_nc)
print ('timing xarray: {:6.2f}s'.format(time.time()-t00))
# xarray tune
t00 = time.time()
ds3 = xr.open_mfdataset(l_fichiers_nc, decode_cf=False, concat_dim='time')
ds3 = xr.decode_cf(ds3)
print ('timing xarray tune: {:6.2f}s'.format(time.time()-t00))The output I get is :
timing glob: 0.00s timing netcdf4: 3.80s timing xarray: 44.60s timing xarray tune: 15.61s
I made tests on a centOS server using python2.7 and 3.6, and on mac OS as well with python3.6. The timing changes but the ratios are similar between netCDF4 and xarray.
Is there any way of making open_mfdataset go faster?
In case it helps, here are output from xr.show_versions and %prun xr.open_mfdataset(l_fichiers_nc). I do not know anything about the output of %prun but I have noticed that the first two lines of the ouput are different wether I'm using python 2.7 or python 3.6. I made those tests on centOS and macOS with anaconda environments.
for python 2.7:
13996351 function calls (13773659 primitive calls) in 42.133 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
2664 16.290 0.006 16.290 0.006 {time.sleep}
912 6.330 0.007 6.623 0.007 netCDF4_.py:244(_open_netcdf4_group)for python 3.6:
9663408 function calls (9499759 primitive calls) in 31.934 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
5472 15.140 0.003 15.140 0.003 {method 'acquire' of '_thread.lock' objects}
912 5.661 0.006 5.718 0.006 netCDF4_.py:244(_open_netcdf4_group)longer output of %prun with python3.6:
9663408 function calls (9499759 primitive calls) in 31.934 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
5472 15.140 0.003 15.140 0.003 {method 'acquire' of '_thread.lock' objects}
912 5.661 0.006 5.718 0.006 netCDF4_.py:244(_open_netcdf4_group)
4104 0.564 0.000 0.757 0.000 {built-in method _operator.getitem}
133152/129960 0.477 0.000 0.660 0.000 indexing.py:496(shape)
1554550/1554153 0.414 0.000 0.711 0.000 {built-in method builtins.isinstance}
912 0.260 0.000 0.260 0.000 {method 'close' of 'netCDF4._netCDF4.Dataset' objects}
6384 0.244 0.000 0.953 0.000 netCDF4_.py:361(open_store_variable)
910 0.241 0.000 0.595 0.001 duck_array_ops.py:141(array_equiv)
20990 0.235 0.000 0.343 0.000 {pandas._libs.lib.is_scalar}
37483/36567 0.228 0.000 0.230 0.000 {built-in method builtins.iter}
93986 0.219 0.000 1.607 0.000 variable.py:239(__init__)
93982 0.194 0.000 0.194 0.000 variable.py:706(attrs)
33744 0.189 0.000 0.189 0.000 {method 'getncattr' of 'netCDF4._netCDF4.Variable' objects}
15511 0.175 0.000 0.638 0.000 core.py:1776(normalize_chunks)
5930 0.162 0.000 0.350 0.000 missing.py:183(_isna_ndarraylike)
297391/296926 0.159 0.000 0.380 0.000 {built-in method builtins.getattr}
134230 0.155 0.000 0.269 0.000 abc.py:180(__instancecheck__)
6384 0.142 0.000 0.199 0.000 netCDF4_.py:34(__init__)
93986 0.126 0.000 0.671 0.000 variable.py:414(_parse_dimensions)
156545 0.119 0.000 0.811 0.000 utils.py:450(ndim)
12768 0.119 0.000 0.203 0.000 core.py:747(blockdims_from_blockshape)
6384 0.117 0.000 2.526 0.000 conventions.py:245(decode_cf_variable)
741183/696380 0.116 0.000 0.134 0.000 {built-in method builtins.len}
41957/23717 0.110 0.000 4.395 0.000 {built-in method numpy.core.multiarray.array}
93978 0.110 0.000 0.110 0.000 variable.py:718(encoding)
219940 0.109 0.000 0.109 0.000 _weakrefset.py:70(__contains__)
99458 0.100 0.000 0.440 0.000 variable.py:137(as_compatible_data)
53882 0.085 0.000 0.095 0.000 core.py:891(shape)
140604 0.084 0.000 0.628 0.000 variable.py:272(shape)
3192 0.084 0.000 0.170 0.000 utils.py:88(_StartCountStride)
10494 0.081 0.000 0.081 0.000 {method 'reduce' of 'numpy.ufunc' objects}
44688 0.077 0.000 0.157 0.000 variables.py:102(unpack_for_decoding)output of xr.show_versions()
xr.show_versions()
INSTALLED VERSIONS
------------------
commit: None
python: 3.6.8.final.0
python-bits: 64
OS: Linux
OS-release: 3.10.0-514.2.2.el7.x86_64
machine: x86_64
processor: x86_64
byteorder: little
LC_ALL: None
LANG: en_CA.UTF-8
LOCALE: en_CA.UTF-8
xarray: 0.11.0
pandas: 0.24.1
numpy: 1.15.4
scipy: None
netCDF4: 1.4.2
h5netcdf: None
h5py: None
Nio: None
zarr: None
cftime: 1.0.3.4
PseudonetCDF: None
rasterio: None
iris: None
bottleneck: None
cyordereddict: None
dask: 1.1.1
distributed: 1.25.3
matplotlib: 3.0.2
cartopy: None
seaborn: None
setuptools: 40.7.3
pip: 19.0.1
conda: None
pytest: None
IPython: 7.2.0
sphinx: None
TomNicholas
commented
5 years ago Looks like you're using xarray v0.11.0, but the most recent one is v0.11.3. There have been several changes since then which might affect this, try that first.
On Thu, 7 Feb 2019, 18:53 sbiner, notifications@github.com wrote:
I have the same problem. open_mfdatasset is 10X slower than nc.MFDataset. I used the following code to get some timing on opening 456 local netcdf files located in a nc_local directory (of total size of 532MB)
clef = 'nc_local/*.nc' t00 = time.time() l_fichiers_nc = sorted(glob.glob(clef)) print ('timing glob: {:6.2f}s'.format(time.time()-t00))
netcdf4
t00 = time.time() ds1 = nc.MFDataset(l_fichiers_nc)
dates1 = ouralib.netcdf.calcule_dates(ds1)
print ('timing netcdf4: {:6.2f}s'.format(time.time()-t00))
xarray
t00 = time.time() ds2 = xr.open_mfdataset(l_fichiers_nc) print ('timing xarray: {:6.2f}s'.format(time.time()-t00))
xarray tune
t00 = time.time() ds3 = xr.open_mfdataset(l_fichiers_nc, decode_cf=False, concat_dim='time') ds3 = xr.decode_cf(ds3) print ('timing xarray tune: {:6.2f}s'.format(time.time()-t00))
The output I get is :
timing glob: 0.00s timing netcdf4: 3.80s timing xarray: 44.60s timing xarray tune: 15.61s
I made tests on a centOS server using python2.7 and 3.6, and on mac OS as well with python3.6. The timing changes but the ratios are similar between netCDF4 and xarray.
Is there any way of making open_mfdataset go faster?
In case it helps, here are output from xr.show_versions and %prun xr.open_mfdataset(l_fichiers_nc). I do not know anything about the output of %prun but I have noticed that the first two lines of the ouput are different wether I'm using python 2.7 or python 3.6. I made those tests on centOS and macOS with anaconda environments.
for python 2.7:
13996351 function calls (13773659 primitive calls) in 42.133 secondsOrdered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function) 2664 16.290 0.006 16.290 0.006 {time.sleep} 912 6.330 0.007 6.623 0.007 netCDF4_.py:244(_open_netcdf4_group)
for python 3.6:
9663408 function calls (9499759 primitive calls) in 31.934 secondsOrdered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function) 5472 15.140 0.003 15.140 0.003 {method 'acquire' of 'thread.lock' objects} 912 5.661 0.006 5.718 0.006 netCDF4.py:244(_open_netcdf4_group)
longer output of %prun with python3.6:
9663408 function calls (9499759 primitive calls) in 31.934 secondsOrdered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function) 5472 15.140 0.003 15.140 0.003 {method 'acquire' of 'thread.lock' objects} 912 5.661 0.006 5.718 0.006 netCDF4.py:244(_open_netcdf4_group) 4104 0.564 0.000 0.757 0.000 {built-in method _operator.getitem} 133152/129960 0.477 0.000 0.660 0.000 indexing.py:496(shape) 1554550/1554153 0.414 0.000 0.711 0.000 {built-in method builtins.isinstance} 912 0.260 0.000 0.260 0.000 {method 'close' of 'netCDF4.netCDF4.Dataset' objects} 6384 0.244 0.000 0.953 0.000 netCDF4.py:361(open_store_variable) 910 0.241 0.000 0.595 0.001 duck_array_ops.py:141(array_equiv) 20990 0.235 0.000 0.343 0.000 {pandas._libs.lib.is_scalar} 37483/36567 0.228 0.000 0.230 0.000 {built-in method builtins.iter} 93986 0.219 0.000 1.607 0.000 variable.py:239(init) 93982 0.194 0.000 0.194 0.000 variable.py:706(attrs) 33744 0.189 0.000 0.189 0.000 {method 'getncattr' of 'netCDF4._netCDF4.Variable' objects} 15511 0.175 0.000 0.638 0.000 core.py:1776(normalize_chunks) 5930 0.162 0.000 0.350 0.000 missing.py:183(_isnandarraylike) 297391/296926 0.159 0.000 0.380 0.000 {built-in method builtins.getattr} 134230 0.155 0.000 0.269 0.000 abc.py:180(instancecheck) 6384 0.142 0.000 0.199 0.000 netCDF4.py:34(init) 93986 0.126 0.000 0.671 0.000 variable.py:414(_parse_dimensions) 156545 0.119 0.000 0.811 0.000 utils.py:450(ndim) 12768 0.119 0.000 0.203 0.000 core.py:747(blockdims_from_blockshape) 6384 0.117 0.000 2.526 0.000 conventions.py:245(decode_cf_variable) 741183/696380 0.116 0.000 0.134 0.000 {built-in method builtins.len} 41957/23717 0.110 0.000 4.395 0.000 {built-in method numpy.core.multiarray.array} 93978 0.110 0.000 0.110 0.000 variable.py:718(encoding) 219940 0.109 0.000 0.109 0.000 _weakrefset.py:70(contains) 99458 0.100 0.000 0.440 0.000 variable.py:137(as_compatible_data) 53882 0.085 0.000 0.095 0.000 core.py:891(shape) 140604 0.084 0.000 0.628 0.000 variable.py:272(shape) 3192 0.084 0.000 0.170 0.000 utils.py:88(_StartCountStride) 10494 0.081 0.000 0.081 0.000 {method 'reduce' of 'numpy.ufunc' objects} 44688 0.077 0.000 0.157 0.000 variables.py:102(unpack_for_decoding)
output of xr.show_versions()
xr.show_versions()
INSTALLED VERSIONS
commit: None python: 3.6.8.final.0 python-bits: 64 OS: Linux OS-release: 3.10.0-514.2.2.el7.x86_64 machine: x86_64 processor: x86_64 byteorder: little LC_ALL: None LANG: en_CA.UTF-8 LOCALE: en_CA.UTF-8
xarray: 0.11.0 pandas: 0.24.1 numpy: 1.15.4 scipy: None netCDF4: 1.4.2 h5netcdf: None h5py: None Nio: None zarr: None cftime: 1.0.3.4 PseudonetCDF: None rasterio: None iris: None bottleneck: None cyordereddict: None dask: 1.1.1 distributed: 1.25.3 matplotlib: 3.0.2 cartopy: None seaborn: None setuptools: 40.7.3 pip: 19.0.1 conda: None pytest: None IPython: 7.2.0 sphinx: None
— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub https://github.com/pydata/xarray/issues/1385#issuecomment-461551320, or mute the thread https://github.com/notifications/unsubscribe-auth/AiTXo7EQRagOh5iu3cYenLDTFDk68MGIks5vLHYMgaJpZM4NJOcQ .
sbiner
commented
5 years ago I just tried and it did not help ...
In [5]: run test_ouverture_fichier_nc_vs_xr.py
timing glob: 0.00s
timing netcdf4: 3.36s
timing xarray: 44.82s
timing xarray tune: 14.47s
In [6]: xr.show_versions()
INSTALLED VERSIONS
------------------
commit: None
python: 2.7.15 |Anaconda, Inc.| (default, Dec 14 2018, 19:04:19)
[GCC 7.3.0]
python-bits: 64
OS: Linux
OS-release: 3.10.0-514.2.2.el7.x86_64
machine: x86_64
processor: x86_64
byteorder: little
LC_ALL: None
LANG: en_CA.UTF-8
LOCALE: None.None
libhdf5: 1.10.4
libnetcdf: 4.6.1
xarray: 0.11.3
pandas: 0.24.0
numpy: 1.13.3
scipy: 1.2.0
netCDF4: 1.4.2
pydap: None
h5netcdf: None
h5py: None
Nio: None
zarr: None
cftime: 1.0.3.4
PseudonetCDF: None
rasterio: None
cfgrib: None
iris: None
bottleneck: 1.2.1
cyordereddict: None
dask: 1.0.0
distributed: 1.25.2
matplotlib: 2.2.3
cartopy: None
seaborn: None
setuptools: 40.5.0
pip: 19.0.1
conda: None
pytest: None
IPython: 5.8.0
sphinx: 1.8.2It seems my issue has to do with the time coordinate:
fname = '/work/xrc/AM4_xrc/c192L33_am4p0_cmip6Diag/daily/5yr/atmos.20100101-20141231.sphum.nc'
%prun ds = xr.open_mfdataset(fname,drop_variables='time')
7510 function calls (7366 primitive calls) in 0.068 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.039 0.039 0.039 0.039 netCDF4_.py:244(_open_netcdf4_group)
3 0.022 0.007 0.022 0.007 {built-in method _operator.getitem}
1 0.001 0.001 0.001 0.001 {built-in method posix.lstat}
125/113 0.000 0.000 0.001 0.000 indexing.py:504(shape)
11 0.000 0.000 0.000 0.000 core.py:137(<genexpr>)
fname = '/work/xrc/AM4_xrc/c192L33_am4p0_cmip6Diag/daily/5yr/atmos.20000101-20041231.sphum.nc'
%prun ds = xr.open_mfdataset(fname)
13143 function calls (12936 primitive calls) in 23.853 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
6 23.791 3.965 23.791 3.965 {built-in method _operator.getitem}
1 0.029 0.029 0.029 0.029 netCDF4_.py:244(_open_netcdf4_group)
2 0.023 0.012 0.023 0.012 {cftime._cftime.num2date}
1 0.001 0.001 0.001 0.001 {built-in method posix.lstat}
158/139 0.000 0.000 0.001 0.000 indexing.py:504(shape)Both files are 33 GB. This is using xarray 0.11.3.
I also confirm that nc.MFDataset is much faster (<1s).
Is there any speed-up for the time coordinates possible, given that my data follows a standard calendar? (Short of using drop_variables='time' and then manually adding the time coordinate...)
rabernat
commented
5 years ago What if you do xr.open_mfdataset(fname, decode_times=False)?
chuaxr
commented
5 years ago In that case, the speedup disappears. It seems that the slowdown arises from the entire time array being loaded into memory at once.
EDIT: I subsequently realized that using drop_variables = 'time' caused all the data values to become nan, which makes that an invalid option.
%prun ds = xr.open_mfdataset(fname,decode_times=False)
8025 function calls (7856 primitive calls) in 29.662 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
4 29.608 7.402 29.608 7.402 {built-in method _operator.getitem}
1 0.032 0.032 0.032 0.032 netCDF4_.py:244(_open_netcdf4_group)
1 0.015 0.015 0.015 0.015 {built-in method posix.lstat}
126/114 0.000 0.000 0.001 0.000 indexing.py:504(shape)
1196 0.000 0.000 0.000 0.000 {built-in method builtins.isinstance}
81 0.000 0.000 0.001 0.000 variable.py:239(__init__)See the rest of the prun output under the Details for more information:
Output of ds:
<xarray.Dataset>
Dimensions: (bnds: 2, lat: 360, level: 23, lon: 576, time: 1827)
Coordinates:
* lat (lat) float64 -89.75 -89.25 -88.75 -88.25 ... 88.75 89.25 89.75
* level (level) float32 1000.0 925.0 850.0 775.0 700.0 ... 5.0 3.0 2.0 1.0
* lon (lon) float64 0.3125 0.9375 1.562 2.188 ... 358.4 359.1 359.7
* time (time) float64 7.671e+03 7.672e+03 ... 9.496e+03 9.497e+03
Dimensions without coordinates: bnds
Data variables:
lat_bnds (lat, bnds) float64 dask.array<shape=(360, 2), chunksize=(360, 2)>
lon_bnds (lon, bnds) float64 dask.array<shape=(576, 2), chunksize=(576, 2)>
sphum (time, level, lat, lon) float32 dask.array<shape=(1827, 23, 360, 576), chunksize=(1827, 23, 360, 576)>On a related note, is it possible to clear out the memory used by the xarray dataset after it is no longer needed?
Here's an example:
fname = '/work/xrc/AM4_xrc/c192L33_am4p0_cmip6Diag/daily/5yr/atmos.19800101-19841231.ucomp.nc'import xarray as xrwith xr.set_options(file_cache_maxsize=1):
%time ds = xr.open_mfdataset(fname)CPU times: user 48 ms, sys: 124 ms, total: 172 ms
Wall time: 29.7 s
fname2 = '/work/xrc/AM4_xrc/c192L33_am4p0_cmip6Diag/daily/5yr/atmos.20100101-20141231.ucomp.nc'
with xr.set_options(file_cache_maxsize=1):
%time ds = xr.open_mfdataset(fname2) # would like this to free up memory used by fnameCPU times: user 39 ms, sys: 124 ms, total: 163 ms
Wall time: 28.8 simport gc
gc.collect()
with xr.set_options(file_cache_maxsize=1): # expected to take same time as first call
%time ds = xr.open_mfdataset(fname)CPU times: user 28 ms, sys: 10 ms, total: 38 ms
Wall time: 37.9 ms
keltonhalbert
commented
4 years ago So is there any word on a best practice, fix, or workaround with the MFDataset performance? Still getting abysmal reading perfomance with a list of NetCDF files that represent sequential times. I want to use MFDataset to chunk multiple time steps into memory at once but its taking 5-10 minutes to construct MFDataset objects and even longer to run .values on it.
rabernat
commented
4 years ago @keltonhalbert - I'm sorry you're frustrated by this issue. It's hard to provide a general answer to "why is open_mfdataset slow?" without seeing the data in question. I'll try to provide some best practices and recommendations here. In the meantime, could you please post the xarray repr of two of your files? To be explicit.
ds1 = xr.open_dataset('file1.nc')
print(ds1)
ds2 = xr.open_dataset('file2.nc')
print(ds2)This will help us debug.
rabernat
commented
4 years ago In your twitter thread you said
Do any of my xarray/dask folks know why open_mfdataset takes such a significant amount of time compared to looping over a list of files? Each file corresponds to a new time, just wanting to open multiple times at once...
The general reason for this is usually that open_mfdataset performs coordinate compatibility checks when it concatenates the files. It's useful to actually read the code of open_mfdataset to see how it works.
First, all the files are opened individually https://github.com/pydata/xarray/blob/577d3a75ea8bb25b99f9d31af8da14210cddff78/xarray/backends/api.py#L900-L903
You can recreate this step outside of xarray yourself by doing something like
from glob import glob
datasets = [xr.open_dataset(fname, chunks={}) for fname in glob('*.nc')]Once each dataset is open, xarray calls out to one of its combine functions. This logic has gotten more complex over the years as different options have been introduced, but the gist is this: https://github.com/pydata/xarray/blob/577d3a75ea8bb25b99f9d31af8da14210cddff78/xarray/backends/api.py#L947-L952
You can reproduce this step outside of xarray, e.g.
ds = xr.concat(datasets, dim='time')At that point, various checks will kick in to be sure that the coordinates in the different datasets are compatible. Performing these checks requires the data to be read eagerly, which can be a source of slow performance.
Without seeing more details about your files, it's hard to know exactly where the issue lies. A good place to start is to simply drop all coordinates from your data as a preprocessing step.
def drop_all_coords(ds):
return ds.reset_coords(drop=True)
xr.open_mfdataset('*.nc', combine='by_coords', preprocess=drop_all_coords)If you observe a big speedup, this points at coordinate compatibility checks as the culprit. From there you can experiment with the various options for open_mfdataset, such as coords='minimal', compat='override', etc.
Once you post your file details, we can provide more concrete suggestions.
dksasaki
commented
4 years ago Hi,
I have used xarray for a few years now and always had this slow performance associated to xr.open_mfdataset. Had I known about this issue earlier, it would save a lot of my time. I believe other users would benefit with a warning about this issue, when the method is called. Would this be possible?
dcherian
commented
4 years ago This is the most up-to-date documentation on this issue: https://xarray.pydata.org/en/stable/io.html#reading-multi-file-datasets
jameshalgren
commented
3 years ago @rabernat Is test dataset you mention still somewhere on Cheyenne -- we're seeing a general slowness processing multifile netcdf output from the National Water Model (our project here: NOAA-OWP/t-route) and we would like to see how things compare to your mini-benchmark test.
cc @groutr
An update on this long-standing issue.
I have learned that
open_mfdatasetcan be blazingly fast ifdecode_cf=Falsebut extremely slow withdecode_cf=True.As an example, I am loading a POP datataset on cheyenne. Anyone with access can try this example.
base_dir = '/glade/scratch/rpa/' prefix = 'BRCP85C5CN_ne120_t12_pop62.c13b17.asdphys.001' code = 'pop.h.nday1.SST' glob_pattern = os.path.join(base_dir, prefix, '%s.%s.*.nc' % (prefix, code)) def non_time_coords(ds): return [v for v in ds.data_vars if 'time' not in ds[v].dims] def drop_non_essential_vars_pop(ds): return ds.drop(non_time_coords(ds)) # this runs almost instantly ds = xr.open_mfdataset(glob_pattern, decode_times=False, chunks={'time': 1}, preprocess=drop_non_essential_vars_pop, decode_cf=False)And returns this
<xarray.Dataset> Dimensions: (d2: 2, nlat: 2400, nlon: 3600, time: 16401, z_t: 62, z_t_150m: 15, z_w: 62, z_w_bot: 62, z_w_top: 62) Coordinates: * z_w_top (z_w_top) float32 0.0 1000.0 2000.0 3000.0 4000.0 5000.0 ... * z_t (z_t) float32 500.0 1500.0 2500.0 3500.0 4500.0 5500.0 ... * z_w (z_w) float32 0.0 1000.0 2000.0 3000.0 4000.0 5000.0 6000.0 ... * z_t_150m (z_t_150m) float32 500.0 1500.0 2500.0 3500.0 4500.0 5500.0 ... * z_w_bot (z_w_bot) float32 1000.0 2000.0 3000.0 4000.0 5000.0 6000.0 ... * time (time) float64 7.322e+05 7.322e+05 7.322e+05 7.322e+05 ... Dimensions without coordinates: d2, nlat, nlon Data variables: time_bound (time, d2) float64 dask.array<shape=(16401, 2), chunksize=(1, 2)> SST (time, nlat, nlon) float32 dask.array<shape=(16401, 2400, 3600), chunksize=(1, 2400, 3600)> Attributes: nsteps_total: 480 tavg_sum: 64800.0 title: BRCP85C5CN_ne120_t12_pop62.c13b17.asdphys.001 start_time: This dataset was created on 2016-03-14 at 05:32:30.3 Conventions: CF-1.0; http://www.cgd.ucar.edu/cms/eaton/netcdf/CF-curren... source: CCSM POP2, the CCSM Ocean Component cell_methods: cell_methods = time: mean ==> the variable values are aver... calendar: All years have exactly 365 days. history: none contents: Diagnostic and Prognostic Variables revision: $Id: tavg.F90 56176 2013-12-20 18:35:46Z mlevy@ucar.edu $This is roughly 45 years of daily data, one file per year.
Instead, if I just change
decode_cf=True(the default), it takes forever. I can monitor what is happening via the distributed dashboard. It looks like this:There are more of these
open_datasettasks then there are number of files (45), so I can only presume there are 16401 individual tasks (one for each timestep), which each takes about 1 s in serial.This is a real failure of lazy decoding. Maybe it can be fixed by #1725, possibly related to #1372.
cc Pangeo folks: @jhamman, @mrocklin
dcherian
commented
3 years ago @jameshalgren A lot of these issues have been fixed. Have you tried the advice here: https://xarray.pydata.org/en/stable/io.html#reading-multi-file-datasets?
If not, a reproducible example would help (I have access to Cheyenne). Let's also move this conversation to the "Discussions" forum: https://github.com/pydata/xarray/discussions
jameshalgren
commented
3 years ago @dcherian We had looked at a number of options. In the end, the best performance I could achieve was with the work-around pre-processor script, rather than any of the built-in options. It's worth noting that a major part of the slowdown we were experiencing was from the dataframe transform option we were doing after reading the files. Once that was fixed, performance was much better, but not necessarily with any of the expected options. This script reading one-day's worth of NWM q_laterals runs in about 8 seconds (on Cheyenne). If you change the globbing pattern to include a full month, it takes about 380 seconds.
setting parallel=True seg faults... I'm betting that is some quirk of my python environment, though.
We are reading everything into memory, which negates the lazy-access benefits of using a dataset and our next steps include looking into that.
300 seconds to read a month isn't totally unacceptable, but we'd like it be faster for the operational runs we'll eventually be doing -- for longer simulations, we may be able to achieve some improvement with asynchronous data access. We'll keep looking into it. (We'll start by trying to adapt the "slightly more sophisticated example" under the docs you referenced here...)
Thanks (for the great package and for getting back on this question!)
# python /glade/scratch/halgren/qlat_mfopen_test.py
import time
import xarray as xr
import pandas as pd
def get_ql_from_wrf_hydro_mf(
qlat_files, index_col="feature_id", value_col="q_lateral"
):
"""
qlat_files: globbed list of CHRTOUT files containing desired lateral inflows
index_col: column/field in the CHRTOUT files with the segment/link id
value_col: column/field in the CHRTOUT files with the lateral inflow value
In general the CHRTOUT files contain one value per time step. At present, there is
no capability for handling non-uniform timesteps in the qlaterals.
The qlateral may also be input using comma delimited file -- see
`get_ql_from_csv`
Note/Todo:
For later needs, filtering for specific features or times may
be accomplished with one of:
ds.loc[{selectors}]
ds.sel({selectors})
ds.isel({selectors})
Returns from these selection functions are sub-datasets.
For example:(Pdb) ds.sel({"feature_id":[4186117, 4186169],"time":ds.time.values[:2]})['q_lateral'].to_dataframe()
latitude longitude q_lateral
time feature_id
2018-01-01 13:00:00 4186117 41.233807 -75.413895 0.006496
2018-01-02 00:00:00 4186117 41.233807 -75.413895 0.006460
```
or...
```
(Pdb) ds.sel({"feature_id":[4186117, 4186169],"time":[np.datetime64('2018-01-01T13:00:00')]})['q_lateral'].to_dataframe()
latitude longitude q_lateral
time feature_id
2018-01-01 13:00:00 4186117 41.233807 -75.413895 0.006496
```
"""
filter_list = None
with xr.open_mfdataset(
qlat_files,
combine="by_coords",
# combine="nested",
# concat_dim="time",
# data_vars="minimal",
# coords="minimal",
# compat="override",
preprocess=drop_all_coords,
# parallel=True,
) as ds:
ql = pd.DataFrame(
ds[value_col].values.T,
index=ds[index_col].values,
columns=ds.time.values,
# dtype=float,
)
return qldef drop_all_coords(ds): return ds.reset_coords(drop=True)
def main():
input_folder = "/glade/p/cisl/nwc/nwmv21_finals/CONUS/retro/Retro8yr/FullRouting/OUTPUT_chrtout_comp_20181001_20191231"
file_pattern_filter = "/20181101*.CHRTOUT*"
file_index_col = "feature_id"
file_value_col = "q_lateral"
# file_value_col = "streamflow"
start_time = time.time()
qlat_files = (input_folder + file_pattern_filter)
print(f"reading {qlat_files}")
qlat_df = get_ql_from_wrf_hydro_mf(
qlat_files=qlat_files,
index_col=file_index_col,
value_col=file_value_col,
)
print(qlat_df)
print("read qlaterals in %s seconds." % (time.time() - start_time))if name == "main": main()
@groutr, @jmccreight setting parallel=True seg faults... I'm betting that is some quirk of my python environment, though.
This is important! Otherwise that timing scales with number of files. If you get that to work, then you can convert to a dask dataframe and keep things lazy.
jameshalgren
commented
3 years ago setting parallel=True seg faults... I'm betting that is some quirk of my python environment, though.
This is important! Otherwise that timing scales with number of files. If you get that to work, then you can convert to a dask dataframe and keep things lazy.
Indeed @dcherian -- it took some experimentation to get the right engine to support parallel execution and even then, results are still mixed, which, to me, means further work is needed to isolate the issue.
Along the lines of suggestions here (thanks @jmccreight for pointing this out), we've introduced a very practical pre-processing step to rewrite the datasets so that the read is not striped across the file system, effectively isolating the performance bottleneck to a position where it can be dealt with independently. Of course, such an asynchronous workflow is not possible in all situations, so we're still looking at improving the direct performance.
Two notes as we keep working:
jtomfarrar
commented
2 years ago @rabernat wrote:
An update on this long-standing issue.
I have learned that
open_mfdatasetcan be blazingly fast ifdecode_cf=Falsebut extremely slow withdecode_cf=True.
I seem to be experiencing a similar (same?) issue with open_dataset: https://stackoverflow.com/questions/71147712/can-i-force-xarray-open-dataset-to-do-a-lazy-load?stw=2
rabernat
commented
2 years ago Hi Tom! 👋
So much has evolved about xarray since this original issue was posted. However, we continue to use it as a catchall for people looking to speed up open_mfdataset. I saw your stackoverflow post. Any chance you could post a link to the actual file in question?
jtomfarrar
commented
2 years ago Thanks, Ryan! Sure-- here's a link to the file: https://drive.google.com/file/d/1-05bG2kF8wbvldYtDpZ3LYLyqXnvZyw1/view?usp=sharing
(I could post to a web server if there's any reason to prefer that.)
rabernat
commented
2 years ago (I could post to a web server if there's any reason to prefer that.)
In general that would be a little more convenient than google drive, because then we could download the file from python (rather than having a manual step). This would allow us to share a fully copy-pasteable code snippet to reproduce the issue. But don't worry about that for now.
First, I'd note that your issue is not really related to open_mfdataset at all, since it is reproduced just using open_dataset. The core problem is that you have ~15M timesteps, and it is taking forever to decode the times out of them. It's fast when you do decode_times=False because the data aren't actually being read. I'm going to make a post over in discussions to dig a bit deeper into this. StackOverflow isn't monitored too regularly by this community.
jtomfarrar
commented
2 years ago Thank you, Ryan. I will post the file to a server with a stable URL and replace the google drive link in the other post. My original issue was that I wanted to not read the data (yet), only to have a look at the metadata.
rabernat
commented
2 years ago Ah ok so if that is your goal, decode_times=False should be enough to solve it.
There is a problem with the time encoding in this file. The units (days since 1950-01-01T00:00:00Z) are not compatible with the values (738457.04166667, etc.). That would place your measurements sometime in the year 3971. This is part of the problem, but not the whole story.
jtomfarrar
commented
2 years ago Thank you. A member of my research group made the netcdf file, so we will make a second file with the time encoding fixed.
rabernat
commented
2 years ago See deeper dive in https://github.com/pydata/xarray/discussions/6284
fraserwg
commented
1 year ago I've recently been trying to run open_mfdataset on a large list of large files. When using more than ~100 files the function became so slow that I gave up trying to run it. I then came upon this thread and discovered that if I passed the argument decode_cf=False the function would run in a matter of seconds. Applying decode_cf to the returned dataset after opening then ran in seconds and I ended up with the same dataset following this two step process as I did before. Would it be possible to change one of:
decode_cf is called in open_mfdataset — essentially, open the individual datasets with decode_cf=False and then apply decode_cf to the merged dataset before it is returned;decode_cf=False to be the default in open_mfdataset?To me the first solution feels better and I can make a pull request to do this.
From reading this thread I'm under the impression that there's probably something else going on under the hood that's causing the slowness of open_mfdataset at present. Obviously it would be best to address this; however, given that the problem was first raised in 2017 and a solution to the underlying problem doesn't seem to be forthcoming I'd be very pleased to see a "fix" that addresses the symptoms (the slowness) rather than the illness (whatever's going wrong behind the scenes).
shoyer
commented
1 year ago @fraserwg do you know what the performance bottleneck is in your case? (i.e., if you interrupt the comptuation, what is being computed?)
dcherian
commented
1 year ago It is very common for different netCDF files in a "dataset" (a folder) to be encoded differently so we can't set decode_cf=False by default.
there's probably something else going on under the hood that's causing the slowness of open_mfdataset at present.
There's
parallel to help a bit here.data_vars='minimal', coords='minimal', compat='override' is a common choice.What your describing sounds like a failure of lazy decoding or acftime slowdown (example)which should be fixed. If you can provide a reproducible example, that would help.
fraserwg
commented
1 year ago @shoyer I will double check what the bottle neck is and report back. @dcherian interestingly, the parallel option doesn't seem to do anything when decode_cf=True. From looking at the dask dashboard it seems to load each file sequentially, with each opening being carried out by a different worker but not concurrently. I will see what I can do minimal example wise!
ashjbarnes
commented
8 months ago I'm another person who stumbled across this thread, and found that decode_cf = False fix to work really well.
I appreciate that we can't set this by default, but maybe this could be put into the docstring of open_mfdataset directly? It appears to be passed as a kwarg, so is hard to find despite it being such a helpful fix for so many people in this thread!
It also seems like the decode_cf step is done in serial. My dask cluster has plenty of workers but when decode_cf is set to True it only processes one of my (many) files at a time. Switching to decode_cf = False and the task stream shows my entire cluster being utilised. Perhaps this is part of the issue?
xarray version: 2024.2.0
dcherian
commented
8 months ago @ashjbarnes Are you able to share two small files that illustrate the issue?
ashjbarnes
commented
8 months ago @dcherian Thanks, the files are shared in this google drive folder.
This is a spatial subsample of the same files. Perhaps it's a bad idea to store static data like the lat/lon coordinates in each file? The overall size of this is so tiny compared to the 4D data that I left the coordinates there for convenience but I'm not sure whether this has broader implications.
In my tests, running:
xr.open_mfdataset(PATH,decode_times = False,parallel = True,decode_cf = False)on ~3000 files of 300mb each had an order of magnitude speedup over the same command with decode_cf = True on xarray 2024.2.0. The real files are chunked on disk in time and the yb dimension
dcherian
commented
8 months ago Wow, thank you!
This is an amazing bug. The defaults say data_vars="all", coords="different" which means always concatenate all data_vars along the concat dimensions (here inferred to be "time") but only concatenate coords if they differ in the different files.
When decode_cf=False , lat ,lon are data_vars and get concatenated without any checking or reading.
When decode_cf=True, lat, lon are promoted to coords, then get checked for equality across all files. The two variables get read sequentially from all files. This is the slowdown you see.
Once again, this is a consequence of bad defaults for concat and open_mfdataset.
I would follow https://docs.xarray.dev/en/stable/user-guide/io.html#reading-multi-file-datasets and use data_vars="minimal", coords="minimal", compat="override" which will only concatenate those variables with the time dimension, and skip any checking for variables that don't have a time dimension (simply pick the variable from the first file).
ashjbarnes
commented
8 months ago Well done @dcherian great find! Changing the defaults does seem like a really good idea in this case
hannahzafar
commented
7 months ago @dcherian I am yet another person stumbling on this problem. Unfortunately decode_cf = False seems to override decode_times=True (https://stackoverflow.com/questions/77243075/xarray-wont-decode-times-from-netcdf-file-with-decode-cf-false-even-if-decode) so you cannot use that fix if you want to maintain datetime objects.
dcherian
commented
7 months ago A simpler fix is probably decode_coords=False
We have a dataset stored across multiple netCDF files. We are getting very slow performance with
open_mfdataset, and I would like to improve this.Each individual netCDF file looks like this:
As shown above, a single data file opens in ~60 ms.
When I call
open_mdsdataseton 49 files (each with a differenttimedimension but the samenpart), here is what happens:It takes over 2 minutes to open the dataset. Specifying
concat_dim='time'does not improve performance.Here is
%prunof theopen_mfdatasetcommand.It looks like most of the time is being spent on
reindex_variables. I understand why this happens...xarray needs to make sure the dimensions are the same in order to concatenate them together.Is there any obvious way I could improve the load time? For example, can I give a hint to xarray that this
reindex_variablesstep is not necessary, since I know that all thenpartdimensions are the same in each file?Possibly related to #1301 and #1340.