process.h

Go to the documentation of this file.

#pragma once

#include <stdbool.h>

#include <mm/state.h>
#include <mm/mm.h>
#include <mm/ecs.h>
#include <datatypes/list.h>
#include <datatypes/msgchannel.h>
#include <arch/ult.h>
#include <lib/numerical.h>
#include <lib/abm_layer.h>
#include <lib/topology.h>
#include <communication/communication.h>
#include <arch/x86/linux/cross_state_manager/cross_state_manager.h>

#define LP_STACK_SIZE   4194304 // 4 MB

#define LP_STATE_READY          0x00001
#define LP_STATE_RUNNING        0x00002
#define LP_STATE_RUNNING_ECS        0x00004
#define LP_STATE_ROLLBACK       0x00008
#define LP_STATE_SILENT_EXEC        0x00010
#define LP_STATE_SUSPENDED      0x01010
#define LP_STATE_READY_FOR_SYNCH    0x00011 // This should be a blocked state! Check schedule() and stf()
#define LP_STATE_WAIT_FOR_SYNCH     0x01001
#define LP_STATE_WAIT_FOR_UNBLOCK   0x01002
#define LP_STATE_WAIT_FOR_DATA      0x01004

#define BLOCKED_STATE           0x01000
#define is_blocked_state(state) (bool)(state & BLOCKED_STATE)

struct lp_struct {
    LP_context_t context;

    LP_context_t default_context;

    void *stack;

    struct memory_map *mm;

    LID_t lid;

    GID_t gid;

    unsigned int worker_thread;

    short unsigned int state;

    unsigned int ckpt_period;

    unsigned int from_last_ckpt;

    bool state_log_forced;

    void *current_base_pointer;

     list(msg_t) queue_in;

    msg_t *bound;

     list(msg_hdr_t) queue_out;

     list(state_t) queue_states;

    msg_channel *bottom_halves;

     list(msg_t) rendezvous_queue;

    unsigned long long mark;

    outgoing_t outgoing_buffer;

    bool (*OnGVT)(unsigned int me, void *snapshot);

    void (*ProcessEvent)(unsigned int me, simtime_t now, int event_type,
                 void *event_content, unsigned int size,
                 void *state);

#ifdef HAVE_CROSS_STATE
    GID_t ECS_synch_table[MAX_CROSS_STATE_DEPENDENCIES];
    unsigned int ECS_index;
#endif

    unsigned long long wait_on_rendezvous;
    unsigned int wait_on_object;

    /* Per-Library variables */
    numerical_state_t numerical;

    topology_t *topology;

    region_abm_t *region;
    
};

// LPs process control blocks and binding control blocks
extern struct lp_struct **lps_blocks;
extern __thread struct lp_struct **lps_bound_blocks;

#define lvt(lp) (lp->bound != NULL ? lp->bound->timestamp : 0.0)

// TODO: see issue #121 to see how to make this ugly hack disappear
extern __thread unsigned int __lp_counter;
extern __thread unsigned int __lp_bound_counter;

#define foreach_lp(lp)      __lp_counter = 0;\
                for(struct lp_struct *(lp) = lps_blocks[__lp_counter]; __lp_counter < n_prc && ((lp) = lps_blocks[__lp_counter]); ++__lp_counter)

#define foreach_bound_lp(lp)    __lp_bound_counter = 0;\
                for(struct lp_struct *(lp) = lps_bound_blocks[__lp_bound_counter]; __lp_bound_counter < n_prc_per_thread && ((lp) = lps_bound_blocks[__lp_bound_counter]); ++__lp_bound_counter)

#define LPS_bound_set(entry, lp)    lps_bound_blocks[(entry)] = (lp);

extern void initialize_binding_blocks(void);
extern void initialize_lps(void);
extern struct lp_struct *find_lp_by_gid(GID_t);