debug.c 17 KB
Newer Older
1
2
/*******************************************************************************
 * This file is part of SWIFT.
Peter W. Draper's avatar
Peter W. Draper committed
3
4
5
6
 * Copyright (c) 2013- 2015:
 *                    Matthieu Schaller (matthieu.schaller@durham.ac.uk),
 *                    Pedro Gonnet (pedro.gonnet@durham.ac.uk),
 *                    Peter W. Draper (p.w.draper@durham.ac.uk).
7
 *
8
9
10
11
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
12
 *
13
14
15
16
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
17
 *
18
19
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
 *
21
22
 ******************************************************************************/

23
24
25
26
/* Config parameters. */
#include "../config.h"

/* Some standard headers. */
27
#include <float.h>
28
#include <stdio.h>
29
#include <unistd.h>
30

31
32
33
34
/* This object's header. */
#include "debug.h"

/* Local includes. */
35
#include "active.h"
36
37
#include "cell.h"
#include "engine.h"
38
#include "hydro.h"
39
#include "inline.h"
40
#include "part.h"
41
#include "space.h"
42

43
/* Import the right hydro definition */
44
45
46
#if defined(MINIMAL_SPH)
#include "./hydro/Minimal/hydro_debug.h"
#elif defined(GADGET2_SPH)
47
#include "./hydro/Gadget2/hydro_debug.h"
48
49
#elif defined(HOPKINS_PE_SPH)
#include "./hydro/PressureEntropy/hydro_debug.h"
50
#elif defined(DEFAULT_SPH)
51
#include "./hydro/Default/hydro_debug.h"
52
53
#elif defined(GIZMO_SPH)
#include "./hydro/Gizmo/hydro_debug.h"
54
#elif defined(SHADOWFAX_SPH)
55
#include "./hydro/Shadowswift/hydro_debug.h"
56
57
#else
#error "Invalid choice of SPH variant"
58
59
#endif

60
61
#include "./gravity/Default/gravity_debug.h"

62
/**
63
64
65
 * @brief Looks for the particle with the given id and prints its information to
 *the standard output.
 *
66
 * @param parts The array of particles.
Matthieu Schaller's avatar
Matthieu Schaller committed
67
 * @param xparts The array of particle extended data.
68
69
70
71
72
 * @param id The id too look for.
 * @param N The size of the array of particles.
 *
 * (Should be used for debugging only as it runs in O(N).)
 */
73
void printParticle(const struct part *parts, const struct xpart *xparts,
Matthieu Schaller's avatar
Style    
Matthieu Schaller committed
74
                   long long int id, size_t N) {
75

76
  int found = 0;
77
78

  /* Look for the particle. */
79
  for (size_t i = 0; i < N; i++)
80
    if (parts[i].id == id) {
81
      printf("## Particle[%zu]:\n id=%lld ", i, parts[i].id);
82
      hydro_debug_particle(&parts[i], &xparts[i]);
83
      found = 1;
84
      break;
85
86
    }

87
88
  if (!found) printf("## Particles[???] id=%lld not found\n", id);
}
89

90
91
92
93
94
95
/**
 * @brief Looks for the g-particle with the given id and prints its information
 * to
 * the standard output.
 *
 * @param gparts The array of g-particles.
Matthieu Schaller's avatar
Matthieu Schaller committed
96
 * @param parts The array of particles.
97
98
99
100
101
 * @param id The id too look for.
 * @param N The size of the array of g-particles.
 *
 * (Should be used for debugging only as it runs in O(N).)
 */
Matthieu Schaller's avatar
Style    
Matthieu Schaller committed
102
103
void printgParticle(const struct gpart *gparts, const struct part *parts,
                    long long int id, size_t N) {
104

105
  int found = 0;
106
107

  /* Look for the particle. */
108
  for (size_t i = 0; i < N; i++)
109
    if (gparts[i].id_or_neg_offset == id) {
110
      printf("## gParticle[%zu] (DM) :\n id=%lld", i, id);
111
112
113
      gravity_debug_particle(&gparts[i]);
      found = 1;
      break;
114
115
    } else if (gparts[i].id_or_neg_offset < 0 &&
               parts[-gparts[i].id_or_neg_offset].id == id) {
116
      printf("## gParticle[%zu] (hydro) :\n id=%lld", i, id);
117
      gravity_debug_particle(&gparts[i]);
118
      found = 1;
119
      break;
120
    }
121

122
123
  if (!found) printf("## Particles[???] id=%lld not found\n", id);
}
124

