Date: 2025-03-29T05:58:44+00:00

Actual source code: loghandler.c

      1: #include <petscviewer.h>
      2: #include <petsc/private/logimpl.h>
      3: #include <petsc/private/loghandlerimpl.h>
      4: #include <petsc/private/petscimpl.h>

      6: /*@
      7:   PetscLogHandlerCreate - Create a log handler for profiling events and stages.  PETSc
      8:   provides several implementations of `PetscLogHandler` that interface to different ways to
      9:   summarize or visualize profiling data: see `PetscLogHandlerType` for a list.

     11:   Collective

     13:   Input Parameter:
     14: . comm - the communicator for synchronizing and viewing events with this handler

     16:   Output Parameter:
     17: . handler - the `PetscLogHandler`

     19:   Level: developer

     21:   Notes:
     22:   This does not put the handler in use in PETSc's global logging system: use `PetscLogHandlerStart()` after creation.

     24:   See `PetscLogHandler` for example usage.

     26: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogHandlerSetType()`, `PetscLogHandlerStart()`, `PetscLogHandlerStop()`
     27: @*/
     28: PetscErrorCode PetscLogHandlerCreate(MPI_Comm comm, PetscLogHandler *handler)
     29: {
     30:   PetscLogHandler h;

     32:   PetscFunctionBegin;
     33:   *handler = NULL;
     34:   PetscCall(PetscLogHandlerPackageInitialize());
     35:   // We do not use PetscHeaderCreate() here because having PetscLogObjectCreate() run for PetscLogHandler would be very fragile
     36:   PetscCall(PetscNew(&h));
     37:   PetscCall(PetscHeaderCreate_Private((PetscObject)(h), PETSCLOGHANDLER_CLASSID, "PetscLogHandler", "Profile events, stages, and objects", "Profiling", comm, (PetscObjectDestroyFn *)PetscLogHandlerDestroy, (PetscObjectViewFn *)PetscLogHandlerView));
     38:   *handler = h;
     39:   PetscFunctionReturn(PETSC_SUCCESS);
     40: }

     42: /*@
     43:   PetscLogHandlerDestroy - Destroy a `PetscLogHandler`

     45:   Logically collective

     47:   Input Parameter:
     48: . handler - handler to be destroyed

     50:   Level: developer

     52: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogHandlerCreate()`
     53: @*/
     54: PetscErrorCode PetscLogHandlerDestroy(PetscLogHandler *handler)
     55: {
     56:   PetscLogHandler h;

     58:   PetscFunctionBegin;
     59:   if (!*handler) PetscFunctionReturn(PETSC_SUCCESS);
     60:   h        = *handler;
     61:   *handler = NULL;
     63:   if (--((PetscObject)h)->refct > 0) PetscFunctionReturn(PETSC_SUCCESS);
     64:   PetscTryTypeMethod(h, destroy);
     65:   PetscCall(PetscLogStateDestroy(&h->state));
     66:   // We do not use PetscHeaderDestroy() because having PetscLogObjectDestroy() run for PetscLgoHandler would be very fragile
     67:   PetscCall(PetscHeaderDestroy_Private((PetscObject)(h), PETSC_FALSE));
     68:   PetscCall(PetscFree(h));
     69:   PetscFunctionReturn(PETSC_SUCCESS);
     70: }

     72: /*@
     73:   PetscLogHandlerSetState - Set the logging state that provides the stream of events and stages for a log handler.

     75:   Logically collective

     77:   Input Parameters:
     78: + h     - the `PetscLogHandler`
     79: - state - the `PetscLogState`

     81:   Level: developer

     83:   Note:
     84:   Most users well not need to set a state explicitly: the global logging state (`PetscLogGetState()`) is set when calling `PetscLogHandlerStart()`

     86: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogState`, `PetscLogEventBegin()`, `PetscLogHandlerStart()`
     87: @*/
     88: PetscErrorCode PetscLogHandlerSetState(PetscLogHandler h, PetscLogState state)
     89: {
     90:   PetscFunctionBegin;
     92:   if (state) {
     93:     PetscAssertPointer(state, 2);
     94:     state->refct++;
     95:   }
     96:   PetscCall(PetscLogStateDestroy(&h->state));
     97:   h->state = state;
     98:   PetscFunctionReturn(PETSC_SUCCESS);
     99: }

    101: /*@
    102:   PetscLogHandlerGetState - Get the logging state that provides the stream of events and stages for a log handler.

    104:   Logically collective

    106:   Input Parameter:
    107: . h - the `PetscLogHandler`

    109:   Output Parameter:
    110: . state - the `PetscLogState`

    112:   Level: developer

    114:   Note:
    115:   For a log handler started with `PetscLogHandlerStart()`, this will be the PETSc global logging state (`PetscLogGetState()`)

    117: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogState`, `PetscLogEventBegin()`, `PetscLogHandlerStart()`
    118: @*/
    119: PetscErrorCode PetscLogHandlerGetState(PetscLogHandler h, PetscLogState *state)
    120: {
    121:   PetscFunctionBegin;
    123:   PetscAssertPointer(state, 2);
    124:   *state = h->state;
    125:   PetscFunctionReturn(PETSC_SUCCESS);
    126: }

    128: /*@
    129:   PetscLogHandlerEventBegin - Record the beginning of an event in a log handler

    131:   Not collective

    133:   Input Parameters:
    134: + h  - the `PetscLogHandler`
    135: . e  - a registered `PetscLogEvent`
    136: . o1 - `PetscObject` associated with the event (may be `NULL`)
    137: . o2 - `PetscObject` associated with the event (may be `NULL`)
    138: . o3 - `PetscObject` associated with the event (may be `NULL`)
    139: - o4 - `PetscObject` associated with the event (may be `NULL`)

    141:   Level: developer

    143:   Note:
    144:   Most users will use `PetscLogEventBegin()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`

    146: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogEventBegin()`, `PetscLogEventEnd()`, `PetscLogEventSync()`, `PetscLogHandlerEventEnd()`, `PetscLogHandlerEventSync()`
    147: @*/
    148: PetscErrorCode PetscLogHandlerEventBegin(PetscLogHandler h, PetscLogEvent e, PetscObject o1, PetscObject o2, PetscObject o3, PetscObject o4)
    149: {
    150:   PetscFunctionBegin;
    152:   PetscTryTypeMethod(h, eventbegin, e, o1, o2, o3, o4);
    153:   PetscFunctionReturn(PETSC_SUCCESS);
    154: }

    156: /*@
    157:   PetscLogHandlerEventEnd - Record the end of an event in a log handler

    159:   Not collective

    161:   Input Parameters:
    162: + h  - the `PetscLogHandler`
    163: . e  - a registered `PetscLogEvent`
    164: . o1 - `PetscObject` associated with the event (may be `NULL`)
    165: . o2 - `PetscObject` associated with the event (may be `NULL`)
    166: . o3 - `PetscObject` associated with the event (may be `NULL`)
    167: - o4 - `PetscObject` associated with the event (may be `NULL`)

    169:   Level: developer

    171:   Note:
    172:   Most users will use `PetscLogEventEnd()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`

    174: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogEventBegin()`, `PetscLogEventEnd()`, `PetscLogEventSync()`, `PetscLogHandlerEventBegin()`, `PetscLogHandlerEventSync()`
    175: @*/
    176: PetscErrorCode PetscLogHandlerEventEnd(PetscLogHandler h, PetscLogEvent e, PetscObject o1, PetscObject o2, PetscObject o3, PetscObject o4)
    177: {
    178:   PetscFunctionBegin;
    180:   PetscTryTypeMethod(h, eventend, e, o1, o2, o3, o4);
    181:   PetscFunctionReturn(PETSC_SUCCESS);
    182: }

    184: /*@
    185:   PetscLogHandlerEventSync - Synchronize a logging event

    187:   Collective

    189:   Input Parameters:
    190: + h    - the `PetscLogHandler`
    191: . e    - a registered `PetscLogEvent`
    192: - comm - the communicator over which to synchronize `e`

    194:   Level: developer

    196:   Note:
    197:   Most users will use `PetscLogEventSync()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`

    199: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogEventBegin()`, `PetscLogEventEnd()`, `PetscLogEventSync()`, `PetscLogHandlerEventBegin()`, `PetscLogHandlerEventEnd()`
    200: @*/
    201: PetscErrorCode PetscLogHandlerEventSync(PetscLogHandler h, PetscLogEvent e, MPI_Comm comm)
    202: {
    203:   MPI_Comm    h_comm;
    204:   PetscMPIInt size;

    206:   PetscFunctionBegin;
    208:   PetscCall(PetscObjectGetComm((PetscObject)h, &h_comm));
    209:   PetscCallMPI(MPI_Comm_size(comm, &size));
    210:   if (comm == MPI_COMM_NULL || size == 1) PetscFunctionReturn(PETSC_SUCCESS); // nothing to sync
    211:   if (PetscDefined(USE_DEBUG)) {
    212:     PetscMPIInt h_comm_world, compare;
    213:     PetscCallMPI(MPI_Comm_compare(h_comm, PETSC_COMM_WORLD, &h_comm_world));
    214:     PetscCallMPI(MPI_Comm_compare(h_comm, comm, &compare));
    215:     // only synchronze if h->comm and comm have the same processes or h->comm is PETSC_COMM_WORLD
    216:     PetscCheck(h_comm_world != MPI_UNEQUAL || compare != MPI_UNEQUAL, comm, PETSC_ERR_SUP, "PetscLogHandlerSync does not support arbitrary mismatched communicators");
    217:   }
    218:   PetscTryTypeMethod(h, eventsync, e, comm);
    219:   PetscFunctionReturn(PETSC_SUCCESS);
    220: }

    222: /*@
    223:   PetscLogHandlerObjectCreate - Record the creation of an object in a log handler.

    225:   Not collective

    227:   Input Parameters:
    228: + h   - the `PetscLogHandler`
    229: - obj - a newly created `PetscObject`

    231:   Level: developer

    233:   Notes:
    234:   Most users will use `PetscLogObjectCreate()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`.

    236: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogObjectCreate()`, `PetscLogObjectDestroy()`, `PetscLogHandlerObjectDestroy()`
    237: @*/
    238: PetscErrorCode PetscLogHandlerObjectCreate(PetscLogHandler h, PetscObject obj)
    239: {
    240:   PetscFunctionBegin;
    242:   PetscTryTypeMethod(h, objectcreate, obj);
    243:   PetscFunctionReturn(PETSC_SUCCESS);
    244: }

    246: /*@
    247:   PetscLogHandlerObjectDestroy - Record the destruction of an object in a log handler.

    249:   Not collective

    251:   Input Parameters:
    252: + h   - the `PetscLogHandler`
    253: - obj - a newly created `PetscObject`

    255:   Level: developer

    257:   Notes:
    258:   Most users will use `PetscLogObjectDestroy()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`.

    260: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogObjectCreate()`, `PetscLogObjectDestroy()`, `PetscLogHandlerObjectCreate()`
    261: @*/
    262: PetscErrorCode PetscLogHandlerObjectDestroy(PetscLogHandler h, PetscObject obj)
    263: {
    264:   PetscFunctionBegin;
    266:   PetscTryTypeMethod(h, objectdestroy, obj);
    267:   PetscFunctionReturn(PETSC_SUCCESS);
    268: }

    270: /*@
    271:   PetscLogHandlerStagePush - Begin a new logging stage in a log handler.

    273:   Not collective

    275:   Input Parameters:
    276: + h     - the `PetscLogHandler`
    277: - stage - a registered `PetscLogStage`

    279:   Level: developer

    281:   Notes:
    282:   Most users will use `PetscLogStagePush()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`.

    284:   This function is called right before the stage is pushed for the handler's `PetscLogState`, so `PetscLogStateGetCurrentStage()`
    285:   can be used to see what the previous stage was.

    287: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogStagePush()`, `PetscLogStagePop()`, `PetscLogHandlerStagePop()`
    288: @*/
    289: PetscErrorCode PetscLogHandlerStagePush(PetscLogHandler h, PetscLogStage stage)
    290: {
    291:   PetscFunctionBegin;
    293:   PetscTryTypeMethod(h, stagepush, stage);
    294:   PetscFunctionReturn(PETSC_SUCCESS);
    295: }

    297: /*@
    298:   PetscLogHandlerStagePop - End the current logging stage in a log handler.

    300:   Not collective

    302:   Input Parameters:
    303: + h     - the `PetscLogHandler`
    304: - stage - a registered `PetscLogStage`

    306:   Level: developer

    308:   Notes:
    309:   Most users will use `PetscLogStagePop()`, which will call this function for all handlers registered with `PetscLogHandlerStart()`.

    311:   This function is called right after the stage is popped for the handler's `PetscLogState`, so `PetscLogStateGetCurrentStage()`
    312:   can be used to see what the next stage will be.

    314: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogStagePush()`, `PetscLogStagePop()`, `PetscLogHandlerStagePush()`
    315: @*/
    316: PetscErrorCode PetscLogHandlerStagePop(PetscLogHandler h, PetscLogStage stage)
    317: {
    318:   PetscFunctionBegin;
    320:   PetscTryTypeMethod(h, stagepop, stage);
    321:   PetscFunctionReturn(PETSC_SUCCESS);
    322: }

    324: /*@
    325:   PetscLogHandlerView - View the data recorded in a log handler.

    327:   Collective

    329:   Input Parameters:
    330: + h      - the `PetscLogHandler`
    331: - viewer - the `PetscViewer`

    333:   Level: developer

    335: .seealso: [](ch_profiling), `PetscLogHandler`, `PetscLogView()`
    336: @*/
    337: PetscErrorCode PetscLogHandlerView(PetscLogHandler h, PetscViewer viewer)
    338: {
    339:   PetscFunctionBegin;
    342:   PetscTryTypeMethod(h, view, viewer);
    343:   PetscFunctionReturn(PETSC_SUCCESS);
    344: }

    346: /*@C
    347:   PetscLogHandlerGetEventPerfInfo - Get a direct reference to the `PetscEventPerfInfo` of a stage and event

    349:   Not collective, No Fortran Support

    351:   Input Parameters:
    352: + handler - a `PetscLogHandler`
    353: . stage   - a `PetscLogStage` (or `PETSC_DEFAULT` for the current stage)
    354: - event   - a `PetscLogEvent`

    356:   Output Parameter:
    357: . event_info - a pointer to a performance log for `event` during `stage` (or `NULL` if this handler does not use
    358:               `PetscEventPerfInfo` to record performance data); writing to `event_info` will change the record in
    359:               `handler`

    361:   Level: developer

    363: .seealso: [](ch_profiling), `PetscLogEventGetPerfInfo()`, `PETSCLOGHANDLERDEFAULT`
    364: @*/
    365: PetscErrorCode PetscLogHandlerGetEventPerfInfo(PetscLogHandler handler, PetscLogStage stage, PetscLogEvent event, PetscEventPerfInfo **event_info)
    366: {
    367:   PetscFunctionBegin;
    369:   PetscAssertPointer(event_info, 4);
    370:   *event_info = NULL;
    371:   PetscTryMethod(handler, "PetscLogHandlerGetEventPerfInfo_C", (PetscLogHandler, PetscLogStage, PetscLogEvent, PetscEventPerfInfo **), (handler, stage, event, event_info));
    372:   PetscFunctionReturn(PETSC_SUCCESS);
    373: }

    375: /*@C
    376:   PetscLogHandlerGetStagePerfInfo - Get a direct reference to the `PetscEventPerfInfo` of a stage

    378:   Not collective, No Fortran Support

    380:   Input Parameters:
    381: + handler - a `PetscLogHandler`
    382: - stage   - a `PetscLogStage` (or `PETSC_DEFAULT` for the current stage)

    384:   Output Parameter:
    385: . stage_info - a pointer to a performance log for `stage` (or `NULL` if this handler does not use `PetscEventPerfInfo`
    386:                to record performance data); writing to `stage_info` will change the record in `handler`

    388:   Level: developer

    390: .seealso: [](ch_profiling), `PetscLogEventGetPerfInfo()`, `PETSCLOGHANDLERDEFAULT`
    391: @*/
    392: PetscErrorCode PetscLogHandlerGetStagePerfInfo(PetscLogHandler handler, PetscLogStage stage, PetscEventPerfInfo **stage_info)
    393: {
    394:   PetscFunctionBegin;
    396:   PetscAssertPointer(stage_info, 3);
    397:   *stage_info = NULL;
    398:   PetscTryMethod(handler, "PetscLogHandlerGetStagePerfInfo_C", (PetscLogHandler, PetscLogStage, PetscEventPerfInfo **), (handler, stage, stage_info));
    399:   PetscFunctionReturn(PETSC_SUCCESS);
    400: }

    402: /*@
    403:   PetscLogHandlerSetLogActions - Determines whether actions are logged for a log handler.

    405:   Not Collective

    407:   Input Parameters:
    408: + handler - a `PetscLogHandler`
    409: - flag    - `PETSC_TRUE` if actions are to be logged (ignored if `handler` does not log actions)

    411:   Level: developer

    413:   Notes:
    414:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    415:   `PetscLogSetLogActions()` to call this function for the default log handler that is connected to the global
    416:   logging state (`PetscLogGetState()`).

    418:   Logging of actions continues to consume more memory as the program runs. Long running programs should consider
    419:   turning this feature off.

    421: .seealso: [](ch_profiling), `PetscLogSetLogActions()`, `PetscLogStagePush()`, `PetscLogStagePop()`, `PetscLogGetDefaultHandler()`
    422: @*/
    423: PetscErrorCode PetscLogHandlerSetLogActions(PetscLogHandler handler, PetscBool flag)
    424: {
    425:   PetscFunctionBegin;
    427:   PetscTryMethod(handler, "PetscLogHandlerSetLogActions_C", (PetscLogHandler, PetscBool), (handler, flag));
    428:   PetscFunctionReturn(PETSC_SUCCESS);
    429: }

    431: /*@
    432:   PetscLogHandlerSetLogObjects - Determines whether objects are logged for a log handler.

    434:   Not Collective

    436:   Input Parameters:
    437: + handler - a `PetscLogHandler`
    438: - flag    - `PETSC_TRUE` if objects are to be logged (ignored if `handler` does not log objects)

    440:   Level: developer

    442:   Notes:
    443:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    444:   `PetscLogSetLogObjects()` to call this function for the default log handler that is connected to the global
    445:   logging state (`PetscLogGetState()`).

    447:   Logging of objects continues to consume more memory as the program runs. Long running programs should consider
    448:   turning this feature off.

    450: .seealso: [](ch_profiling), `PetscLogSetLogObjects()`, `PetscLogStagePush()`, `PetscLogStagePop()`, `PetscLogGetDefaultHandler()`
    451: @*/
    452: PetscErrorCode PetscLogHandlerSetLogObjects(PetscLogHandler handler, PetscBool flag)
    453: {
    454:   PetscFunctionBegin;
    456:   PetscTryMethod(handler, "PetscLogHandlerSetLogObjects_C", (PetscLogHandler, PetscBool), (handler, flag));
    457:   PetscFunctionReturn(PETSC_SUCCESS);
    458: }

    460: PetscErrorCode PetscLogHandlerLogObjectState_Internal(PetscLogHandler handler, PetscObject obj, const char format[], va_list argp)
    461: {
    462:   PetscFunctionBegin;
    463:   PetscTryMethod(handler, "PetscLogHandlerLogObjectState_C", (PetscLogHandler, PetscObject, const char *, va_list), (handler, obj, format, argp));
    464:   PetscFunctionReturn(PETSC_SUCCESS);
    465: }

    467: /*@C
    468:   PetscLogHandlerLogObjectState - Record information about an object with the default log handler

    470:   Not Collective, No Fortran Support

    472:   Input Parameters:
    473: + handler - a `PetscLogHandler`
    474: . obj     - the `PetscObject`
    475: . format  - a printf-style format string
    476: - ...     - printf arguments to format

    478:   Level: developer

    480:   Note:
    481:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    482:   `PetscLogObjectState()` to call this function for the default log handler that is connected to the global
    483:   logging state (`PetscLogGetState()`).

    485: .seealso: [](ch_profiling), `PetscLogObjectState`, `PetscLogObjectCreate()`, `PetscLogObjectDestroy()`, `PetscLogGetDefaultHandler()`
    486: @*/
    487: PetscErrorCode PetscLogHandlerLogObjectState(PetscLogHandler handler, PetscObject obj, const char format[], ...)
    488: {
    489:   va_list argp;

    491:   PetscFunctionBegin;
    494:   PetscAssertPointer(format, 3);
    495:   va_start(argp, format);
    496:   PetscCall(PetscLogHandlerLogObjectState_Internal(handler, obj, format, argp));
    497:   va_end(argp);
    498:   PetscFunctionReturn(PETSC_SUCCESS);
    499: }

    501: /*@
    502:   PetscLogHandlerGetNumObjects - Get the number of objects that were logged with a log handler

    504:   Not Collective

    506:   Input Parameter:
    507: . handler - a `PetscLogHandler`

    509:   Output Parameter:
    510: . num_objects - the number of objects whose creations and destructions were logged with `handler`
    511:                 (`PetscLogHandlerObjectCreate()` / `PetscLogHandlerObjectDestroy()`), or -1
    512:                 if the handler does not keep track of this number.

    514:   Level: developer

    516:   Note:
    517:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.

    519: .seealso: [](ch_profiling)
    520: @*/
    521: PetscErrorCode PetscLogHandlerGetNumObjects(PetscLogHandler handler, PetscInt *num_objects)
    522: {
    523:   PetscFunctionBegin;
    525:   PetscAssertPointer(num_objects, 2);
    526:   PetscTryMethod(handler, "PetscLogHandlerGetNumObjects_C", (PetscLogHandler, PetscInt *), (handler, num_objects));
    527:   PetscFunctionReturn(PETSC_SUCCESS);
    528: }

    530: /*@
    531:   PetscLogHandlerEventDeactivatePush - Temporarily deactivate a logging event for a log handler

    533:   Not collective

    535:   Input Parameters:
    536: + handler - a `PetscLogHandler`
    537: . stage   - a `PetscLogStage` (or `PETSC_DEFAULT` for the current stage)
    538: - event   - a `PetscLogEvent`

    540:   Level: developer

    542:   Note:
    543:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    544:   `PetscLogEventDeactivatePush()` to call this function for the default log handler that is connected to the global
    545:   logging state (`PetscLogGetState()`).

    547: .seealso: [](ch_profiling), `PetscLogHandlerEventDeactivatePop()`
    548: @*/
    549: PetscErrorCode PetscLogHandlerEventDeactivatePush(PetscLogHandler handler, PetscLogStage stage, PetscLogEvent event)
    550: {
    551:   PetscFunctionBegin;
    553:   PetscTryMethod(handler, "PetscLogHandlerEventDeactivatePush_C", (PetscLogHandler, PetscLogStage, PetscLogEvent), (handler, stage, event));
    554:   PetscFunctionReturn(PETSC_SUCCESS);
    555: }

    557: /*@
    558:   PetscLogHandlerEventDeactivatePop - Undo temporary deactivation a logging event for a log handler

    560:   Not collective

    562:   Input Parameters:
    563: + handler - a `PetscLogHandler`
    564: . stage   - a `PetscLogStage` (or `PETSC_DEFAULT` for the current stage)
    565: - event   - a `PetscLogEvent`

    567:   Level: developer

    569:   Note:
    570:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    571:   `PetscLogEventDeactivatePop()` to call this function for the default log handler that is connected to the global
    572:   logging state (`PetscLogGetState()`).

    574: .seealso: [](ch_profiling), `PetscLogHandlerEventDeactivatePush()`
    575: @*/
    576: PetscErrorCode PetscLogHandlerEventDeactivatePop(PetscLogHandler handler, PetscLogStage stage, PetscLogEvent event)
    577: {
    578:   PetscFunctionBegin;
    580:   PetscTryMethod(handler, "PetscLogHandlerEventDeactivatePop_C", (PetscLogHandler, PetscLogStage, PetscLogEvent), (handler, stage, event));
    581:   PetscFunctionReturn(PETSC_SUCCESS);
    582: }

    584: /*@
    585:   PetscLogHandlerEventsPause - Put event logging into "paused" mode (see `PetscLogEventsPause()` for details.) for a log handler

    587:   Not collective

    589:   Input Parameter:
    590: . handler - a `PetscLogHandler`

    592:   Level: developer

    594:   Note:
    595:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    596:   `PetscLogEventsPause()` to call this function for the default log handler that is connected to the global
    597:   logging state (`PetscLogGetState()`).

    599: .seealso: [](ch_profiling), `PetscLogHandlerEventsResume()`
    600: @*/
    601: PetscErrorCode PetscLogHandlerEventsPause(PetscLogHandler handler)
    602: {
    603:   PetscFunctionBegin;
    605:   PetscTryMethod(handler, "PetscLogHandlerEventsPause_C", (PetscLogHandler), (handler));
    606:   PetscFunctionReturn(PETSC_SUCCESS);
    607: }

    609: /*@
    610:   PetscLogHandlerEventsResume - Resume event logging that had been put into "paused" mode (see `PetscLogEventsPause()` for details.) for a log handler

    612:   Not collective

    614:   Input Parameter:
    615: . handler - a `PetscLogHandler`

    617:   Level: developer

    619:   Note:
    620:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    621:   `PetscLogEventsResume()` to call this function for the default log handler that is connected to the global
    622:   logging state (`PetscLogGetState()`).

    624: .seealso: [](ch_profiling), `PetscLogHandlerEventsPause()`
    625: @*/
    626: PetscErrorCode PetscLogHandlerEventsResume(PetscLogHandler handler)
    627: {
    628:   PetscFunctionBegin;
    630:   PetscTryMethod(handler, "PetscLogHandlerEventsResume_C", (PetscLogHandler), (handler));
    631:   PetscFunctionReturn(PETSC_SUCCESS);
    632: }

    634: /*@
    635:   PetscLogHandlerDump - Dump the records of a log handler to file

    637:   Not collective

    639:   Input Parameters:
    640: + handler - a `PetscLogHandler`
    641: - sname   - the name of the file to dump log data to

    643:   Level: developer

    645:   Note:
    646:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    647:   `PetscLogDump()` to call this function for the default log handler that is connected to the global
    648:   logging state (`PetscLogGetState()`).

    650: .seealso: [](ch_profiling)
    651: @*/
    652: PetscErrorCode PetscLogHandlerDump(PetscLogHandler handler, const char sname[])
    653: {
    654:   PetscFunctionBegin;
    655:   PetscTryMethod(handler, "PetscLogHandlerDump_C", (PetscLogHandler, const char *), (handler, sname));
    656:   PetscFunctionReturn(PETSC_SUCCESS);
    657: }

    659: /*@
    660:   PetscLogHandlerStageSetVisible - Set the visibility of logging stage in `PetscLogHandlerView()` for a log handler

    662:   Not collective

    664:   Input Parameters:
    665: + handler   - a `PetscLogHandler`
    666: . stage     - a `PetscLogStage`
    667: - isVisible - the visibility flag, `PETSC_TRUE` to print, else `PETSC_FALSE` (defaults to `PETSC_TRUE`)

    669:   Level: developer

    671:   Note:
    672:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    673:   `PetscLogStageSetVisible()` to call this function for the default log handler that is connected to the global
    674:   logging state (`PetscLogGetState()`).

    676: .seealso: [](ch_profiling), `PetscLogHandlerStageGetVisible()`
    677: @*/
    678: PetscErrorCode PetscLogHandlerStageSetVisible(PetscLogHandler handler, PetscLogStage stage, PetscBool isVisible)
    679: {
    680:   PetscFunctionBegin;
    682:   PetscTryMethod(handler, "PetscLogHandlerStageSetVisible_C", (PetscLogHandler, PetscLogStage, PetscBool), (handler, stage, isVisible));
    683:   PetscFunctionReturn(PETSC_SUCCESS);
    684: }

    686: /*@
    687:   PetscLogHandlerStageGetVisible - Get the visibility of logging stage in `PetscLogHandlerView()` for a log handler

    689:   Not collective

    691:   Input Parameters:
    692: + handler - a `PetscLogHandler`
    693: - stage   - a `PetscLogStage`

    695:   Output Parameter:
    696: . isVisible - the visibility flag, `PETSC_TRUE` to print, else `PETSC_FALSE` (defaults to `PETSC_TRUE`)

    698:   Level: developer

    700:   Note:
    701:   The default log handler `PETSCLOGHANDLERDEFAULT` implements this function, but others generally do not.  You can use
    702:   `PetscLogStageGetVisible()` to call this function for the default log handler that is connected to the global
    703:   logging state (`PetscLogGetState()`).

    705: .seealso: [](ch_profiling), `PetscLogHandlerStageSetVisible()`
    706: @*/
    707: PetscErrorCode PetscLogHandlerStageGetVisible(PetscLogHandler handler, PetscLogStage stage, PetscBool *isVisible)
    708: {
    709:   PetscFunctionBegin;
    711:   PetscTryMethod(handler, "PetscLogHandlerStageGetVisible_C", (PetscLogHandler, PetscLogStage, PetscBool *), (handler, stage, isVisible));
    712:   PetscFunctionReturn(PETSC_SUCCESS);
    713: }