[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnuastro-commits] master a0b094b: Library (pointer.h): message when cre
|
From: |
Mohammad Akhlaghi |
|
Subject: |
[gnuastro-commits] master a0b094b: Library (pointer.h): message when creating/deleting mmap'd file |
|
Date: |
Mon, 17 Jun 2019 13:35:50 -0400 (EDT) |
branch: master
commit a0b094bd3d19bc7d95694390719724bf7e463717
Author: Mohammad Akhlaghi <address@hidden>
Commit: Mohammad Akhlaghi <address@hidden>
Library (pointer.h): message when creating/deleting mmap'd file
Until now, the creation of memory-mapped files and their deletion was done
quietly in the background. This had two negative side-effects: 1) The
program would run much slower. 2) The left-over temporary files when the
program crashes would consume too much space (and the user wouldn't know to
delete them manually).
With this commit, the memory allocation function in charge of this
(`gal_pointer_allocate_mmap') accepts a new argument called
`quietmmap'. When it is zero, a message will be printed informing the user
of the file name and its size, and that they can use `--minmapsize' to
toggle this feature. Another message will later be printed when its
freed. This option then propagated to all the higher-level library
functions that call it and subsequently to the programs. As a result, a new
common option called `--quietmmap' is added to Gnuastro to let program
users directly disable such messages if it is annoying for them.
This task was implemented after a discussion with Michael Wilkinson.
---
NEWS | 34 +++++++
THANKS | 1 +
bin/arithmetic/arithmetic.c | 12 ++-
bin/arithmetic/operands.c | 3 +-
bin/convertt/color.c | 18 ++--
bin/convertt/ui.c | 24 +++--
bin/convolve/convolve.c | 3 +-
bin/convolve/ui.c | 9 +-
bin/cosmiccal/ui.c | 2 +-
bin/crop/ui.c | 16 ++--
bin/crop/wcsmode.c | 2 +-
bin/fits/fits.c | 8 +-
bin/gnuastro.conf | 3 +-
bin/match/match.c | 4 +-
bin/match/ui.c | 8 +-
bin/mkcatalog/columns.c | 17 ++--
bin/mkcatalog/mkcatalog.c | 4 +-
bin/mkcatalog/parse.c | 7 +-
bin/mkcatalog/ui.c | 22 +++--
bin/mkcatalog/upperlimit.c | 8 +-
bin/mknoise/ui.c | 3 +-
bin/mkprof/mkprof.c | 4 +-
bin/mkprof/oneprofile.c | 4 +-
bin/mkprof/ui.c | 28 +++---
bin/noisechisel/detection.c | 16 ++--
bin/noisechisel/sky.c | 12 ++-
bin/noisechisel/threshold.c | 9 +-
bin/noisechisel/ui.c | 18 ++--
bin/segment/clumps.c | 16 ++--
bin/segment/segment.c | 35 ++++---
bin/segment/ui.c | 24 +++--
bin/statistics/sky.c | 4 +-
bin/statistics/statistics.c | 13 +--
bin/statistics/ui.c | 17 ++--
bin/table/arithmetic.c | 2 +-
bin/table/table.c | 10 +-
bin/table/ui.c | 2 +-
bin/warp/ui.c | 10 +-
bin/warp/warp.c | 4 +-
doc/announce-acknowledge.txt | 1 +
doc/gnuastro.texi | 185 +++++++++++++++++++++++--------------
lib/arithmetic.c | 24 +++--
lib/array.c | 22 ++---
lib/binary.c | 13 ++-
lib/blank.c | 7 +-
lib/convolve.c | 8 +-
lib/data.c | 22 +++--
lib/dimension.c | 14 +--
lib/eps.c | 2 +-
lib/fits.c | 38 ++++----
lib/gnuastro-internal/commonopts.h | 13 +++
lib/gnuastro-internal/options.h | 2 +
lib/gnuastro/array.h | 8 +-
lib/gnuastro/data.h | 10 +-
lib/gnuastro/fits.h | 9 +-
lib/gnuastro/jpeg.h | 2 +-
lib/gnuastro/label.h | 3 +-
lib/gnuastro/list.h | 4 +-
lib/gnuastro/match.h | 3 +-
lib/gnuastro/pointer.h | 2 +-
lib/gnuastro/table.h | 2 +-
lib/gnuastro/tiff.h | 2 +-
lib/gnuastro/txt.h | 5 +-
lib/gnuastro/type.h | 8 ++
lib/interpolate.c | 10 +-
lib/jpeg.c | 5 +-
lib/label.c | 6 +-
lib/list.c | 6 +-
lib/match.c | 15 +--
lib/options.c | 40 ++++----
lib/pointer.c | 8 +-
lib/statistics.c | 52 ++++++-----
lib/table.c | 6 +-
lib/tiff.c | 17 ++--
lib/tile.c | 10 +-
lib/txt.c | 24 ++---
lib/wcs.c | 5 +-
tests/buildprog/simpleio.c | 2 +-
tests/lib/multithread.c | 2 +-
79 files changed, 629 insertions(+), 424 deletions(-)
diff --git a/NEWS b/NEWS
index b80c6d2..2d2a501 100644
--- a/NEWS
+++ b/NEWS
@@ -7,6 +7,17 @@ See the end of the file for license conditions.
** New features
+ All programs:
+ - When an array is memory-mapped to non-volatile space (like the
+ HDD/SSD), a warning/message is printed that shows the file name and
+ its size. Later, when its deleted, a warning/message is also printed,
+ informing you that it has been deleted. These warnings can be very
+ useful when you actually have enough RAM, but forget to increase the
+ `--minmapsize' value (therefore significantly slowing down the
+ program). When you don't have enough RAM, but don't want to be annoyed
+ with the warnings, you can use the new `--quietmmap' option to disable
+ them.
+
Arithmetic:
- `unique' operator removes all duplicate (and blank) elements from the
dataset and returns a single-dimension output, containing only the
@@ -62,6 +73,8 @@ See the end of the file for license conditions.
- gal_dimension_remove_extra: Remove extra (length 1) dimensions.
- gal_list_data_to_array_ptr: Make an array of pointers from the list.
- gal_fits_img_info_dim: Only return the size information of a dataset.
+ - GAL_TYPE_INT: Corresponding to respective width based on system.
+ - GAL_TYPE_UINT: Corresponding to respective width based on system.
- GAL_BLANK_INT: Blank value for `int' (can be 16-bit or 32-bit).
- GAL_BLANK_UINT: Blank value for unsigned `int' (can be 16-bit or 32-bit).
@@ -91,6 +104,27 @@ See the end of the file for license conditions.
Library:
- gal_statistics_outlier_flat_cfp: Improved implementation with new API.
+ - New `quietmmap' argument added to the following functions (as the
+ argument following `minmapsize'). For more, see the description above
+ of the new similarly named option to all programs.
+ - gal_array_read
+ - gal_array_read_to_type
+ - gal_array_read_one_ch
+ - gal_array_read_one_ch_to_type
+ - gal_data_alloc
+ - gal_data_initialize
+ - gal_fits_img_read
+ - gal_fits_img_read_to_type
+ - gal_fits_img_read_kernel
+ - gal_fits_tab_read
+ - gal_jpeg_read
+ - gal_label_indexs
+ - gal_list_data_add_alloc
+ - gal_match_coordinates
+ - gal_pointer_allocate_mmap
+ - gal_table_read
+ - gal_tiff_read
+ - gal_txt_image_read
** Bugs fixed
bug #56195: astscript-sort-by-night crashing because of AWK.
diff --git a/THANKS b/THANKS
index 45074bc..dbc5c88 100644
--- a/THANKS
+++ b/THANKS
@@ -77,6 +77,7 @@ support in Gnuastro. The list is ordered alphabetically (by
family name).
Ignacio Trujillo address@hidden
David Valls-Gabaud address@hidden
Aaron Watkins address@hidden
+ Michael H.F. Wilkinson address@hidden
Christopher Willmer address@hidden
Sara Yousefi Taemeh address@hidden
Johannes Zabl address@hidden
diff --git a/bin/arithmetic/arithmetic.c b/bin/arithmetic/arithmetic.c
index f0586b4..b14f7e3 100644
--- a/bin/arithmetic/arithmetic.c
+++ b/bin/arithmetic/arithmetic.c
@@ -208,7 +208,7 @@ arithmetic_filter(void *in_prm)
size_t i, j, coord[ARITHMETIC_FILTER_DIM], ndim=input->ndim;
size_t start[ARITHMETIC_FILTER_DIM], end[ARITHMETIC_FILTER_DIM];
gal_data_t *tile=gal_data_alloc(NULL, input->type, ndim, afp->fsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
/* Prepare the tile. */
free(tile->array);
@@ -296,7 +296,7 @@ arithmetic_filter(void *in_prm)
/* Allocate the output and write the value into it. */
result=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
((float *)(result->array))[0] =
((float *)(sigclip->array))[sind];
@@ -372,7 +372,7 @@ wrapper_for_filter(struct arithmeticparams *p, char *token,
int operator)
/* A zero value for checking the value of input widths. */
- zero=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &one, NULL, 1, -1, NULL,
+ zero=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &one, NULL, 1, -1, 1, NULL,
NULL, NULL);
@@ -503,7 +503,8 @@ wrapper_for_filter(struct arithmeticparams *p, char *token,
int operator)
the units of the dataset. */
afp.out=gal_data_alloc(NULL, type, ndim, afp.input->dsize,
afp.input->wcs, 0, afp.input->minmapsize,
- NULL, afp.input->unit, NULL);
+ afp.input->quietmmap, NULL, afp.input->unit,
+ NULL);
/* Spin off threads for each pixel. */
@@ -1210,7 +1211,8 @@ reversepolish(struct arithmeticparams *p)
{
/* Read the data, note that the WCS has already been set. */
p->operands->data=gal_array_read_one_ch(filename, hdu, NULL,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
data=p->operands->data;
data->ndim=gal_dimension_remove_extra(data->ndim, data->dsize, NULL);
if(!p->cp.quiet) printf(" - %s (hdu %s) is read.\n", filename, hdu);
diff --git a/bin/arithmetic/operands.c b/bin/arithmetic/operands.c
index 9b7cceb..9b24ece 100644
--- a/bin/arithmetic/operands.c
+++ b/bin/arithmetic/operands.c
@@ -355,7 +355,8 @@ operands_pop(struct arithmeticparams *p, char *operator)
filename=operands->filename;
/* Read the dataset and remove possibly extra dimensions. */
- data=gal_array_read_one_ch(filename, hdu, NULL, p->cp.minmapsize);
+ data=gal_array_read_one_ch(filename, hdu, NULL, p->cp.minmapsize,
+ p->cp.quietmmap);
data->ndim=gal_dimension_remove_extra(data->ndim, data->dsize, NULL);
/* Arithmetic changes the contents of a dataset, so the existing name
diff --git a/bin/convertt/color.c b/bin/convertt/color.c
index 7346e1d..bdd8daa 100644
--- a/bin/convertt/color.c
+++ b/bin/convertt/color.c
@@ -101,13 +101,13 @@ color_from_mono_hsv(struct converttparams *p)
/* Allocate the three datasets to keep the RGB colors. */
R=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "RED", NULL, "Red color channel.");
+ p->cp.quietmmap, "RED", NULL, "Red color channel.");
G=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "GREEN", NULL, "Green color channel.");
+ p->cp.quietmmap, "GREEN", NULL, "Green color channel.");
B=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "BLUE", NULL, "Blue color channel.");
+ p->cp.quietmmap, "BLUE", NULL, "Blue color channel.");
/* Start the conversion. Note that the "Choroma" (`C') is fixed by our
definition. */
@@ -187,13 +187,13 @@ color_from_mono_sls(struct converttparams *p)
/* Allocate the three datasets to keep the RGB colors. */
R=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "RED", NULL, "Red color channel.");
+ p->cp.quietmmap, "RED", NULL, "Red color channel.");
G=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "GREEN", NULL, "Green color channel.");
+ p->cp.quietmmap, "GREEN", NULL, "Green color channel.");
B=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, channel->ndim,
channel->dsize, channel->wcs, 0, p->cp.minmapsize,
- "BLUE", NULL, "Blue color channel.");
+ p->cp.quietmmap, "BLUE", NULL, "Blue color channel.");
/* Start the conversion. Note that the "Choroma" (`C') is fixed by our
definition. */
@@ -493,13 +493,13 @@ color_rgb_to_hsv(struct converttparams *p)
/* Allocate the three datasets to keep the RGB colors. */
H=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->chll->ndim,
p->chll->dsize, p->chll->wcs, 0, p->cp.minmapsize,
- "HUE", NULL, NULL);
+ p->cp.quietmmap, "HUE", NULL, NULL);
S=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->chll->ndim,
p->chll->dsize, p->chll->wcs, 0, p->cp.minmapsize,
- "SATURATION", NULL, NULL);
+ p->cp.quietmmap, "SATURATION", NULL, NULL);
V=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->chll->ndim,
p->chll->dsize, p->chll->wcs, 0, p->cp.minmapsize,
- "VALUE", NULL, NULL);
+ p->cp.quietmmap, "VALUE", NULL, NULL);
/* Initiate the pointer arrays. */
h=H->array;
diff --git a/bin/convertt/ui.c b/bin/convertt/ui.c
index 145ae5d..56f405f 100644
--- a/bin/convertt/ui.c
+++ b/bin/convertt/ui.c
@@ -261,8 +261,9 @@ ui_colormap_sanity_check(struct converttparams *p)
if(p->colormap->size==1)
{
p->colormap->next=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1,
- &nparams, NULL, 0,
- p->cp.minmapsize, NULL,NULL,NULL);
+ &nparams, NULL, 0,
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL,NULL,NULL);
farray=p->colormap->next->array;
switch(p->colormap->status)
{
@@ -489,7 +490,7 @@ ui_make_channels_ll(struct converttparams *p)
lines=gal_txt_stdin_read(p->cp.stdintimeout);
if(lines)
{
- data=gal_txt_image_read(NULL, lines, p->cp.minmapsize);
+ data=gal_txt_image_read(NULL, lines, p->cp.minmapsize, p->cp.quietmmap);
gal_list_data_add(&p->chll, data);
gal_list_str_free(lines, 1);
++p->numch;
@@ -521,7 +522,8 @@ ui_make_channels_ll(struct converttparams *p)
"for each input FITS image (in the same order)");
/* Read in the array and its WCS information. */
- data=gal_fits_img_read(name->v, hdu, p->cp.minmapsize);
+ data=gal_fits_img_read(name->v, hdu, p->cp.minmapsize,
+ p->cp.quietmmap);
data->wcs=gal_wcs_read(name->v, hdu, 0, 0, &data->nwcs);
data->ndim=gal_dimension_remove_extra(data->ndim, data->dsize,
data->wcs);
@@ -545,7 +547,8 @@ ui_make_channels_ll(struct converttparams *p)
dirnum=0;
/* Read the TIFF image into memory. */
- data=gal_tiff_read(name->v, dirnum, p->cp.minmapsize);
+ data=gal_tiff_read(name->v, dirnum, p->cp.minmapsize,
+ p->cp.quietmmap);
p->numch += gal_list_data_number(data);
gal_list_data_add(&p->chll, data);
}
@@ -554,7 +557,7 @@ ui_make_channels_ll(struct converttparams *p)
/* JPEG: */
else if ( gal_jpeg_name_is_jpeg(name->v) )
{
- data=gal_jpeg_read(name->v, p->cp.minmapsize);
+ data=gal_jpeg_read(name->v, p->cp.minmapsize, p->cp.quietmmap);
p->numch += gal_list_data_number(data);
gal_list_data_add(&p->chll, data);
}
@@ -566,7 +569,7 @@ ui_make_channels_ll(struct converttparams *p)
{
gal_list_data_add_alloc(&p->chll, NULL, GAL_TYPE_INVALID, 0,
&dsize, NULL, 0, p->cp.minmapsize,
- "blank", NULL, NULL);
+ p->cp.quietmmap, "blank", NULL, NULL);
++p->numch;
}
@@ -590,7 +593,8 @@ ui_make_channels_ll(struct converttparams *p)
/* Text: */
else
{
- data=gal_txt_image_read(name->v, NULL, p->cp.minmapsize);
+ data=gal_txt_image_read(name->v, NULL, p->cp.minmapsize,
+ p->cp.quietmmap);
gal_list_data_add(&p->chll, data);
++p->numch;
}
@@ -701,8 +705,8 @@ ui_prepare_input_channels(struct converttparams *p)
{
/* Make the blank data structure. */
blank=gal_data_alloc(NULL, GAL_TYPE_UINT8, ndim, dsize,
- wcs, 1, p->cp.minmapsize, "blank channel",
- NULL, NULL);
+ wcs, 1, p->cp.minmapsize, p->cp.quietmmap,
+ "blank channel", NULL, NULL);
/* We will use the status value of the data structuer to mark it
as one that was originally blank. */
diff --git a/bin/convolve/convolve.c b/bin/convolve/convolve.c
index 4d23262..8db100b 100644
--- a/bin/convolve/convolve.c
+++ b/bin/convolve/convolve.c
@@ -642,7 +642,8 @@ convolve_frequency(struct convolveparams *p)
don't need the array that is initially made. */
dsize[0]=p->ps0; dsize[1]=p->ps1;
data=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 2, dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
free(data->array);
/* Save the padded input image. */
diff --git a/bin/convolve/ui.c b/bin/convolve/ui.c
index b80530e..6722c69 100644
--- a/bin/convolve/ui.c
+++ b/bin/convolve/ui.c
@@ -376,7 +376,8 @@ ui_read_column(struct convolveparams *p, int i0k1)
/* Read the desired column(s). */
out=gal_table_read(filename, hdu, lines, column, p->cp.searchin,
- p->cp.ignorecase, p->cp.minmapsize, NULL);
+ p->cp.ignorecase, p->cp.minmapsize, p->cp.quietmmap,
+ NULL);
gal_list_str_free(lines, 1);
/* Confirm if only one column was read (it is possible to match more than
@@ -435,7 +436,8 @@ ui_read_input(struct convolveparams *p)
{
p->input=gal_array_read_one_ch_to_type(p->filename, p->cp.hdu, NULL,
INPUT_USE_TYPE,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->input->wcs=gal_wcs_read(p->filename, p->cp.hdu, 0, 0,
&p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim,
@@ -465,7 +467,8 @@ ui_read_kernel(struct convolveparams *p)
{
p->kernel = gal_array_read_one_ch_to_type(p->kernelname, p->khdu,
NULL, INPUT_USE_TYPE,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->kernel->ndim=gal_dimension_remove_extra(p->kernel->ndim,
p->kernel->dsize,
p->kernel->wcs);
diff --git a/bin/cosmiccal/ui.c b/bin/cosmiccal/ui.c
index 32f4008..8e31895 100644
--- a/bin/cosmiccal/ui.c
+++ b/bin/cosmiccal/ui.c
@@ -299,7 +299,7 @@ ui_parse_obsline(struct argp_option *option, char *arg,
/* Allocate the new space. */
tobsline=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &two, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
tobsline->status=GAL_SPECLINES_INVALID;
/* Write the values into tptr. */
diff --git a/bin/crop/ui.c b/bin/crop/ui.c
index 429d17a..6e8599c 100644
--- a/bin/crop/ui.c
+++ b/bin/crop/ui.c
@@ -516,7 +516,7 @@ ui_set_img_sizes(struct cropparams *p)
{
/* Allocate the new width dataset. */
newwidth=gal_data_alloc(NULL, p->width->type, 1, &ndim, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
/* Fill the new width. */
warray=newwidth->array;
@@ -676,7 +676,8 @@ ui_read_cols(struct cropparams *p)
/* Read the desired columns from the file. */
cols=gal_table_read(p->catname, p->cathdu, NULL, colstrs, p->cp.searchin,
- p->cp.ignorecase, p->cp.minmapsize, NULL);
+ p->cp.ignorecase, p->cp.minmapsize, p->cp.quietmmap,
+ NULL);
if(cols==NULL)
error(EXIT_FAILURE, 0, "%s: is empty! No usable information "
"(un-commented lines) could be read from this file",
@@ -812,19 +813,20 @@ ui_make_log(struct cropparams *p)
"%u: not checked)", GAL_BLANK_UINT8)<0 )
error(EXIT_FAILURE, 0, "%s: asprintf allocation", __func__);
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_UINT8, 1, &p->numout,
- NULL, 1, p->cp.minmapsize, "CENTER_FILLED",
- "bool", comment);
+ NULL, 1, p->cp.minmapsize, p->cp.quietmmap,
+ "CENTER_FILLED", "bool", comment);
free(comment);
/* Column for number of datasets used in this crop. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_UINT16, 1, &p->numout,
- NULL, 1, p->cp.minmapsize, "NUM_INPUTS", "count",
+ NULL, 1, p->cp.minmapsize, p->cp.quietmmap,
+ "NUM_INPUTS", "count",
"Number of input datasets used to make this crop.");
/* Filename of crop. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_STRING, 1, &p->numout,
- NULL, 1, p->cp.minmapsize, "CROP_NAME", "name",
- "File name of crop.");
+ NULL, 1, p->cp.minmapsize, p->cp.quietmmap,
+ "CROP_NAME", "name", "File name of crop.");
}
diff --git a/bin/crop/wcsmode.c b/bin/crop/wcsmode.c
index 04ea1d0..8f6fe34 100644
--- a/bin/crop/wcsmode.c
+++ b/bin/crop/wcsmode.c
@@ -330,7 +330,7 @@ fillcrpipolygon(struct onecropparams *crp)
/* Allocate the necessary arrays for each column. */
for(d=0;d<ndim;++d)
gal_list_data_add_alloc(&coords, NULL, GAL_TYPE_FLOAT64, 1, &p->nvertices,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
/* Fill in the world coordinate columns. */
diff --git a/bin/fits/fits.c b/bin/fits/fits.c
index 09b0f06..6ecb6d6 100644
--- a/bin/fits/fits.c
+++ b/bin/fits/fits.c
@@ -110,16 +110,16 @@ fits_print_extension_info(struct fitsparams *p)
/* Allocate all the columns (in reverse order, since this is a simple
linked list). */
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
- -1, "HDU_SIZE", "name", "Size of image or table "
+ -1, 1, "HDU_SIZE", "name", "Size of image or table "
"number of rows and columns.");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
- -1, "HDU_TYPE", "name", "Image data type or "
+ -1, 1, "HDU_TYPE", "name", "Image data type or "
"`table' format (ASCII or binary).");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_STRING, 1, &numext, NULL, 1,
- -1, "EXTNAME", "name", "Extension name of this "
+ -1, 1, "EXTNAME", "name", "Extension name of this "
"HDU (EXTNAME in FITS).");
gal_list_data_add_alloc(&cols, NULL, GAL_TYPE_UINT16, 1, &numext, NULL, 1,
- -1, "HDU_INDEX", "count", "Index (starting from "
+ -1, 1, "HDU_INDEX", "count", "Index (starting from "
"zero) of each HDU (extension).");
diff --git a/bin/gnuastro.conf b/bin/gnuastro.conf
index 42f9a84..1ed1845 100644
--- a/bin/gnuastro.conf
+++ b/bin/gnuastro.conf
@@ -38,4 +38,5 @@
tableformat fits-binary
# Operating mode
- minmapsize 1000000000
\ No newline at end of file
+ quietmmap 0
+ minmapsize 2000000000
\ No newline at end of file
diff --git a/bin/match/match.c b/bin/match/match.c
index d60c39e..a1f6eac 100644
--- a/bin/match/match.c
+++ b/bin/match/match.c
@@ -205,7 +205,7 @@ match_catalog_read_write_all(struct matchparams *p, size_t
*permutation,
if(filename || p->stdinlines)
cat=gal_table_read(filename, hdu, filename ? NULL : p->stdinlines, cols,
p->cp.searchin, p->cp.ignorecase, p->cp.minmapsize,
- *numcolmatch);
+ p->cp.quietmmap, *numcolmatch);
else
cat=match_cat_from_coord(p, cols, *numcolmatch);
origsize = cat ? cat->size : 0;
@@ -358,7 +358,7 @@ match_catalog(struct matchparams *p)
/* Find the matching coordinates. We are doing the processing in
place, */
mcols=gal_match_coordinates(p->cols1, p->cols2, p->aperture->array, 0, 1,
- p->cp.minmapsize, &nummatched);
+ p->cp.minmapsize, p->cp.quietmmap, &nummatched);
/* If the output is to be taken from the input columns (it isn't just the
log), then do the job. */
diff --git a/bin/match/ui.c b/bin/match/ui.c
index 43a0ff9..e5b5bef 100644
--- a/bin/match/ui.c
+++ b/bin/match/ui.c
@@ -402,7 +402,7 @@ ui_read_columns_aperture_2d(struct matchparams *p)
if(p->aperture->size!=3)
{
newaper=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &apersize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
naper=newaper->array;
}
@@ -527,7 +527,7 @@ ui_set_columns_from_coord(struct matchparams *p)
for(i=0;i<p->coord->size;++i)
{
gal_list_data_add_alloc(&out, NULL, GAL_TYPE_FLOAT64, 1, &one, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*((double *)(out->array))=coord[i];
}
gal_list_data_reverse(&out);
@@ -563,7 +563,7 @@ ui_read_columns_to_double(struct matchparams *p, char
*filename, char *hdu,
"input");
tout=gal_table_read(filename, hdu, filename ? NULL : p->stdinlines,
cols, cp->searchin, cp->ignorecase, cp->minmapsize,
- NULL);
+ p->cp.quietmmap, NULL);
/* A small sanity check. */
if(gal_list_data_number(tout)!=numcols)
@@ -669,7 +669,7 @@ ui_preparations_out_cols(struct matchparams *p)
if(rptr)
{
read=gal_data_alloc(rptr, readtype, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
if(gal_type_is_int(readtype))
{
read=gal_data_copy_to_new_type_free(read,GAL_TYPE_LONG);
diff --git a/bin/mkcatalog/columns.c b/bin/mkcatalog/columns.c
index 99863a2..ac4640d 100644
--- a/bin/mkcatalog/columns.c
+++ b/bin/mkcatalog/columns.c
@@ -64,14 +64,14 @@ columns_alloc_radec(struct mkcatalogparams *p)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_vo, NULL, GAL_TYPE_FLOAT64, 1,
&p->numobjects, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
/* For clumps */
if(p->clumps && p->wcs_vc==NULL)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_vc, NULL, GAL_TYPE_FLOAT64, 1,
&p->numclumps, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
}
@@ -89,14 +89,14 @@ columns_alloc_georadec(struct mkcatalogparams *p)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_go, NULL, GAL_TYPE_FLOAT64, 1,
&p->numobjects, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
/* For clumps */
if(p->clumps && p->wcs_gc==NULL)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_gc, NULL, GAL_TYPE_FLOAT64, 1,
&p->numclumps, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
}
@@ -113,7 +113,7 @@ columns_alloc_clumpsradec(struct mkcatalogparams *p)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_vcc, NULL, GAL_TYPE_FLOAT64, 1,
&p->numobjects, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
}
@@ -130,7 +130,7 @@ columns_alloc_clumpsgeoradec(struct mkcatalogparams *p)
for(i=0;i<p->objects->ndim;++i)
gal_list_data_add_alloc(&p->wcs_gcc, NULL, GAL_TYPE_FLOAT64, 1,
&p->numobjects, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
}
@@ -1196,7 +1196,7 @@ columns_define_alloc(struct mkcatalogparams *p)
{
gal_list_data_add_alloc(&p->objectcols, NULL, otype, 1,
&p->numobjects, NULL, 0, p->cp.minmapsize,
- name, unit, ocomment);
+ p->cp.quietmmap, name, unit, ocomment);
p->objectcols->status = colcode->v;
p->objectcols->disp_fmt = disp_fmt;
p->objectcols->disp_width = disp_width;
@@ -1214,7 +1214,8 @@ columns_define_alloc(struct mkcatalogparams *p)
{
gal_list_data_add_alloc(&p->clumpcols, NULL, ctype, 1,
&p->numclumps, NULL, 0,
- p->cp.minmapsize, name, unit, ccomment);
+ p->cp.minmapsize, p->cp.quietmmap,
+ name, unit, ccomment);
p->clumpcols->status = colcode->v;
p->clumpcols->disp_fmt = disp_fmt;
p->clumpcols->disp_width = disp_width;
diff --git a/bin/mkcatalog/mkcatalog.c b/bin/mkcatalog/mkcatalog.c
index 94f440a..fab5d33 100644
--- a/bin/mkcatalog/mkcatalog.c
+++ b/bin/mkcatalog/mkcatalog.c
@@ -129,8 +129,8 @@ mkcatalog_single_object(void *in_prm)
{
/* Allocate the space to keep the upper-limit values. */
pp.up_vals = gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &p->upnum,
- NULL, 0, p->cp.minmapsize, NULL, NULL,
- NULL);
+ NULL, 0, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Set the blank checked flag to 1. By definition, this dataset won't
have any blank values. Also `flag' is initialized to `0'. So we
diff --git a/bin/mkcatalog/parse.c b/bin/mkcatalog/parse.c
index 12084c9..879a7d1 100644
--- a/bin/mkcatalog/parse.c
+++ b/bin/mkcatalog/parse.c
@@ -592,7 +592,8 @@ parse_median(struct mkcatalog_passparams *pp)
size_t *tsize=pp->tile->dsize, ndim=p->objects->ndim;
size_t counter=0, *ccounter=NULL, tmpsize=pp->oi[OCOL_NUM];
gal_data_t *objmed=gal_data_alloc(NULL, p->values->type, 1, &tmpsize, NULL,
- 0, p->cp.minmapsize, NULL, NULL, NULL);
+ 0, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Allocate space for the clump medians. */
if(p->clumps)
@@ -611,8 +612,8 @@ parse_median(struct mkcatalog_passparams *pp)
{
tmpsize=pp->ci[ i * CCOL_NUMCOLS + CCOL_NUM ];
clumpsmed[i]=gal_data_alloc(NULL, p->values->type, 1, &tmpsize,
- NULL, 0, p->cp.minmapsize, NULL, NULL,
- NULL);
+ NULL, 0, p->cp.minmapsize,
+ p->cp.quietmmap, NULL, NULL, NULL);
}
}
diff --git a/bin/mkcatalog/ui.c b/bin/mkcatalog/ui.c
index 4a17435..8ade64c 100644
--- a/bin/mkcatalog/ui.c
+++ b/bin/mkcatalog/ui.c
@@ -384,7 +384,7 @@ ui_read_check_only_options(struct mkcatalogparams *p)
{
/* Allocate the data structure. */
p->sky=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
/* Write the value inside it. */
*((float *)(p->sky->array))=tmp;
@@ -399,7 +399,7 @@ ui_read_check_only_options(struct mkcatalogparams *p)
{
/* Allocate the data structure. */
p->std=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
/* Write the value inside it. */
*((float *)(p->std->array))=tmp;
@@ -621,7 +621,7 @@ ui_read_labels(struct mkcatalogparams *p)
/* Read it into memory. */
p->objects = gal_array_read_one_ch(p->objectsfile, p->cp.hdu, NULL,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
p->objects->ndim=gal_dimension_remove_extra(p->objects->ndim,
p->objects->dsize, NULL);
@@ -685,7 +685,8 @@ ui_read_labels(struct mkcatalogparams *p)
/* Read the clumps image. */
p->clumps = gal_array_read_one_ch(p->usedclumpsfile, p->clumpshdu,
- NULL, p->cp.minmapsize);
+ NULL, p->cp.minmapsize,
+ p->cp.quietmmap);
p->clumps->ndim=gal_dimension_remove_extra(p->clumps->ndim,
p->clumps->dsize, NULL);
@@ -983,7 +984,8 @@ ui_preparations_read_inputs(struct mkcatalogparams *p)
/* Read the values dataset. */
p->values=gal_array_read_one_ch_to_type(p->usedvaluesfile, p->valueshdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->values->ndim=gal_dimension_remove_extra(p->values->ndim,
p->values->dsize, NULL);
@@ -1032,7 +1034,8 @@ ui_preparations_read_inputs(struct mkcatalogparams *p)
/* Read the Sky dataset. */
p->sky=gal_array_read_one_ch_to_type(p->usedskyfile, p->skyhdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->sky->ndim=gal_dimension_remove_extra(p->sky->ndim,
p->sky->dsize, NULL);
@@ -1063,7 +1066,7 @@ ui_preparations_read_inputs(struct mkcatalogparams *p)
/* Read the Sky standard deviation image into memory. */
p->std=gal_array_read_one_ch_to_type(p->usedstdfile, p->stdhdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
p->std->ndim=gal_dimension_remove_extra(p->std->ndim,
p->std->dsize, NULL);
@@ -1098,7 +1101,8 @@ ui_preparations_read_inputs(struct mkcatalogparams *p)
/* Read the mask image. */
p->upmask = gal_array_read_one_ch(p->upmaskfile, p->upmaskhdu,
- NULL, p->cp.minmapsize);
+ NULL, p->cp.minmapsize,
+ p->cp.quietmmap);
p->upmask->ndim=gal_dimension_remove_extra(p->upmask->ndim,
p->upmask->dsize,
NULL);
@@ -1123,7 +1127,7 @@ ui_preparations_read_inputs(struct mkcatalogparams *p)
/* Convert the mask to a uint8_t: with a 1 for all non-zero
pixels and 0 for zero pixels. */
zero=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &one, NULL, 1, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
p->upmask=gal_arithmetic(GAL_ARITHMETIC_OP_NE, 1,
( GAL_ARITHMETIC_INPLACE
| GAL_ARITHMETIC_FREE
diff --git a/bin/mkcatalog/upperlimit.c b/bin/mkcatalog/upperlimit.c
index b700005..c0576e7 100644
--- a/bin/mkcatalog/upperlimit.c
+++ b/bin/mkcatalog/upperlimit.c
@@ -372,13 +372,13 @@ upperlimit_write_check(struct mkcatalogparams *p,
gal_list_sizet_t *check_x,
/* Put the arrays into a data container. */
x=gal_data_alloc(xarr, GAL_TYPE_SIZE_T, 1, &num, NULL, 0, p->cp.minmapsize,
- "RANDOM_X", "pixel",
+ p->cp.quietmmap, "RANDOM_X", "pixel",
"X-axis position of random footprint's first pixel.");
y=gal_data_alloc(yarr, GAL_TYPE_SIZE_T, 1, &num, NULL, 0, p->cp.minmapsize,
- "RANDOM_Y", "pixel",
+ p->cp.quietmmap, "RANDOM_Y", "pixel",
"Y-axis position of random footprint's first pixel.");
s=gal_data_alloc(sarr, GAL_TYPE_FLOAT32, 1, &num, NULL, 0, p->cp.minmapsize,
- "RANDOM_SUM",
+ p->cp.quietmmap, "RANDOM_SUM",
p->values->unit ? p->values->unit : "input-units",
"Sum of pixel values over random footprint.");
@@ -506,7 +506,7 @@ upperlimit_measure(struct mkcatalog_passparams *pp, int32_t
clumplab,
keep the size here also. */
init_size=pp->up_vals->size;
sum=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0,
- -1, NULL, NULL, NULL);
+ -1, 1, NULL, NULL, NULL);
((float *)(sum->array))[0]=o[clumplab?CCOL_SUM:OCOL_SUM];
qfunc=gal_statistics_quantile_function(pp->up_vals, sum, 1);
diff --git a/bin/mknoise/ui.c b/bin/mknoise/ui.c
index 5c4baad..c30cd7b 100644
--- a/bin/mknoise/ui.c
+++ b/bin/mknoise/ui.c
@@ -284,7 +284,8 @@ ui_preparations(struct mknoiseparams *p)
{
/* Read the input image as a double type */
p->input=gal_array_read_one_ch_to_type(p->inputname, p->cp.hdu, NULL,
- GAL_TYPE_FLOAT64, p->cp.minmapsize);
+ GAL_TYPE_FLOAT64, p->cp.minmapsize,
+ p->cp.quietmmap);
p->input->wcs=gal_wcs_read(p->inputname, p->cp.hdu, 0, 0, &p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim, p->input->dsize,
p->input->wcs);
diff --git a/bin/mkprof/mkprof.c b/bin/mkprof/mkprof.c
index 6a532cc..17c623b 100644
--- a/bin/mkprof/mkprof.c
+++ b/bin/mkprof/mkprof.c
@@ -345,7 +345,7 @@ mkprof_build_single(struct mkonthread *mkp, long *fpixel_i,
long *lpixel_i,
}
else ptr=ibq->image->array;
ibq->overlap_i=gal_data_alloc(ptr, ibq->image->type, ndim, dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ibq->overlap_i->block=ibq->image;
@@ -353,7 +353,7 @@ mkprof_build_single(struct mkonthread *mkp, long *fpixel_i,
long *lpixel_i,
ind=gal_dimension_coord_to_index(ndim, p->out->dsize, start_mrg);
ptr=gal_pointer_increment(p->out->array, ind, p->out->type);
ibq->overlap_m=gal_data_alloc(ptr, p->out->type, ndim, dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ibq->overlap_m->block=p->out;
}
}
diff --git a/bin/mkprof/oneprofile.c b/bin/mkprof/oneprofile.c
index 1c405ba..471fdd4 100644
--- a/bin/mkprof/oneprofile.c
+++ b/bin/mkprof/oneprofile.c
@@ -696,8 +696,8 @@ oneprofile_make(struct mkonthread *mkp)
/* Allocate and clear the array for this one profile. */
mkp->ibq->image=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, ndim, dsize,
- NULL, 1, p->cp.minmapsize, "MOCK",
- "Brightness", NULL);
+ NULL, 1, p->cp.minmapsize, p->cp.quietmmap,
+ "MOCK", "Brightness", NULL);
/* Build the profile in the image. */
diff --git a/bin/mkprof/ui.c b/bin/mkprof/ui.c
index 4501b8b..2fda359 100644
--- a/bin/mkprof/ui.c
+++ b/bin/mkprof/ui.c
@@ -622,7 +622,8 @@ ui_read_cols(struct mkprofparams *p)
/* Read the desired columns from the file. */
lines=gal_options_check_stdin(p->catname, p->cp.stdintimeout, "input");
cols=gal_table_read(p->catname, p->cp.hdu, lines, colstrs, p->cp.searchin,
- p->cp.ignorecase, p->cp.minmapsize, NULL);
+ p->cp.ignorecase, p->cp.minmapsize, p->cp.quietmmap,
+ NULL);
gal_list_str_free(lines, 1);
/* The name of the input catalog is only for informative steps from now
@@ -1143,7 +1144,8 @@ ui_prepare_canvas(struct mkprofparams *p)
/* Make the output structure. */
p->out=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, ndim_counter, dsize,
- NULL, 1, p->cp.minmapsize, NULL, NULL, NULL);
+ NULL, 1, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
}
}
@@ -1216,7 +1218,7 @@ ui_finalize_coordinates(struct mkprofparams *p)
/* Allocate the list of coordinates. */
gal_list_data_add_alloc(&coords, arr, GAL_TYPE_FLOAT64, 1, &p->num,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
}
/* Convert the world coordinates to image coordinates (inplace). */
@@ -1273,24 +1275,27 @@ ui_make_log(struct mkprofparams *p)
/* Individual created. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_UINT8, 1, &p->num, NULL,
- 1, p->cp.minmapsize, "INDIV_CREATED", "bool",
+ 1, p->cp.minmapsize, p->cp.quietmmap,
+ "INDIV_CREATED", "bool",
"If an individual image was made (1) or not (0).");
/* Fraction of monte-carlo. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_FLOAT32, 1, &p->num, NULL,
- 1, p->cp.minmapsize, "FRAC_MONTECARLO", "frac",
+ 1, p->cp.minmapsize, p->cp.quietmmap,
+ "FRAC_MONTECARLO", "frac",
"Fraction of brightness in Monte-carlo integrated "
"pixels.");
/* Number of monte-carlo. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_UINT64, 1, &p->num, NULL,
- 1, p->cp.minmapsize, "NUM_MONTECARLO", "count",
+ 1, p->cp.minmapsize, p->cp.quietmmap,
+ "NUM_MONTECARLO", "count",
"Number of Monte Carlo integrated pixels.");
/* Magnitude of profile overlap. */
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_FLOAT32, 1, &p->num, NULL,
- 1, p->cp.minmapsize, "MAG_OVERLAP", "mag",
- "Magnitude of profile's overlap with merged "
+ 1, p->cp.minmapsize, p->cp.quietmmap, "MAG_OVERLAP",
+ "mag", "Magnitude of profile's overlap with merged "
"image.");
/* Row number in input catalog. */
@@ -1298,8 +1303,8 @@ ui_make_log(struct mkprofparams *p)
if( asprintf(&comment, "Row number of profile in %s.", name)<0 )
error(EXIT_FAILURE, 0, "%s: asprintf allocation", __func__);
gal_list_data_add_alloc(&p->log, NULL, GAL_TYPE_UINT64, 1, &p->num, NULL,
- 1, p->cp.minmapsize, "INPUT_ROW_NO", "count",
- comment);
+ 1, p->cp.minmapsize, p->cp.quietmmap, "INPUT_ROW_NO",
+ "count", comment);
free(comment);
free(name);
}
@@ -1348,7 +1353,8 @@ ui_read_ndim(struct mkprofparams *p)
/* Read the image. */
p->out=gal_array_read_one_ch_to_type(p->backname, p->backhdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->out->ndim=gal_dimension_remove_extra(p->out->ndim,
p->out->dsize, NULL);
p->ndim=p->out->ndim;
diff --git a/bin/noisechisel/detection.c b/bin/noisechisel/detection.c
index 3f5b62a..244248b 100644
--- a/bin/noisechisel/detection.c
+++ b/bin/noisechisel/detection.c
@@ -247,7 +247,7 @@ detection_fill_holes_open(void *in_prm)
/* A temporary data structure to wrap around the copy space. Note that
the initially allocated space for this tile is only 1 pixel! */
copy=gal_data_alloc(NULL, GAL_TYPE_UINT8, p->input->ndim, dsize,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
free(copy->array);
copy->array=&fho_prm->copyspace[p->maxltcontig*tprm->id];
@@ -535,12 +535,12 @@ detection_sn(struct noisechiselparams *p, gal_data_t
*worklab, size_t num,
"flag")
: NULL );
sn = gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &tablen, NULL, 1,
- p->cp.minmapsize, "SIGNAL-TO-NOISE", "ratio",
- NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ "SIGNAL-TO-NOISE", "ratio", NULL);
snind = ( p->checksn==0 ? NULL
: gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &tablen, NULL, 1,
- p->cp.minmapsize, "LABEL", "counter",
- NULL) );
+ p->cp.minmapsize, p->cp.quietmmap, "LABEL",
+ "counter", NULL) );
/* Go over all the pixels and get the necessary information. */
fs = f = p->input->array;
@@ -751,7 +751,7 @@ detection_pseudo_real(struct noisechiselparams *p)
worklab=gal_data_copy(p->olabel);
workbin=gal_data_alloc(NULL, GAL_TYPE_UINT8, p->input->ndim,
p->input->dsize, p->input->wcs, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
workbin->flag=p->input->flag;
@@ -1003,8 +1003,8 @@ detection_quantile_expand(struct noisechiselparams *p,
gal_data_t *workbin)
/* Allocate the space necessary to keep the index of all the pixels
that must be expanded and re-initialize the necessary pointers. */
diffuseindexs=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, &p->numexpand,
- NULL, 0, p->cp.minmapsize, NULL, NULL,
- NULL);
+ NULL, 0, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Fill in the diffuse indexs and initialize the objects dataset. */
b = workbin->array;
diff --git a/bin/noisechisel/sky.c b/bin/noisechisel/sky.c
index 78abfa2..cd66b55 100644
--- a/bin/noisechisel/sky.c
+++ b/bin/noisechisel/sky.c
@@ -67,14 +67,14 @@ sky_mean_std_undetected(void *in_prm)
/* Put the temporary usage space for this thread into a data set for easy
processing. */
fusage=gal_data_alloc(NULL, type, ndim, p->maxtsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL, NULL, NULL);
busage=gal_data_alloc(NULL, GAL_TYPE_UINT8, ndim, p->maxtsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL, NULL, NULL);
/* An empty dataset to replicate a tile on the binary array. */
bintile=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &bdsize,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
bintile->ndim=ndim;
free(bintile->array);
free(bintile->dsize);
@@ -198,9 +198,11 @@ sky_and_std(struct noisechiselparams *p, char *checkname)
/* Allocate space for the mean and standard deviation. */
p->sky=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->input->ndim, tl->numtiles,
- NULL, 0, cp->minmapsize, NULL, p->input->unit, NULL);
+ NULL, 0, cp->minmapsize, p->cp.quietmmap, NULL,
+ p->input->unit, NULL);
p->std=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->input->ndim, tl->numtiles,
- NULL, 0, cp->minmapsize, NULL, p->input->unit, NULL);
+ NULL, 0, cp->minmapsize, p->cp.quietmmap, NULL,
+ p->input->unit, NULL);
/* Find the Sky and its STD on proper tiles. */
diff --git a/bin/noisechisel/threshold.c b/bin/noisechisel/threshold.c
index 9f09dc3..2d4fa02 100644
--- a/bin/noisechisel/threshold.c
+++ b/bin/noisechisel/threshold.c
@@ -402,7 +402,7 @@ qthresh_on_tile(void *in_prm)
usage=gal_data_alloc(gal_pointer_increment(qprm->usage,
tprm->id*p->maxtcontig, type),
type, ndim, p->maxtsize, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
/* Go over all the tiles given to this thread. */
for(i=0; tprm->indexs[i] != GAL_BLANK_SIZE_T; ++i)
@@ -606,14 +606,15 @@ threshold_quantile_find_apply(struct noisechiselparams *p)
/* Allocate space for the quantile threshold values. */
qprm.erode_th=gal_data_alloc(NULL, p->input->type, p->input->ndim,
tl->numtiles, NULL, 0, cp->minmapsize,
- NULL, p->input->unit, NULL);
+ p->cp.quietmmap, NULL, p->input->unit, NULL);
qprm.noerode_th=gal_data_alloc(NULL, p->input->type, p->input->ndim,
tl->numtiles, NULL, 0, cp->minmapsize,
- NULL, p->input->unit, NULL);
+ p->cp.quietmmap, NULL, p->input->unit, NULL);
qprm.expand_th = ( p->detgrowquant!=1.0f
? gal_data_alloc(NULL, p->input->type, p->input->ndim,
tl->numtiles, NULL, 0, cp->minmapsize,
- NULL, p->input->unit, NULL)
+ p->cp.quietmmap, NULL, p->input->unit,
+ NULL)
: NULL );
diff --git a/bin/noisechisel/ui.c b/bin/noisechisel/ui.c
index c4c1c66..090c3ab 100644
--- a/bin/noisechisel/ui.c
+++ b/bin/noisechisel/ui.c
@@ -419,7 +419,7 @@ ui_prepare_kernel(struct noisechiselparams *p)
{
if( strcmp(p->kernelname, UI_NO_CONV_KERNEL_NAME) )
p->kernel=gal_fits_img_read_kernel(p->kernelname, p->khdu,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
else
p->kernel=NULL;
}
@@ -429,7 +429,7 @@ ui_prepare_kernel(struct noisechiselparams *p)
allocated array. */
p->kernel=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 2,
kernel_2d_dsize, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
/* Now copy the staticly allocated array into it. */
k=p->kernel->array;
@@ -442,7 +442,7 @@ ui_prepare_kernel(struct noisechiselparams *p)
ignore it. */
if(p->widekernelname)
p->widekernel=gal_fits_img_read_kernel(p->widekernelname, p->whdu,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
}
@@ -564,7 +564,8 @@ ui_preparations_read_input(struct noisechiselparams *p)
(with a length of 1). */
p->input = gal_array_read_one_ch_to_type(p->inputname, p->cp.hdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->input->wcs = gal_wcs_read(p->inputname, p->cp.hdu, 0, 0,
&p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim,
@@ -634,7 +635,8 @@ ui_preparations(struct noisechiselparams *p)
/* Read the input convolved image. */
p->conv = gal_array_read_one_ch_to_type(p->convolvedname, p->chdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
/* Make sure the convolved image is the same size as the input. */
if( gal_dimension_is_different(p->input, p->conv) )
@@ -655,10 +657,12 @@ ui_preparations(struct noisechiselparams *p)
/* Allocate space for the over-all necessary arrays. */
p->binary=gal_data_alloc(NULL, GAL_TYPE_UINT8, p->input->ndim,
p->input->dsize, p->input->wcs, 0,
- p->cp.minmapsize, NULL, "binary", NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL,
+ "binary", NULL);
p->olabel=gal_data_alloc(NULL, GAL_TYPE_INT32, p->input->ndim,
p->input->dsize, p->input->wcs, 0,
- p->cp.minmapsize, NULL, "labels", NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL,
+ "labels", NULL);
p->binary->flag = p->olabel->flag = p->input->flag;
}
diff --git a/bin/segment/clumps.c b/bin/segment/clumps.c
index ce0bbe3..5192715 100644
--- a/bin/segment/clumps.c
+++ b/bin/segment/clumps.c
@@ -134,7 +134,8 @@ clumps_grow_prepare_initial(struct clumps_thread_params
*cltprm)
`diffuseindexs' will also be already sorted. */
cltprm->diffuseindexs=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1,
cltprm->indexs->dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
dindexs=cltprm->diffuseindexs->array;
sf=(s=indexs->array)+indexs->size;
do
@@ -237,7 +238,8 @@ clumps_correct_sky_labels_for_check(struct
clumps_thread_params *cltprm,
to be set to zero). So we also need to clear the allocated
space. */
newinds=gal_data_alloc(NULL, p->clabel->type, 1, &len, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Get the next available label for these clumps. If more than one
@@ -356,8 +358,8 @@ clumps_find_make_sn_table(void *in_prm)
/* Add the indexs of all undetected pixels in this tile into an
array. */
cltprm.indexs=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, &numsky,
- NULL, 0, p->cp.minmapsize, NULL, NULL,
- NULL);
+ NULL, 0, p->cp.minmapsize,
+ p->cp.quietmmap, NULL, NULL, NULL);
/* Change the tile's block to the clump labels dataset (because
@@ -703,12 +705,12 @@ clumps_true_find_sn_thresh(struct segmentparams *p)
/* Allocate the space to keep all the S/N values. */
sn=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &numsn, NULL, 0,
- p->cp.minmapsize, "CLUMP_S/N", "ratio",
+ p->cp.minmapsize, p->cp.quietmmap, "CLUMP_S/N", "ratio",
"Signal-to-noise ratio");
snind = ( p->checksn
? gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &numsn, NULL, 0,
- p->cp.minmapsize, "CLUMP_ID", "counter",
- "Unique ID for this clump.")
+ p->cp.minmapsize, p->cp.quietmmap, "CLUMP_ID",
+ "counter", "Unique ID for this clump.")
: NULL );
diff --git a/bin/segment/segment.c b/bin/segment/segment.c
index ae95b8c..eaa13fe 100644
--- a/bin/segment/segment.c
+++ b/bin/segment/segment.c
@@ -117,10 +117,12 @@ segment_initialize(struct segmentparams *p)
/* Allocate the clump labels image and the binary image. */
p->clabel=gal_data_alloc(NULL, p->olabel->type, p->olabel->ndim,
p->olabel->dsize, p->olabel->wcs, 1,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
p->binary=gal_data_alloc(NULL, GAL_TYPE_UINT8, p->olabel->ndim,
p->olabel->dsize, p->olabel->wcs, 1,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
p->clabel->flag=p->input->flag;
p->binary->wcs=gal_wcs_copy(p->input->wcs);
p->clabel->wcs=gal_wcs_copy(p->input->wcs);
@@ -221,12 +223,14 @@ segment_relab_to_objects(struct clumps_thread_params
*cltprm)
size_t mdsize[2]={amwidth, amwidth};
gal_data_t *nums_d=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 2, mdsize, NULL,
- 1, p->cp.minmapsize, NULL, NULL, NULL);
+ 1, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
gal_data_t *sums_d=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 2, mdsize, NULL,
- 1, p->cp.minmapsize, NULL, NULL, NULL);
+ 1, p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
gal_data_t *adjacency_d=gal_data_alloc(NULL, GAL_TYPE_UINT8, 2, mdsize,
- NULL, 1, p->cp.minmapsize, NULL,
- NULL, NULL);
+ NULL, 1, p->cp.minmapsize,
+ p->cp.quietmmap, NULL, NULL, NULL);
float *imgss=p->input->array;
double var=cltprm->std*cltprm->std;
uint8_t *adjacency=adjacency_d->array;
@@ -373,8 +377,8 @@ segment_relab_to_objects(struct clumps_thread_params
*cltprm)
{
/* Allocate the `clumptoobj' array. */
cltprm->clumptoobj = gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &amwidth,
- NULL, 1, p->cp.minmapsize, NULL,
- NULL, NULL);
+ NULL, 1, p->cp.minmapsize,
+ p->cp.quietmmap, NULL, NULL, NULL);
clumptoobj = cltprm->clumptoobj->array;
/* Fill in the `clumptoobj' array with the indexs of the objects. */
@@ -557,7 +561,8 @@ segment_on_threads(void *in_prm)
given to this detected region. */
topinds=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1,
cltprm.indexs->dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
cltprm.topinds=topinds->array;
}
else { cltprm.topinds=NULL; topinds=NULL; }
@@ -756,13 +761,14 @@ segment_save_sn_table(struct clumps_params *clprm)
/* Allocate the columns for the table. */
sn=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &totclumps, NULL, 0,
- p->cp.minmapsize, "CLUMP_S/N", "ratio",
+ p->cp.minmapsize, p->cp.quietmmap, "CLUMP_S/N", "ratio",
"Signal-to-noise ratio.");
objind=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &totclumps, NULL, 0,
- p->cp.minmapsize, "HOST_DET_ID", "counter",
- "ID of detection hosting this clump.");
+ p->cp.minmapsize, p->cp.quietmmap, "HOST_DET_ID",
+ "counter", "ID of detection hosting this clump.");
clumpinobj=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &totclumps, NULL, 0,
- p->cp.minmapsize, "CLUMP_ID_IN_OBJ", "counter",
+ p->cp.minmapsize, p->cp.quietmmap,
+ "CLUMP_ID_IN_OBJ", "counter",
"ID of clump in host detection.");
@@ -828,7 +834,8 @@ segment_detections(struct segmentparams *p)
/* Get the indexs of all the pixels in each label. */
- labindexs=gal_label_indexs(p->olabel, p->numdetections, p->cp.minmapsize);
+ labindexs=gal_label_indexs(p->olabel, p->numdetections, p->cp.minmapsize,
+ p->cp.quietmmap);
/* Initialize the necessary thread parameters. Note that since the object
diff --git a/bin/segment/ui.c b/bin/segment/ui.c
index f046c64..e41b651 100644
--- a/bin/segment/ui.c
+++ b/bin/segment/ui.c
@@ -410,7 +410,7 @@ ui_prepare_inputs(struct segmentparams *p)
/* Read the input as a single precision floating point dataset. */
p->input = gal_array_read_one_ch_to_type(p->inputname, p->cp.hdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
p->input->wcs = gal_wcs_read(p->inputname, p->cp.hdu, 0, 0,
&p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim,
@@ -439,7 +439,8 @@ ui_prepare_inputs(struct segmentparams *p)
/* Read the input convolved image. */
p->conv = gal_array_read_one_ch_to_type(p->convolvedname, p->chdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->conv->ndim=gal_dimension_remove_extra(p->conv->ndim,
p->conv->dsize,
p->conv->wcs);
@@ -460,7 +461,8 @@ ui_prepare_inputs(struct segmentparams *p)
{
/* Read the dataset into memory. */
p->olabel = gal_array_read_one_ch(p->useddetectionname, p->dhdu,
- NULL, p->cp.minmapsize);
+ NULL, p->cp.minmapsize,
+ p->cp.quietmmap);
p->olabel->ndim=gal_dimension_remove_extra(p->olabel->ndim,
p->olabel->dsize, NULL);
if( gal_dimension_is_different(p->input, p->olabel) )
@@ -512,7 +514,8 @@ ui_prepare_inputs(struct segmentparams *p)
/* Allocate the array. */
p->olabel=gal_data_alloc(NULL, GAL_TYPE_INT32, p->input->ndim,
p->input->dsize, p->input->wcs, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Initialize it to 1. */
ii=(i=p->olabel->array)+p->olabel->size; do *i++=1; while(i<ii);
@@ -539,7 +542,8 @@ ui_prepare_kernel(struct segmentparams *p)
if( strcmp(p->kernelname, UI_NO_CONV_KERNEL_NAME) )
{
p->kernel=gal_fits_img_read_kernel(p->kernelname, p->khdu,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->kernel->ndim=gal_dimension_remove_extra(p->kernel->ndim,
p->kernel->dsize,
NULL);
@@ -553,7 +557,7 @@ ui_prepare_kernel(struct segmentparams *p)
allocated array. */
p->kernel=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 2,
kernel_2d_dsize, NULL, 0, p->cp.minmapsize,
- NULL, NULL, NULL);
+ p->cp.quietmmap, NULL, NULL, NULL);
/* Now copy the staticly allocated array into it. */
k=p->kernel->array;
@@ -725,7 +729,7 @@ ui_read_std_and_sky(struct segmentparams *p)
{
/* Allocate the dataset to keep the value and write it in. */
p->std=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0,
- -1, NULL, NULL, NULL);
+ -1, 1, NULL, NULL, NULL);
*(float *)(p->std->array) = tmpval;
}
else
@@ -743,7 +747,7 @@ ui_read_std_and_sky(struct segmentparams *p)
/* Read the STD image. */
p->std=gal_array_read_one_ch_to_type(p->usedstdname, p->stdhdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
p->std->ndim=gal_dimension_remove_extra(p->std->ndim,
p->std->dsize, NULL);
@@ -786,7 +790,7 @@ ui_read_std_and_sky(struct segmentparams *p)
if(*tailptr=='\0')
{
sky=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
*(float *)(sky->array) = skyval = tmpval;
}
else
@@ -803,7 +807,7 @@ ui_read_std_and_sky(struct segmentparams *p)
/* Read the Sky dataset. */
sky=gal_array_read_one_ch_to_type(p->skyname, p->skyhdu,
NULL, GAL_TYPE_FLOAT32,
- p->cp.minmapsize);
+ p->cp.minmapsize, p->cp.quietmmap);
sky->ndim=gal_dimension_remove_extra(sky->ndim, sky->dsize,
NULL);
diff --git a/bin/statistics/sky.c b/bin/statistics/sky.c
index 865cfc4..b2ecdd7 100644
--- a/bin/statistics/sky.c
+++ b/bin/statistics/sky.c
@@ -182,10 +182,10 @@ sky(struct statisticsparams *p)
/* Make the arrays keeping the Sky and Sky standard deviation values. */
p->sky_t=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->input->ndim,
tl->numtiles, NULL, 0, p->input->minmapsize,
- "SKY", p->input->unit, NULL);
+ p->cp.quietmmap, "SKY", p->input->unit, NULL);
p->std_t=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, p->input->ndim,
tl->numtiles, NULL, 0, p->input->minmapsize,
- "SKY STD", p->input->unit, NULL);
+ p->cp.quietmmap, "SKY STD", p->input->unit, NULL);
/* Find the Sky and Sky standard deviation on the tiles. */
diff --git a/bin/statistics/statistics.c b/bin/statistics/statistics.c
index 30686d9..db87377 100644
--- a/bin/statistics/statistics.c
+++ b/bin/statistics/statistics.c
@@ -60,7 +60,7 @@ statistics_pull_out_element(gal_data_t *input, size_t index)
{
size_t dsize=1;
gal_data_t *out=gal_data_alloc(NULL, input->type, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
memcpy( out->array,
gal_pointer_increment(input->array, index, input->type),
gal_type_sizeof(input->type) );
@@ -201,7 +201,7 @@ statistics_print_one_row(struct statisticsparams *p)
case UI_KEY_QUANTFUNC:
arg = statistics_read_check_args(p);
tmpv = gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
*((double *)(tmpv->array)) = arg;
tmpv = gal_data_copy_to_new_type_free(tmpv, p->input->type);
out = gal_statistics_quantile_function(p->sorted, tmpv, 0);
@@ -339,7 +339,8 @@ statistics_on_tile(struct statisticsparams *p)
/* Allocate the space necessary to keep the value for each tile. */
values=gal_data_alloc(NULL, type, p->input->ndim, tl->numtiles, NULL,
- 0, p->input->minmapsize, NULL, NULL, NULL);
+ 0, p->input->minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
/* Read the argument for those operations that need it. This is done
here, because below, the functions are repeated on each tile. */
@@ -351,7 +352,7 @@ statistics_on_tile(struct statisticsparams *p)
case UI_KEY_QUANTFUNC:
arg = statistics_read_check_args(p);
tmpv = gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
*((double *)(tmpv->array)) = arg;
tmpv = gal_data_copy_to_new_type_free(tmpv, p->input->type);
}
@@ -511,7 +512,7 @@ set_bin_range_params(struct statisticsparams *p)
if(p->manualbinrange)
{
/* Allocate the range data structure. */
- range=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &rsize, NULL, 0, -1,
+ range=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &rsize, NULL, 0, -1, 1,
NULL, NULL, NULL);
((float *)(range->array))[0]=p->greaterequal;
((float *)(range->array))[1]=p->lessthan;
@@ -715,7 +716,7 @@ print_mirror_hist_cfp(struct statisticsparams *p)
gal_data_t *table;
double mirror_val;
gal_data_t *mirror=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* Convert the given mirror value into the type of the input dataset. */
*((double *)(mirror->array)) = p->mirror;
diff --git a/bin/statistics/ui.c b/bin/statistics/ui.c
index 2378b31..86597e1 100644
--- a/bin/statistics/ui.c
+++ b/bin/statistics/ui.c
@@ -608,8 +608,8 @@ ui_out_of_range_to_blank(struct statisticsparams *p)
less-than */
if(!isnan(p->greaterequal))
{
- tmp=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ tmp=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1, 1,
+ NULL, NULL, NULL);
*((float *)(tmp->array)) = p->greaterequal;
cond_g=gal_arithmetic(GAL_ARITHMETIC_OP_LT, 1, flags, ref, tmp);
gal_data_free(tmp);
@@ -619,8 +619,8 @@ ui_out_of_range_to_blank(struct statisticsparams *p)
/* Same reasoning as above for `p->greaterthan'. */
if(!isnan(p->lessthan))
{
- tmp=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1,
- NULL, NULL, NULL);
+ tmp=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL, 0, -1, 1,
+ NULL, NULL, NULL);
*((float *)(tmp->array)) = p->lessthan;
cond_l=gal_arithmetic(GAL_ARITHMETIC_OP_GE, 1, flags, ref, tmp);
gal_data_free(tmp);
@@ -644,7 +644,7 @@ ui_out_of_range_to_blank(struct statisticsparams *p)
/* Allocate a blank value to mask all pixels that don't satisfy the
condition. */
blank=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &one, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*((float *)(blank->array)) = NAN;
@@ -769,7 +769,8 @@ ui_read_columns(struct statisticsparams *p)
/* Read the desired column(s). */
cols=gal_table_read(p->inputname, p->cp.hdu, lines, column, p->cp.searchin,
- p->cp.ignorecase, p->cp.minmapsize, NULL);
+ p->cp.ignorecase, p->cp.minmapsize, p->cp.quietmmap,
+ NULL);
gal_list_str_free(lines, 1);
/* If the input was from standard input, we can actually write this into
@@ -845,7 +846,7 @@ ui_preparations(struct statisticsparams *p)
{
p->inputformat=INPUT_FORMAT_IMAGE;
p->input=gal_array_read_one_ch(p->inputname, cp->hdu, NULL,
- cp->minmapsize);
+ cp->minmapsize, p->cp.quietmmap);
p->input->wcs=gal_wcs_read(p->inputname, cp->hdu, 0, 0,
&p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim,
@@ -862,7 +863,7 @@ ui_preparations(struct statisticsparams *p)
if(p->sky && p->kernelname)
{
p->kernel=gal_fits_img_read_kernel(p->kernelname, p->khdu,
- cp->minmapsize);
+ cp->minmapsize, p->cp.quietmmap);
p->kernel->ndim=gal_dimension_remove_extra(p->kernel->ndim,
p->kernel->dsize, NULL);
}
diff --git a/bin/table/arithmetic.c b/bin/table/arithmetic.c
index 3ed15dc..5eb073f 100644
--- a/bin/table/arithmetic.c
+++ b/bin/table/arithmetic.c
@@ -203,7 +203,7 @@ arithmetic_init(struct tableparams *p, struct
arithmetic_token **arith,
{
/* Token is a single number.*/
if( (num=gal_type_string_to_number(token, &ntype)) )
- node->constant=gal_data_alloc(num, ntype, 1, &one, NULL, 0, -1,
+ node->constant=gal_data_alloc(num, ntype, 1, &one, NULL, 0, -1, 1,
NULL, NULL, NULL);
/* Token is a column operand (column number or name). */
diff --git a/bin/table/table.c b/bin/table/table.c
index 97bd560..6051c38 100644
--- a/bin/table/table.c
+++ b/bin/table/table.c
@@ -90,14 +90,14 @@ table_range(struct tableparams *p)
int inplace=GAL_ARITHMETIC_INPLACE;
/* Allocate datasets for the necessary numbers and write them in. */
- min=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &one, NULL, 0, -1,
+ min=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &one, NULL, 0, -1, 1,
NULL, NULL, NULL);
- max=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &one, NULL, 0, -1,
+ max=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &one, NULL, 0, -1, 1,
NULL, NULL, NULL);
perm=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, p->table->dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL, NULL, NULL);
mask=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, p->table->dsize, NULL, 1,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL, NULL, NULL);
/* Go over all the necessary range options. */
range=p->range;
@@ -212,7 +212,7 @@ table_sort(struct tableparams *p)
/* Allocate the permutation array and fill it. */
perm=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, p->table->dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap, NULL, NULL, NULL);
sf=(s=perm->array)+perm->size; do *s=c++; while(++s<sf);
/* Set the proper qsort function. */
diff --git a/bin/table/ui.c b/bin/table/ui.c
index 2259c5b..86cc27d 100644
--- a/bin/table/ui.c
+++ b/bin/table/ui.c
@@ -970,7 +970,7 @@ ui_preparations(struct tableparams *p)
/* Read the necessary columns. */
p->table=gal_table_read(p->filename, cp->hdu, lines, p->columns,
cp->searchin, cp->ignorecase, cp->minmapsize,
- colmatch);
+ p->cp.quietmmap, colmatch);
if(p->filename==NULL) p->filename="stdin";
gal_list_str_free(lines, 1);
diff --git a/bin/warp/ui.c b/bin/warp/ui.c
index 386a874..20893d6 100644
--- a/bin/warp/ui.c
+++ b/bin/warp/ui.c
@@ -245,8 +245,8 @@ ui_add_to_modular_warps_ll(struct argp_option *option, char
*arg,
if(arg && *arg=='0') return NULL;
/* Allocate the data structure. */
- new=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 0, NULL, NULL, 0,
- -1, NULL, NULL, NULL);
+ new=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 0, NULL, NULL, 0, -1, 1,
+ NULL, NULL, NULL);
}
else new=gal_options_parse_list_of_numbers(arg, filename, lineno);
@@ -345,7 +345,8 @@ ui_check_options_and_arguments(struct warpparams *p)
/* Read the input image as double type and its WCS structure. */
p->input=gal_array_read_one_ch_to_type(p->inputname, p->cp.hdu,
NULL, GAL_TYPE_FLOAT64,
- p->cp.minmapsize);
+ p->cp.minmapsize,
+ p->cp.quietmmap);
p->input->wcs=gal_wcs_read(p->inputname, p->cp.hdu, p->hstartwcs,
p->hendwcs, &p->input->nwcs);
p->input->ndim=gal_dimension_remove_extra(p->input->ndim,
@@ -595,7 +596,8 @@ ui_matrix_from_modular(struct warpparams *p)
/* Allocate space for the final matrix. */
p->matrix=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 2, dsize, NULL, 0,
- p->cp.minmapsize, NULL, NULL, NULL);
+ p->cp.minmapsize, p->cp.quietmmap,
+ NULL, NULL, NULL);
final=p->matrix->array;
/* Fill in the final matrix to start with. */
diff --git a/bin/warp/warp.c b/bin/warp/warp.c
index db8c00f..68cf7cf 100644
--- a/bin/warp/warp.c
+++ b/bin/warp/warp.c
@@ -344,8 +344,8 @@ warp_preparations(struct warpparams *p)
coordinates in the output image (bottom left corners of pixels)
for the transformation. */
p->output=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 2, dsize,
- p->input->wcs, 0, p->cp.minmapsize, "Warped",
- p->input->unit, NULL);
+ p->input->wcs, 0, p->cp.minmapsize,
+ p->cp.quietmmap, "Warped", p->input->unit, NULL);
/* Order the corners of the inverse-transformed pixel (from the
diff --git a/doc/announce-acknowledge.txt b/doc/announce-acknowledge.txt
index 431c8a0..a83dd5d 100644
--- a/doc/announce-acknowledge.txt
+++ b/doc/announce-acknowledge.txt
@@ -8,6 +8,7 @@ Raul Infante-Sainz
Lee Kelvin
Elham Saremi
David Valls-Gabaud
+Michael Wilkinson
diff --git a/doc/gnuastro.texi b/doc/gnuastro.texi
index 835f3b5..2f1f443 100644
--- a/doc/gnuastro.texi
+++ b/doc/gnuastro.texi
@@ -7721,32 +7721,39 @@ display in the @option{--help} output of the program.
@item --minmapsize=INT
The minimum size (in bytes) to store the contents of each main processing
array of a program as a file (on the non-volatile HDD/SSD), not in
-RAM. This can be very useful for large datasets which can be very memory
-intensive such that your RAM will not be sufficient to keep/process them. A
-random filename is assigned to the array which will keep the contents of
-the array as long as it is necessary.
+RAM. This can be very useful when you have limited RAM, but need to process
+large datasets which can be very memory intensive. In such scenarios,
+without this option, the program will crash.
+
+A random filename is assigned to the array. This file will keep the
+contents of the array as long as it is necessary and the program will
+delete it as soon as its not necessary any more.
If the @file{.gnuastro} directory exists and is writable, then the random
-file will be placed there. Otherwise, the @file{.gnuastro_mmap} directory
-will be checked. If @file{.gnuastro_mmap} does not exist, or is not
-writable also, the random file will be directly written in the current
-directory with the @file{.gnuastro_mmap_} prefix (followed by some random
-characters).
-
-When this option has a value of @code{0} (zero), all arrays that use this
-option in a program will actually be in a file (not in RAM). When the value
-is @code{-1} (largest possible number in the unsigned integer types) these
-arrays will be definitely allocated in RAM. However, for complex programs
-like @ref{NoiseChisel}, it is recommended to not set it to @code{0}, but a
-value like @code{10000} so the many small arrays necessary during
-processing are stored in RAM and only larger ones are saved as a file.
+file will be placed in there. Otherwise, the @file{.gnuastro_mmap}
+directory will be checked. If @file{.gnuastro_mmap} does not exist, or
+@file{.gnuastro} is not writable, the random file will be directly written
+in the current directory with the @file{.gnuastro_mmap_} prefix.
+
+By default, the name of the created file, and its size (in bytes) is
+printed by the program when it is created and later, when its
+deleted/freed. These messages are useful to the user who has enough RAM,
+but has forgot to increase the value to @code{--minmapsize} (this is often
+the case). To supress/disable such messages, use the @code{--quietmmap}
+option.
+
+When this option has a value of @code{0} (zero, strongly discouraged, see
+box below), all arrays that use this feature in a program will actually be
+placed in a file (not in RAM). When this option is larger than all the
+input datasets, all arrays will be definitely allocated in RAM and the
+program will run MUCH faster.
Please note that using a non-volatile file (in the HDD/SDD) instead of RAM
-can significantly increase the program's running time, especially on
-HDDs. So it is best to give this option large values by default. You can
-then decrease it for a specific program's invocation on a large input after
-you see memory issues arise (for example an error, or the program not
-aborting and fully consuming your memory).
+can significantly increase the program's running time, especially on HDDs
+(where read/write is slower). So it is best to give this option large
+values by default. You can then decrease it for a specific program's
+invocation on a large input after you see memory issues arise (for example
+an error, or the program not aborting and fully consuming your memory).
The random file will be deleted once it is no longer needed by the
program. The @file{.gnuastro} directory will also be deleted if it has no
@@ -7755,6 +7762,20 @@ see @ref{Configuration files}). If you see randomly
named files remaining
in this directory when the program finishes normally, please send us a bug
report so we address the problem, see @ref{Report a bug}.
+@cartouche
+@noindent
+@strong{Limited number of memory-mapped files:} The operating system
+kernels usually support a limited number of memory-mapped files. Therefore
+never set @code{--minmapsize} to zero or a small number of bytes (so too
+many files are created). If the kernel capacity is exceeded, the program
+will crash.
+@end cartouche
+
+@item --quietmmap
+Don't print any message when an array is stored in non-volatile memory
+(HDD/SSD) and not RAM, see the description of @option{--minmapsize} (above)
+for more.
+
@item -Z INT[,INT[,...]]
@itemx --tilesize=[,INT[,...]]
The size of regular tiles for tessellation, see @ref{Tessellation}. For
@@ -24414,10 +24435,14 @@ Identifier for a signed, 64-bit integer type:
@code{int64_t} (from
@file{stdint.h}), or an @code{long} in most modern 64-bit systems.
@end deffn
-@deffn {Global integer} GAL_TYPE_SIZE_T
-Identifier for a @code{size_t} type. This is just an alias to
-@code{uint32}, or @code{uint64} types for 32-bit, or 64-bit systems
-respectively.
+@deffn {Global integer} GAL_TYPE_INT
+Identifier for a @code{int} type. This is just an alias to @code{int16}, or
+@code{int32} types, depending on the system.
+@end deffn
+
+@deffn {Global integer} GAL_TYPE_UINT
+Identifier for a @code{unsigned int} type. This is just an alias to
+@code{uint16}, or @code{uint32} types, depending on the system.
@end deffn
@deffn {Global integer} GAL_TYPE_ULONG
@@ -24431,6 +24456,12 @@ Identifier for a @code{long} type. This is just an
alias to @code{int32},
or @code{int64} types for 32-bit, or 64-bit systems respectively.
@end deffn
+@deffn {Global integer} GAL_TYPE_SIZE_T
+Identifier for a @code{size_t} type. This is just an alias to
+@code{uint32}, or @code{uint64} types for 32-bit, or 64-bit systems
+respectively.
+@end deffn
+
@deffn {Global integer} GAL_TYPE_FLOAT32
Identifier for a 32-bit single precision floating point type or
@code{float} in C.
@@ -24966,6 +24997,7 @@ typedef struct gal_data_t
size_t ndim;
size_t *dsize;
size_t size;
+ int quietmmap;
char *mmapname;
size_t minmapsize;
@@ -25057,6 +25089,13 @@ independent parameter. However, low-level operations
with the dataset
(irrespective of its dimensions) commonly need this number, so this element
is designed to avoid calculating it every time.
+@item int quietmmap
+When this value is zero, and the dataset must not be allocated in RAM (see
+@code{mmapname} and @code{minmapsize}), a warning will be printed to inform
+the user when the file is created and when it is deleted. The warning
+includes the filename, the size in bytes, and the fact that they can toggle
+this behavior through @code{--minmapsize} option in Gnuastro's programs.
+
@item char *mmapname
Name of file hosting the @code{mmap}'d contents of @code{array}. If the
value of this variable is @code{NULL}, then the contents of @code{array}
@@ -25213,7 +25252,7 @@ The functions listed in this section describe the most
basic operations on
are declared in @file{gnuastro/data.h} which is also visible from the
function names (see @ref{Gnuastro library}).
-@deftypefun {gal_data_t *} gal_data_alloc (void @code{*array}, uint8_t
@code{type}, size_t @code{ndim}, size_t @code{*dsize}, struct wcsprm
@code{*wcs}, int @code{clear}, size_t @code{minmapsize}, char @code{*name},
char @code{*unit}, char @code{*comment})
+@deftypefun {gal_data_t *} gal_data_alloc (void @code{*array}, uint8_t
@code{type}, size_t @code{ndim}, size_t @code{*dsize}, struct wcsprm
@code{*wcs}, int @code{clear}, size_t @code{minmapsize}, int @code{quietmmap},
char @code{*name}, char @code{*unit}, char @code{*comment})
Dynamically allocate a @code{gal_data_t} and initialize it will all the
given values. See the description of @code{gal_data_initialize} and
@@ -25224,7 +25263,7 @@ the dataset, be sure to clean up all the allocated
spaces with
@code{gal_data_free}.
@end deftypefun
-@deftypefun void gal_data_initialize (gal_data_t @code{*data}, void
@code{*array}, uint8_t @code{type}, size_t @code{ndim}, size_t @code{*dsize},
struct wcsprm @code{*wcs}, int @code{clear}, size_t @code{minmapsize}, char
@code{*name}, char @code{*unit}, char @code{*comment})
+@deftypefun void gal_data_initialize (gal_data_t @code{*data}, void
@code{*array}, uint8_t @code{type}, size_t @code{ndim}, size_t @code{*dsize},
struct wcsprm @code{*wcs}, int @code{clear}, size_t @code{minmapsize}, int
@code{quietmmap}, char @code{*name}, char @code{*unit}, char @code{*comment})
Initialize the given data structure (@code{data}) with all the given
values. Note that the raw input @code{gal_data_t} must already have been
@@ -26354,16 +26393,17 @@ itself a list), then @code{list} will be added to its
end.
In this example multiple images are linked together as a list:
@example
+int quietmmap=1;
size_t minmapsize=-1;
gal_data_t *tmp, *list=NULL;
-tmp = gal_fits_img_read("file1.fits", "1", minmapsize);
+tmp = gal_fits_img_read("file1.fits", "1", minmapsize, quietmmap);
gal_list_data_add( &list, tmp );
-tmp = gal_fits_img_read("file2.fits", "1", minmapsize);
+tmp = gal_fits_img_read("file2.fits", "1", minmapsize, quietmmap);
gal_list_data_add( &list, tmp );
@end example
@end deftypefun
-@deftypefun void gal_list_data_add_alloc (gal_data_t @code{**list}, void
@code{*array}, uint8_t @code{type}, size_t @code{ndim}, size_t @code{*dsize},
struct wcsprm @code{*wcs}, int @code{clear}, size_t @code{minmapsize}, char
@code{*name}, char @code{*unit}, char @code{*comment})
+@deftypefun void gal_list_data_add_alloc (gal_data_t @code{**list}, void
@code{*array}, uint8_t @code{type}, size_t @code{ndim}, size_t @code{*dsize},
struct wcsprm @code{*wcs}, int @code{clear}, size_t @code{minmapsize}, int
@code{quietmmap}, char @code{*name}, char @code{*unit}, char @code{*comment})
Allocate a new dataset (with @code{gal_data_alloc} in @ref{Dataset
allocation}) and put it as the first element of @code{list}. Note that if
this is the first node to be added to the list, @code{list} must be
@@ -26426,15 +26466,17 @@ types for reading arrays which may contain multiple
extensions (for example
FITS or TIFF) formats.
@end deftypefun
-@deftypefun gal_data_t gal_array_read (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, size_t @code{minmapsize})
+@deftypefun gal_data_t gal_array_read (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, size_t @code{minmapsize}, int
@code{quietmmap})
Read the array within the given extension (@code{extension}) of
@code{filename}, or the @code{lines} list (see below). If the array is
larger than @code{minmapsize} bytes, then it won't be read into RAM, but a
-file on the HDD/SSD (no difference for the programmer). @code{extension}
-will be ignored for files that don't support them (for example JPEG or
-text). For FITS files, @code{extension} can be a number or a string (name
-of the extension), but for TIFF files, it has to be number. In both cases,
-counting starts from zero.
+file on the HDD/SSD (no difference for the programmer). Messages about the
+memory-mapped file can be disabled with @code{quietmmap}.
+
+@code{extension} will be ignored for files that don't support them (for
+example JPEG or text). For FITS files, @code{extension} can be a number or
+a string (name of the extension), but for TIFF files, it has to be
+number. In both cases, counting starts from zero.
For multi-channel formats (like RGB images in JPEG or TIFF), this function
will return a @ref{List of gal_data_t}: one data structure per
@@ -26450,12 +26492,12 @@ the program's input as separate lines from the
standard input (see
exclusive and one of them must be @code{NULL}.
@end deftypefun
-@deftypefun void gal_array_read_to_type (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, uint8_t @code{type}, size_t
@code{minmapsize})
+@deftypefun void gal_array_read_to_type (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, uint8_t @code{type}, size_t
@code{minmapsize}, int @code{quietmmap})
Similar to @code{gal_array_read}, but the output data structure(s) will
have a numeric data type of @code{type}, see @ref{Numeric data types}.
@end deftypefun
-@deftypefun void gal_array_read_one_ch (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, size_t @code{minmapsize})
+@deftypefun void gal_array_read_one_ch (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, size_t @code{minmapsize}, int
@code{quietmmap})
@cindex Channel
@cindex Color channel
Read the dataset within @code{filename} (extension/hdu/dir
@@ -26470,7 +26512,7 @@ be a convenient way to make sure that the data that
comes into your program
is only one channel.
@end deftypefun
-@deftypefun void gal_array_read_one_ch_to_type (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, uint8_t @code{type}, size_t
@code{minmapsize})
+@deftypefun void gal_array_read_one_ch_to_type (char @code{*filename}, char
@code{*extension}, gal_list_str_t @code{*lines}, uint8_t @code{type}, size_t
@code{minmapsize}, int @code{quietmmap})
Similar to @code{gal_array_read_one_ch}, but the output data structure will
has a numeric data type of @code{type}, see @ref{Numeric data types}.
@end deftypefun
@@ -26590,7 +26632,7 @@ $ asttable --info table.fits
@end example
@end deftypefun
-@deftypefun {gal_data_t *} gal_table_read (char @code{*filename}, char
@code{*hdu}, gal_list_str_t @code{*lines}, gal_list_str_t @code{*cols}, int
@code{searchin}, int @code{ignorecase}, size_t @code{minmapsize}, size_t
@code{*colmatch})
+@deftypefun {gal_data_t *} gal_table_read (char @code{*filename}, char
@code{*hdu}, gal_list_str_t @code{*lines}, gal_list_str_t @code{*cols}, int
@code{searchin}, int @code{ignorecase}, size_t @code{minmapsize}, int
@code{quietmmap}, size_t @code{*colmatch})
Read the specified columns in a file (named @code{filename}), or list of
strings (@code{lines}) into a linked list of data structures. If the file
@@ -27218,13 +27260,13 @@ in the space that @code{ndim} points to and return
the size of the dataset
along each dimension as an allocated array with @code{*ndim} elements.
@end deftypefun
-@deftypefun {gal_data_t *} gal_fits_img_read (char @code{*filename}, char
@code{*hdu}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_fits_img_read (char @code{*filename}, char
@code{*hdu}, size_t @code{minmapsize}, int @code{quietmmap})
Read the contents of the @code{hdu} extension/HDU of @code{filename} into a
Gnuastro generic data container (see @ref{Generic data container}) and
return it. If the necessary space is larger than @code{minmapsize}, then
don't keep the data in RAM, but in a file on the HDD/SSD. For more on
-@code{minmapsize} see the description under the same name in @ref{Generic
-data container}.
+@code{minmapsize} and @code{quietmmap} see the description under the same
+name in @ref{Generic data container}.
Note that this function only reads the main data within the requested FITS
extension, the WCS will not be read into the returned dataset. To read the
@@ -27232,12 +27274,12 @@ WCS, you can use @code{gal_wcs_read} function as
shown below. Afterwards,
the @code{gal_data_free} function will free both the dataset and any WCS
structure (if there are any).
@example
-data=gal_fits_img_read(filename, hdu, -1);
+data=gal_fits_img_read(filename, hdu, -1, 1);
data->wcs=gal_wcs_read(filename, hdu, 0, 0, &data->wcs->nwcs);
@end example
@end deftypefun
-@deftypefun {gal_data_t *} gal_fits_img_read_to_type (char @code{*inputname},
char @code{*inhdu}, uint8_t @code{type}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_fits_img_read_to_type (char @code{*inputname},
char @code{*inhdu}, uint8_t @code{type}, size_t @code{minmapsize}, int
@code{quietmmap})
Read the contents of the @code{hdu} extension/HDU of @code{filename} into a
Gnuastro generic data container (see @ref{Generic data container}) of type
@code{type} and return it.
@@ -27251,7 +27293,7 @@ description there for more.
@cindex NaN
@cindex Convolution kernel
@cindex Kernel, convolution
-@deftypefun {gal_data_t *} gal_fits_img_read_kernel (char @code{*filename},
char @code{*hdu}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_fits_img_read_kernel (char @code{*filename},
char @code{*hdu}, size_t @code{minmapsize}, int @code{quietmmap})
Read the @code{hdu} of @code{filename} as a convolution kernel. A
convolution kernel must have an odd size along all dimensions, it must not
have blank (NaN in floating point types) values and must be flipped around
@@ -27351,13 +27393,14 @@ reading tables in FITS format. To be generic, it is
recommended to use
of table formats based on the filename (see @ref{Table input output}).
@end deftypefun
-@deftypefun {gal_data_t *} gal_fits_tab_read (char @code{*filename}, char
@code{*hdu}, size_t @code{numrows}, gal_data_t @code{*colinfo},
gal_list_sizet_t @code{*indexll}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_fits_tab_read (char @code{*filename}, char
@code{*hdu}, size_t @code{numrows}, gal_data_t @code{*colinfo},
gal_list_sizet_t @code{*indexll}, size_t @code{minmapsize}, int
@code{quietmmap})
Read the columns given in the list @code{indexll} from a FITS table (in
@file{filename} and HDU/extension @code{hdu}) into the returned linked list
of data structures, see @ref{List of size_t} and @ref{List of
gal_data_t}. If the necessary space for each column is larger than
-@code{minmapsize}, don't keep it in the RAM, but in a file in the HDD/SSD,
-see the description under the same name in @ref{Generic data container}.
+@code{minmapsize}, don't keep it in the RAM, but in a file in the HDD/SSD.
+For more on @code{minmapsize} and @code{quietmmap}, see the description
+under the same name in @ref{Generic data container}.
Each column will have @code{numrows} rows and @code{colinfo} contains any
further information about the columns (returned by
@@ -27470,13 +27513,14 @@ variety of table formats based on the filename (see
@ref{Table input
output}).
@end deftypefun
-@deftypefun {gal_data_t *} gal_txt_table_read (char @code{*filename},
gal_list_str_t @code{*lines}, size_t @code{numrows}, gal_data_t
@code{*colinfo}, gal_list_sizet_t @code{*indexll}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_txt_table_read (char @code{*filename},
gal_list_str_t @code{*lines}, size_t @code{numrows}, gal_data_t
@code{*colinfo}, gal_list_sizet_t @code{*indexll}, size_t @code{minmapsize},
int @code{quietmmap})
Read the columns given in the list @code{indexll} from a plain text file
(@code{filename}) or list of strings (@code{lines}), into a linked list of
data structures (see @ref{List of size_t} and @ref{List of gal_data_t}). If
the necessary space for each column is larger than @code{minmapsize}, don't
-keep it in the RAM, but in a file on the HDD/SSD, see the description under
-the same name in @ref{Generic data container}.
+keep it in the RAM, but in a file on the HDD/SSD. For more one
+@code{minmapsize} and @code{quietmmap}, see the description under the same
+name in @ref{Generic data container}.
@code{lines} is a list of strings with each node representing one line
(including the new-line character), see @ref{List of strings}. It will
@@ -27491,12 +27535,13 @@ inverse of the input indexs linked list. It is
recommended to use
@ref{Table input output}.
@end deftypefun
-@deftypefun {gal_data_t *} gal_txt_image_read (char @code{*filename},
gal_list_str_t @code{*lines}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_txt_image_read (char @code{*filename},
gal_list_str_t @code{*lines}, size_t @code{minmapsize}, int @code{quietmmap})
Read the 2D plain text dataset in file (@code{filename}) or list of strings
(@code{lines}) into a dataset and return the dataset. If the necessary
space for the image is larger than @code{minmapsize}, don't keep it in the
-RAM, but in a file on the HDD/SSD, see the description under the same name
-in @ref{Generic data container}.
+RAM, but in a file on the HDD/SSD. For more on @code{minmapsize} and
+@code{quietmmap}, see the description under the same name in @ref{Generic
+data container}.
@code{lines} is a list of strings with each node representing one line
(including the new-line character), see @ref{List of strings}. It will
@@ -27610,7 +27655,7 @@ identify a TIFF directory. Note that the directories
start counting from
zero.
@end deftypefun
-@deftypefun {gal_data_t *} gal_tiff_read (char @code{*filename}, size_t
@code{dir}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_tiff_read (char @code{*filename}, size_t
@code{dir}, size_t @code{minmapsize}, int @code{quietmmap})
Read the @code{dir} directory within the TIFF file @code{filename} and
return the contents of that TIFF directory as @code{gal_data_t}. If the
directory's image contains multiple channels, the output will be a list
@@ -27652,7 +27697,7 @@ recognized suffixes are @code{.jpg}, @code{.JPG},
@code{.jpeg},
@code{.JPEG}, @code{.jpe}, @code{.jif}, @code{.jfif} and @code{.jfi}.
@end deftypefun
-@deftypefun {gal_data_t *} gal_jpeg_read (char @code{*filename}, size_t
@code{minmapsize})
+@deftypefun {gal_data_t *} gal_jpeg_read (char @code{*filename}, size_t
@code{minmapsize}, int @code{quietmmap})
Read the JPEG file @code{filename} and return the contents as
@code{gal_data_t}. If the directory's image contains multiple
colors/channels, the output will be a list with one node per color/channel
@@ -28605,7 +28650,7 @@ gal_data_t *faketile;
/* Allocate the fake tile, these can be done outside a loop
* (over many tiles). */
faketile=gal_data_alloc(NULL, new->type, 1, &zero,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
free(faketile->array); /* To keep things clean. */
free(faketile->dsize); /* To keep things clean. */
faketile->block = new;
@@ -28764,7 +28809,7 @@ char *filename="input.fits", *hdu="1";
...
/* Read the input dataset. */
-input=gal_fits_img_read(filename, hdu, -1);
+input=gal_fits_img_read(filename, hdu, -1, 1);
/* Do a sanity check and preparations. */
gal_tile_full_sanity_check(filename, hdu, input, &tl);
@@ -29222,7 +29267,7 @@ catalogs (register them). Currently it only provides
the The high-level
measurements are stored in tables with positions (commonly in RA and Dec
with units of degrees).
-@deftypefun {gal_data_t *} gal_match_coordinates (gal_data_t @code{*coord1},
gal_data_t @code{*coord2}, double @code{*aperture}, int @code{sorted_by_first},
int @code{inplace}, size_t @code{minmapsize}, size_t @code{*nummatched})
+@deftypefun {gal_data_t *} gal_match_coordinates (gal_data_t @code{*coord1},
gal_data_t @code{*coord2}, double @code{*aperture}, int @code{sorted_by_first},
int @code{inplace}, size_t @code{minmapsize}, int @code{quietmmap}, size_t
@code{*nummatched})
Return the permutations that when applied, the first @code{nummatched} rows
of both inputs match with each other (are the nearest within the given
@@ -29258,7 +29303,8 @@ take more time and memory.
If internal allocation is necessary and the space is larger than
@code{minmapsize}, the space will be not allocated in the RAM, but in a
-file, see description of @option{--minmapsize} in @ref{Processing options}.
+file, see description of @option{--minmapsize} and @code{--quietmmap} in
+@ref{Processing options}.
The number of matches will be put in the space pointed by
@code{nummatched}. If there wasn't any match, this function will return
@@ -29968,7 +30014,7 @@ labels, therefore negative integers can be used for any
extra
classification in the labeled datasets.
@end deffn
-@deftypefun {gal_data_t *} gal_label_indexs (gal_data_t @code{*labels}, size_t
@code{numlabs}, size_t @code{minmapsize})
+@deftypefun {gal_data_t *} gal_label_indexs (gal_data_t @code{*labels}, size_t
@code{numlabs}, size_t @code{minmapsize}, int @code{quietmmap})
Return an array of @code{gal_data_t} containers, each containing the pixel
indexs of the respective label (see @ref{Generic data
@@ -30414,7 +30460,7 @@ main(void)
gal_list_str_add(&cols, "1", 0);
gal_list_str_add(&cols, "2", 0);
Y=gal_table_read("table.txt", NULL, cols, GAL_TABLE_SEARCH_NAME,
- 0, -1, NULL);
+ 0, -1, 1, NULL);
X=Y->next;
/* Allocate the GSL interpolation accelerator and make the
@@ -30761,7 +30807,8 @@ main(void)
/* Read `img.fits' (HDU: 1) as a float32 array. */
- image=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32, -1);
+ image=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32,
+ -1, 1);
/* Use the allocated space as a single precision floating
@@ -30810,7 +30857,7 @@ main(void)
float *array;
size_t i, num, *dinc;
gal_data_t *input=gal_fits_img_read_to_type("input.fits", "1",
- GAL_TYPE_FLOAT32, -1);
+ GAL_TYPE_FLOAT32, -1, 1);
/* To avoid the `void *' pointer and have `dinc'. */
array=input->array;
@@ -30949,9 +30996,9 @@ main(void)
/* Read the image into memory as a float32 data type. We are using
* `-1' for `minmapsize' to ensure that the image is read into
- * memory. */
+ * memory and `1' for `quietmmap' (which can also be zero). */
p.image=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32,
- -1);
+ -1, 1);
/* Print some basic information before the actual contents: */
@@ -31053,7 +31100,7 @@ main(void)
/* Read the desired columns. */
columns = gal_table_read(inname, hdu, column_ids,
- GAL_TABLE_SEARCH_NAME, 1, -1, NULL);
+ GAL_TABLE_SEARCH_NAME, 1, -1, 1, NULL);
/* Go over the columns, we'll assume that you don't know their type
* a-priori, so we'll check */
diff --git a/lib/arithmetic.c b/lib/arithmetic.c
index 0bd8cb8..d6d1378 100644
--- a/lib/arithmetic.c
+++ b/lib/arithmetic.c
@@ -178,8 +178,8 @@ arithmetic_not(gal_data_t *data, int flags)
/* Allocate the output array. */
out=gal_data_alloc(NULL, GAL_TYPE_UINT8, data->ndim, data->dsize,
- data->wcs, 0, data->minmapsize, data->name, data->unit,
- data->comment);
+ data->wcs, 0, data->minmapsize, data->quietmmap,
+ data->name, data->unit, data->comment);
o=out->array;
@@ -247,7 +247,7 @@ arithmetic_bitwise_not(int flags, gal_data_t *in)
o = in;
else
o = gal_data_alloc(NULL, in->type, in->ndim, in->dsize, in->wcs,
- 0, in->minmapsize, NULL, NULL, NULL);
+ 0, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* Start setting the types. */
switch(in->type)
@@ -312,8 +312,8 @@ arithmetic_abs(int flags, gal_data_t *in)
out=in;
else
out = gal_data_alloc(NULL, in->type, in->ndim, in->dsize,
- in->wcs, 0, in->minmapsize, in->name, in->unit,
- in->comment);
+ in->wcs, 0, in->minmapsize, in->quietmmap,
+ in->name, in->unit, in->comment);
/* Put the absolute value depending on the type. */
switch(in->type)
@@ -460,7 +460,8 @@ arithmetic_unary_function(int operator, int flags,
gal_data_t *in)
? GAL_TYPE_FLOAT64
: GAL_TYPE_FLOAT32 );
o = gal_data_alloc(NULL, otype, in->ndim, in->dsize, in->wcs,
- 0, in->minmapsize, NULL, NULL, NULL);
+ 0, in->minmapsize, in->quietmmap,
+ NULL, NULL, NULL);
}
/* Start setting the operator and operands. */
@@ -939,7 +940,7 @@ struct multioperandparams
TYPE *pixs=gal_pointer_allocate(p->list->type, p->dnum, 0, \
__func__, "pixs"); \
gal_data_t *cont=gal_data_alloc(pixs, p->list->type, 1, &p->dnum, \
- NULL, 0, -1, NULL, NULL, NULL); \
+ NULL, 0, -1, 1, NULL, NULL, NULL); \
\
/* Go over all the pixels assigned to this thread. */ \
for(tind=0; tprm->indexs[tind] != GAL_BLANK_SIZE_T; ++tind) \
@@ -1192,7 +1193,8 @@ arithmetic_multioperand(int operator, int flags,
gal_data_t *list,
out = list; /* The top element in the list. */
else
out = gal_data_alloc(NULL, otype, list->ndim, list->dsize,
- list->wcs, 0, list->minmapsize, NULL, NULL, NULL);
+ list->wcs, 0, list->minmapsize, list->quietmmap,
+ NULL, NULL, NULL);
/* hasblank is used to see if a blank value should be checked for each
@@ -1303,6 +1305,7 @@ arithmetic_binary(int operator, int flags, gal_data_t *l,
gal_data_t *r)
int32_t otype;
gal_data_t *o=NULL;
size_t out_size, minmapsize;
+ int quietmmap=l->quietmmap && r->quietmmap;
/* Simple sanity check on the input sizes */
@@ -1348,7 +1351,7 @@ arithmetic_binary(int operator, int flags, gal_data_t *l,
gal_data_t *r)
l->size>1 ? l->ndim : r->ndim,
l->size>1 ? l->dsize : r->dsize,
l->size>1 ? l->wcs : r->wcs,
- 0, minmapsize, NULL, NULL, NULL );
+ 0, minmapsize, quietmmap, NULL, NULL, NULL );
/* Call the proper function for the operator. Since they heavily involve
@@ -1462,6 +1465,7 @@ arithmetic_binary_function_flt(int operator, int flags,
gal_data_t *l,
int final_otype;
gal_data_t *o=NULL;
size_t out_size, minmapsize;
+ int quietmmap=l->quietmmap && r->quietmmap;
/* Simple sanity check on the input sizes */
@@ -1503,7 +1507,7 @@ arithmetic_binary_function_flt(int operator, int flags,
gal_data_t *l,
l->size>1 ? l->ndim : r->ndim,
l->size>1 ? l->dsize : r->dsize,
l->size>1 ? l->wcs : r->wcs, 0, minmapsize,
- NULL, NULL, NULL);
+ quietmmap, NULL, NULL, NULL);
/* Start setting the operator and operands. */
diff --git a/lib/array.c b/lib/array.c
index 27271ec..8142bd0 100644
--- a/lib/array.c
+++ b/lib/array.c
@@ -87,28 +87,28 @@ gal_array_name_recognized_multiext(char *name)
extension/dir of the given file. */
gal_data_t *
gal_array_read(char *filename, char *extension, gal_list_str_t *lines,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
size_t ext;
/* FITS */
if( gal_fits_name_is_fits(filename) )
- return gal_fits_img_read(filename, extension, minmapsize);
+ return gal_fits_img_read(filename, extension, minmapsize, quietmmap);
/* TIFF */
else if ( gal_tiff_name_is_tiff(filename) )
{
ext=gal_tiff_dir_string_read(extension);
- return gal_tiff_read(filename, ext, minmapsize);
+ return gal_tiff_read(filename, ext, minmapsize, quietmmap);
}
/* JPEG */
else if ( gal_jpeg_name_is_jpeg(filename) )
- return gal_jpeg_read(filename, minmapsize);
+ return gal_jpeg_read(filename, minmapsize, quietmmap);
/* Default: plain text. */
else
- return gal_txt_image_read(filename, lines, minmapsize);
+ return gal_txt_image_read(filename, lines, minmapsize, quietmmap);
/* Control should not get to here, but just to avoid compiler warnings,
we'll return a NULL. */
@@ -126,11 +126,11 @@ gal_array_read(char *filename, char *extension,
gal_list_str_t *lines,
gal_data_t *
gal_array_read_to_type(char *filename, char *extension,
gal_list_str_t *lines, uint8_t type,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
gal_data_t *out=NULL;
gal_data_t *next, *in=gal_array_read(filename, extension, lines,
- minmapsize);
+ minmapsize, quietmmap);
/* Go over all the channels. */
while(in)
@@ -153,11 +153,11 @@ gal_array_read_to_type(char *filename, char *extension,
/* Read the input array and make sure it is only one channel. */
gal_data_t *
gal_array_read_one_ch(char *filename, char *extension, gal_list_str_t *lines,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
char *fname;
gal_data_t *out;
- out=gal_array_read(filename, extension, lines, minmapsize);
+ out=gal_array_read(filename, extension, lines, minmapsize, quietmmap);
if(out->next)
{
@@ -189,10 +189,10 @@ gal_array_read_one_ch(char *filename, char *extension,
gal_list_str_t *lines,
gal_data_t *
gal_array_read_one_ch_to_type(char *filename, char *extension,
gal_list_str_t *lines, uint8_t type,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
gal_data_t *out=gal_array_read_one_ch(filename, extension, lines,
- minmapsize);
+ minmapsize, quietmmap);
return gal_data_copy_to_new_type_free(out, type);
}
diff --git a/lib/binary.c b/lib/binary.c
index 39aa556..a10e2e4 100644
--- a/lib/binary.c
+++ b/lib/binary.c
@@ -384,7 +384,8 @@ gal_binary_connected_components(gal_data_t *binary,
gal_data_t **out,
else
lab=*out=gal_data_alloc(NULL, GAL_TYPE_INT32, binary->ndim,
binary->dsize, binary->wcs, 1,
- binary->minmapsize, NULL, "labels", NULL);
+ binary->minmapsize, binary->quietmmap,
+ NULL, "labels", NULL);
/* Initialize the labels array. If we have blank pixels in the byt
@@ -479,7 +480,8 @@ gal_binary_connected_adjacency_matrix(gal_data_t *adjacency,
/* Allocate (and clear) the output datastructure. */
newlabs_d=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &num, NULL, 1,
- adjacency->minmapsize, NULL, NULL, NULL);
+ adjacency->minmapsize, adjacency->quietmmap,
+ NULL, NULL, NULL);
newlabs=newlabs_d->array;
@@ -586,15 +588,16 @@ binary_make_padded_inverse(gal_data_t *input, gal_data_t
**outtile)
the connected components and any hole, will get a value larger than
1. */
inv=gal_data_alloc(NULL, GAL_TYPE_UINT8, input->ndim, dsize, NULL, 0,
- input->minmapsize, "INVERSE", "binary", NULL);
+ input->minmapsize, input->quietmmap,
+ "INVERSE", "binary", NULL);
memset(inv->array, 1, inv->size);
/* Define a tile to fill the central regions of the inverse. */
startind=gal_dimension_coord_to_index(input->ndim, inv->dsize, startcoord);
tile=gal_data_alloc(gal_pointer_increment(inv->array, startind, inv->type),
- inv->type, input->ndim, input->dsize, NULL, 0, 0, NULL,
- NULL, NULL);
+ inv->type, input->ndim, input->dsize, NULL, 0, 0, 0,
+ NULL, NULL, NULL);
*outtile=tile;
tile->block=inv;
diff --git a/lib/blank.c b/lib/blank.c
index a195018..77e6969 100644
--- a/lib/blank.c
+++ b/lib/blank.c
@@ -534,8 +534,8 @@ gal_blank_flag(gal_data_t *input)
/* Allocate a non-cleared output array, we are going to parse the
input and fill in each element. */
out=gal_data_alloc(NULL, GAL_TYPE_UINT8, input->ndim, input->dsize,
- input->wcs, 0, input->minmapsize, NULL, "bool",
- NULL);
+ input->wcs, 0, input->minmapsize, input->quietmmap,
+ NULL, "bool", NULL);
/* Set the pointers for easy looping. */
of=(o=out->array)+input->size;
@@ -576,7 +576,8 @@ gal_blank_flag(gal_data_t *input)
else
/* Allocate a CLEAR data structure (all zeros). */
out=gal_data_alloc(NULL, GAL_TYPE_UINT8, input->ndim, input->dsize,
- input->wcs, 1, input->minmapsize, NULL, "bool", NULL);
+ input->wcs, 1, input->minmapsize, input->quietmmap,
+ NULL, "bool", NULL);
/* Return */
return out;
diff --git a/lib/convolve.c b/lib/convolve.c
index dd1ccbb..27b0574 100644
--- a/lib/convolve.c
+++ b/lib/convolve.c
@@ -444,9 +444,9 @@ convolve_spatial_on_thread(void *inparam)
pprm->overlap_start = gal_pointer_allocate(GAL_TYPE_SIZE_T, ndim, 0,
__func__, "pprm->overlap_start");
pprm->i_overlap = gal_data_alloc(NULL, block->type, ndim, dsize,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
pprm->k_overlap = gal_data_alloc(NULL, cprm->kernel->type, ndim, dsize,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
free(dsize);
free(pprm->i_overlap->array);
free(pprm->k_overlap->array);
@@ -519,8 +519,8 @@ gal_convolve_spatial_general(gal_data_t *tiles, gal_data_t
*kernel,
{
/* Allocate the space for the convolved image. */
out=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, block->ndim, block->dsize,
- block->wcs, 0, block->minmapsize, NULL,
- block->unit, NULL);
+ block->wcs, 0, block->minmapsize, block->quietmmap,
+ NULL, block->unit, NULL);
/* Spatial convolution won't change the blank bit-flag, so use the
block structure's blank bit flag. */
diff --git a/lib/data.c b/lib/data.c
index 15027da..d09c436 100644
--- a/lib/data.c
+++ b/lib/data.c
@@ -69,7 +69,7 @@ along with Gnuastro. If not, see
<http://www.gnu.org/licenses/>.
gal_data_t *
gal_data_alloc(void *array, uint8_t type, size_t ndim, size_t *dsize,
struct wcsprm *wcs, int clear, size_t minmapsize,
- char *name, char *unit, char *comment)
+ int quietmmap, char *name, char *unit, char *comment)
{
gal_data_t *out;
@@ -82,7 +82,7 @@ gal_data_alloc(void *array, uint8_t type, size_t ndim, size_t
*dsize,
/* Initialize the allocated array. */
gal_data_initialize(out, array, type, ndim, dsize, wcs, clear, minmapsize,
- name, unit, comment);
+ quietmmap, name, unit, comment);
/* Return the final structure. */
return out;
@@ -112,8 +112,8 @@ gal_data_alloc(void *array, uint8_t type, size_t ndim,
size_t *dsize,
void
gal_data_initialize(gal_data_t *data, void *array, uint8_t type,
size_t ndim, size_t *dsize, struct wcsprm *wcs,
- int clear, size_t minmapsize, char *name,
- char *unit, char *comment)
+ int clear, size_t minmapsize, int quietmmap,
+ char *name, char *unit, char *comment)
{
size_t i;
size_t data_size_limit = (size_t)(-1);
@@ -128,6 +128,7 @@ gal_data_initialize(gal_data_t *data, void *array, uint8_t
type,
data->type = type;
data->block = NULL;
data->mmapname = NULL;
+ data->quietmmap = quietmmap;
data->minmapsize = minmapsize;
gal_checkset_allocate_copy(name, &data->name);
gal_checkset_allocate_copy(unit, &data->unit);
@@ -192,7 +193,8 @@ gal_data_initialize(gal_data_t *data, void *array, uint8_t
type,
if( gal_type_sizeof(type)*data->size > minmapsize )
/* Allocate the space into disk (HDD/SSD). */
data->array=gal_pointer_allocate_mmap(data->type, data->size,
- clear, &data->mmapname);
+ clear, &data->mmapname,
+ quietmmap);
else
/* Allocate the space in RAM. */
data->array = gal_pointer_allocate(data->type, data->size,
@@ -261,6 +263,10 @@ gal_data_free_contents(gal_data_t *data)
/* Delete the file keeping the array. */
remove(data->mmapname);
+ /* Inform the user. */
+ if(!data->quietmmap)
+ error(EXIT_SUCCESS, 0, "%s: deleted", data->mmapname);
+
/* Free the file name space. */
free(data->mmapname);
@@ -338,6 +344,7 @@ gal_data_array_calloc(size_t size)
out[i].size = 0;
out[i].mmapname = NULL;
out[i].minmapsize = -1;
+ out[i].quietmmap = 1;
out[i].nwcs = 0;
out[i].wcs = NULL;
out[i].flag = 0;
@@ -698,7 +705,8 @@ gal_data_copy_to_new_type(gal_data_t *in, uint8_t newtype)
/* Allocate the output datastructure. */
out=gal_data_alloc(NULL, newtype, in->ndim, in->dsize, in->wcs,
- 0, in->minmapsize, in->name, in->unit, in->comment);
+ 0, in->minmapsize, in->quietmmap, in->name,
+ in->unit, in->comment);
/* Fill in the output array: */
gal_data_copy_to_allocated(in, out);
@@ -844,6 +852,6 @@ gal_data_copy_string_to_number(char *string)
ptr=gal_type_string_to_number(string, &type);
return ( ptr
? gal_data_alloc(ptr, type, 1, &dsize, NULL, 0, -1,
- NULL, NULL, NULL)
+ 1, NULL, NULL, NULL)
: NULL );
}
diff --git a/lib/dimension.c b/lib/dimension.c
index 61397b8..294d811 100644
--- a/lib/dimension.c
+++ b/lib/dimension.c
@@ -519,12 +519,12 @@ gal_dimension_collapse_sum(gal_data_t *in, size_t c_dim,
gal_data_t *weight)
/* Allocate the sum (output) dataset. */
sum=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, outndim, outdsize, in->wcs,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* The number dataset (when there are blank values).*/
if(hasblank)
num=gal_data_alloc(NULL, GAL_TYPE_INT8, outndim, outdsize, NULL,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* Set the array pointers. */
if(sum) farr=sum->array;
@@ -595,7 +595,7 @@ gal_dimension_collapse_mean(gal_data_t *in, size_t c_dim,
/* The sum array. */
sum=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, outndim, outdsize, in->wcs,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* If a weighted mean is requested. */
if( weight )
@@ -618,7 +618,7 @@ gal_dimension_collapse_mean(gal_data_t *in, size_t c_dim,
/* No weight is given, so we'll need the number of elements. */
else if( hasblank )
num=gal_data_alloc(NULL, GAL_TYPE_INT32, outndim, outdsize, NULL,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* Set the array pointers. */
if(sum) farr=sum->array;
@@ -694,7 +694,7 @@ gal_dimension_collapse_number(gal_data_t *in, size_t c_dim)
/* The number dataset (when there are blank values).*/
num=gal_data_alloc(NULL, GAL_TYPE_INT32, outndim, outdsize, in->wcs,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
/* Set the array pointers. */
iarr=num->array;
@@ -759,11 +759,11 @@ gal_dimension_collapse_minmax(gal_data_t *in, size_t
c_dim, int max1_min0)
to count how many elements whent into the calculation so we can set
them to blank. */
minmax=gal_data_alloc(NULL, in->type, outndim, outdsize, in->wcs,
- 0, in->minmapsize, NULL, NULL, NULL);
+ 0, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
if(hasblank)
{
num=gal_data_alloc(NULL, GAL_TYPE_UINT8, outndim, outdsize, in->wcs,
- 1, in->minmapsize, NULL, NULL, NULL);
+ 1, in->minmapsize, in->quietmmap, NULL, NULL, NULL);
iarr=num->array;
}
diff --git a/lib/eps.c b/lib/eps.c
index 8c95e88..9e07402 100644
--- a/lib/eps.c
+++ b/lib/eps.c
@@ -166,7 +166,7 @@ eps_convert_to_bitstream(gal_data_t *in, size_t *numbytes,
uint8_t bitone)
allocation system for bits, so we'll allocate space in bytes, then
convert */
gal_list_data_add_alloc(&out, NULL, GAL_TYPE_UINT8, 1, numbytes,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
out->type=GAL_TYPE_BIT;
bits=out->array;
diff --git a/lib/fits.c b/lib/fits.c
index 6ccdae7..06f7381 100644
--- a/lib/fits.c
+++ b/lib/fits.c
@@ -1735,13 +1735,13 @@ gal_fits_img_info(fitsfile *fptr, int *type, size_t
*ndim, size_t **dsize,
CFITSIO. The way Gnuastro writes the FITS keywords, the output will
first have `BZERO', then `BSCALE', then `EXTNAME', then, `BUNIT'.*/
gal_list_data_add_alloc(&keysll, NULL, GAL_TYPE_STRING, 1, &dsize_key,
- NULL, 0, -1, "BUNIT", NULL, NULL);
+ NULL, 0, -1, 1, "BUNIT", NULL, NULL);
gal_list_data_add_alloc(&keysll, NULL, GAL_TYPE_STRING, 1, &dsize_key,
- NULL, 0, -1, "EXTNAME", NULL, NULL);
+ NULL, 0, -1, 1, "EXTNAME", NULL, NULL);
gal_list_data_add_alloc(&keysll, NULL, GAL_TYPE_FLOAT64, 1, &dsize_key,
- NULL, 0, -1, "BSCALE", NULL, NULL);
+ NULL, 0, -1, 1, "BSCALE", NULL, NULL);
gal_list_data_add_alloc(&keysll, NULL, GAL_TYPE_STRING, 1, &dsize_key,
- NULL, 0, -1, "BZERO", NULL, NULL);
+ NULL, 0, -1, 1, "BZERO", NULL, NULL);
gal_fits_key_read_from_ptr(fptr, keysll, 0, 0);
@@ -1813,7 +1813,8 @@ gal_fits_img_info_dim(char *filename, char *hdu, size_t
*ndim)
/* Read a FITS image HDU into a Gnuastro data structure. */
gal_data_t *
-gal_fits_img_read(char *filename, char *hdu, size_t minmapsize)
+gal_fits_img_read(char *filename, char *hdu, size_t minmapsize,
+ int quietmmap)
{
void *blank;
long *fpixel;
@@ -1856,7 +1857,7 @@ gal_fits_img_read(char *filename, char *hdu, size_t
minmapsize)
/* Allocate the space for the array and for the blank values. */
img=gal_data_alloc(NULL, type, ndim, dsize, NULL, 0, minmapsize,
- name, unit, NULL);
+ quietmmap, name, unit, NULL);
blank=gal_blank_alloc_write(type);
if(name) free(name);
if(unit) free(unit);
@@ -1889,12 +1890,12 @@ gal_fits_img_read(char *filename, char *hdu, size_t
minmapsize)
used to convert the input file to the desired type. */
gal_data_t *
gal_fits_img_read_to_type(char *inputname, char *hdu, uint8_t type,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
gal_data_t *in, *converted;
/* Read the specified input image HDU. */
- in=gal_fits_img_read(inputname, hdu, minmapsize);
+ in=gal_fits_img_read(inputname, hdu, minmapsize, quietmmap);
/* If the input had another type, convert it to float. */
if(in->type!=type)
@@ -1913,7 +1914,8 @@ gal_fits_img_read_to_type(char *inputname, char *hdu,
uint8_t type,
gal_data_t *
-gal_fits_img_read_kernel(char *filename, char *hdu, size_t minmapsize)
+gal_fits_img_read_kernel(char *filename, char *hdu, size_t minmapsize,
+ int quietmmap)
{
size_t i;
int check=0;
@@ -1923,7 +1925,7 @@ gal_fits_img_read_kernel(char *filename, char *hdu,
size_t minmapsize)
/* Read the image as a float and if it has a WCS structure, free it. */
kernel=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32,
- minmapsize);
+ minmapsize, quietmmap);
if(kernel->wcs) { wcsfree(kernel->wcs); kernel->wcs=NULL; }
/* Check if the size along each dimension of the kernel is an odd
@@ -2017,7 +2019,8 @@ gal_fits_img_write_to_ptr(gal_data_t *input, char
*filename)
{
/* Allocate the necessary space. */
i64data=gal_data_alloc(NULL, GAL_TYPE_INT64, ndim, towrite->dsize,
- NULL, 0, block->minmapsize, NULL, NULL, NULL);
+ NULL, 0, block->minmapsize, block->quietmmap,
+ NULL, NULL, NULL);
/* Copy the values while making the conversion. */
i64=i64data->array;
@@ -2666,7 +2669,8 @@ gal_fits_tab_info(char *filename, char *hdu, size_t
*numcols,
static void
fits_tab_read_ascii_float_special(char *filename, char *hdu, fitsfile *fptr,
gal_data_t *out, size_t colnum,
- size_t numrows, size_t minmapsize)
+ size_t numrows, size_t minmapsize,
+ int quietmmap)
{
double tmp;
char **strarr;
@@ -2677,7 +2681,7 @@ fits_tab_read_ascii_float_special(char *filename, char
*hdu, fitsfile *fptr,
/* Allocate the dataset to keep the string values. */
strrows=gal_data_alloc(NULL, GAL_TYPE_STRING, 1, &numrows, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
/* Allocate the space to keep the string values. */
strarr=strrows->array;
@@ -2724,7 +2728,7 @@ fits_tab_read_ascii_float_special(char *filename, char
*hdu, fitsfile *fptr,
gal_data_t *
gal_fits_tab_read(char *filename, char *hdu, size_t numrows,
gal_data_t *allcols, gal_list_sizet_t *indexll,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
size_t i=0;
void *blank;
@@ -2751,7 +2755,7 @@ gal_fits_tab_read(char *filename, char *hdu, size_t
numrows,
/* Allocate the necessary data structure (including the array)
for this column. */
gal_list_data_add_alloc(&out, NULL, allcols[ind->v].type, 1,
- &numrows, NULL, 0, minmapsize,
+ &numrows, NULL, 0, minmapsize, quietmmap,
allcols[ind->v].name, allcols[ind->v].unit,
allcols[ind->v].comment);
@@ -2804,7 +2808,7 @@ gal_fits_tab_read(char *filename, char *hdu, size_t
numrows,
{
fits_tab_read_ascii_float_special(filename, hdu, fptr, out,
ind->v+1, numrows,
- minmapsize);
+ minmapsize, quietmmap);
status=0;
}
@@ -2830,7 +2834,7 @@ gal_fits_tab_read(char *filename, char *hdu, size_t
numrows,
{
/* Do the allocation. */
gal_list_data_add_alloc(&out, NULL, allcols[ind->v].type, 1,
- &numrows, NULL, 0, minmapsize,
+ &numrows, NULL, 0, minmapsize, quietmmap,
allcols[ind->v].name, allcols[ind->v].unit,
allcols[ind->v].comment);
diff --git a/lib/gnuastro-internal/commonopts.h
b/lib/gnuastro-internal/commonopts.h
index cadd541..ff35933 100644
--- a/lib/gnuastro-internal/commonopts.h
+++ b/lib/gnuastro-internal/commonopts.h
@@ -351,6 +351,19 @@ struct argp_option gal_commonopts_options[] =
GAL_OPTIONS_NOT_SET
},
{
+ "quietmmap",
+ GAL_OPTIONS_KEY_QUIETMMAP,
+ 0,
+ 0,
+ "Don't print mmap'd file's name and size.",
+ GAL_OPTIONS_GROUP_OPERATING_MODE,
+ &cp->quietmmap,
+ GAL_OPTIONS_NO_ARG_TYPE,
+ GAL_OPTIONS_RANGE_0_OR_1,
+ GAL_OPTIONS_NOT_MANDATORY,
+ GAL_OPTIONS_NOT_SET
+ },
+ {
"log",
GAL_OPTIONS_KEY_LOG,
0,
diff --git a/lib/gnuastro-internal/options.h b/lib/gnuastro-internal/options.h
index ec5b4ed..64c4785 100644
--- a/lib/gnuastro-internal/options.h
+++ b/lib/gnuastro-internal/options.h
@@ -109,6 +109,7 @@ enum options_common_keys
/* Only long option (integers for keywords). */
GAL_OPTIONS_KEY_STDINTIMEOUT = 500,
GAL_OPTIONS_KEY_MINMAPSIZE,
+ GAL_OPTIONS_KEY_QUIETMMAP,
GAL_OPTIONS_KEY_LOG,
GAL_OPTIONS_KEY_CITE,
GAL_OPTIONS_KEY_CONFIG,
@@ -200,6 +201,7 @@ struct gal_options_common_params
uint8_t quiet; /* Only print errors. */
size_t numthreads; /* Number of threads to use. */
size_t minmapsize; /* Minimum bytes necessary to use mmap. */
+ uint8_t quietmmap; /* ==0: print mmap'd file name and size. */
uint8_t log; /* Make a log file. */
char *onlyversion; /* Redundant, kept/set for generality. */
diff --git a/lib/gnuastro/array.h b/lib/gnuastro/array.h
index dd43a8b..137d5bc 100644
--- a/lib/gnuastro/array.h
+++ b/lib/gnuastro/array.h
@@ -60,21 +60,21 @@ gal_array_name_recognized_multiext(char *name);
gal_data_t *
gal_array_read(char *filename, char *extension, gal_list_str_t *lines,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
gal_data_t *
gal_array_read_to_type(char *filename, char *extension,
gal_list_str_t *lines, uint8_t type,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
gal_data_t *
gal_array_read_one_ch(char *filename, char *extension, gal_list_str_t *lines,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
gal_data_t *
gal_array_read_one_ch_to_type(char *filename, char *extension,
gal_list_str_t *lines, uint8_t type,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
__END_C_DECLS /* From C++ preparations */
diff --git a/lib/gnuastro/data.h b/lib/gnuastro/data.h
index c81bcc2..048e05a 100644
--- a/lib/gnuastro/data.h
+++ b/lib/gnuastro/data.h
@@ -201,6 +201,7 @@ typedef struct gal_data_t
size_t ndim; /* Number of dimensions in the array. */
size_t *dsize; /* Size of array along each dimension. */
size_t size; /* Total number of data-elements. */
+ int quietmmap; /* ==1: print a notice whem mmap'ing. */
char *mmapname; /* File name of the mmap. */
size_t minmapsize; /* Minimum number of bytes to mmap the array. */
@@ -235,12 +236,13 @@ typedef struct gal_data_t
gal_data_t *
gal_data_alloc(void *array, uint8_t type, size_t ndim, size_t *dsize,
struct wcsprm *wcs, int clear, size_t minmapsize,
- char *name, char *unit, char *comment);
+ int quietmmap, char *name, char *unit, char *comment);
void
-gal_data_initialize(gal_data_t *data, void *array, uint8_t type, size_t ndim,
- size_t *dsize, struct wcsprm *wcs, int clear,
- size_t minmapsize, char *name, char *unit, char *comment);
+gal_data_initialize(gal_data_t *data, void *array, uint8_t type,
+ size_t ndim, size_t *dsize, struct wcsprm *wcs,
+ int clear, size_t minmapsize, int quietmmap,
+ char *name, char *unit, char *comment);
void
gal_data_free_contents(gal_data_t *data);
diff --git a/lib/gnuastro/fits.h b/lib/gnuastro/fits.h
index f25a997..b330baa 100644
--- a/lib/gnuastro/fits.h
+++ b/lib/gnuastro/fits.h
@@ -239,14 +239,15 @@ size_t *
gal_fits_img_info_dim(char *filename, char *hdu, size_t *ndim);
gal_data_t *
-gal_fits_img_read(char *filename, char *hdu, size_t minmapsize);
+gal_fits_img_read(char *filename, char *hdu, size_t minmapsize, int quietmmap);
gal_data_t *
gal_fits_img_read_to_type(char *inputname, char *hdu, uint8_t type,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
gal_data_t *
-gal_fits_img_read_kernel(char *filename, char *hdu, size_t minmapsize);
+gal_fits_img_read_kernel(char *filename, char *hdu, size_t minmapsize,
+ int quietmmap);
fitsfile *
gal_fits_img_write_to_ptr(gal_data_t *data, char *filename);
@@ -286,7 +287,7 @@ gal_fits_tab_info(char *filename, char *hdu, size_t
*numcols,
gal_data_t *
gal_fits_tab_read(char *filename, char *hdu, size_t numrows,
gal_data_t *colinfo, gal_list_sizet_t *indexll,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
void
gal_fits_tab_write(gal_data_t *cols, gal_list_str_t *comments,
diff --git a/lib/gnuastro/jpeg.h b/lib/gnuastro/jpeg.h
index 0a66267..9ab0cf4 100644
--- a/lib/gnuastro/jpeg.h
+++ b/lib/gnuastro/jpeg.h
@@ -61,7 +61,7 @@ int
gal_jpeg_suffix_is_jpeg(char *name);
gal_data_t *
-gal_jpeg_read(char *filename, size_t minmapsize);
+gal_jpeg_read(char *filename, size_t minmapsize, int quietmmap);
void
gal_jpeg_write(gal_data_t *in, char *filename, uint8_t quality,
diff --git a/lib/gnuastro/label.h b/lib/gnuastro/label.h
index 314a7f4..73299f9 100644
--- a/lib/gnuastro/label.h
+++ b/lib/gnuastro/label.h
@@ -60,7 +60,8 @@ __BEGIN_C_DECLS /* From C++ preparations */
/* Functions. */
gal_data_t *
-gal_label_indexs(gal_data_t *labels, size_t numlabs, size_t minmapsize);
+gal_label_indexs(gal_data_t *labels, size_t numlabs, size_t minmapsize,
+ int quietmmap);
size_t
gal_label_watershed(gal_data_t *values, gal_data_t *indexs,
diff --git a/lib/gnuastro/list.h b/lib/gnuastro/list.h
index 9a164c9..202cc8b 100644
--- a/lib/gnuastro/list.h
+++ b/lib/gnuastro/list.h
@@ -331,8 +331,8 @@ gal_list_data_add(gal_data_t **list, gal_data_t *newnode);
void
gal_list_data_add_alloc(gal_data_t **list, void *array, uint8_t type,
size_t ndim, size_t *dsize, struct wcsprm *wcs,
- int clear, size_t minmapsize, char *name,
- char *unit, char *comment);
+ int clear, size_t minmapsize, int quietmmap,
+ char *name, char *unit, char *comment);
gal_data_t *
gal_list_data_pop(gal_data_t **list);
diff --git a/lib/gnuastro/match.h b/lib/gnuastro/match.h
index cb3cf56..4804f16 100644
--- a/lib/gnuastro/match.h
+++ b/lib/gnuastro/match.h
@@ -47,7 +47,8 @@ along with Gnuastro. If not, see
<http://www.gnu.org/licenses/>.
gal_data_t *
gal_match_coordinates(gal_data_t *coord1, gal_data_t *coord2,
double *aperture, int sorted_by_first,
- int inplace, size_t minmapsize, size_t *nummatched);
+ int inplace, size_t minmapsize, int quietmmap,
+ size_t *nummatched);
diff --git a/lib/gnuastro/pointer.h b/lib/gnuastro/pointer.h
index 1a05e52..e3f6b6d 100644
--- a/lib/gnuastro/pointer.h
+++ b/lib/gnuastro/pointer.h
@@ -60,7 +60,7 @@ gal_pointer_allocate(uint8_t type, size_t size, int clear,
void *
gal_pointer_allocate_mmap(uint8_t type, size_t size, int clear,
- char **filename);
+ char **filename, int quiet);
diff --git a/lib/gnuastro/table.h b/lib/gnuastro/table.h
index bcb34f6..f0808f3 100644
--- a/lib/gnuastro/table.h
+++ b/lib/gnuastro/table.h
@@ -139,7 +139,7 @@ gal_table_print_info(gal_data_t *allcols, size_t numcols,
size_t numrows);
gal_data_t *
gal_table_read(char *filename, char *hdu, gal_list_str_t *lines,
gal_list_str_t *cols, int searchin, int ignorecase,
- size_t minmapsize, size_t *colmatch);
+ size_t minmapsize, int quietmmap, size_t *colmatch);
gal_list_sizet_t *
gal_table_list_of_indexs(gal_list_str_t *cols, gal_data_t *allcols,
diff --git a/lib/gnuastro/tiff.h b/lib/gnuastro/tiff.h
index 2b953b4..aba3379 100644
--- a/lib/gnuastro/tiff.h
+++ b/lib/gnuastro/tiff.h
@@ -64,7 +64,7 @@ size_t
gal_tiff_dir_string_read(char *string);
gal_data_t *
-gal_tiff_read(char *filename, size_t dir, size_t minmapsize);
+gal_tiff_read(char *filename, size_t dir, size_t minmapsize, int quietmmap);
diff --git a/lib/gnuastro/txt.h b/lib/gnuastro/txt.h
index 8371fb8..6e7f38b 100644
--- a/lib/gnuastro/txt.h
+++ b/lib/gnuastro/txt.h
@@ -89,10 +89,11 @@ gal_txt_image_info(char *filename, gal_list_str_t *lines,
size_t *numimg,
gal_data_t *
gal_txt_table_read(char *filename, gal_list_str_t *lines, size_t numrows,
gal_data_t *colinfo, gal_list_sizet_t *indexll,
- size_t minmapsize);
+ size_t minmapsize, int quietmmap);
gal_data_t *
-gal_txt_image_read(char *filename, gal_list_str_t *lines, size_t minmapsize);
+gal_txt_image_read(char *filename, gal_list_str_t *lines, size_t minmapsize,
+ int quietmmap);
gal_list_str_t *
gal_txt_stdin_read(long timeout_microsec);
diff --git a/lib/gnuastro/type.h b/lib/gnuastro/type.h
index 195cfce..e43661b 100644
--- a/lib/gnuastro/type.h
+++ b/lib/gnuastro/type.h
@@ -113,6 +113,14 @@ enum gal_types
#define GAL_TYPE_ULONG GAL_TYPE_UINT64
#endif
+#if GAL_CONFIG_SIZEOF_INT == 2
+#define GAL_TYPE_INT GAL_TYPE_INT16
+#define GAL_TYPE_UINT GAL_TYPE_UINT16
+#elif GAL_CONFIG_SIZEOF_INT == 4
+#define GAL_TYPE_INT GAL_TYPE_INT32
+#define GAL_TYPE_UINT GAL_TYPE_UINT32
+#endif
+
diff --git a/lib/interpolate.c b/lib/interpolate.c
index bdc4f50..ffeacb3 100644
--- a/lib/interpolate.c
+++ b/lib/interpolate.c
@@ -120,7 +120,7 @@ interpolate_close_neighbors_on_thread(void *in_prm)
nv=gal_pointer_increment(tvll->v, tprm->id*prm->numneighbors,
input->type);
gal_list_data_add_alloc(&nearest, nv, tin->type, 1, &prm->numneighbors,
- NULL, 0, -1, NULL, NULL, NULL);
+ NULL, 0, -1, 1, NULL, NULL, NULL);
tin=tin->next;
}
gal_list_data_reverse(&nearest);
@@ -396,8 +396,8 @@ gal_interpolate_close_neighbors(gal_data_t *input,
/* Allocate space for the (first) output. */
prm.out=gal_data_alloc(NULL, input->type, input->ndim, input->dsize,
- input->wcs, 0, input->minmapsize, NULL,
- input->unit, NULL);
+ input->wcs, 0, input->minmapsize,
+ input->quietmmap, NULL, input->unit, NULL);
gal_list_void_add(&prm.ngb_vals,
gal_pointer_allocate(input->type, ngbvnum, 0, __func__,
"prm.ngb_vals"));
@@ -419,7 +419,7 @@ gal_interpolate_close_neighbors(gal_data_t *input,
/* Allocate the output array for this node. */
gal_list_data_add_alloc(&prm.out, NULL, tin->type, tin->ndim,
tin->dsize, tin->wcs, 0, tin->minmapsize,
- NULL, tin->unit, NULL);
+ tin->quietmmap, NULL, tin->unit, NULL);
/* Allocate the space for the neighbor values of this input. */
gal_list_void_add(&prm.ngb_vals,
@@ -556,7 +556,7 @@ gal_interpolate_1d_make_gsl_spline(gal_data_t *X,
gal_data_t *Y, int type_1d)
? gal_data_copy_to_new_type(X, GAL_TYPE_FLOAT64)
: X )
: gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, Y->dsize, NULL,
- 0, -1, NULL, NULL, NULL) );
+ 0, -1, 1, NULL, NULL, NULL) );
/* Fill in the X axis values while also removing NaN/blank elements. */
c=0;
diff --git a/lib/jpeg.c b/lib/jpeg.c
index 2e86e60..9d41b07 100644
--- a/lib/jpeg.c
+++ b/lib/jpeg.c
@@ -255,7 +255,7 @@ readjpg(char *inname, size_t *outs0, size_t *outs1, size_t
*numcolors)
/* Read each color channel of a JPEG image as a separate array and put them
in a linked list of data-structures. */
gal_data_t *
-gal_jpeg_read(char *filename, size_t minmapsize)
+gal_jpeg_read(char *filename, size_t minmapsize, int quietmmap)
{
#ifdef HAVE_LIBJPEG
char *name;
@@ -275,7 +275,8 @@ gal_jpeg_read(char *filename, size_t minmapsize)
if( asprintf(&name, "JPEG_CH_%zu", i+1)<0 )
error(EXIT_FAILURE, 0, "%s: asprintf allocation", __func__);
gal_list_data_add_alloc(&out, allcolors[i], GAL_TYPE_UINT8, ndim,
- dsize, NULL, 0, minmapsize, name, NULL, NULL);
+ dsize, NULL, 0, minmapsize, quietmmap,
+ name, NULL, NULL);
free(name);
}
diff --git a/lib/label.c b/lib/label.c
index f22c564..b6f16a6 100644
--- a/lib/label.c
+++ b/lib/label.c
@@ -85,7 +85,8 @@ label_check_type(gal_data_t *in, uint8_t needed_type, char
*variable,
(where each element is a dataset containing the respective label's
indexs). */
gal_data_t *
-gal_label_indexs(gal_data_t *labels, size_t numlabs, size_t minmapsize)
+gal_label_indexs(gal_data_t *labels, size_t numlabs, size_t minmapsize,
+ int quietmmap)
{
size_t i, *areas;
int32_t *a, *l, *lf;
@@ -127,7 +128,8 @@ gal_label_indexs(gal_data_t *labels, size_t numlabs, size_t
minmapsize)
(areas[0]). So we'll set that to zero.*/
for(i=1;i<numlabs+1;++i)
gal_data_initialize(&labindexs[i], NULL, GAL_TYPE_SIZE_T, 1,
- &areas[i], NULL, 0, minmapsize, NULL, NULL, NULL);
+ &areas[i], NULL, 0, minmapsize, quietmmap,
+ NULL, NULL, NULL);
/* Put the indexs into each dataset. We will use the areas array again,
but this time, use it as a counter. */
diff --git a/lib/list.c b/lib/list.c
index c28b845..fc4be54 100644
--- a/lib/list.c
+++ b/lib/list.c
@@ -1302,14 +1302,14 @@ gal_list_data_add(gal_data_t **list, gal_data_t
*newnode)
void
gal_list_data_add_alloc(gal_data_t **list, void *array, uint8_t type,
size_t ndim, size_t *dsize, struct wcsprm *wcs,
- int clear, size_t minmapsize, char *name,
- char *unit, char *comment)
+ int clear, size_t minmapsize, int quietmmap,
+ char *name, char *unit, char *comment)
{
gal_data_t *newnode;
/* Put all the input information into a new data structure node. */
newnode=gal_data_alloc(array, type, ndim, dsize, wcs, clear,
- minmapsize, name, unit, comment);
+ minmapsize, quietmmap, name, unit, comment);
/* Add the new node to the list. */
gal_list_data_add(list, newnode);
diff --git a/lib/match.c b/lib/match.c
index 5a7d42c..da59e41 100644
--- a/lib/match.c
+++ b/lib/match.c
@@ -619,7 +619,7 @@ static gal_data_t *
gal_match_coordinates_output(gal_data_t *A, gal_data_t *B, size_t *A_perm,
size_t *B_perm,
struct match_coordinate_sfll **bina,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
float r;
double *rval;
@@ -638,14 +638,15 @@ gal_match_coordinates_output(gal_data_t *A, gal_data_t
*B, size_t *A_perm,
/* Allocate the output list. */
out=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, &A->size, NULL, 0,
- minmapsize, "CAT1_ROW", "counter",
+ minmapsize, quietmmap, "CAT1_ROW", "counter",
"Row index in first catalog (counting from 0).");
out->next=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, &B->size, NULL, 0,
- minmapsize, "CAT2_ROW", "counter",
+ minmapsize, quietmmap, "CAT2_ROW", "counter",
"Row index in second catalog (counting "
"from 0).");
out->next->next=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &nummatched,
- NULL, 0, minmapsize, "MATCH_DIST", NULL,
+ NULL, 0, minmapsize, quietmmap,
+ "MATCH_DIST", NULL,
"Distance between the match.");
@@ -756,7 +757,8 @@ gal_match_coordinates_output(gal_data_t *A, gal_data_t *B,
size_t *A_perm,
gal_data_t *
gal_match_coordinates(gal_data_t *coord1, gal_data_t *coord2,
double *aperture, int sorted_by_first,
- int inplace, size_t minmapsize, size_t *nummatched)
+ int inplace, size_t minmapsize, int quietmmap,
+ size_t *nummatched)
{
int allf64=1;
gal_data_t *A, *B, *out;
@@ -791,7 +793,8 @@ gal_match_coordinates(gal_data_t *coord1, gal_data_t
*coord2,
/* The match is done, write the output. */
- out=gal_match_coordinates_output(A, B, A_perm, B_perm, bina, minmapsize);
+ out=gal_match_coordinates_output(A, B, A_perm, B_perm, bina, minmapsize,
+ quietmmap);
/* Clean up. */
diff --git a/lib/options.c b/lib/options.c
index 71bbd40..1103723 100644
--- a/lib/options.c
+++ b/lib/options.c
@@ -578,6 +578,7 @@ gal_options_parse_list_of_numbers(char *string, char
*filename, size_t lineno)
/* The nature of the arrays/numbers read here is very small, so since
`p->cp.minmapsize' might not have been read yet, we will set it to -1
(largest size_t number), so the values are kept in memory. */
+ int quietmmap=1;
size_t minmapsize=-1;
/* If we have an empty string, just return NULL. */
@@ -666,7 +667,7 @@ gal_options_parse_list_of_numbers(char *string, char
*filename, size_t lineno)
{
i=num;
out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &num, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
for(tdll=list;tdll!=NULL;tdll=tdll->next)
((double *)(out->array))[--i]=tdll->v;
}
@@ -677,7 +678,7 @@ gal_options_parse_list_of_numbers(char *string, char
*filename, size_t lineno)
we'll allocate space for one element, then free it. */
i=1;
out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &i, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
out->size=out->dsize[0]=0;
free(out->array);
out->array=NULL;
@@ -709,6 +710,7 @@ gal_options_parse_csv_strings_raw(char *string, char
*filename, size_t lineno)
/* The nature of the arrays/numbers read here is very small, so since
`p->cp.minmapsize' might not have been read yet, we will set it to -1
(largest size_t number), so the values are kept in memory. */
+ int quietmmap=1;
size_t minmapsize=-1;
@@ -749,7 +751,7 @@ gal_options_parse_csv_strings_raw(char *string, char
*filename, size_t lineno)
{
i=num=gal_list_str_number(list);
out=gal_data_alloc(NULL, GAL_TYPE_STRING, 1, &num, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
for(tstrll=list;tstrll!=NULL;tstrll=tstrll->next)
((char **)(out->array))[--i]=tstrll->v;
}
@@ -760,7 +762,7 @@ gal_options_parse_csv_strings_raw(char *string, char
*filename, size_t lineno)
we'll allocate space for one element, then free it. */
i=1;
out=gal_data_alloc(NULL, GAL_TYPE_STRING, 1, &i, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
out->size=out->dsize[0]=0;
free(out->array);
out->array=NULL;
@@ -1213,7 +1215,7 @@ options_sanity_check(struct argp_option *option, char
*arg,
/* Put the option value into a data structure. */
value=gal_data_alloc(option->value, option->type, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
/* Set the operator(s) and operands: */
switch(option->range)
@@ -1222,7 +1224,7 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GT_0:
message="greater than zero";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
operator1=GAL_ARITHMETIC_OP_GT;
ref2=NULL;
@@ -1232,7 +1234,7 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GE_0:
message="greater or equal to zero";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
operator1=GAL_ARITHMETIC_OP_GE;
ref2=NULL;
@@ -1242,9 +1244,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_0_OR_1:
message="either 0 or 1";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=1;
@@ -1257,9 +1259,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GE_0_LE_1:
message="between zero and one (inclusive)";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=1;
@@ -1272,9 +1274,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GE_0_LT_1:
message="between zero (inclusive) and one (exclusive)";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=1;
@@ -1287,9 +1289,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GT_0_LT_1:
message="between zero and one (not inclusive)";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=1;
@@ -1302,9 +1304,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_GT_0_ODD:
message="greater than zero and odd";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=2;
@@ -1316,9 +1318,9 @@ options_sanity_check(struct argp_option *option, char
*arg,
case GAL_OPTIONS_RANGE_0_OR_ODD:
message="greater than, or equal to, zero and odd";
ref1=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
ref2=gal_data_alloc(NULL, GAL_TYPE_UINT8, 1, &dsize, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
*(unsigned char *)(ref1->array)=0;
*(unsigned char *)(ref2->array)=2;
diff --git a/lib/pointer.c b/lib/pointer.c
index c467217..183e924 100644
--- a/lib/pointer.c
+++ b/lib/pointer.c
@@ -106,7 +106,7 @@ gal_pointer_allocate(uint8_t type, size_t size, int clear,
void *
gal_pointer_allocate_mmap(uint8_t type, size_t size, int clear,
- char **filename)
+ char **filename, int quietmmap)
{
void *out;
int filedes;
@@ -159,6 +159,12 @@ gal_pointer_allocate_mmap(uint8_t type, size_t size, int
clear,
"%zu bytes", __func__, *filename, bsize);
+ /* Inform the user. */
+ if(!quietmmap)
+ error(EXIT_SUCCESS, 0, "%s: temporary %zu byte file (consider "
+ "`--minmapsize')", *filename, bsize);
+
+
/* Write to the newly set file position so the space is allocated. To do
this, we are simply writing `uc' (a byte with value 0) into the space
we identified by `lseek' (above). This will ensure that this space is
diff --git a/lib/statistics.c b/lib/statistics.c
index e6e6024..6a400e3 100644
--- a/lib/statistics.c
+++ b/lib/statistics.c
@@ -61,7 +61,7 @@ gal_statistics_number(gal_data_t *input)
{
size_t counter=0, dsize=1;
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* If there is no blank values in the input, then the total number is
just the size. */
@@ -86,7 +86,7 @@ gal_statistics_minimum(gal_data_t *input)
{
size_t dsize=1, n=0;
gal_data_t *out=gal_data_alloc(NULL, gal_tile_block(input)->type, 1,
- &dsize, NULL, 1, -1, NULL, NULL, NULL);
+ &dsize, NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
@@ -116,7 +116,7 @@ gal_statistics_maximum(gal_data_t *input)
{
size_t dsize=1, n=0;
gal_data_t *out=gal_data_alloc(NULL, gal_tile_block(input)->type, 1,
- &dsize, NULL, 1, -1, NULL, NULL, NULL);
+ &dsize, NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
{
@@ -145,7 +145,7 @@ gal_statistics_sum(gal_data_t *input)
{
size_t dsize=1, n=0;
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
@@ -170,7 +170,7 @@ gal_statistics_mean(gal_data_t *input)
{
size_t dsize=1, n=0;
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
@@ -198,7 +198,7 @@ gal_statistics_std(gal_data_t *input)
size_t dsize=1, n=0;
double s=0.0f, s2=0.0f;
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
@@ -223,7 +223,7 @@ gal_statistics_mean_std(gal_data_t *input)
size_t dsize=2, n=0;
double s=0.0f, s2=0.0f;
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* See if the input actually has any elements. */
if(input->size)
/* Parse the input. */
@@ -287,7 +287,7 @@ gal_statistics_median(gal_data_t *input, int inplace)
size_t dsize=1;
gal_data_t *nbs=gal_statistics_no_blank_sorted(input, inplace);;
gal_data_t *out=gal_data_alloc(NULL, nbs->type, 1, &dsize, NULL, 1, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
/* Write the median. */
if(nbs->size)
@@ -349,7 +349,7 @@ gal_statistics_quantile(gal_data_t *input, double quantile,
int inplace)
size_t dsize=1, index;
gal_data_t *nbs=gal_statistics_no_blank_sorted(input, inplace);
gal_data_t *out=gal_data_alloc(NULL, nbs->type, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* Only continue processing if there are non-blank elements. */
if(nbs->size)
@@ -492,7 +492,7 @@ gal_statistics_quantile_function(gal_data_t *input,
gal_data_t *value,
size_t dsize=1;
gal_data_t *nbs=gal_statistics_no_blank_sorted(input, inplace);
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
size_t ind=gal_statistics_quantile_function_index(input, value, inplace);
/* Only continue processing if there are non-blank values. */
@@ -952,12 +952,12 @@ gal_statistics_mode(gal_data_t *input, float mirrordist,
int inplace)
size_t dsize=4, mdsize=1;
struct statistics_mode_params p;
int type=gal_tile_block(input)->type;
- gal_data_t *tmptype=gal_data_alloc(NULL, type, 1, &mdsize, NULL, 1, -1,
+ gal_data_t *tmptype=gal_data_alloc(NULL, type, 1, &mdsize, NULL, 1, -1, 1,
NULL, NULL, NULL);
- gal_data_t *b_val=gal_data_alloc(NULL, type, 1, &mdsize, NULL, 1, -1,
+ gal_data_t *b_val=gal_data_alloc(NULL, type, 1, &mdsize, NULL, 1, -1, 1,
NULL, NULL, NULL);
gal_data_t *out=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* A small sanity check. */
@@ -1063,7 +1063,7 @@ statistics_make_mirror(gal_data_t *noblank_sorted, size_t
index,
{
size_t i, dsize = 2*index+1;
gal_data_t *mirror=gal_data_alloc(NULL, noblank_sorted->type, 1, &dsize,
- NULL, 1, -1, NULL, NULL, NULL);
+ NULL, 1, -1, 1, NULL, NULL, NULL);
/* Make sure the index is less than or equal to the number of
elements. */
@@ -1427,7 +1427,8 @@ gal_statistics_no_blank_sorted(gal_data_t *input, int
inplace)
sorted = ( inplace
? input
: gal_data_alloc(NULL, input->type, 0, NULL, input->wcs, 0,
- input->minmapsize, NULL, NULL, NULL) );
+ input->minmapsize, input->quietmmap,
+ NULL, NULL, NULL) );
/* Set the blank and sorted flags if the dataset has zero-elements. Even
if having blank values or being sorted is not defined on a
@@ -1582,8 +1583,8 @@ gal_statistics_regular_bins(gal_data_t *input, gal_data_t
*inrange,
/* Allocate the space for the bins. */
bins=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &numbins, NULL,
- 0, input->minmapsize, "bin_center", input->unit,
- "Center value of each bin.");
+ 0, input->minmapsize, input->quietmmap, "bin_center",
+ input->unit, "Center value of each bin.");
/* Set central bin values. */
@@ -1677,7 +1678,8 @@ gal_statistics_histogram(gal_data_t *input, gal_data_t
*bins, int normalize,
/* Allocate the histogram (note that we are clearning it so all values
are zero. */
hist=gal_data_alloc(NULL, GAL_TYPE_SIZE_T, bins->ndim, bins->dsize,
- NULL, 1, input->minmapsize, "hist_number", "counts",
+ NULL, 1, input->minmapsize, input->quietmmap,
+ "hist_number", "counts",
"Number of data points within each bin.");
@@ -1817,7 +1819,7 @@ gal_statistics_cfp(gal_data_t *input, gal_data_t *bins,
int normalize)
/* Allocate the cumulative frequency plot's necessary space. */
cfp=gal_data_alloc( NULL, hist->type, bins->ndim, bins->dsize,
- NULL, 1, input->minmapsize,
+ NULL, 1, input->minmapsize, input->quietmmap,
( hist->type==GAL_TYPE_FLOAT32
? "cfp_normalized" : "cfp_number" ),
( hist->type==GAL_TYPE_FLOAT32
@@ -1983,9 +1985,9 @@ gal_statistics_sigma_clip(gal_data_t *input, float
multip, float param,
/* Allocate the necessary spaces. */
out=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, 1, &four, NULL, 0,
- input->minmapsize, NULL, NULL, NULL);
+ input->minmapsize, input->quietmmap, NULL, NULL, NULL);
median_i=gal_data_alloc(NULL, type, 1, &one, NULL, 0, input->minmapsize,
- NULL, NULL, NULL);
+ input->quietmmap, NULL, NULL, NULL);
/* Only continue processing if we have non-blank elements. */
@@ -2134,7 +2136,7 @@ gal_statistics_sigma_clip(gal_data_t *input, float
multip, float param,
{ \
/* Allocate the output dataset. */ \
out=gal_data_alloc(NULL, input->type, 1, &one, NULL, 0, -1, \
- NULL, NULL, NULL); \
+ 1, NULL, NULL, NULL); \
\
/* Write the outlier, clean up and break. */ \
*(IT *)(out->array)=arr[i-1]; \
@@ -2180,7 +2182,7 @@ gal_statistics_outlier_positive(gal_data_t *input, size_t
window_size,
/* Allocate space to keep the distances. */
wtakeone=window_size-1;
dist=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &wtakeone, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
darr=dist->array;
/* Find the outlier based on the type of the input dataset. */
@@ -2300,7 +2302,7 @@ gal_statistics_outlier_flat_cfp(gal_data_t *input, size_t
numprev,
/* Keep previous slopes. */
prev=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &numprev, NULL, 0, -1,
- NULL, NULL, NULL);
+ 1, NULL, NULL, NULL);
/* Find the index where the distribution becomes sufficiently flat. */
switch(nbs->type)
@@ -2324,7 +2326,7 @@ gal_statistics_outlier_flat_cfp(gal_data_t *input, size_t
numprev,
NULL. */
if(flatind!=GAL_BLANK_SIZE_T)
{
- out=gal_data_alloc(NULL, input->type, 1, &one, NULL, 0, -1,
+ out=gal_data_alloc(NULL, input->type, 1, &one, NULL, 0, -1, 1,
NULL, NULL, NULL);
memcpy(out->array,
gal_pointer_increment(nbs->array, flatind, nbs->type),
diff --git a/lib/table.c b/lib/table.c
index d6d82ce..b653267 100644
--- a/lib/table.c
+++ b/lib/table.c
@@ -410,7 +410,7 @@ gal_table_list_of_indexs(gal_list_str_t *cols, gal_data_t
*allcols,
gal_data_t *
gal_table_read(char *filename, char *hdu, gal_list_str_t *lines,
gal_list_str_t *cols, int searchin, int ignorecase,
- size_t minmapsize, size_t *colmatch)
+ size_t minmapsize, int quietmmap, size_t *colmatch)
{
int tableformat;
gal_list_sizet_t *indexll;
@@ -442,13 +442,13 @@ gal_table_read(char *filename, char *hdu, gal_list_str_t
*lines,
{
case GAL_TABLE_FORMAT_TXT:
out=gal_txt_table_read(filename, lines, numrows, allcols, indexll,
- minmapsize);
+ minmapsize, quietmmap);
break;
case GAL_TABLE_FORMAT_AFITS:
case GAL_TABLE_FORMAT_BFITS:
out=gal_fits_tab_read(filename, hdu, numrows, allcols, indexll,
- minmapsize);
+ minmapsize, quietmmap);
break;
default:
diff --git a/lib/tiff.c b/lib/tiff.c
index a853746..d688dce 100644
--- a/lib/tiff.c
+++ b/lib/tiff.c
@@ -379,7 +379,7 @@ tiff_read_separate_strip_data(TIFF* tif, char *filename,
size_t dir,
the rows */
static gal_data_t *
tiff_separate_channels_reverse(gal_data_t *out, size_t numch,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
size_t k, l, i, j;
gal_data_t *tch, *ch=NULL;
@@ -397,7 +397,7 @@ tiff_separate_channels_reverse(gal_data_t *out, size_t
numch,
out->dsize[1] /= numch;
for(k=0; k<numch; ++k)
gal_list_data_add_alloc(&ch, NULL, out->type, out->ndim, out->dsize,
- NULL, 0, minmapsize, NULL, NULL, NULL);
+ NULL, 0, minmapsize, quietmmap, NULL, NULL, NULL);
out->dsize[1] *= numch;
@@ -491,7 +491,8 @@ tiff_reverse_rows(gal_data_t *out)
/* Read the data following the `TIFFReadData' of Libtiff's
`tools/tiffinfo.c' in the libtiff source code. */
static gal_data_t *
-tiff_img_read(TIFF *tif, char *filename, size_t dir, size_t minmapsize)
+tiff_img_read(TIFF *tif, char *filename, size_t dir, size_t minmapsize,
+ int quietmmap)
{
uint8_t type;
uint16_t config;
@@ -512,12 +513,12 @@ tiff_img_read(TIFF *tif, char *filename, size_t dir,
size_t minmapsize)
channels to keep the contiguous color information in one array. */
dsize[ndim-1] *= numch;
out=gal_data_alloc(NULL, type, ndim, dsize, NULL, 0, minmapsize,
- NULL, NULL, NULL);
+ quietmmap, NULL, NULL, NULL);
}
else
for(i=0; i<numch; ++i)
gal_list_data_add_alloc(&out, NULL, type, ndim, dsize, NULL, 0,
- minmapsize, NULL, NULL, NULL);
+ minmapsize, quietmmap, NULL, NULL, NULL);
/* The reading of the dataset depends on how it is organized, so first
@@ -550,7 +551,7 @@ tiff_img_read(TIFF *tif, char *filename, size_t dir, size_t
minmapsize)
separated, we just need to reverse them.*/
if( numch>1 && config==PLANARCONFIG_CONTIG )
{
- sep=tiff_separate_channels_reverse(out, numch, minmapsize);
+ sep=tiff_separate_channels_reverse(out, numch, minmapsize, quietmmap);
gal_data_free(out);
out=sep;
}
@@ -568,7 +569,7 @@ tiff_img_read(TIFF *tif, char *filename, size_t dir, size_t
minmapsize)
gal_data_t *
-gal_tiff_read(char *filename, size_t dir, size_t minmapsize)
+gal_tiff_read(char *filename, size_t dir, size_t minmapsize, int quietmmap)
{
#ifdef HAVE_LIBTIFF
TIFF *tif;
@@ -601,7 +602,7 @@ gal_tiff_read(char *filename, size_t dir, size_t minmapsize)
}
/* Read the image. */
- out=tiff_img_read(tif, filename, dir, minmapsize);
+ out=tiff_img_read(tif, filename, dir, minmapsize, quietmmap);
/* Close file, clean up and return. */
TIFFClose(tif);
diff --git a/lib/tile.c b/lib/tile.c
index 94a55bc..ad827cf 100644
--- a/lib/tile.c
+++ b/lib/tile.c
@@ -441,8 +441,9 @@ gal_tile_block_write_const_value(gal_data_t *tilevalues,
gal_data_t *tilesll,
/* Allocate the output array. */
tofill=gal_data_alloc(NULL, type, block->ndim, block->dsize, block->wcs,
- 0, block->minmapsize, tilevalues->name,
- tilevalues->unit, tilevalues->comment);
+ 0, block->minmapsize, block->quietmmap,
+ tilevalues->name, tilevalues->unit,
+ tilevalues->comment);
/* If requested, initialize `tofill', otherwise it is assumed that the
full area of the output is covered by the tiles. */
@@ -494,7 +495,8 @@ gal_tile_block_check_tiles(gal_data_t *tilesll)
/* Allocate the array to keep the IDs of each tile. */
ids=gal_data_alloc(NULL, GAL_TYPE_INT32, 1, &dsize,
- NULL, 0, block->minmapsize, NULL, NULL, NULL);
+ NULL, 0, block->minmapsize, block->quietmmap,
+ NULL, NULL, NULL);
/* Put the IDs into the array. */
arr=ids->array; for(i=0;i<dsize;++i) arr[i]=i;
@@ -1169,7 +1171,7 @@ gal_tile_full_values_smooth(gal_data_t *tilevalues,
/* Make the kernel. */
kernel=gal_data_alloc(NULL, GAL_TYPE_FLOAT32, tilevalues->ndim,
- kdsize, NULL, 0, -1, NULL, NULL, NULL);
+ kdsize, NULL, 0, -1, 1, NULL, NULL, NULL);
knum=gal_dimension_total_size(tl->ndim, kernel->dsize);
for(i=0;i<knum;++i) ((float *)(kernel->array))[i]=1/((double)knum);
diff --git a/lib/txt.c b/lib/txt.c
index 96d2027..d9182ba 100644
--- a/lib/txt.c
+++ b/lib/txt.c
@@ -274,8 +274,9 @@ txt_info_from_comment(char *in_line, gal_data_t **datall,
char *comm_start,
into the array by `gal_table_read_blank'. To keep the name, unit,
and comment strings, trim the white space before and after each
before using them here. */
- gal_list_data_add_alloc(datall, NULL, type, 0, NULL, NULL, 0, -1, name,
- txt_trim_space(unit), txt_trim_space(comment) );
+ gal_list_data_add_alloc(datall, NULL, type, 0, NULL, NULL, 0, -1, 1,
+ name, txt_trim_space(unit),
+ txt_trim_space(comment) );
/* Put the number of this column into the status variable of the data
@@ -406,7 +407,7 @@ txt_info_from_first_row(char *in_line, gal_data_t **datall,
int format,
if( *datall==NULL || format==TXT_FORMAT_TABLE )
{
gal_list_data_add_alloc(datall, NULL, GAL_TYPE_FLOAT64, 0,
- NULL, NULL, 0, -1, NULL, NULL, NULL);
+ NULL, NULL, 0, -1, 1, NULL, NULL, NULL);
(*datall)->status=n;
}
}
@@ -926,7 +927,7 @@ txt_fill(char *in_line, char **tokens, size_t maxcolnum,
gal_data_t *info,
static gal_data_t *
txt_read(char *filename, gal_list_str_t *lines, size_t *dsize,
gal_data_t *info, gal_list_sizet_t *indexll, size_t minmapsize,
- int format)
+ int quietmmap, int format)
{
FILE *fp;
int test;
@@ -971,8 +972,8 @@ txt_read(char *filename, gal_list_str_t *lines, size_t
*dsize,
maxcolnum = maxcolnum>ind->v+1 ? maxcolnum : ind->v+1;
gal_list_data_add_alloc(&out, NULL, info[ind->v].type, ndim,
dsize[0]?dsize:&one, NULL, 0, minmapsize,
- info[ind->v].name, info[ind->v].unit,
- info[ind->v].comment);
+ quietmmap, info[ind->v].name,
+ info[ind->v].unit, info[ind->v].comment);
out->disp_width=info[ind->v].disp_width;
out->status=ind->v+1;
@@ -998,7 +999,7 @@ txt_read(char *filename, gal_list_str_t *lines, size_t
*dsize,
ndim=2;
maxcolnum=dsize[1];
out=gal_data_alloc(NULL, info->type, ndim, dsize, NULL, 0, minmapsize,
- info->name, info->unit, info->comment);
+ quietmmap, info->name, info->unit, info->comment);
break;
@@ -1065,10 +1066,10 @@ txt_read(char *filename, gal_list_str_t *lines, size_t
*dsize,
gal_data_t *
gal_txt_table_read(char *filename, gal_list_str_t *lines, size_t numrows,
gal_data_t *colinfo, gal_list_sizet_t *indexll,
- size_t minmapsize)
+ size_t minmapsize, int quietmmap)
{
return txt_read(filename, lines, &numrows, colinfo, indexll, minmapsize,
- TXT_FORMAT_TABLE);
+ quietmmap, TXT_FORMAT_TABLE);
}
@@ -1076,7 +1077,8 @@ gal_txt_table_read(char *filename, gal_list_str_t *lines,
size_t numrows,
gal_data_t *
-gal_txt_image_read(char *filename, gal_list_str_t *lines, size_t minmapsize)
+gal_txt_image_read(char *filename, gal_list_str_t *lines, size_t minmapsize,
+ int quietmmap)
{
size_t numimg, dsize[2];
gal_data_t *img, *imginfo;
@@ -1087,7 +1089,7 @@ gal_txt_image_read(char *filename, gal_list_str_t *lines,
size_t minmapsize)
/* Read the table. */
img=txt_read(filename, lines, dsize, imginfo, indexll, minmapsize,
- TXT_FORMAT_IMAGE);
+ quietmmap, TXT_FORMAT_IMAGE);
/* Clean up and return. */
gal_data_free(imginfo);
diff --git a/lib/wcs.c b/lib/wcs.c
index 9e3c00c..8ca6cf6 100644
--- a/lib/wcs.c
+++ b/lib/wcs.c
@@ -670,7 +670,7 @@ gal_wcs_pixel_scale(struct wcsprm *wcs)
permutation=gal_pointer_allocate(GAL_TYPE_SIZE_T, n, 0, __func__,
"permutation");
pixscale=gal_data_alloc(NULL, GAL_TYPE_FLOAT64, 1, &n, NULL,
- 0, -1, NULL, NULL, NULL);
+ 0, -1, 1, NULL, NULL, NULL);
/* To avoid confusing issues with floating point errors being written in
@@ -943,7 +943,8 @@ wcs_convert_prepare_out(gal_data_t *coords, struct wcsprm
*wcs, int inplace)
for(i=0;i<wcs->naxis;++i)
gal_list_data_add_alloc(&out, NULL, GAL_TYPE_FLOAT64, 1,
&coords->size, NULL, 0, coords->minmapsize,
- wcs->ctype[i], wcs->cunit[i], NULL);
+ coords->quietmmap, wcs->ctype[i], wcs->cunit[i],
+ NULL);
return out;
}
diff --git a/tests/buildprog/simpleio.c b/tests/buildprog/simpleio.c
index 60ed624..cff53f3 100644
--- a/tests/buildprog/simpleio.c
+++ b/tests/buildprog/simpleio.c
@@ -39,7 +39,7 @@ main(int argc, char *argv[])
}
/* Read the image into memory. */
- image=gal_fits_img_read(argv[1], argv[2], -1);
+ image=gal_fits_img_read(argv[1], argv[2], -1, 1);
/* Let the user know. */
printf("%s (hdu %s) is read into memory.\n", argv[1], argv[2]);
diff --git a/tests/lib/multithread.c b/tests/lib/multithread.c
index 646c61d..1bb9113 100644
--- a/tests/lib/multithread.c
+++ b/tests/lib/multithread.c
@@ -95,7 +95,7 @@ main(void)
/* Read the image into memory as a float32 data type. */
- p.image=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32, -1);
+ p.image=gal_fits_img_read_to_type(filename, hdu, GAL_TYPE_FLOAT32, -1, 1);
/* Print some basic information before the actual contents: */
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [gnuastro-commits] master a0b094b: Library (pointer.h): message when creating/deleting mmap'd file,
Mohammad Akhlaghi <=