Pedro Gonnet's avatar
Pedro Gonnet committed
125
/**
126
 * @brief Prints the details of a given particle to stdout
127
 *
128
 * @param p The particle to print
129
 * @param xp The extended data ot the particle to print
Pedro Gonnet's avatar
Pedro Gonnet committed
130
 */
131
void printParticle_single(const struct part *p, const struct xpart *xp) {
132

133
  printf("## Particle: id=%lld ", p->id);
134
  hydro_debug_particle(p, xp);
Matthieu Schaller's avatar
Matthieu Schaller committed
135
  printf("\n");
136
}
Peter W. Draper's avatar
Peter W. Draper committed
137

138
139
140
141
142
143
144
/**
 * @brief Prints the details of a given particle to stdout
 *
 * @param gp The g-particle to print
 */
void printgParticle_single(struct gpart *gp) {

145
  printf("## g-Particle: id=%lld ", gp->id_or_neg_offset);
146
147
  gravity_debug_particle(gp);
  printf("\n");
148
}
Peter W. Draper's avatar
Peter W. Draper committed
149

150
151
152
153
154
155
156
157
158
/**
 * @brief Check that the cells and particles of a space have consistent h_max
 *        values.
 *
 * @param s the space.
 * @result 1 or 0
 */
int checkSpacehmax(struct space *s) {

Peter W. Draper's avatar
Peter W. Draper committed
159
160
161
  /* Loop over local cells. */
  float cell_h_max = 0.0f;
  for (int k = 0; k < s->nr_cells; k++) {
162
163
164
    if (s->cells_top[k].nodeID == s->e->nodeID &&
        s->cells_top[k].h_max > cell_h_max) {
      cell_h_max = s->cells_top[k].h_max;
165
    }
Peter W. Draper's avatar
Peter W. Draper committed
166
  }
167

Peter W. Draper's avatar
Peter W. Draper committed
168
169
  /* Now all particles. */
  float part_h_max = 0.0f;
170
  for (size_t k = 0; k < s->nr_parts; k++) {
Peter W. Draper's avatar
Peter W. Draper committed
171
172
    if (s->parts[k].h > part_h_max) {
      part_h_max = s->parts[k].h;
173
    }
Peter W. Draper's avatar
Peter W. Draper committed
174
  }
175

Peter W. Draper's avatar
Peter W. Draper committed
176
  /*  If within some epsilon we are OK. */
177
  if (fabsf(cell_h_max - part_h_max) <= FLT_EPSILON) return 1;
178

Peter W. Draper's avatar
Peter W. Draper committed
179
180
  /* There is a problem. Hunt it down. */
  for (int k = 0; k < s->nr_cells; k++) {
181
182
183
    if (s->cells_top[k].nodeID == s->e->nodeID) {
      if (s->cells_top[k].h_max > part_h_max) {
        message("cell %d is inconsistent (%f > %f)", k, s->cells_top[k].h_max,
Peter W. Draper's avatar
Peter W. Draper committed
184
                part_h_max);
185
186
      }
    }
Peter W. Draper's avatar
Peter W. Draper committed
187
  }
188

189
  for (size_t k = 0; k < s->nr_parts; k++) {
Peter W. Draper's avatar
Peter W. Draper committed
190
191
192
    if (s->parts[k].h > cell_h_max) {
      message("part %lld is inconsistent (%f > %f)", s->parts[k].id,
              s->parts[k].h, cell_h_max);
193
    }
Peter W. Draper's avatar
Peter W. Draper committed
194
  }
195

Peter W. Draper's avatar
Peter W. Draper committed
196
  return 0;
197
198
}

