ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

More changes to the object system (again) to transparently run the

Просмотр исходного кода 
constructor and destructor hierarchy.

Also changing lam_class_info_t --> lam_class_t for brevity.

This commit was SVN r749.
Этот коммит содержится в:
David Daniel 2004-02-12 22:42:39 +00:00
родитель 076cead5e8
Коммит 01b5491c18
65 изменённых файлов: 210 добавлений и 288 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

12
src/lam/ctnetwork/ctchannel.c
Просмотреть файл

@ -12,7 +12,6 @@
static void lam_cth_construct(lam_ctchannel_t *channel)
{
OBJ_CONSTRUCT_SUPER(channel, lam_object_t);
channel->cth_status = CT_CHNL_CLOSED;
channel->cth_id = 0;
channel->cth_timeout_secs = 0;
@ -21,14 +20,13 @@ static void lam_cth_construct(lam_ctchannel_t *channel)
static void lam_cth_construct(lam_ctchannel_t *channel)
{
OBJ_DESTRUCT_SUPER(channel, lam_object_t);
}
lam_ctchannel_class_t lam_ct_channel_t_class_info = {
lam_ctchannel_class_t lam_ct_channel_t_class = {
{
"lam_ct_channel_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_cth_construct,
(lam_destruct_t) lam_object_destruct
},
@ -105,7 +103,6 @@ uint32_t lam_cth_send_packed_msg(lam_ctchannel_t *channel,
static void lam_tcpch_construct(lam_tcp_chnl_t *channel)
{
OBJ_CONSTRUCT_SUPER(channel, lam_object_t);
channel->tcp_sockfd = 0;
memset(&(channel->tcp_addr), 0, sizeof(channel->tcp_addr));
channel->tcp_blocking = 0;
@ -114,14 +111,13 @@ static void lam_tcpch_construct(lam_tcp_chnl_t *channel)
static void lam_tcpch_destruct(lam_tcp_chnl_t *channel)
{
OBJ_DESTRUCT_SUPER(channel, lam_ct_channel_t);
}
lam_ctchannel_class_t lam_tcp_chnl_t_class_info = {
lam_ctchannel_class_t lam_tcp_chnl_t_class = {
{
"lam_tcp_chnl_t",
CLASS_INFO(lam_ctchannel_t),
OBJ_CLASS(lam_ctchannel_t),
(lam_construct_t) lam_tcpch_construct,
(lam_destruct_t) lam_tcpch_destruct
},

6
src/lam/ctnetwork/ctchannel.h
Просмотреть файл

@ -77,7 +77,7 @@ typedef uint32_t (*lam_cth_send_packed_msg_fn_t)(struct lam_ctchannel *,
typedef struct lam_ctchannel_class
{
lam_class_info_t super;
lam_class_t super;
/* return: error code args: (channel, data, data length, bytes sent) */
lam_cth_send_fn_t *send;
@ -98,7 +98,7 @@ typedef struct lam_ctchannel_class
} lam_ctchannel_class_t;
extern lam_ctchannel_class_t lam_ct_channel_t_class_info;
extern lam_ctchannel_class_t lam_ct_channel_t_class;
typedef struct lam_ctchannel
{
@ -187,7 +187,7 @@ typedef struct lam_tcp_channel
int tcp_blocking;
} lam_tcp_chnl_t;
extern lam_ctchannel_class_t lam_tcp_chnl_t_class_info;
extern lam_ctchannel_class_t lam_tcp_chnl_t_class;
uint32_t lam_tcpch_send(lam_tcp_chnl_t *channel, const uint8_t *data,
uint32_t data_len, uint32_t *bytes_sent);

13
src/lam/ctnetwork/ctmessage.c
Просмотреть файл

@ -6,17 +6,17 @@
#include "lam/mem/malloc.h"
lam_class_info_t lam_ct_ctrl_t_class_info = {
lam_class_t lam_ct_ctrl_t_class = {
"lam_ct_ctrl_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_ctc_construct,
(lam_destruct_t) lam_ctc_destruct
};
lam_class_info_t lam_ctmsg_t_class_info = {
lam_class_t lam_ctmsg_t_class = {
"lam_ctmsg_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_ctm_construct,
(lam_destruct_t) lam_ctm_destruct
};
@ -27,8 +27,6 @@ static const uint32_t ctrl_alloc_len = sizeof(lam_ct_ctrl_t) -
void lam_ctc_construct(lam_ct_ctrl_t *ctrl)
{
OBJ_CONSTRUCT_SUPER(ctrl, lam_object_t);
ctrl->ctc_is_user_msg = 0;
ctrl->ctc_routing_type = LAM_CT_PT2PT;
ctrl->ctc_sender = 0;
@ -44,7 +42,6 @@ void lam_ctc_construct(lam_ct_ctrl_t *ctrl)
void lam_ctc_destruct(lam_ct_ctrl_t *ctrl)
{
lam_free(ctrl->ctc_info);
OBJ_DESTRUCT_SUPER(ctrl, lam_object_t);
}
@ -200,7 +197,6 @@ void lam_pk_ctc_set_info(uint8_t *buffer, uint8_t *info)
void lam_ctm_construct(lam_ctmsg_t *msg)
{
OBJ_CONSTRUCT_SUPER(msg, lam_object_t);
msg->ctm_ctrl = OBJ_NEW(lam_ct_ctrl_t);
msg->ctm_len = 0;
msg->ctm_data = 0;
@ -213,7 +209,6 @@ void lam_ctm_destruct(lam_ctmsg_t *msg)
lam_free(msg->ctm_data);
}
OBJECT_RELEASE(msg->ctm_ctrl);
OBJ_DESTRUCT_SUPER(msg, lam_object_t);
}
lam_ctmsg_t *lam_ctm_create_with(int is_user_msg, int routing_type,

4
src/lam/ctnetwork/ctmessage.h
Просмотреть файл

@ -14,8 +14,8 @@
*
*/
extern lam_class_info_t lam_ct_ctrl_t_class_info;
extern lam_class_info_t lam_ctmsg_t_class_info;
extern lam_class_t lam_ct_ctrl_t_class;
extern lam_class_t lam_ctmsg_t_class;
/*
*

6
src/lam/ctnetwork/ctnode.h
Просмотреть файл

@ -25,7 +25,7 @@ typedef char *(*lam_ctl_isa_neighbor_fn_t)(struct lam_ctnode *, uint32_t);
typedef struct lam_ctnode_class
{
lam_class_info_t super;
lam_class_t super;
lam_ctl_label_for_link_fn_t *ctl_label_for_link;
lam_ctl_isa_neighbor_fn_t *ctl_isa_neighbor;
} lam_ctnode_class_t;
@ -40,7 +40,7 @@ typedef struct lam_ctnode_class
*/
extern lam_ctnode_class_t hypercube_t_class_info;
extern lam_ctnode_class_t hypercube_t_class;
@ -153,6 +153,6 @@ typedef struct lam_hcube
unsigned int hc_hsize; /* hc_hsize = log2(# nodes in network) */
} lam_hcube_t;
extern lam_class_info_t hcube_t_class_info;
extern lam_class_t hcube_t_class;
#endif /* LAM_CT_NODE_H */

8
src/lam/event/event.h
Просмотреть файл

@ -33,6 +33,14 @@
extern "C" {
#endif
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef WIN32
#include <windows.h>
#endif

60
src/lam/event/kqueue.c
Просмотреть файл

@ -81,13 +81,13 @@ struct kqop {
} kqueueop;
static void *kq_init (void);
static int kq_add (void *, struct event *);
static int kq_del (void *, struct event *);
static int kq_add (void *, struct lam_event *);
static int kq_del (void *, struct lam_event *);
static int kq_recalc (void *, int);
static int kq_dispatch (void *, struct timeval *);
static int kq_insert (struct kqop *, struct kevent *);
const struct eventop kqops = {
const struct lam_eventop lam_kqops = {
"kqueue",
kq_init,
kq_add,
@ -96,8 +96,8 @@ const struct eventop kqops = {
kq_dispatch
};
void *
static kq_init(void)
static void *
kq_init(void)
{
int kq;
@ -193,7 +193,7 @@ kq_dispatch(void *arg, struct timeval *tv)
struct kqop *kqop = arg;
struct kevent *changes = kqop->changes;
struct kevent *events = kqop->events;
struct event *ev;
struct lam_event *ev;
struct timespec ts;
int i, res;
@ -233,26 +233,26 @@ kq_dispatch(void *arg, struct timeval *tv)
return (-1);
}
ev = (struct event *)events[i].udata;
ev = (struct lam_event *)events[i].udata;
if (events[i].filter == EVFILT_READ) {
which |= EV_READ;
which |= LAM_EV_READ;
} else if (events[i].filter == EVFILT_WRITE) {
which |= EV_WRITE;
which |= LAM_EV_WRITE;
} else if (events[i].filter == EVFILT_SIGNAL) {
which |= EV_SIGNAL;
which |= LAM_EV_SIGNAL;
}
if (!which)
continue;
if (!(ev->ev_events & EV_PERSIST)) {
if (!(ev->ev_events & LAM_EV_PERSIST)) {
ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
event_del(ev);
lam_event_del(ev);
}
event_active(ev, which,
ev->ev_events & EV_SIGNAL ? events[i].data : 1);
lam_event_active(ev, which,
ev->ev_events & LAM_EV_SIGNAL ? events[i].data : 1);
}
return (0);
@ -260,21 +260,21 @@ kq_dispatch(void *arg, struct timeval *tv)
static int
kq_add(void *arg, struct event *ev)
kq_add(void *arg, struct lam_event *ev)
{
struct kqop *kqop = arg;
struct kevent kev;
if (ev->ev_events & EV_SIGNAL) {
int nsignal = EVENT_SIGNAL(ev);
if (ev->ev_events & LAM_EV_SIGNAL) {
int nsignal = LAM_EVENT_SIGNAL(ev);
memset(&kev, 0, sizeof(kev));
kev.ident = nsignal;
kev.filter = EVFILT_SIGNAL;
kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST))
if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev);
kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1)
return (-1);
@ -286,14 +286,14 @@ kq_add(void *arg, struct event *ev)
return (0);
}
if (ev->ev_events & EV_READ) {
if (ev->ev_events & LAM_EV_READ) {
memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd;
kev.filter = EVFILT_READ;
kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST))
if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev);
kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1)
return (-1);
@ -301,14 +301,14 @@ kq_add(void *arg, struct event *ev)
ev->ev_flags |= EVLIST_X_KQINKERNEL;
}
if (ev->ev_events & EV_WRITE) {
if (ev->ev_events & LAM_EV_WRITE) {
memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd;
kev.filter = EVFILT_WRITE;
kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST))
if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev);
kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1)
return (-1);
@ -320,7 +320,7 @@ kq_add(void *arg, struct event *ev)
}
static int
kq_del(void *arg, struct event *ev)
kq_del(void *arg, struct lam_event *ev)
{
struct kqop *kqop = arg;
struct kevent kev;
@ -328,8 +328,8 @@ kq_del(void *arg, struct event *ev)
if (!(ev->ev_flags & EVLIST_X_KQINKERNEL))
return (0);
if (ev->ev_events & EV_SIGNAL) {
int nsignal = EVENT_SIGNAL(ev);
if (ev->ev_events & LAM_EV_SIGNAL) {
int nsignal = LAM_EVENT_SIGNAL(ev);
memset(&kev, 0, sizeof(kev));
kev.ident = (int)signal;
@ -346,7 +346,7 @@ kq_del(void *arg, struct event *ev)
return (0);
}
if (ev->ev_events & EV_READ) {
if (ev->ev_events & LAM_EV_READ) {
memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd;
kev.filter = EVFILT_READ;
@ -358,7 +358,7 @@ kq_del(void *arg, struct event *ev)
ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
}
if (ev->ev_events & EV_WRITE) {
if (ev->ev_events & LAM_EV_WRITE) {
memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd;
kev.filter = EVFILT_WRITE;

22
src/lam/event/rtsig.c
Просмотреть файл

@ -119,13 +119,13 @@ activate(struct event *ev, int flags)
event_active(ev, flags, 1);
}
void *rtsig_init(void);
int rtsig_add(void *, struct event *);
int rtsig_del(void *, struct event *);
int rtsig_recalc(void *, int);
int rtsig_dispatch(void *, struct timeval *);
static void *rtsig_init(void);
static int rtsig_add(void *, struct event *);
static int rtsig_del(void *, struct event *);
static int rtsig_recalc(void *, int);
static int rtsig_dispatch(void *, struct timeval *);
struct eventop rtsigops = {
struct lam_eventop rtsigops = {
"rtsig",
rtsig_init,
rtsig_add,
@ -134,7 +134,7 @@ struct eventop rtsigops = {
rtsig_dispatch
};
void *
static void *
rtsig_init(void)
{
struct rtsigop *op;
@ -168,7 +168,7 @@ rtsig_init(void)
return (op);
}
int
static int
rtsig_add(void *arg, struct event *ev)
{
struct rtsigop *op = (struct rtsigop *) arg;
@ -222,7 +222,7 @@ rtsig_add(void *arg, struct event *ev)
return (-1);
}
int
static int
rtsig_del(void *arg, struct event *ev)
{
struct rtsigop *op = (struct rtsigop *) arg;
@ -250,13 +250,13 @@ rtsig_del(void *arg, struct event *ev)
return (0);
}
int
static int
rtsig_recalc(void *arg, int max)
{
return (0);
}
int
static int
rtsig_dispatch(void *arg, struct timeval *tv)
{
struct rtsigop *op = (struct rtsigop *) arg;

24
src/lam/lfc/lam_hash_table.c
Просмотреть файл

@ -21,9 +21,9 @@ static void lam_hash_table_construct(lam_hash_table_t* ht);
static void lam_hash_table_destruct(lam_hash_table_t* ht);
lam_class_info_t lam_hash_table_t_class_info = {
lam_class_t lam_hash_table_t_class = {
"lam_hash_table_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_hash_table_construct,
(lam_destruct_t)lam_hash_table_destruct
};
@ -32,7 +32,6 @@ lam_class_info_t lam_hash_table_t_class_info = {
static void lam_hash_table_construct(lam_hash_table_t* ht)
{
OBJ_CONSTRUCT_SUPER(ht, lam_object_t);
OBJ_CONSTRUCT(&ht->ht_nodes, lam_list_t);
ht->ht_table = NULL;
ht->ht_table_size = 0;
@ -49,7 +48,6 @@ static void lam_hash_table_destruct(lam_hash_table_t* ht)
if(NULL != ht->ht_table)
free(ht->ht_table);
OBJ_DESTRUCT(&ht->ht_nodes);
OBJ_DESTRUCT_SUPER(ht, lam_object_t);
}
@ -106,17 +104,15 @@ typedef struct lam_uint32_hash_node_t lam_uint32_hash_node_t;
static void lam_uint32_hash_node_construct(lam_uint32_hash_node_t* hn)
{
OBJ_CONSTRUCT_SUPER(hn, lam_list_item_t);
}
static void lam_uint32_hash_node_destruct(lam_uint32_hash_node_t* hn)
{
OBJ_DESTRUCT_SUPER(hn, lam_list_item_t);
}
static lam_class_info_t lam_uint32_hash_node_t_class_info = {
static lam_class_t lam_uint32_hash_node_t_class = {
"lam_uint32_hash_node_t",
&lam_list_item_t_class_info,
&lam_list_item_t_class,
(lam_construct_t)lam_uint32_hash_node_construct,
(lam_destruct_t)lam_uint32_hash_node_destruct
};
@ -217,17 +213,15 @@ typedef struct lam_uint64_hash_node_t lam_uint64_hash_node_t;
static void lam_uint64_hash_node_construct(lam_uint64_hash_node_t* hn)
{
OBJ_CONSTRUCT_SUPER(hn, lam_list_item_t);
}
static void lam_uint64_hash_node_destruct(lam_uint64_hash_node_t* hn)
{
OBJ_DESTRUCT_SUPER(hn, lam_list_item_t);
}
static lam_class_info_t lam_uint64_hash_node_t_class_info = {
static lam_class_t lam_uint64_hash_node_t_class = {
"lam_uint64_hash_node_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_uint64_hash_node_construct,
(lam_destruct_t)lam_uint64_hash_node_destruct
};
@ -330,7 +324,6 @@ typedef struct lam_ptr_hash_node_t lam_ptr_hash_node_t;
static void lam_ptr_hash_node_construct(lam_ptr_hash_node_t* hn)
{
OBJ_CONSTRUCT_SUPER(hn, lam_list_item_t);
hn->hn_key_size = 0;
hn->hn_key = NULL;
hn->hn_value = NULL;
@ -338,14 +331,13 @@ static void lam_ptr_hash_node_construct(lam_ptr_hash_node_t* hn)
static void lam_ptr_hash_node_destruct(lam_ptr_hash_node_t* hn)
{
OBJ_DESTRUCT_SUPER(hn, lam_list_item_t);
if(NULL != hn->hn_key)
free(hn->hn_key);
}
static lam_class_info_t lam_ptr_hash_node_t_class_info = {
static lam_class_t lam_ptr_hash_node_t_class = {
"lam_ptr_hash_node_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_ptr_hash_node_construct,
(lam_destruct_t)lam_ptr_hash_node_destruct
};

2
src/lam/lfc/lam_hash_table.h
Просмотреть файл

@ -18,7 +18,7 @@
#include "lam/lfc/lam_list.h"
extern lam_class_info_t lam_hash_table_t_class_info;
extern lam_class_t lam_hash_table_t_class;
struct lam_hash_table_t
{

12
src/lam/lfc/lam_list.c
Просмотреть файл

@ -11,9 +11,9 @@
static void lam_list_item_construct(lam_list_item_t*);
static void lam_list_item_destruct(lam_list_item_t*);
lam_class_info_t lam_list_item_t_class_info = {
lam_class_t lam_list_item_t_class = {
"lam_list_item_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_list_item_construct,
(lam_destruct_t) lam_list_item_destruct
};
@ -21,9 +21,9 @@ lam_class_info_t lam_list_item_t_class_info = {
static void lam_list_construct(lam_list_t*);
static void lam_list_destruct(lam_list_t*);
lam_class_info_t lam_list_t_class_info = {
lam_class_t lam_list_t_class = {
"lam_list_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_list_construct,
(lam_destruct_t) lam_list_destruct
};
@ -37,14 +37,12 @@ lam_class_info_t lam_list_t_class_info = {
static void lam_list_item_construct(lam_list_item_t *item)
{
OBJ_CONSTRUCT_SUPER(item, lam_object_t);
item->lam_list_next = item->lam_list_prev = NULL;
item->lam_list_type = 0;
}
static void lam_list_item_destruct(lam_list_item_t *item)
{
OBJ_DESTRUCT_SUPER(item, lam_object_t);
}
@ -56,7 +54,6 @@ static void lam_list_item_destruct(lam_list_item_t *item)
static void lam_list_construct(lam_list_t *list)
{
OBJ_CONSTRUCT_SUPER(list, lam_object_t);
list->lam_list_head.lam_list_prev = NULL;
list->lam_list_head.lam_list_next = &list->lam_list_tail;
list->lam_list_tail.lam_list_prev = &list->lam_list_head;
@ -70,7 +67,6 @@ static void lam_list_destruct(lam_list_t *list)
{
/* release all items in list */
lam_list_construct(list);
OBJ_DESTRUCT_SUPER(list, lam_object_t);
}

4
src/lam/lfc/lam_list.h
Просмотреть файл

@ -14,8 +14,8 @@
*
*/
extern lam_class_info_t lam_list_item_t_class_info;
extern lam_class_info_t lam_list_t_class_info;
extern lam_class_t lam_list_item_t_class;
extern lam_class_t lam_list_t_class;
typedef int lam_list_type_t;

6
src/lam/lfc/lam_object.c
Просмотреть файл

@ -18,7 +18,7 @@
* special, since be mark it as already initialized, with no parent
* and no constructor or desctructor
*/
lam_class_info_t lam_object_t_class_info = {
lam_class_t lam_object_t_class = {
"lam_object_t", /* name */
NULL, /* parent class */
NULL, /* constructor */
@ -33,9 +33,9 @@ lam_class_info_t lam_object_t_class_info = {
/*
* Lazy initialization of class descriptor.
*/
void lam_class_initialize(lam_class_info_t *class)
void lam_class_initialize(lam_class_t *class)
{
lam_class_info_t *c;
lam_class_t *c;
int i;
assert(class);

58
src/lam/lfc/lam_object.h
Просмотреть файл

@ -28,7 +28,7 @@
* ...
* };
*
* extern lam_class_info_t sally_t_class;
* extern lam_class_t sally_t_class;
* @endcode
* All classes must have a parent.
*
@ -36,9 +36,9 @@
* this class, and should be the name of the class with "_class"
* appended:
* @code
* lam_class_info_t sally_t_class = {
* lam_class_t sally_t_class = {
* "sally_t",
* CLASS_INFO(parent_t), // pointer to parent_t_class
* OBJ_CLASS(parent_t), // pointer to parent_t_class
* sally_construct,
* sally_destruct
* };
@ -122,7 +122,7 @@
/* typedefs ***********************************************************/
typedef struct lam_object_t lam_object_t;
typedef struct lam_class_info_t lam_class_info_t;
typedef struct lam_class_t lam_class_t;
typedef void (*lam_construct_t) (lam_object_t *);
typedef void (*lam_destruct_t) (lam_object_t *);
@ -135,9 +135,9 @@ typedef void (*lam_destruct_t) (lam_object_t *);
* There should be a single instance of this descriptor for each class
* definition.
*/
struct lam_class_info_t {
struct lam_class_t {
const char *cls_name; /**< symbolic name for class */
lam_class_info_t *cls_parent; /**< parent class descriptor */
lam_class_t *cls_parent; /**< parent class descriptor */
lam_construct_t cls_construct; /**< class constructor */
lam_destruct_t cls_destruct; /**< class destructor */
int cls_initialized; /**< is class initialized */
@ -155,8 +155,8 @@ struct lam_class_info_t {
* This is special and does not follow the pattern for other classes.
*/
struct lam_object_t {
lam_class_info_t *obj_class_info; /**< class descriptor */
int obj_reference_count; /**< reference count */
lam_class_t *obj_class; /**< class descriptor */
int obj_reference_count; /**< reference count */
};
@ -169,7 +169,7 @@ struct lam_object_t {
* @param type Name of class
* @return Pointer to class descriptor
*/
#define CLASS_INFO(type) (&(type ## _class_info))
#define OBJ_CLASS(type) (&(type ## _class))
/**
@ -181,7 +181,7 @@ struct lam_object_t {
* @param DESTRUCTOR Pointer to destructor
* @return Static initializer string
*/
#define CLASS_INITIALIZE(NAME, PARENT, CONSTRUCTOR, DESTRUCTOR) \
#define OBJ_CLASS_INIT(NAME, PARENT, CONSTRUCTOR, DESTRUCTOR) \
{ NAME, PARENT, CONSTRUCTOR, DESTRUCTOR, 0, 0, NULL, NULL }
@ -193,7 +193,7 @@ struct lam_object_t {
* @return Pointer to the object
*/
#define OBJ_NEW(type) \
((type *) lam_obj_new(sizeof(type), CLASS_INFO(type)))
((type *) lam_obj_new(sizeof(type), OBJ_CLASS(type)))
/**
@ -232,11 +232,11 @@ struct lam_object_t {
*/
#define OBJ_CONSTRUCT(object, type) \
do { \
if (0 == CLASS_INFO(type)->cls_initialized) { \
lam_class_initialize(CLASS_INFO(type)); \
if (0 == OBJ_CLASS(type)->cls_initialized) { \
lam_class_initialize(OBJ_CLASS(type)); \
} \
if (object) { \
((lam_object_t *) object)->obj_class_info = CLASS_INFO(type); \
((lam_object_t *) object)->obj_class = OBJ_CLASS(type); \
((lam_object_t *) object)->obj_reference_count = 1; \
lam_obj_run_constructors((lam_object_t *) object); \
} \
@ -256,15 +256,11 @@ struct lam_object_t {
} while (0)
#define OBJ_CONSTRUCT_SUPER(A, B)
#define OBJ_DESTRUCT_SUPER(A, B)
/* declarations *******************************************************/
BEGIN_C_DECLS
extern lam_class_info_t lam_object_t_class_info;
extern lam_class_t lam_object_t_class;
/**
* Lazy initialization of class descriptor.
@ -274,7 +270,7 @@ extern lam_class_info_t lam_object_t_class_info;
*
* @param class Pointer to class descriptor
*/
void lam_class_initialize(lam_class_info_t *);
void lam_class_initialize(lam_class_t *);
END_C_DECLS
@ -292,13 +288,13 @@ END_C_DECLS
*/
static inline void lam_obj_run_constructors(lam_object_t *object)
{
lam_class_info_t *cls;
lam_class_t *cls;
int i;
assert(NULL != object);
assert(NULL != object->obj_class_info);
assert(NULL != object->obj_class);
cls = object->obj_class_info;
cls = object->obj_class;
for (i = cls->cls_depth - 1; i >= 0; i--) {
if (cls->cls_construct_array[i]) {
(cls->cls_construct_array[i])(object);
@ -317,13 +313,13 @@ static inline void lam_obj_run_constructors(lam_object_t *object)
*/
static inline void lam_obj_run_destructors(lam_object_t *object)
{
lam_class_info_t *cls;
lam_class_t *cls;
int i;
assert(NULL != object);
assert(NULL != object->obj_class_info);
assert(NULL != object->obj_class);
cls = object->obj_class_info;
cls = object->obj_class;
for (i = 0; i < cls->cls_depth; i++) {
if (cls->cls_destruct_array[i]) {
(cls->cls_destruct_array[i])(object);
@ -343,7 +339,7 @@ static inline void lam_obj_run_destructors(lam_object_t *object)
* @return Pointer to the object
*/
static inline lam_object_t *lam_obj_new(size_t size,
lam_class_info_t *cls)
lam_class_t *cls)
{
lam_object_t *object;
@ -351,7 +347,7 @@ static inline lam_object_t *lam_obj_new(size_t size,
object = (lam_object_t *) malloc(size);
if (NULL != object) {
object->obj_class_info = cls;
object->obj_class = cls;
object->obj_reference_count = 1;
lam_obj_run_constructors(object);
}
@ -377,7 +373,7 @@ static inline int fetchNadd(volatile int *addr, int inc);
static inline void lam_obj_retain(lam_object_t *object)
{
assert(NULL != object);
assert(NULL != object->obj_class_info);
assert(NULL != object->obj_class);
fetchNadd(&(object->obj_reference_count), 1);
@ -397,10 +393,10 @@ static inline void lam_obj_retain(lam_object_t *object)
static inline void lam_obj_release(lam_object_t *object)
{
assert(NULL != object);
assert(NULL != object->obj_class_info);
assert(NULL != object->obj_class);
if (fetchNadd(&object->obj_reference_count, -1) == 1) {
object->obj_class_info->cls_destruct(object);
object->obj_class->cls_destruct(object);
free(object);
}
}

6
src/lam/lfc/lam_value_array.c
Просмотреть файл

@ -7,7 +7,6 @@
static void lam_value_array_construct(lam_value_array_t* array)
{
OBJ_CONSTRUCT_SUPER(array, lam_object_t);
array->array_items = NULL;
array->array_size = 0;
array->array_item_sizeof = 0;
@ -18,12 +17,11 @@ static void lam_value_array_destruct(lam_value_array_t* array)
{
if (NULL != array->array_items)
free(array->array_items);
OBJ_DESTRUCT_SUPER(array, lam_object_t);
}
lam_class_info_t lam_value_array_t_class_info = {
lam_class_t lam_value_array_t_class = {
"lam_value_array_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_value_array_construct,
(lam_destruct_t)lam_value_array_destruct
};

2
src/lam/lfc/lam_value_array.h
Просмотреть файл

@ -18,7 +18,7 @@
* @file Array of elements maintained by value.
*/
extern lam_class_info_t lam_value_array_t_class_info;
extern lam_class_t lam_value_array_t_class;
struct lam_value_array_t

6
src/lam/mem/allocator.c
Просмотреть файл

@ -10,7 +10,6 @@ void lam_allocator_default_free(lam_allocator_t *allocator, void *base_ptr);
static void lam_allocator_construct(lam_allocator_t *allocator)
{
OBJ_CONSTRUCT_SUPER(allocator, lam_object_t);
allocator->alc_alloc_fn = lam_allocator_malloc;
allocator->alc_free_fn = lam_allocator_free;
allocator->alc_is_shared = 0;
@ -22,12 +21,11 @@ static void lam_allocator_construct(lam_allocator_t *allocator)
static void lam_allocator_destruct(lam_allocator_t *allocator)
{
OBJ_DESTRUCT_SUPER(allocator, lam_object_t);
}
lam_class_info_t lam_allocator_t_class_info = {
lam_class_t lam_allocator_t_class = {
"lam_allocator_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_allocator_construct,
(lam_destruct_t) lam_allocator_destruct
};

2
src/lam/mem/allocator.h
Просмотреть файл

@ -31,7 +31,7 @@ typedef struct lam_allocator {
void (*alc_free_fn) (struct lam_allocator *, void *);
} lam_allocator_t;
extern lam_class_info_t lam_allocator_t_class_info;
extern lam_class_t lam_allocator_t_class;
void *lam_alg_get_chunk(size_t chunk_size, int is_shared, int mem_protect);

12
src/lam/mem/free_list.c
Просмотреть файл

@ -9,9 +9,9 @@ static void lam_free_list_construct(lam_free_list_t* fl);
static void lam_free_list_destruct(lam_free_list_t* fl);
lam_class_info_t lam_free_list_t_class_info = {
lam_class_t lam_free_list_t_class = {
"lam_free_list_t",
CLASS_INFO(lam_list_t),
OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_free_list_construct,
(lam_destruct_t)lam_free_list_destruct
};
@ -19,18 +19,16 @@ lam_class_info_t lam_free_list_t_class_info = {
static void lam_free_list_construct(lam_free_list_t* fl)
{
OBJ_CONSTRUCT_SUPER(fl, lam_list_t);
}
static void lam_free_list_destruct(lam_free_list_t* fl)
{
OBJ_DESTRUCT_SUPER(fl, lam_object_t);
}
int lam_free_list_init(
lam_free_list_t *flist,
size_t elem_size,
lam_class_info_t* elem_class,
lam_class_t* elem_class,
int num_elements_to_alloc,
int max_elements_to_alloc,
int num_elements_per_alloc,
@ -64,9 +62,9 @@ int lam_free_list_grow(lam_free_list_t* flist, size_t num_elements)
lam_list_item_t* item = (lam_list_item_t*)ptr;
if (NULL != flist->fl_elem_class) {
/* bypass OBJ_CONSTRUCT() in this case (generic types) */
((lam_object_t *) item)->obj_class_info = flist->fl_elem_class;
((lam_object_t *) item)->obj_class = flist->fl_elem_class;
((lam_object_t *) item)
->obj_class_info->cls_construct((lam_object_t *) item);
->obj_class->cls_construct((lam_object_t *) item);
}
lam_list_append(&flist->super, item);
ptr += flist->fl_elem_size;

6
src/lam/mem/free_list.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "lam/mem/seg_list.h"
#include "lam/mem/mem_pool.h"
extern lam_class_info_t lam_free_list_t_class_info;
extern lam_class_t lam_free_list_t_class;
struct lam_free_list_t
@ -21,7 +21,7 @@ struct lam_free_list_t
int fl_num_allocated;
int fl_num_per_alloc;
size_t fl_elem_size;
lam_class_info_t* fl_elem_class;
lam_class_t* fl_elem_class;
lam_allocator_t* fl_allocator;
lam_mutex_t fl_lock;
};
@ -31,7 +31,7 @@ typedef struct lam_free_list_t lam_free_list_t;
int lam_free_list_init(
lam_free_list_t *flist,
size_t element_size,
lam_class_info_t* element_class,
lam_class_t* element_class,
int num_elements_to_alloc,
int max_elements_to_alloc,
int num_elements_per_alloc,

11
src/lam/mem/free_lists.c
Просмотреть файл

@ -32,9 +32,9 @@ static int lam_free_lists_mem_pool_construct(lam_free_lists_t *flist, int nlists
long default_min_pages_per_list, long default_pages_per_list,
long max_pages_per_list, ssize_t max_mem_in_pool);
lam_class_info_t lam_free_lists_t_class_info = {
lam_class_t lam_free_lists_t_class = {
"lam_free_lists_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_free_lists_construct,
(lam_destruct_t) lam_free_lists_destruct
};
@ -42,7 +42,6 @@ lam_class_info_t lam_free_lists_t_class_info = {
void lam_free_lists_construct(lam_free_lists_t *flist)
{
OBJ_CONSTRUCT_SUPER(flist, lam_object_t);
lam_mutex_init(&flist->fl_lock);
flist->fl_pool = NULL;
flist->fl_elt_cls = NULL;
@ -98,8 +97,6 @@ void lam_free_lists_destruct(lam_free_lists_t *flist)
if ( flist->fl_chunks_returned )
free(flist->fl_chunks_returned);
#endif
OBJ_DESTRUCT_SUPER(flist, lam_object_t);
}
@ -455,9 +452,9 @@ static int lam_free_lists_create_more_elts(lam_free_lists_t *flist, int pool_idx
for (desc = 0; desc < flist->fl_elt_per_chunk; desc++)
{
/* bypass OBJ_CONSTRUCT() in this case (generic types) */
((lam_object_t *) current_loc)->obj_class_info = flist->fl_elt_cls;
((lam_object_t *) current_loc)->obj_class = flist->fl_elt_cls;
((lam_object_t *) current_loc)
->obj_class_info->cls_construct((lam_object_t *) current_loc);
->obj_class->cls_construct((lam_object_t *) current_loc);
current_loc += flist->fl_elt_size;
}

4
src/lam/mem/free_lists.h
Просмотреть файл

@ -33,7 +33,7 @@ struct lam_free_lists_t
int fl_enforce_affinity;
lam_affinity_t *fl_affinity; /* array of lam_affinity_t */
int fl_threshold_grow;
lam_class_info_t *fl_elt_cls; /* this will be used to create new free list elements. */
lam_class_t *fl_elt_cls; /* this will be used to create new free list elements. */
lam_mutex_t fl_lock;
/* for mem profiling */
@ -49,7 +49,7 @@ struct lam_free_lists_t
typedef struct lam_free_lists_t lam_free_lists_t;
extern lam_class_info_t lam_free_lists_t_class_info;
extern lam_class_t lam_free_lists_t_class;
void lam_free_lists_construct(lam_free_lists_t *flist);
void lam_free_lists_destruct(lam_free_lists_t *flist);

24
src/lam/mem/mem_pool.c
Просмотреть файл

@ -16,25 +16,23 @@
#include "lam/util/output.h"
#include "lam/os/numa.h"
lam_class_info_t lam_mem_pool_t_class_info = {
lam_class_t lam_mem_pool_t_class = {
"lam_mem_pool_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_mp_construct,
(lam_destruct_t) lam_mp_destruct
};
/* process-shared mem pool class */
lam_class_info_t shmem_pool_t_class_info = {
lam_class_t shmem_pool_t_class = {
"shmem_pool_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_mp_shared_construct,
(lam_destruct_t) lam_mp_destruct
};
void lam_mp_construct(lam_mem_pool_t *pool)
{
OBJ_CONSTRUCT_SUPER(pool, lam_object_t);
pool->mp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_mutex_init(&(pool->mp_lock));
pool->mp_dev_alloc = NULL;
@ -42,8 +40,6 @@ void lam_mp_construct(lam_mem_pool_t *pool)
void lam_mp_shared_construct(lam_mem_pool_t *pool)
{
OBJ_CONSTRUCT_SUPER(pool, lam_object_t);
pool->mp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_mutex_init(&(pool->mp_lock));
lam_allocator_set_is_shared(pool->mp_private_alloc, 1);
@ -56,8 +52,7 @@ void lam_mp_destruct(lam_mem_pool_t *pool)
if ( pool->mp_dev_alloc )
OBJ_RELEASE(pool->mp_dev_alloc);
OBJ_RELEASE(pool->mp_private_alloc);
OBJ_DESTRUCT_SUPER(pool, lam_object_t);
}
int lam_mp_construct_with(lam_mem_pool_t *pool, uint64_t pool_size,
@ -277,17 +272,15 @@ void *lam_mp_request_chunk(lam_mem_pool_t *pool, int pool_index)
*/
lam_class_info_t lam_fixed_mpool_t_class_info = {
lam_class_t lam_fixed_mpool_t_class = {
"lam_fixed_mpool_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_fmp_construct,
(lam_destruct_t) lam_fmp_destruct
};
void lam_fmp_construct(lam_fixed_mpool_t *pool)
{
OBJ_CONSTRUCT_SUPER(pool, lam_object_t);
pool->fmp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_allocator_set_is_shared(pool->fmp_private_alloc, 1);
lam_allocator_set_mem_prot(pool->fmp_private_alloc, MMAP_SHARED_PROT);
@ -318,8 +311,7 @@ void lam_fmp_destruct(lam_fixed_mpool_t *pool)
if ( pool->fmp_n_segs_in_array )
free(pool->fmp_n_segs_in_array);
OBJ_DESTRUCT_SUPER(pool, lam_object_t);
}

6
src/lam/mem/mem_pool.h
Просмотреть файл

@ -46,10 +46,10 @@ typedef struct lam_mem_pool
} lam_mem_pool_t;
/* process-private mem pool class */
extern lam_class_info_t lam_mem_pool_t_class_info;
extern lam_class_t lam_mem_pool_t_class;
/* process-shared mem pool class */
extern lam_class_info_t shmem_pool_t_class_info;
extern lam_class_t shmem_pool_t_class;
void lam_mp_construct(lam_mem_pool_t *pool);
void lam_mp_shared_construct(lam_mem_pool_t *pool);
@ -121,7 +121,7 @@ typedef struct lam_fixed_mpool
int fmp_apply_affinity;
} lam_fixed_mpool_t;
extern lam_class_info_t lam_fixed_mpool_t_class_info;
extern lam_class_t lam_fixed_mpool_t_class;
void lam_fmp_construct(lam_fixed_mpool_t *pool);
void lam_fmp_destruct(lam_fixed_mpool_t *pool);

6
src/lam/mem/seg_list.c
Просмотреть файл

@ -8,16 +8,15 @@
/*
* Public variable
*/
lam_class_info_t lam_seg_list_t_class_info = {
lam_class_t lam_seg_list_t_class = {
"lam_seg_list_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_sgl_construct,
(lam_destruct_t) lam_sgl_destruct
};
void lam_sgl_construct(lam_seg_list_t *slist)
{
OBJ_CONSTRUCT_SUPER(slist, lam_object_t);
OBJ_CONSTRUCT(&slist->sgl_list, lam_list_t);
lam_mutex_init(&slist->sgl_lock);
slist->sgl_min_bytes_pushed = 0;
@ -30,7 +29,6 @@ void lam_sgl_construct(lam_seg_list_t *slist)
void lam_sgl_destruct(lam_seg_list_t *slist)
{
OBJ_DESTRUCT(&(slist->sgl_list));
OBJ_DESTRUCT_SUPER(slist, lam_object_t);
}

2
src/lam/mem/seg_list.h
Просмотреть файл

@ -22,7 +22,7 @@ struct lam_seg_list_t
};
typedef struct lam_seg_list_t lam_seg_list_t;
extern lam_class_info_t lam_seg_list_t_class_info;
extern lam_class_t lam_seg_list_t_class;
void lam_sgl_construct(lam_seg_list_t *slist);
void lam_sgl_destruct(lam_seg_list_t *slist);

13
src/lam/util/reactor.c
Просмотреть файл

@ -23,16 +23,16 @@ const int LAM_REACTOR_NOTIFY_ALL = 7;
#define MAX_DESCRIPTOR_POOL_SIZE 256
lam_class_info_t lam_reactor_t_class_info = {
lam_class_t lam_reactor_t_class = {
"lam_reactor_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_reactor_construct,
(lam_destruct_t)lam_reactor_destruct
};
lam_class_info_t lam_reactor_descriptor_t_class_info = {
lam_class_t lam_reactor_descriptor_t_class = {
"lam_reactor_descriptor_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_reactor_descriptor_construct,
(lam_destruct_t)lam_reactor_descriptor_destruct
};
@ -40,13 +40,11 @@ lam_class_info_t lam_reactor_descriptor_t_class_info = {
void lam_reactor_descriptor_construct(lam_reactor_descriptor_t* rd)
{
OBJ_CONSTRUCT_SUPER(rd, lam_list_item_t);
}
void lam_reactor_descriptor_destruct(lam_reactor_descriptor_t* rd)
{
OBJ_DESTRUCT_SUPER(rd, lam_object_t);
}
@ -72,8 +70,6 @@ static inline lam_reactor_descriptor_t* lam_reactor_get_descriptor(lam_reactor_t
void lam_reactor_construct(lam_reactor_t* r)
{
OBJ_CONSTRUCT_SUPER(r, lam_object_t);
lam_mutex_init(&r->r_mutex);
OBJ_CONSTRUCT(&r->r_active, lam_list_t);
OBJ_CONSTRUCT(&r->r_free, lam_list_t);
@ -97,7 +93,6 @@ void lam_reactor_destruct(lam_reactor_t* r)
OBJ_DESTRUCT(&r->r_free);
OBJ_DESTRUCT(&r->r_pending);
OBJ_DESTRUCT(&r->r_hash);
OBJ_DESTRUCT_SUPER(r, lam_object_t);
}

4
src/lam/util/reactor.h
Просмотреть файл

@ -15,8 +15,8 @@ extern const int LAM_REACTOR_NOTIFY_RECV;
extern const int LAM_REACTOR_NOTIFY_SEND;
extern const int LAM_REACTOR_NOTIFY_EXCEPT;
extern lam_class_info_t lam_reactor_t_class_info;
extern lam_class_info_t lam_reactor_descriptor_t_class_info;
extern lam_class_t lam_reactor_t_class;
extern lam_class_t lam_reactor_descriptor_t_class;
/*

6
src/mca/mpi/pml/base/pml_base_request.c
Просмотреть файл

@ -5,22 +5,20 @@
#include "mca/mpi/pml/base/pml_base_request.h"
lam_class_info_t mca_pml_base_request_t_class_info = {
lam_class_t mca_pml_base_request_t_class = {
"mca_pml_base_request_t",
CLASS_INFO(lam_request_t),
OBJ_CLASS(lam_request_t),
(lam_construct_t) mca_pml_base_request_construct,
(lam_destruct_t) mca_pml_base_request_destruct
};
void mca_pml_base_request_construct(mca_pml_base_request_t* req)
{
OBJ_CONSTRUCT_SUPER(req, lam_request_t);
lam_mutex_init(&req->req_lock);
}
void mca_pml_base_request_destruct(mca_pml_base_request_t* req)
{
lam_mutex_destroy(&req->req_lock);
OBJ_DESTRUCT_SUPER(req, lam_request_t);
}

2
src/mca/mpi/pml/base/pml_base_request.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "mpi/datatype/datatype.h"
#include "mpi/communicator/communicator.h"
extern lam_class_info_t mca_pml_base_request_t_class_info;
extern lam_class_t mca_pml_base_request_t_class;
/* MPI request status */
typedef enum {

6
src/mca/mpi/pml/teg/src/pml_ptl_array.c
Просмотреть файл

@ -6,9 +6,9 @@
#include "pml_ptl_array.h"
lam_class_info_t mca_pml_teg_array_t_class_info = {
lam_class_t mca_pml_teg_array_t_class = {
"mca_ptl_array_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) mca_ptl_array_construct,
(lam_destruct_t) mca_ptl_array_destruct
};
@ -16,7 +16,6 @@ lam_class_info_t mca_pml_teg_array_t_class_info = {
void mca_ptl_array_construct(mca_ptl_array_t* array)
{
OBJ_CONSTRUCT_SUPER(array, lam_object_t);
array->ptl_procs = 0;
array->ptl_size = 0;
array->ptl_index = 0;
@ -28,7 +27,6 @@ void mca_ptl_array_destruct(mca_ptl_array_t* array)
{
if(array->ptl_procs != 0)
free(array->ptl_procs);
OBJ_DESTRUCT_SUPER(array, lam_object_t);
}

2
src/mca/mpi/pml/teg/src/pml_ptl_array.h
Просмотреть файл

@ -8,7 +8,7 @@
#include "lam/util/output.h"
#include "mca/mpi/ptl/ptl.h"
extern lam_class_info_t mca_ptl_array_t_class_info;
extern lam_class_t mca_ptl_array_t_class;
struct mca_ptl_proc_t {
double ptl_weight; /* PTL weight for scheduling */

2
src/mca/mpi/pml/teg/src/pml_teg_module.c
Просмотреть файл

@ -101,7 +101,7 @@ mca_pml_t* mca_pml_teg_module_init(int* priority,
lam_free_list_init(
&mca_pml_teg.teg_recv_requests,
sizeof(mca_ptl_base_recv_request_t),
CLASS_INFO(mca_ptl_base_recv_request_t),
OBJ_CLASS(mca_ptl_base_recv_request_t),
mca_pml_teg.teg_free_list_num,
mca_pml_teg.teg_free_list_max,
mca_pml_teg.teg_free_list_inc,

7
src/mca/mpi/pml/teg/src/pml_teg_proc.c
Просмотреть файл

@ -7,9 +7,9 @@
#include "pml_teg_proc.h"
#include "pml_ptl_array.h"
lam_class_info_t mca_pml_teg_proc_t_class_info = {
lam_class_t mca_pml_teg_proc_t_class = {
"mca_pml_teg_proc_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t) mca_pml_teg_proc_construct,
(lam_destruct_t) mca_pml_teg_proc_destruct
};
@ -17,7 +17,6 @@ lam_class_info_t mca_pml_teg_proc_t_class_info = {
void mca_pml_teg_proc_construct(mca_pml_proc_t* proc)
{
OBJ_CONSTRUCT_SUPER(proc, lam_list_item_t);
mca_ptl_array_construct(&proc->proc_ptl_first);
mca_ptl_array_construct(&proc->proc_ptl_next);
@ -32,7 +31,5 @@ void mca_pml_teg_proc_destruct(mca_pml_proc_t* proc)
THREAD_LOCK(&mca_pml_teg.teg_lock);
lam_list_remove_item(&mca_pml_teg.teg_procs, (lam_list_item_t*)proc);
THREAD_UNLOCK(&mca_pml_teg.teg_lock);
OBJ_DESTRUCT_SUPER(proc, lam_list_item_t);
}

2
src/mca/mpi/pml/teg/src/pml_teg_proc.h
Просмотреть файл

@ -26,7 +26,7 @@ struct mca_pml_proc_t {
typedef struct mca_pml_proc_t mca_pml_proc_t;
extern lam_class_info_t mca_pml_teg_proc_t_class_info;
extern lam_class_t mca_pml_teg_proc_t_class;
typedef struct mca_pml_proc_t mca_pml_teg_proc_t;

6
src/mca/mpi/ptl/base/ptl_base_comm.c
Просмотреть файл

@ -8,9 +8,9 @@ static void mca_pml_ptl_comm_construct(mca_pml_comm_t* comm);
static void mca_pml_ptl_comm_destruct(mca_pml_comm_t* comm);
lam_class_info_t mca_pml_comm_t_class_info = {
lam_class_t mca_pml_comm_t_class = {
"mca_pml_comm_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t)mca_pml_ptl_comm_construct,
(lam_destruct_t)mca_pml_ptl_comm_destruct
};
@ -18,7 +18,6 @@ lam_class_info_t mca_pml_comm_t_class_info = {
static void mca_pml_ptl_comm_construct(mca_pml_comm_t* comm)
{
OBJ_CONSTRUCT_SUPER(comm, lam_object_t);
OBJ_CONSTRUCT(&comm->c_wild_receives, lam_list_t);
lam_mutex_init(&comm->c_wild_lock);
}
@ -33,7 +32,6 @@ static void mca_pml_ptl_comm_destruct(mca_pml_comm_t* comm)
free(comm->c_frags_cant_match);
free(comm->c_specific_receives);
OBJ_DESTRUCT(&comm->c_wild_receives);
OBJ_DESTRUCT_SUPER(comm, lam_object_t);
}

2
src/mca/mpi/ptl/base/ptl_base_comm.h
Просмотреть файл

@ -10,7 +10,7 @@
* specific to the PML.
*/
extern lam_class_info_t mca_pml_comm_t_class_info;
extern lam_class_t mca_pml_comm_t_class;
struct mca_pml_comm_t {
lam_object_t super;

6
src/mca/mpi/ptl/base/ptl_base_fragment.c
Просмотреть файл

@ -10,20 +10,18 @@ static void mca_ptl_base_frag_construct(mca_ptl_base_frag_t* frag);
static void mca_ptl_base_frag_destruct(mca_ptl_base_frag_t* frag);
lam_class_info_t mca_ptl_base_frag_t_class_info = {
lam_class_t mca_ptl_base_frag_t_class = {
"mca_ptl_base_frag_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t) mca_ptl_base_frag_construct,
(lam_destruct_t) mca_ptl_base_frag_destruct
};
static void mca_ptl_base_frag_construct(mca_ptl_base_frag_t* frag)
{
OBJ_CONSTRUCT_SUPER(frag, lam_list_item_t);
}
static void mca_ptl_base_frag_destruct(mca_ptl_base_frag_t* frag)
{
OBJ_DESTRUCT_SUPER(frag, lam_list_item_t);
}

2
src/mca/mpi/ptl/base/ptl_base_fragment.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "mca/mpi/ptl/base/ptl_base_header.h"
extern lam_class_info_t mca_ptl_base_frag_t_class_info;
extern lam_class_t mca_ptl_base_frag_t_class;
struct mca_ptl_base_frag_t {
lam_list_item_t super;

6
src/mca/mpi/ptl/base/ptl_base_recvfrag.c
Просмотреть файл

@ -11,9 +11,9 @@ static void mca_ptl_base_recv_frag_construct(mca_ptl_base_recv_frag_t* frag);
static void mca_ptl_base_recv_frag_destruct(mca_ptl_base_recv_frag_t* frag);
lam_class_info_t mca_ptl_base_recv_frag_t_class_info = {
lam_class_t mca_ptl_base_recv_frag_t_class = {
"mca_ptl_base_recv_frag_t",
CLASS_INFO(mca_ptl_base_frag_t),
OBJ_CLASS(mca_ptl_base_frag_t),
(lam_construct_t) mca_ptl_base_recv_frag_construct,
(lam_destruct_t) mca_ptl_base_recv_frag_destruct
};
@ -21,11 +21,9 @@ lam_class_info_t mca_ptl_base_recv_frag_t_class_info = {
void mca_ptl_base_recv_frag_construct(mca_ptl_base_recv_frag_t* frag)
{
OBJ_CONSTRUCT_SUPER(frag, mca_ptl_base_frag_t);
}
void mca_ptl_base_recv_frag_destruct(mca_ptl_base_recv_frag_t* frag)
{
OBJ_DESTRUCT_SUPER(frag, mca_ptl_base_frag_t);
}

2
src/mca/mpi/ptl/base/ptl_base_recvfrag.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "mca/mpi/ptl/base/ptl_base_recvreq.h"
#include "mca/mpi/ptl/base/ptl_base_match.h"
extern lam_class_info_t mca_ptl_base_recv_frag_t_class_info;
extern lam_class_t mca_ptl_base_recv_frag_t_class;
struct mca_ptl_base_recv_frag_t {

6
src/mca/mpi/ptl/base/ptl_base_recvreq.c
Просмотреть файл

@ -14,9 +14,9 @@ static void mca_ptl_base_recv_request_destruct(mca_ptl_base_recv_request_t*);
static bool mca_ptl_base_recv_request_match_specific_proc(mca_ptl_base_recv_request_t*, int);
lam_class_info_t mca_ptl_base_recv_request_t_class_info = {
lam_class_t mca_ptl_base_recv_request_t_class = {
"mca_ptl_base_recv_request_t",
CLASS_INFO(mca_pml_base_request_t),
OBJ_CLASS(mca_pml_base_request_t),
(lam_construct_t) mca_ptl_base_recv_request_construct,
(lam_destruct_t) mca_ptl_base_recv_request_destruct
};
@ -24,13 +24,11 @@ lam_class_info_t mca_ptl_base_recv_request_t_class_info = {
static void mca_ptl_base_recv_request_construct(mca_ptl_base_recv_request_t* request)
{
OBJ_CONSTRUCT_SUPER(request, mca_pml_base_request_t);
}
static void mca_ptl_base_recv_request_destruct(mca_ptl_base_recv_request_t* request)
{
OBJ_DESTRUCT_SUPER(request, mca_pml_base_request_t);
}

2
src/mca/mpi/ptl/base/ptl_base_recvreq.h
Просмотреть файл

@ -8,7 +8,7 @@
#include "mca/mpi/ptl/ptl.h"
#include "mca/mpi/pml/base/pml_base_request.h"
extern lam_class_info_t mca_ptl_base_recv_request_t_class_info;;
extern lam_class_t mca_ptl_base_recv_request_t_class;;
struct mca_ptl_base_recv_frag_t;

6
src/mca/mpi/ptl/base/ptl_base_sendfrag.c
Просмотреть файл

@ -8,9 +8,9 @@ static void mca_ptl_base_send_frag_construct(mca_ptl_base_send_frag_t* frag);
static void mca_ptl_base_send_frag_destruct(mca_ptl_base_send_frag_t* frag);
lam_class_info_t mca_ptl_base_send_frag_t_class_info = {
lam_class_t mca_ptl_base_send_frag_t_class = {
"mca_ptl_base_send_frag_t",
CLASS_INFO(mca_ptl_base_frag_t),
OBJ_CLASS(mca_ptl_base_frag_t),
(lam_construct_t) mca_ptl_base_send_frag_construct,
(lam_destruct_t) mca_ptl_base_send_frag_destruct
};
@ -18,11 +18,9 @@ lam_class_info_t mca_ptl_base_send_frag_t_class_info = {
static void mca_ptl_base_send_frag_construct(mca_ptl_base_send_frag_t* frag)
{
OBJ_CONSTRUCT_SUPER(frag, mca_ptl_base_frag_t);
}
static void mca_ptl_base_send_frag_destruct(mca_ptl_base_send_frag_t* frag)
{
OBJ_DESTRUCT_SUPER(frag, mca_ptl_base_frag_t);
}

2
src/mca/mpi/ptl/base/ptl_base_sendfrag.h
Просмотреть файл

@ -7,7 +7,7 @@
#include "mca/mpi/ptl/ptl.h"
#include "mca/mpi/ptl/base/ptl_base_fragment.h"
extern lam_class_info_t mca_ptl_base_send_frag_t_class_info;
extern lam_class_t mca_ptl_base_send_frag_t_class;
struct mca_ptl_base_send_frag_t {

6
src/mca/mpi/ptl/base/ptl_base_sendreq.c
Просмотреть файл

@ -8,9 +8,9 @@ static void mca_ptl_base_send_request_construct(mca_ptl_base_send_request_t* req
static void mca_ptl_base_send_request_destruct(mca_ptl_base_send_request_t* req);
lam_class_info_t mca_ptl_base_send_request_t_class_info = {
lam_class_t mca_ptl_base_send_request_t_class = {
"mca_ptl_base_send_request_t",
CLASS_INFO(mca_pml_base_request_t),
OBJ_CLASS(mca_pml_base_request_t),
(lam_construct_t) mca_ptl_base_send_request_construct,
(lam_destruct_t) mca_ptl_base_send_request_destruct
};
@ -18,13 +18,11 @@ lam_class_info_t mca_ptl_base_send_request_t_class_info = {
static void mca_ptl_base_send_request_construct(mca_ptl_base_send_request_t* req)
{
OBJ_CONSTRUCT_SUPER(req, mca_pml_base_request_t);
OBJ_CONSTRUCT(&req->req_unacked_frags, lam_list_t);
}
static void mca_ptl_base_send_request_destruct(mca_ptl_base_send_request_t* req)
{
OBJ_DESTRUCT(&req->req_unacked_frags);
OBJ_DESTRUCT_SUPER(&req->req_unacked_frags, mca_pml_base_request_t);
}

2
src/mca/mpi/ptl/base/ptl_base_sendreq.h
Просмотреть файл

@ -11,7 +11,7 @@
#include "mca/mpi/pml/base/pml_base_request.h"
extern lam_class_info_t mca_ptl_base_send_request_t_class_info;
extern lam_class_t mca_ptl_base_send_request_t_class;
struct mca_ptl_base_send_frag_t;

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_module.c
Просмотреть файл

@ -278,7 +278,7 @@ mca_ptl_t** mca_ptl_tcp_module_init(int *num_ptls,
/* initialize free lists */
lam_free_list_init(&mca_ptl_tcp_module.tcp_send_requests,
sizeof(mca_ptl_tcp_send_request_t),
CLASS_INFO(mca_ptl_tcp_send_request_t),
OBJ_CLASS(mca_ptl_tcp_send_request_t),
mca_ptl_tcp_module.tcp_free_list_num,
mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc,
@ -286,7 +286,7 @@ mca_ptl_t** mca_ptl_tcp_module_init(int *num_ptls,
lam_free_list_init(&mca_ptl_tcp_module.tcp_send_frags,
sizeof(mca_ptl_tcp_send_frag_t),
CLASS_INFO(mca_ptl_tcp_send_frag_t),
OBJ_CLASS(mca_ptl_tcp_send_frag_t),
mca_ptl_tcp_module.tcp_free_list_num,
mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc,
@ -294,7 +294,7 @@ mca_ptl_t** mca_ptl_tcp_module_init(int *num_ptls,
lam_free_list_init(&mca_ptl_tcp_module.tcp_recv_frags,
sizeof(mca_ptl_tcp_recv_frag_t),
CLASS_INFO(mca_ptl_tcp_recv_frag_t),
OBJ_CLASS(mca_ptl_tcp_recv_frag_t),
mca_ptl_tcp_module.tcp_free_list_num,
mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc,

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_peer.c
Просмотреть файл

@ -22,9 +22,9 @@ static void mca_ptl_tcp_peer_recv_handler(int sd, short flags, void* user);
static void mca_ptl_tcp_peer_send_handler(int sd, short flags, void* user);
lam_class_info_t mca_ptl_tcp_peer_t_class_info = {
lam_class_t mca_ptl_tcp_peer_t_class = {
"mca_tcp_ptl_peer_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)mca_ptl_tcp_peer_construct,
(lam_destruct_t)mca_ptl_tcp_peer_destruct
};
@ -35,7 +35,6 @@ lam_class_info_t mca_ptl_tcp_peer_t_class_info = {
static void mca_ptl_tcp_peer_construct(mca_ptl_base_peer_t* ptl_peer)
{
OBJ_CONSTRUCT_SUPER(ptl_peer, lam_list_item_t);
ptl_peer->peer_ptl = 0;
ptl_peer->peer_proc = 0;
ptl_peer->peer_addr = 0;
@ -59,7 +58,6 @@ static void mca_ptl_tcp_peer_destruct(mca_ptl_base_peer_t* ptl_peer)
{
mca_ptl_tcp_proc_remove(ptl_peer->peer_proc, ptl_peer);
mca_ptl_tcp_peer_close_i(ptl_peer);
OBJ_DESTRUCT_SUPER(ptl_peer, lam_list_item_t);
}

2
src/mca/mpi/ptl/tcp/src/ptl_tcp_peer.h
Просмотреть файл

@ -51,7 +51,7 @@ struct mca_ptl_base_peer_t {
};
typedef struct mca_ptl_base_peer_t mca_ptl_base_peer_t;
extern lam_class_info_t mca_ptl_tcp_peer_t_class_info;
extern lam_class_t mca_ptl_tcp_peer_t_class;
typedef struct mca_ptl_base_peer_t mca_ptl_tcp_peer_t;
void mca_ptl_tcp_peer_close(mca_ptl_base_peer_t*);

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_proc.c
Просмотреть файл

@ -14,9 +14,9 @@ static void mca_ptl_tcp_proc_construct(mca_ptl_tcp_proc_t* proc);
static void mca_ptl_tcp_proc_destruct(mca_ptl_tcp_proc_t* proc);
static mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup_lam(lam_proc_t* lam_proc);
lam_class_info_t mca_ptl_tcp_proc_t_class_info = {
lam_class_t mca_ptl_tcp_proc_t_class = {
"mca_ptl_tcp_proc_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)mca_ptl_tcp_proc_construct,
(lam_destruct_t)mca_ptl_tcp_proc_destruct
};
@ -24,7 +24,6 @@ lam_class_info_t mca_ptl_tcp_proc_t_class_info = {
void mca_ptl_tcp_proc_construct(mca_ptl_tcp_proc_t* proc)
{
OBJ_CONSTRUCT_SUPER(proc, lam_list_item_t);
proc->proc_lam = 0;
proc->proc_addrs = 0;
proc->proc_addr_count = 0;
@ -51,7 +50,6 @@ void mca_ptl_tcp_proc_destruct(mca_ptl_tcp_proc_t* proc)
free(proc->proc_peers);
if(NULL != proc->proc_guid)
free(proc->proc_guid);
OBJ_DESTRUCT_SUPER(proc, lam_list_item_t);
}

2
src/mca/mpi/ptl/tcp/src/ptl_tcp_proc.h
Просмотреть файл

@ -14,7 +14,7 @@
#include "ptl_tcp.h"
#include "ptl_tcp_peer.h"
extern lam_class_info_t mca_ptl_tcp_proc_t_class_info;
extern lam_class_t mca_ptl_tcp_proc_t_class;
/**

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_recvfrag.c
Просмотреть файл

@ -20,9 +20,9 @@ static bool mca_ptl_tcp_recv_frag_data(mca_ptl_tcp_recv_frag_t* frag, int sd);
static bool mca_ptl_tcp_recv_frag_discard(mca_ptl_tcp_recv_frag_t* frag, int sd);
lam_class_info_t mca_ptl_tcp_recv_frag_t_class_info = {
lam_class_t mca_ptl_tcp_recv_frag_t_class = {
"mca_ptl_tcp_recv_frag_t",
CLASS_INFO(mca_ptl_base_recv_frag_t),
OBJ_CLASS(mca_ptl_base_recv_frag_t),
(lam_construct_t)mca_ptl_tcp_recv_frag_construct,
(lam_destruct_t)mca_ptl_tcp_recv_frag_destruct
};
@ -30,13 +30,11 @@ lam_class_info_t mca_ptl_tcp_recv_frag_t_class_info = {
static void mca_ptl_tcp_recv_frag_construct(mca_ptl_tcp_recv_frag_t* frag)
{
OBJ_CONSTRUCT_SUPER(frag, mca_ptl_base_recv_frag_t);
}
static void mca_ptl_tcp_recv_frag_destruct(mca_ptl_tcp_recv_frag_t* frag)
{
OBJ_DESTRUCT_SUPER(frag, mca_ptl_base_recv_frag_t);
}

2
src/mca/mpi/ptl/tcp/src/ptl_tcp_recvfrag.h
Просмотреть файл

@ -14,7 +14,7 @@
#include "ptl_tcp.h"
extern lam_class_info_t mca_ptl_tcp_recv_frag_t_class_info;
extern lam_class_t mca_ptl_tcp_recv_frag_t_class;
struct mca_ptl_tcp_recv_frag_t {

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_sendfrag.c
Просмотреть файл

@ -15,9 +15,9 @@ static void mca_ptl_tcp_send_frag_construct(mca_ptl_tcp_send_frag_t* frag);
static void mca_ptl_tcp_send_frag_destruct(mca_ptl_tcp_send_frag_t* frag);
lam_class_info_t mca_ptl_tcp_send_frag_t_class_info = {
lam_class_t mca_ptl_tcp_send_frag_t_class = {
"mca_ptl_tcp_send_frag_t",
CLASS_INFO(mca_ptl_base_send_frag_t),
OBJ_CLASS(mca_ptl_base_send_frag_t),
(lam_construct_t)mca_ptl_tcp_send_frag_construct,
(lam_destruct_t)mca_ptl_tcp_send_frag_destruct
};
@ -25,13 +25,11 @@ lam_class_info_t mca_ptl_tcp_send_frag_t_class_info = {
static void mca_ptl_tcp_send_frag_construct(mca_ptl_tcp_send_frag_t* frag)
{
OBJ_CONSTRUCT_SUPER(frag, mca_ptl_base_send_frag_t);
}
static void mca_ptl_tcp_send_frag_destruct(mca_ptl_tcp_send_frag_t* frag)
{
OBJ_DESTRUCT_SUPER(frag, mca_ptl_base_send_frag_t);
}

2
src/mca/mpi/ptl/tcp/src/ptl_tcp_sendfrag.h
Просмотреть файл

@ -13,7 +13,7 @@
#include "mca/mpi/ptl/base/ptl_base_sendfrag.h"
#include "ptl_tcp.h"
extern lam_class_info_t mca_ptl_tcp_send_frag_t_class_info;
extern lam_class_t mca_ptl_tcp_send_frag_t_class;
struct mca_ptl_tcp_send_frag_t {

6
src/mca/mpi/ptl/tcp/src/ptl_tcp_sendreq.c
Просмотреть файл

@ -14,9 +14,9 @@ static void mca_ptl_tcp_send_request_construct(mca_ptl_tcp_send_request_t*);
static void mca_ptl_tcp_send_request_destruct(mca_ptl_tcp_send_request_t*);
lam_class_info_t mca_ptl_tcp_send_request_t_class_info = {
lam_class_t mca_ptl_tcp_send_request_t_class = {
"mca_ptl_tcp_send_request_t",
CLASS_INFO(mca_ptl_base_send_request_t),
OBJ_CLASS(mca_ptl_base_send_request_t),
(lam_construct_t)mca_ptl_tcp_send_request_construct,
(lam_destruct_t)mca_ptl_tcp_send_request_destruct
};
@ -24,7 +24,6 @@ lam_class_info_t mca_ptl_tcp_send_request_t_class_info = {
void mca_ptl_tcp_send_request_construct(mca_ptl_tcp_send_request_t* request)
{
OBJ_CONSTRUCT_SUPER(request, mca_ptl_base_send_request_t);
OBJ_CONSTRUCT(&request->req_frag, mca_ptl_tcp_send_frag_t);
}
@ -32,6 +31,5 @@ void mca_ptl_tcp_send_request_construct(mca_ptl_tcp_send_request_t* request)
void mca_ptl_tcp_send_request_destruct(mca_ptl_tcp_send_request_t* request)
{
OBJ_DESTRUCT(&request->req_frag);
OBJ_DESTRUCT_SUPER(request, mca_ptl_base_send_request_t);
}

2
src/mca/mpi/ptl/tcp/src/ptl_tcp_sendreq.h
Просмотреть файл

@ -14,7 +14,7 @@
#include "ptl_tcp_sendfrag.h"
extern lam_class_info_t mca_ptl_tcp_send_request_t_class_info;
extern lam_class_t mca_ptl_tcp_send_request_t_class;
struct mca_ptl_tcp_send_request_t {
mca_ptl_base_send_request_t super;

4
src/mpi/datatype/datatype.c
Просмотреть файл

@ -9,9 +9,9 @@
#include "lam_config.h"
#include "lam/datatype.h"
lam_class_info_t lam_datatype_t_class_info = {
lam_class_t lam_datatype_t_class = {
"lam_datatype_t",
CLASS_INFO(lam_dbl_item_t),
OBJ_CLASS(lam_dbl_item_t),
(lam_construct_t) lam_p2p_cdi_construct,
(lam_destruct_t) lam_p2p_cdi_destruct
};

12
src/mpi/info/info.c
Просмотреть файл

@ -7,9 +7,9 @@
/*
* lam_info_t classes
*/
lam_class_info_t lam_info_t_class_info = {
lam_class_t lam_info_t_class = {
"lam_info_t",
CLASS_INFO(lam_list_t),
OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_info_construct,
(lam_destruct_t)lam_info_destruct
};
@ -17,9 +17,9 @@ lam_class_info_t lam_info_t_class_info = {
/*
* lam_info_entry_t classes
*/
lam_class_info_t lam_info_entry_t_class_info = {
lam_class_t lam_info_entry_t_class = {
"lam_info_entry_t",
CLASS_INFO(lam_list_item_t),
OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_info_entry_construct,
(lam_destruct_t)lam_info_entry_destruct
};
@ -28,19 +28,16 @@ lam_class_info_t lam_info_entry_t_class_info = {
* lam_info_t interface functions
*/
void lam_info_construct(lam_info_t *info) {
OBJ_CONSTRUCT_SUPER(info, lam_list_t);
info->i_fhandle = -1;
}
void lam_info_destruct(lam_info_t *info) {
OBJ_DESTRUCT_SUPER(info, lam_list_t);
}
/*
* lam_info_entry_t interface functions
*/
void lam_info_entry_construct(lam_info_entry_t *entry) {
OBJ_CONSTRUCT_SUPER(entry, lam_object_t);
memset(entry->ie_key, 0, sizeof(entry->ie_key));
entry->ie_key[MPI_MAX_INFO_KEY] = 0;
}
@ -49,7 +46,6 @@ void lam_info_entry_destruct(lam_info_entry_t *entry) {
if (NULL != entry->ie_value) {
free(entry->ie_value);
}
OBJ_DESTRUCT_SUPER(entry, lam_object_t);
}
/**

4
src/mpi/info/info.h
Просмотреть файл

@ -40,8 +40,8 @@ typedef struct lam_info_entry_t lam_info_entry_t;
/**
* Some declarations needed to use OBJ_NEW and OBJ_DESTRUCT macros
*/
extern lam_class_info_t lam_info_t_class_info;
extern lam_class_info_t lam_info_entry_t_class_info;
extern lam_class_t lam_info_t_class;
extern lam_class_t lam_info_entry_t_class;
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {

6
src/mpi/proc/proc.c
Просмотреть файл

@ -7,9 +7,9 @@ static lam_mutex_t lam_proc_lock;
lam_proc_t* lam_proc_self = 0;
lam_class_info_t lam_proc_t_class_info = {
lam_class_t lam_proc_t_class = {
"lam_proc_t",
CLASS_INFO(lam_list_t),
OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_proc_construct,
(lam_destruct_t)lam_proc_destruct
};
@ -22,7 +22,6 @@ void lam_proc_construct(lam_proc_t* proc)
lam_mutex_init(&lam_proc_lock);
}
OBJ_CONSTRUCT_SUPER(proc, lam_list_t);
proc->proc_job = 0;
proc->proc_vpid = 0;
proc->proc_pml = 0;
@ -38,6 +37,5 @@ void lam_proc_destruct(lam_proc_t* proc)
THREAD_LOCK(&lam_proc_lock);
lam_list_remove_item(&lam_proc_list, (lam_list_item_t*)proc);
THREAD_UNLOCK(&lam_proc_lock);
OBJ_DESTRUCT_SUPER(proc, lam_list_t);
}

2
src/mpi/proc/proc.h
Просмотреть файл

@ -9,7 +9,7 @@
#include "lam/lfc/lam_list.h"
extern lam_class_info_t lam_proc_t_class_info;
extern lam_class_t lam_proc_t_class;
struct lam_proc_t {

6
src/mpi/request/request.c
Просмотреть файл

@ -4,9 +4,9 @@
#include "mpi/request/request.h"
lam_class_info_t lam_request_t_class_info = {
lam_class_t lam_request_t_class = {
"lam_request_t",
CLASS_INFO(lam_object_t),
OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_request_construct,
(lam_destruct_t) lam_request_destruct,
};
@ -14,13 +14,11 @@ lam_class_info_t lam_request_t_class_info = {
void lam_request_construct(lam_request_t* rq)
{
OBJ_CONSTRUCT_SUPER(rq, lam_object_t);
}
void lam_request_destruct(lam_request_t* rq)
{
OBJ_DESTRUCT_SUPER(rq, lam_object_t);
}

2
src/mpi/request/request.h
Просмотреть файл

@ -9,7 +9,7 @@
#include "lam/lfc/lam_list.h"
extern lam_class_info_t lam_request_t_class_info;
extern lam_class_t lam_request_t_class;
typedef enum {
LAM_REQUEST_PML,