flux-comm

flux-comm —

Synopsis




#define     FLUX_COMM                       (comm)
struct      FluxComm;
void        flux_comm_init                  (FluxComm *comm,
                                             FluxIO *io);
FluxComm*   flux_comm_new                   (FluxIO *io);
void        flux_comm_finalize              (FluxObject *obj);
void        flux_comm_enqueue_full          (FluxComm *comm,
                                             FluxTree *tree,
                                             FluxCommOrder order,
                                             FluxCommSentFunc *func,
                                             gpointer func_data);
void        flux_comm_enqueue               (FluxComm *comm,
                                             FluxTree *tree);
FluxTree*   flux_comm_dequeue               (FluxComm *comm);
void        flux_comm_flush                 (FluxComm *comm);
void        flux_comm_reset                 (FluxComm *comm);
FluxIO*     flux_comm_get_io                (FluxComm *comm);
void        flux_comm_set_dequeue_func      (FluxComm *comm,
                                             FluxCommDequeueFunc *func,
                                             gpointer data);
void        flux_comm_set_limits            (FluxComm *c,
                                             gulong nodes,
                                             gulong size,
                                             gulong depth);
void        flux_comm_get_limits            (FluxComm *c,
                                             gulong *nodes,
                                             gulong *size,
                                             gulong *depth);
void        flux_comm_set_auto_flush        (FluxComm *comm,
                                             gboolean auto_flush);

Description

Details

FLUX_COMM()

#define FLUX_COMM(comm) ((FluxComm *) comm)

comm :

struct FluxComm

struct FluxComm {

  FluxObject object;

  FluxIO *io;

  FluxTree *queue_in, *queue_out;

  FluxTree *root_in, *root_out;
  FluxTree *node_in, *node_out;

  FluxCommSentFunc *sent_out_func;
  gpointer sent_out_func_data;

  FluxTree *sent_func_tree;

  gboolean recursing;
  gboolean do_auto_flush;

  guint32 block_in_size, block_out_size;
  guint32 block_in_bytes_left, block_out_bytes_left;
  guint32 node_in_bytes_left, node_out_bytes_left;
  guint32 block_in_level, block_out_level;  /* Breadth-first traversal */

  guint16 state_in : 2;  /* None, block header, node header, node data */
  guint16 state_out : 2;

  guint16 order_in : 1;
  guint16 order_out : 1;
  
  guint16 trans_in, trans_out;
  
  guint32 block_nodes_max, block_size_max, block_depth_max;
  guint16 trans_last;

  FluxCommDequeueFunc *dequeue_func;
  gpointer dequeue_func_data;
};

flux_comm_init ()

void        flux_comm_init                  (FluxComm *comm,
                                             FluxIO *io);

`comm` :
`io` :

flux_comm_new ()

FluxComm*   flux_comm_new                   (FluxIO *io);

`io` :
Returns :

flux_comm_finalize ()

void        flux_comm_finalize              (FluxObject *obj);

obj :

flux_comm_enqueue_full ()

void        flux_comm_enqueue_full          (FluxComm *comm,
                                             FluxTree *tree,
                                             FluxCommOrder order,
                                             FluxCommSentFunc *func,
                                             gpointer func_data);

`comm` :
`tree` :
`order` :
`func` :
`func_data` :

flux_comm_enqueue ()

void        flux_comm_enqueue               (FluxComm *comm,
                                             FluxTree *tree);

`comm` :
`tree` :

flux_comm_dequeue ()

FluxTree*   flux_comm_dequeue               (FluxComm *comm);

`comm` :
Returns :

flux_comm_flush ()

void        flux_comm_flush                 (FluxComm *comm);

comm :

flux_comm_reset ()

void        flux_comm_reset                 (FluxComm *comm);

comm :

flux_comm_get_io ()

FluxIO*     flux_comm_get_io                (FluxComm *comm);

`comm` :
Returns :

flux_comm_set_dequeue_func ()

void        flux_comm_set_dequeue_func      (FluxComm *comm,
                                             FluxCommDequeueFunc *func,
                                             gpointer data);

`comm` :
`func` :
`data` :

flux_comm_set_limits ()

void        flux_comm_set_limits            (FluxComm *c,
                                             gulong nodes,
                                             gulong size,
                                             gulong depth);

`c` :
`nodes` :
`size` :
`depth` :

flux_comm_get_limits ()

void        flux_comm_get_limits            (FluxComm *c,
                                             gulong *nodes,
                                             gulong *size,
                                             gulong *depth);

`c` :
`nodes` :
`size` :
`depth` :

flux_comm_set_auto_flush ()

void        flux_comm_set_auto_flush        (FluxComm *comm,
                                             gboolean auto_flush);

`comm` :
`auto_flush` :