199
200
/**
 * @brief Check if the h_max and dx_max values of a cell's hierarchy are
201
202
 * consistent with the particles. Also checks if particles are correctly
 * in a cell. Report verbosely if not.
203
204
205
206
207
208
209
210
211
212
213
 *
 * @param c the top cell of the hierarchy.
 * @param depth the recursion depth for use in messages. Set to 0 initially.
 * @result 1 or 0
 */
int checkCellhdxmax(const struct cell *c, int *depth) {

  *depth = *depth + 1;

  float h_max = 0.0f;
  float dx_max = 0.0f;
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
  int result = 1;

  const double loc_min[3] = {c->loc[0], c->loc[1], c->loc[2]};
  const double loc_max[3] = {c->loc[0] + c->width[0], c->loc[1] + c->width[1],
                             c->loc[2] + c->width[2]};

  const size_t nr_parts = c->count;
  struct part *parts = c->parts;
  struct xpart *xparts = c->xparts;
  for (size_t k = 0; k < nr_parts; k++) {

    struct part *const p = &parts[k];
    struct xpart *const xp = &xparts[k];

    if (p->x[0] < loc_min[0] || p->x[0] > loc_max[0] || p->x[1] < loc_min[1] ||
        p->x[1] > loc_max[1] || p->x[2] < loc_min[2] || p->x[2] > loc_max[2]) {

      message(
          "Inconsistent part position p->x=[%e %e %e], c->loc=[%e %e %e] "
          "c->width=[%e %e %e]",
          p->x[0], p->x[1], p->x[2], c->loc[0], c->loc[1], c->loc[2],
          c->width[0], c->width[1], c->width[2]);

      result = 0;
238
    }
239
240
241
242
243
244
245
246
247
248
249

    const float dx2 = xp->x_diff[0] * xp->x_diff[0] +
                      xp->x_diff[1] * xp->x_diff[1] +
                      xp->x_diff[2] * xp->x_diff[2];

    h_max = max(h_max, p->h);
    dx_max = max(dx_max, sqrt(dx2));
  }

  if (c->split) {
    for (int k = 0; k < 8; k++) {
250
251
252
253
      if (c->progeny[k] != NULL) {
        struct cell *cp = c->progeny[k];
        checkCellhdxmax(cp, depth);
      }
254
    }
255
256
257
258
  }

  /* Check. */
  if (c->h_max != h_max) {
259
260
    message("%d Inconsistent h_max: cell %f != parts %f", *depth, c->h_max,
            h_max);
261
    message("location: %f %f %f", c->loc[0], c->loc[1], c->loc[2]);
262
263
    result = 0;
  }
264
265
  if (c->dx_max_part != dx_max) {
    message("%d Inconsistent dx_max: %f != %f", *depth, c->dx_max_part, dx_max);
266
    message("location: %f %f %f", c->loc[0], c->loc[1], c->loc[2]);
267
268
269
270
271
272
    result = 0;
  }

  return result;
}

273
/**
274
275
 * @brief map function for dumping cells. In MPI mode locally active cells
 * only.
276
277
278
279
280
 */
static void dumpCells_map(struct cell *c, void *data) {
  uintptr_t *ldata = (uintptr_t *)data;
  FILE *file = (FILE *)ldata[0];
  struct engine *e = (struct engine *)ldata[1];
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
  float ntasks = c->nr_tasks;

#if SWIFT_DEBUG_CHECKS
  /* The c->nr_tasks field does not include all the tasks. So let's check this
   * the hard way. Note pairs share the task 50/50 with the other cell. */
  ntasks = 0.0f;
  struct task *tasks = e->sched.tasks;
  int nr_tasks = e->sched.nr_tasks;
  for (int k = 0; k < nr_tasks; k++) {
    if (tasks[k].cj == NULL) {
      if (c == tasks[k].ci) {
        ntasks = ntasks + 1.0f;
      }
    } else {
      if (c == tasks[k].ci || c == tasks[k].cj) {
        ntasks = ntasks + 0.5f;
      }
    }
  }
#endif

  /* Only locally active cells are dumped. */
303
  if (c->count > 0 || c->gcount > 0 || c->scount > 0)
304
305
306
307
308
309
    fprintf(file,
            "  %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6d %6d %6d %6d "
            "%6.1f %20lld %6d %6d %6d %6d\n",
            c->loc[0], c->loc[1], c->loc[2], c->width[0], c->width[1],
            c->width[2], c->count, c->gcount, c->scount, c->depth, ntasks,
            c->ti_end_min, get_time_bin(c->ti_end_min), (c->super == c),
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
            cell_is_active(c, e), c->nodeID);
}

/**
 * @brief Dump the location, depth, task counts and timebins and active state,
 * for all cells to a simple text file.
 *
 * @param prefix base output filename
 * @param s the space holding the cells to dump.
 */
void dumpCells(const char *prefix, struct space *s) {

  FILE *file = NULL;

  /* Name of output file. */
  static int nseq = 0;
  char fname[200];
327
328
  int uniq = atomic_inc(&nseq);
  sprintf(fname, "%s_%03d.dat", prefix, uniq);
329
330
331
332

  file = fopen(fname, "w");

  /* Header. */
333
334
335
336
337
  fprintf(file,
          "# %6s %6s %6s %6s %6s %6s %6s %6s %6s %6s %6s %6s "
          "%20s %6s %6s %6s\n",
          "x", "y", "z", "xw", "yw", "zw", "count", "gcount", "scount", "depth",
          "tasks", "ti_end_min", "timebin", "issuper", "active", "rank");
338
339

  uintptr_t data[2];
340
341
  data[0] = (size_t)file;
  data[1] = (size_t)s->e;
342
343
344
345
  space_map_cells_pre(s, 1, dumpCells_map, &data);
  fclose(file);
}

Peter W. Draper's avatar
Peter W. Draper committed
346
347
348
#ifdef HAVE_METIS

/**
349
350
 * @brief Dump the METIS graph in standard format, simple format and weights
 * only, to a file.
Peter W. Draper's avatar
Peter W. Draper committed
351
 *
Matthieu Schaller's avatar
Matthieu Schaller committed
352
 * The standard format output can be read into the METIS
353
354
355
356
357
 * command-line tools. The simple format is just the cell connectivity (this
 * should not change between calls).  The weights format is the standard one,
 * minus the cell connectivity.
 *
 * The output filenames are generated from the prefix and the sequence number
358
359
 * of calls. So the first is called {prefix}_std_001.dat,
 *{prefix}_simple_001.dat,
Matthieu Schaller's avatar
Matthieu Schaller committed
360
 * {prefix}_weights_001.dat, etc.
361
362
363
364
365
366
367
368
369
 *
 * @param prefix base output filename
 * @param nvertices the number of vertices
 * @param nvertexweights the number vertex weights
 * @param cellconruns first part of cell connectivity info (CSR)
 * @param cellcon second part of cell connectivity info (CSR)
 * @param vertexweights weights of vertices
 * @param vertexsizes size of vertices
 * @param edgeweights weights of edges
Peter W. Draper's avatar
Peter W. Draper committed
370
 */
371
void dumpMETISGraph(const char *prefix, idx_t nvertices, idx_t nvertexweights,
372
                    idx_t *cellconruns, idx_t *cellcon, idx_t *vertexweights,
373
374
375
376
377
378
379
380
381
382
383
384
                    idx_t *vertexsizes, idx_t *edgeweights) {
  FILE *stdfile = NULL;
  FILE *simplefile = NULL;
  FILE *weightfile = NULL;
  char fname[200];
  int haveedgeweight = 0;
  int havevertexsize = 0;
  int havevertexweight = 0;
  static int nseq = 0;
  nseq++;

  if (vertexweights != NULL) {
385
    for (idx_t i = 0; i < nvertices * nvertexweights; i++) {
386
387
      if (vertexweights[i] != 1) {
        havevertexweight = 1;
Peter W. Draper's avatar
Peter W. Draper committed
388
389
390
391
        break;
      }
    }
  }
392
393

  if (vertexsizes != NULL) {
394
    for (idx_t i = 0; i < nvertices; i++) {
395
396
      if (vertexsizes[i] != 1) {
        havevertexsize = 1;
Peter W. Draper's avatar
Peter W. Draper committed
397
398
399
400
        break;
      }
    }
  }
401
402

  if (edgeweights != NULL) {
403
    for (idx_t i = 0; i < cellconruns[nvertices]; i++) {
404
405
      if (edgeweights[i] != 1) {
        haveedgeweight = 1;
Peter W. Draper's avatar
Peter W. Draper committed
406
407
408
409
410
        break;
      }
    }
  }

411
412
  /*  Open output files. */
  sprintf(fname, "%s_std_%03d.dat", prefix, nseq);
413
  stdfile = fopen(fname, "w");
414
415

  sprintf(fname, "%s_simple_%03d.dat", prefix, nseq);
416
  simplefile = fopen(fname, "w");
417
418
419

  if (havevertexweight || havevertexsize || haveedgeweight) {
    sprintf(fname, "%s_weights_%03d.dat", prefix, nseq);
420
    weightfile = fopen(fname, "w");
421
422
423
424
  }

  /*  Write the header lines. */
  fprintf(stdfile, "%" PRIDX " %" PRIDX, nvertices, cellconruns[nvertices] / 2);
425
426
  fprintf(simplefile, "%" PRIDX " %" PRIDX, nvertices,
          cellconruns[nvertices] / 2);
427
  if (havevertexweight || havevertexsize || haveedgeweight) {
428
429
    fprintf(weightfile, "%" PRIDX " %" PRIDX, nvertices,
            cellconruns[nvertices] / 2);
430

431
432
433
434
    fprintf(stdfile, " %d%d%d", havevertexsize, havevertexweight,
            haveedgeweight);
    fprintf(weightfile, " %d%d%d", havevertexsize, havevertexweight,
            haveedgeweight);
435
436
437
438

    if (havevertexweight) {
      fprintf(stdfile, " %d", (int)nvertexweights);
      fprintf(weightfile, " %d", (int)nvertexweights);
Peter W. Draper's avatar
Peter W. Draper committed
439
440
441
442
    }
  }

  /*  Write the rest of the graph. */
443
  for (idx_t i = 0; i < nvertices; i++) {
444
445
    fprintf(stdfile, "\n");
    fprintf(simplefile, "\n");
446
    if (weightfile != NULL) {
447
      fprintf(weightfile, "\n");
448
    }
449
450
451
452

    if (havevertexsize) {
      fprintf(stdfile, " %" PRIDX, vertexsizes[i]);
      fprintf(weightfile, " %" PRIDX, vertexsizes[i]);
Peter W. Draper's avatar
Peter W. Draper committed
453
454
    }

455
    if (havevertexweight) {
456
      for (idx_t j = 0; j < nvertexweights; j++) {
457
458
        fprintf(stdfile, " %" PRIDX, vertexweights[i * nvertexweights + j]);
        fprintf(weightfile, " %" PRIDX, vertexweights[i * nvertexweights + j]);
Peter W. Draper's avatar
Peter W. Draper committed
459
460
461
      }
    }

462
    for (idx_t j = cellconruns[i]; j < cellconruns[i + 1]; j++) {
463
464
465
466
467
      fprintf(stdfile, " %" PRIDX, cellcon[j] + 1);
      fprintf(simplefile, " %" PRIDX, cellcon[j] + 1);
      if (haveedgeweight) {
        fprintf(stdfile, " %" PRIDX, edgeweights[j]);
        fprintf(weightfile, " %" PRIDX, edgeweights[j]);
Peter W. Draper's avatar
Peter W. Draper committed
468
469
470
      }
    }
  }
471
472
  fprintf(stdfile, "\n");
  fprintf(simplefile, "\n");
473
  if (weightfile != NULL) {
474
    fprintf(weightfile, "\n");
475
  }
476
477
478
479
480
481

  fclose(stdfile);
  fclose(simplefile);
  if (weightfile != NULL) {
    fclose(weightfile);
  }
Peter W. Draper's avatar
Peter W. Draper committed
482
483
}

484
485
486
487
488
489
490
491
492
493
#endif /* HAVE_METIS */

#ifdef HAVE_MPI
/**
 * @brief Dump the positions and MPI ranks of the given top-level cells
 *        to a simple text file.
 *
 * Can be used to visualise the partitioning of an MPI run. Note should
 * be used immediately after repartitioning when the top-level cells
 * have been assigned their nodes. Each time this is called a new file
Matthieu Schaller's avatar
Matthieu Schaller committed
494
 * with the given prefix, a unique integer and type of .dat is created.
495
496
497
498
499
 *
 * @param prefix base output filename
 * @param cells_top the top-level cells.
 * @param nr_cells the number of cells.
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
500
void dumpCellRanks(const char *prefix, struct cell *cells_top, int nr_cells) {
501
502
503
504
505
506
507
508
509
510
511
512

  FILE *file = NULL;

  /* Name of output file. */
  static int nseq = 0;
  char fname[200];
  sprintf(fname, "%s_%03d.dat", prefix, nseq);
  nseq++;

  file = fopen(fname, "w");

  /* Header. */
Matthieu Schaller's avatar
Matthieu Schaller committed
513
514
  fprintf(file, "# %6s %6s %6s %6s %6s %6s %6s\n", "x", "y", "z", "xw", "yw",
          "zw", "rank");
515
516
517
518

  /* Output */
  for (int i = 0; i < nr_cells; i++) {
    struct cell *c = &cells_top[i];
Matthieu Schaller's avatar
Matthieu Schaller committed
519
520
521
    fprintf(file, "  %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %6d\n", c->loc[0],
            c->loc[1], c->loc[2], c->width[0], c->width[1], c->width[2],
            c->nodeID);
522
523
524
525
526
527
  }

  fclose(file);
}

#endif /* HAVE_MPI */
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546

/**
 * @brief parse the process /proc/self/statm file to get the process
 *        memory use (in KB). Top field in ().
 *
 * @param size     total virtual memory (VIRT)
 * @param resident resident non-swapped memory (RES)
 * @param share    shared (mmap'd) memory  (SHR)
 * @param trs      text (exe) resident set (CODE)
 * @param lrs      library resident set
 * @param drs      data+stack resident set (DATA)
 * @param dt       dirty pages (nDRT)
 */
void getProcMemUse(long *size, long *resident, long *share, long *trs,
                   long *lrs, long *drs, long *dt) {

  /* Open the file. */
  FILE *file = fopen("/proc/self/statm", "r");
  if (file != NULL) {
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
    int nscan = fscanf(file, "%ld %ld %ld %ld %ld %ld %ld", size, resident,
                       share, trs, lrs, drs, dt);

    if (nscan == 7) {
      /* Convert pages into bytes. Usually 4096, but could be 512 on some
       * systems so take care in conversion to KB. */
      long sz = sysconf(_SC_PAGESIZE);
      *size *= sz;
      *resident *= sz;
      *share *= sz;
      *trs *= sz;
      *lrs *= sz;
      *drs *= sz;
      *dt *= sz;

      *size /= 1024;
      *resident /= 1024;
      *share /= 1024;
      *trs /= 1024;
      *lrs /= 1024;
      *drs /= 1024;
      *dt /= 1024;
    } else {
      error("Failed to read sufficient fields from /proc/self/statm");
    }
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
    fclose(file);
  } else {
    error("Failed to open /proc/self/statm");
  }
}

/**
 * @brief Print the current memory use of the process. A la "top".
 */
void printProcMemUse() {
  long size;
  long resident;
  long share;
  long trs;
  long lrs;
  long drs;
  long dt;
  getProcMemUse(&size, &resident, &share, &trs, &lrs, &drs, &dt);
  printf("## VIRT = %ld , RES = %ld , SHR = %ld , CODE = %ld, DATA = %ld\n",
Matthieu Schaller's avatar
Matthieu Schaller committed
591
         size, resident, share, trs, drs);
592
593
  fflush(stdout);
}