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) static void lam_cth_construct(lam_ctchannel_t *channel)
{ {
OBJ_CONSTRUCT_SUPER(channel, lam_object_t);
channel->cth_status = CT_CHNL_CLOSED; channel->cth_status = CT_CHNL_CLOSED;
channel->cth_id = 0; channel->cth_id = 0;
channel->cth_timeout_secs = 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) 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", "lam_ct_channel_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_cth_construct, (lam_construct_t) lam_cth_construct,
(lam_destruct_t) lam_object_destruct (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) static void lam_tcpch_construct(lam_tcp_chnl_t *channel)
{ {
OBJ_CONSTRUCT_SUPER(channel, lam_object_t);
channel->tcp_sockfd = 0; channel->tcp_sockfd = 0;
memset(&(channel->tcp_addr), 0, sizeof(channel->tcp_addr)); memset(&(channel->tcp_addr), 0, sizeof(channel->tcp_addr));
channel->tcp_blocking = 0; 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) 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", "lam_tcp_chnl_t",
CLASS_INFO(lam_ctchannel_t), OBJ_CLASS(lam_ctchannel_t),
(lam_construct_t) lam_tcpch_construct, (lam_construct_t) lam_tcpch_construct,
(lam_destruct_t) lam_tcpch_destruct (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 typedef struct lam_ctchannel_class
{ {
lam_class_info_t super; lam_class_t super;
/* return: error code args: (channel, data, data length, bytes sent) */ /* return: error code args: (channel, data, data length, bytes sent) */
lam_cth_send_fn_t *send; lam_cth_send_fn_t *send;
@ -98,7 +98,7 @@ typedef struct lam_ctchannel_class
} lam_ctchannel_class_t; } 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 typedef struct lam_ctchannel
{ {
@ -187,7 +187,7 @@ typedef struct lam_tcp_channel
int tcp_blocking; int tcp_blocking;
} lam_tcp_chnl_t; } 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 lam_tcpch_send(lam_tcp_chnl_t *channel, const uint8_t *data,
uint32_t data_len, uint32_t *bytes_sent); uint32_t data_len, uint32_t *bytes_sent);

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

@ -6,17 +6,17 @@
#include "lam/mem/malloc.h" #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", "lam_ct_ctrl_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_ctc_construct, (lam_construct_t) lam_ctc_construct,
(lam_destruct_t) lam_ctc_destruct (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", "lam_ctmsg_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_ctm_construct, (lam_construct_t) lam_ctm_construct,
(lam_destruct_t) lam_ctm_destruct (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) void lam_ctc_construct(lam_ct_ctrl_t *ctrl)
{ {
OBJ_CONSTRUCT_SUPER(ctrl, lam_object_t);
ctrl->ctc_is_user_msg = 0; ctrl->ctc_is_user_msg = 0;
ctrl->ctc_routing_type = LAM_CT_PT2PT; ctrl->ctc_routing_type = LAM_CT_PT2PT;
ctrl->ctc_sender = 0; 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) void lam_ctc_destruct(lam_ct_ctrl_t *ctrl)
{ {
lam_free(ctrl->ctc_info); 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) 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_ctrl = OBJ_NEW(lam_ct_ctrl_t);
msg->ctm_len = 0; msg->ctm_len = 0;
msg->ctm_data = 0; msg->ctm_data = 0;
@ -213,7 +209,6 @@ void lam_ctm_destruct(lam_ctmsg_t *msg)
lam_free(msg->ctm_data); lam_free(msg->ctm_data);
} }
OBJECT_RELEASE(msg->ctm_ctrl); 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, 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_t lam_ct_ctrl_t_class;
extern lam_class_info_t lam_ctmsg_t_class_info; 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 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_label_for_link_fn_t *ctl_label_for_link;
lam_ctl_isa_neighbor_fn_t *ctl_isa_neighbor; lam_ctl_isa_neighbor_fn_t *ctl_isa_neighbor;
} lam_ctnode_class_t; } 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) */ unsigned int hc_hsize; /* hc_hsize = log2(# nodes in network) */
} lam_hcube_t; } lam_hcube_t;
extern lam_class_info_t hcube_t_class_info; extern lam_class_t hcube_t_class;
#endif /* LAM_CT_NODE_H */ #endif /* LAM_CT_NODE_H */

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

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

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

@ -81,13 +81,13 @@ struct kqop {
} kqueueop; } kqueueop;
static void *kq_init (void); static void *kq_init (void);
static int kq_add (void *, struct event *); static int kq_add (void *, struct lam_event *);
static int kq_del (void *, struct event *); static int kq_del (void *, struct lam_event *);
static int kq_recalc (void *, int); static int kq_recalc (void *, int);
static int kq_dispatch (void *, struct timeval *); static int kq_dispatch (void *, struct timeval *);
static int kq_insert (struct kqop *, struct kevent *); static int kq_insert (struct kqop *, struct kevent *);
const struct eventop kqops = { const struct lam_eventop lam_kqops = {
"kqueue", "kqueue",
kq_init, kq_init,
kq_add, kq_add,
@ -96,8 +96,8 @@ const struct eventop kqops = {
kq_dispatch kq_dispatch
}; };
void * static void *
static kq_init(void) kq_init(void)
{ {
int kq; int kq;
@ -193,7 +193,7 @@ kq_dispatch(void *arg, struct timeval *tv)
struct kqop *kqop = arg; struct kqop *kqop = arg;
struct kevent *changes = kqop->changes; struct kevent *changes = kqop->changes;
struct kevent *events = kqop->events; struct kevent *events = kqop->events;
struct event *ev; struct lam_event *ev;
struct timespec ts; struct timespec ts;
int i, res; int i, res;
@ -233,26 +233,26 @@ kq_dispatch(void *arg, struct timeval *tv)
return (-1); return (-1);
} }
ev = (struct event *)events[i].udata; ev = (struct lam_event *)events[i].udata;
if (events[i].filter == EVFILT_READ) { if (events[i].filter == EVFILT_READ) {
which |= EV_READ; which |= LAM_EV_READ;
} else if (events[i].filter == EVFILT_WRITE) { } else if (events[i].filter == EVFILT_WRITE) {
which |= EV_WRITE; which |= LAM_EV_WRITE;
} else if (events[i].filter == EVFILT_SIGNAL) { } else if (events[i].filter == EVFILT_SIGNAL) {
which |= EV_SIGNAL; which |= LAM_EV_SIGNAL;
} }
if (!which) if (!which)
continue; continue;
if (!(ev->ev_events & EV_PERSIST)) { if (!(ev->ev_events & LAM_EV_PERSIST)) {
ev->ev_flags &= ~EVLIST_X_KQINKERNEL; ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
event_del(ev); lam_event_del(ev);
} }
event_active(ev, which, lam_event_active(ev, which,
ev->ev_events & EV_SIGNAL ? events[i].data : 1); ev->ev_events & LAM_EV_SIGNAL ? events[i].data : 1);
} }
return (0); return (0);
@ -260,21 +260,21 @@ kq_dispatch(void *arg, struct timeval *tv)
static int static int
kq_add(void *arg, struct event *ev) kq_add(void *arg, struct lam_event *ev)
{ {
struct kqop *kqop = arg; struct kqop *kqop = arg;
struct kevent kev; struct kevent kev;
if (ev->ev_events & EV_SIGNAL) { if (ev->ev_events & LAM_EV_SIGNAL) {
int nsignal = EVENT_SIGNAL(ev); int nsignal = LAM_EVENT_SIGNAL(ev);
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = nsignal; kev.ident = nsignal;
kev.filter = EVFILT_SIGNAL; kev.filter = EVFILT_SIGNAL;
kev.flags = EV_ADD; kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST)) if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT; kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev); kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1) if (kq_insert(kqop, &kev) == -1)
return (-1); return (-1);
@ -286,14 +286,14 @@ kq_add(void *arg, struct event *ev)
return (0); return (0);
} }
if (ev->ev_events & EV_READ) { if (ev->ev_events & LAM_EV_READ) {
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd; kev.ident = ev->ev_fd;
kev.filter = EVFILT_READ; kev.filter = EVFILT_READ;
kev.flags = EV_ADD; kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST)) if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT; kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev); kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1) if (kq_insert(kqop, &kev) == -1)
return (-1); return (-1);
@ -301,14 +301,14 @@ kq_add(void *arg, struct event *ev)
ev->ev_flags |= EVLIST_X_KQINKERNEL; ev->ev_flags |= EVLIST_X_KQINKERNEL;
} }
if (ev->ev_events & EV_WRITE) { if (ev->ev_events & LAM_EV_WRITE) {
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd; kev.ident = ev->ev_fd;
kev.filter = EVFILT_WRITE; kev.filter = EVFILT_WRITE;
kev.flags = EV_ADD; kev.flags = EV_ADD;
if (!(ev->ev_events & EV_PERSIST)) if (!(ev->ev_events & LAM_EV_PERSIST))
kev.flags |= EV_ONESHOT; kev.flags |= EV_ONESHOT;
kev.udata = INTPTR(ev); kev.udata = (void *) INTPTR(ev);
if (kq_insert(kqop, &kev) == -1) if (kq_insert(kqop, &kev) == -1)
return (-1); return (-1);
@ -320,7 +320,7 @@ kq_add(void *arg, struct event *ev)
} }
static int static int
kq_del(void *arg, struct event *ev) kq_del(void *arg, struct lam_event *ev)
{ {
struct kqop *kqop = arg; struct kqop *kqop = arg;
struct kevent kev; struct kevent kev;
@ -328,8 +328,8 @@ kq_del(void *arg, struct event *ev)
if (!(ev->ev_flags & EVLIST_X_KQINKERNEL)) if (!(ev->ev_flags & EVLIST_X_KQINKERNEL))
return (0); return (0);
if (ev->ev_events & EV_SIGNAL) { if (ev->ev_events & LAM_EV_SIGNAL) {
int nsignal = EVENT_SIGNAL(ev); int nsignal = LAM_EVENT_SIGNAL(ev);
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = (int)signal; kev.ident = (int)signal;
@ -346,7 +346,7 @@ kq_del(void *arg, struct event *ev)
return (0); return (0);
} }
if (ev->ev_events & EV_READ) { if (ev->ev_events & LAM_EV_READ) {
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd; kev.ident = ev->ev_fd;
kev.filter = EVFILT_READ; kev.filter = EVFILT_READ;
@ -358,7 +358,7 @@ kq_del(void *arg, struct event *ev)
ev->ev_flags &= ~EVLIST_X_KQINKERNEL; ev->ev_flags &= ~EVLIST_X_KQINKERNEL;
} }
if (ev->ev_events & EV_WRITE) { if (ev->ev_events & LAM_EV_WRITE) {
memset(&kev, 0, sizeof(kev)); memset(&kev, 0, sizeof(kev));
kev.ident = ev->ev_fd; kev.ident = ev->ev_fd;
kev.filter = EVFILT_WRITE; 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); event_active(ev, flags, 1);
} }
void *rtsig_init(void); static void *rtsig_init(void);
int rtsig_add(void *, struct event *); static int rtsig_add(void *, struct event *);
int rtsig_del(void *, struct event *); static int rtsig_del(void *, struct event *);
int rtsig_recalc(void *, int); static int rtsig_recalc(void *, int);
int rtsig_dispatch(void *, struct timeval *); static int rtsig_dispatch(void *, struct timeval *);
struct eventop rtsigops = { struct lam_eventop rtsigops = {
"rtsig", "rtsig",
rtsig_init, rtsig_init,
rtsig_add, rtsig_add,
@ -134,7 +134,7 @@ struct eventop rtsigops = {
rtsig_dispatch rtsig_dispatch
}; };
void * static void *
rtsig_init(void) rtsig_init(void)
{ {
struct rtsigop *op; struct rtsigop *op;
@ -168,7 +168,7 @@ rtsig_init(void)
return (op); return (op);
} }
int static int
rtsig_add(void *arg, struct event *ev) rtsig_add(void *arg, struct event *ev)
{ {
struct rtsigop *op = (struct rtsigop *) arg; struct rtsigop *op = (struct rtsigop *) arg;
@ -222,7 +222,7 @@ rtsig_add(void *arg, struct event *ev)
return (-1); return (-1);
} }
int static int
rtsig_del(void *arg, struct event *ev) rtsig_del(void *arg, struct event *ev)
{ {
struct rtsigop *op = (struct rtsigop *) arg; struct rtsigop *op = (struct rtsigop *) arg;
@ -250,13 +250,13 @@ rtsig_del(void *arg, struct event *ev)
return (0); return (0);
} }
int static int
rtsig_recalc(void *arg, int max) rtsig_recalc(void *arg, int max)
{ {
return (0); return (0);
} }
int static int
rtsig_dispatch(void *arg, struct timeval *tv) rtsig_dispatch(void *arg, struct timeval *tv)
{ {
struct rtsigop *op = (struct rtsigop *) arg; 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); 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", "lam_hash_table_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_hash_table_construct, (lam_construct_t)lam_hash_table_construct,
(lam_destruct_t)lam_hash_table_destruct (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) 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); OBJ_CONSTRUCT(&ht->ht_nodes, lam_list_t);
ht->ht_table = NULL; ht->ht_table = NULL;
ht->ht_table_size = 0; 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) if(NULL != ht->ht_table)
free(ht->ht_table); free(ht->ht_table);
OBJ_DESTRUCT(&ht->ht_nodes); 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) 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) 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_uint32_hash_node_t",
&lam_list_item_t_class_info, &lam_list_item_t_class,
(lam_construct_t)lam_uint32_hash_node_construct, (lam_construct_t)lam_uint32_hash_node_construct,
(lam_destruct_t)lam_uint32_hash_node_destruct (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) 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) 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", "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_construct_t)lam_uint64_hash_node_construct,
(lam_destruct_t)lam_uint64_hash_node_destruct (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) 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_size = 0;
hn->hn_key = NULL; hn->hn_key = NULL;
hn->hn_value = 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) 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) if(NULL != hn->hn_key)
free(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", "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_construct_t)lam_ptr_hash_node_construct,
(lam_destruct_t)lam_ptr_hash_node_destruct (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" #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 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_construct(lam_list_item_t*);
static void lam_list_item_destruct(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", "lam_list_item_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_list_item_construct, (lam_construct_t) lam_list_item_construct,
(lam_destruct_t) lam_list_item_destruct (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_construct(lam_list_t*);
static void lam_list_destruct(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", "lam_list_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_list_construct, (lam_construct_t) lam_list_construct,
(lam_destruct_t) lam_list_destruct (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) 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_next = item->lam_list_prev = NULL;
item->lam_list_type = 0; item->lam_list_type = 0;
} }
static void lam_list_item_destruct(lam_list_item_t *item) 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) 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_prev = NULL;
list->lam_list_head.lam_list_next = &list->lam_list_tail; list->lam_list_head.lam_list_next = &list->lam_list_tail;
list->lam_list_tail.lam_list_prev = &list->lam_list_head; 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 */ /* release all items in list */
lam_list_construct(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_t lam_list_item_t_class;
extern lam_class_info_t lam_list_t_class_info; extern lam_class_t lam_list_t_class;
typedef int lam_list_type_t; 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 * special, since be mark it as already initialized, with no parent
* and no constructor or desctructor * 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 */ "lam_object_t", /* name */
NULL, /* parent class */ NULL, /* parent class */
NULL, /* constructor */ NULL, /* constructor */
@ -33,9 +33,9 @@ lam_class_info_t lam_object_t_class_info = {
/* /*
* Lazy initialization of class descriptor. * 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; int i;
assert(class); assert(class);

56
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 * @endcode
* All classes must have a parent. * All classes must have a parent.
* *
@ -36,9 +36,9 @@
* this class, and should be the name of the class with "_class" * this class, and should be the name of the class with "_class"
* appended: * appended:
* @code * @code
* lam_class_info_t sally_t_class = { * lam_class_t sally_t_class = {
* "sally_t", * "sally_t",
* CLASS_INFO(parent_t), // pointer to parent_t_class * OBJ_CLASS(parent_t), // pointer to parent_t_class
* sally_construct, * sally_construct,
* sally_destruct * sally_destruct
* }; * };
@ -122,7 +122,7 @@
/* typedefs ***********************************************************/ /* typedefs ***********************************************************/
typedef struct lam_object_t lam_object_t; 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_construct_t) (lam_object_t *);
typedef void (*lam_destruct_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 * There should be a single instance of this descriptor for each class
* definition. * definition.
*/ */
struct lam_class_info_t { struct lam_class_t {
const char *cls_name; /**< symbolic name for class */ 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_construct_t cls_construct; /**< class constructor */
lam_destruct_t cls_destruct; /**< class destructor */ lam_destruct_t cls_destruct; /**< class destructor */
int cls_initialized; /**< is class initialized */ int cls_initialized; /**< is class initialized */
@ -155,7 +155,7 @@ struct lam_class_info_t {
* This is special and does not follow the pattern for other classes. * This is special and does not follow the pattern for other classes.
*/ */
struct lam_object_t { struct lam_object_t {
lam_class_info_t *obj_class_info; /**< class descriptor */ lam_class_t *obj_class; /**< class descriptor */
int obj_reference_count; /**< reference count */ int obj_reference_count; /**< reference count */
}; };
@ -169,7 +169,7 @@ struct lam_object_t {
* @param type Name of class * @param type Name of class
* @return Pointer to class descriptor * @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 * @param DESTRUCTOR Pointer to destructor
* @return Static initializer string * @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 } { NAME, PARENT, CONSTRUCTOR, DESTRUCTOR, 0, 0, NULL, NULL }
@ -193,7 +193,7 @@ struct lam_object_t {
* @return Pointer to the object * @return Pointer to the object
*/ */
#define OBJ_NEW(type) \ #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) \ #define OBJ_CONSTRUCT(object, type) \
do { \ do { \
if (0 == CLASS_INFO(type)->cls_initialized) { \ if (0 == OBJ_CLASS(type)->cls_initialized) { \
lam_class_initialize(CLASS_INFO(type)); \ lam_class_initialize(OBJ_CLASS(type)); \
} \ } \
if (object) { \ 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_object_t *) object)->obj_reference_count = 1; \
lam_obj_run_constructors((lam_object_t *) object); \ lam_obj_run_constructors((lam_object_t *) object); \
} \ } \
@ -256,15 +256,11 @@ struct lam_object_t {
} while (0) } while (0)
#define OBJ_CONSTRUCT_SUPER(A, B)
#define OBJ_DESTRUCT_SUPER(A, B)
/* declarations *******************************************************/ /* declarations *******************************************************/
BEGIN_C_DECLS 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. * 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 * @param class Pointer to class descriptor
*/ */
void lam_class_initialize(lam_class_info_t *); void lam_class_initialize(lam_class_t *);
END_C_DECLS END_C_DECLS
@ -292,13 +288,13 @@ END_C_DECLS
*/ */
static inline void lam_obj_run_constructors(lam_object_t *object) static inline void lam_obj_run_constructors(lam_object_t *object)
{ {
lam_class_info_t *cls; lam_class_t *cls;
int i; int i;
assert(NULL != object); 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--) { for (i = cls->cls_depth - 1; i >= 0; i--) {
if (cls->cls_construct_array[i]) { if (cls->cls_construct_array[i]) {
(cls->cls_construct_array[i])(object); (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) static inline void lam_obj_run_destructors(lam_object_t *object)
{ {
lam_class_info_t *cls; lam_class_t *cls;
int i; int i;
assert(NULL != object); 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++) { for (i = 0; i < cls->cls_depth; i++) {
if (cls->cls_destruct_array[i]) { if (cls->cls_destruct_array[i]) {
(cls->cls_destruct_array[i])(object); (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 * @return Pointer to the object
*/ */
static inline lam_object_t *lam_obj_new(size_t size, static inline lam_object_t *lam_obj_new(size_t size,
lam_class_info_t *cls) lam_class_t *cls)
{ {
lam_object_t *object; 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); object = (lam_object_t *) malloc(size);
if (NULL != object) { if (NULL != object) {
object->obj_class_info = cls; object->obj_class = cls;
object->obj_reference_count = 1; object->obj_reference_count = 1;
lam_obj_run_constructors(object); 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) static inline void lam_obj_retain(lam_object_t *object)
{ {
assert(NULL != object); assert(NULL != object);
assert(NULL != object->obj_class_info); assert(NULL != object->obj_class);
fetchNadd(&(object->obj_reference_count), 1); 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) static inline void lam_obj_release(lam_object_t *object)
{ {
assert(NULL != object); assert(NULL != object);
assert(NULL != object->obj_class_info); assert(NULL != object->obj_class);
if (fetchNadd(&object->obj_reference_count, -1) == 1) { if (fetchNadd(&object->obj_reference_count, -1) == 1) {
object->obj_class_info->cls_destruct(object); object->obj_class->cls_destruct(object);
free(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) static void lam_value_array_construct(lam_value_array_t* array)
{ {
OBJ_CONSTRUCT_SUPER(array, lam_object_t);
array->array_items = NULL; array->array_items = NULL;
array->array_size = 0; array->array_size = 0;
array->array_item_sizeof = 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) if (NULL != array->array_items)
free(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", "lam_value_array_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_value_array_construct, (lam_construct_t)lam_value_array_construct,
(lam_destruct_t)lam_value_array_destruct (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. * @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 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) 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_alloc_fn = lam_allocator_malloc;
allocator->alc_free_fn = lam_allocator_free; allocator->alc_free_fn = lam_allocator_free;
allocator->alc_is_shared = 0; 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) 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", "lam_allocator_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_allocator_construct, (lam_construct_t) lam_allocator_construct,
(lam_destruct_t) lam_allocator_destruct (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 *); void (*alc_free_fn) (struct lam_allocator *, void *);
} lam_allocator_t; } 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); 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); 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", "lam_free_list_t",
CLASS_INFO(lam_list_t), OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_free_list_construct, (lam_construct_t)lam_free_list_construct,
(lam_destruct_t)lam_free_list_destruct (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) 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) static void lam_free_list_destruct(lam_free_list_t* fl)
{ {
OBJ_DESTRUCT_SUPER(fl, lam_object_t);
} }
int lam_free_list_init( int lam_free_list_init(
lam_free_list_t *flist, lam_free_list_t *flist,
size_t elem_size, size_t elem_size,
lam_class_info_t* elem_class, lam_class_t* elem_class,
int num_elements_to_alloc, int num_elements_to_alloc,
int max_elements_to_alloc, int max_elements_to_alloc,
int num_elements_per_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; lam_list_item_t* item = (lam_list_item_t*)ptr;
if (NULL != flist->fl_elem_class) { if (NULL != flist->fl_elem_class) {
/* bypass OBJ_CONSTRUCT() in this case (generic types) */ /* 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) ((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); lam_list_append(&flist->super, item);
ptr += flist->fl_elem_size; 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/seg_list.h"
#include "lam/mem/mem_pool.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 struct lam_free_list_t
@ -21,7 +21,7 @@ struct lam_free_list_t
int fl_num_allocated; int fl_num_allocated;
int fl_num_per_alloc; int fl_num_per_alloc;
size_t fl_elem_size; size_t fl_elem_size;
lam_class_info_t* fl_elem_class; lam_class_t* fl_elem_class;
lam_allocator_t* fl_allocator; lam_allocator_t* fl_allocator;
lam_mutex_t fl_lock; lam_mutex_t fl_lock;
}; };
@ -31,7 +31,7 @@ typedef struct lam_free_list_t lam_free_list_t;
int lam_free_list_init( int lam_free_list_init(
lam_free_list_t *flist, lam_free_list_t *flist,
size_t element_size, size_t element_size,
lam_class_info_t* element_class, lam_class_t* element_class,
int num_elements_to_alloc, int num_elements_to_alloc,
int max_elements_to_alloc, int max_elements_to_alloc,
int num_elements_per_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 default_min_pages_per_list, long default_pages_per_list,
long max_pages_per_list, ssize_t max_mem_in_pool); 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", "lam_free_lists_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_free_lists_construct, (lam_construct_t) lam_free_lists_construct,
(lam_destruct_t) lam_free_lists_destruct (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) void lam_free_lists_construct(lam_free_lists_t *flist)
{ {
OBJ_CONSTRUCT_SUPER(flist, lam_object_t);
lam_mutex_init(&flist->fl_lock); lam_mutex_init(&flist->fl_lock);
flist->fl_pool = NULL; flist->fl_pool = NULL;
flist->fl_elt_cls = 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 ) if ( flist->fl_chunks_returned )
free(flist->fl_chunks_returned); free(flist->fl_chunks_returned);
#endif #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++) for (desc = 0; desc < flist->fl_elt_per_chunk; desc++)
{ {
/* bypass OBJ_CONSTRUCT() in this case (generic types) */ /* 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) ((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; 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; int fl_enforce_affinity;
lam_affinity_t *fl_affinity; /* array of lam_affinity_t */ lam_affinity_t *fl_affinity; /* array of lam_affinity_t */
int fl_threshold_grow; 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; lam_mutex_t fl_lock;
/* for mem profiling */ /* for mem profiling */
@ -49,7 +49,7 @@ struct lam_free_lists_t
typedef struct lam_free_lists_t 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_construct(lam_free_lists_t *flist);
void lam_free_lists_destruct(lam_free_lists_t *flist); void lam_free_lists_destruct(lam_free_lists_t *flist);

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

@ -16,25 +16,23 @@
#include "lam/util/output.h" #include "lam/util/output.h"
#include "lam/os/numa.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", "lam_mem_pool_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_mp_construct, (lam_construct_t) lam_mp_construct,
(lam_destruct_t) lam_mp_destruct (lam_destruct_t) lam_mp_destruct
}; };
/* process-shared mem pool class */ /* process-shared mem pool class */
lam_class_info_t shmem_pool_t_class_info = { lam_class_t shmem_pool_t_class = {
"shmem_pool_t", "shmem_pool_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_mp_shared_construct, (lam_construct_t) lam_mp_shared_construct,
(lam_destruct_t) lam_mp_destruct (lam_destruct_t) lam_mp_destruct
}; };
void lam_mp_construct(lam_mem_pool_t *pool) 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); pool->mp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_mutex_init(&(pool->mp_lock)); lam_mutex_init(&(pool->mp_lock));
pool->mp_dev_alloc = NULL; 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) 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); pool->mp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_mutex_init(&(pool->mp_lock)); lam_mutex_init(&(pool->mp_lock));
lam_allocator_set_is_shared(pool->mp_private_alloc, 1); lam_allocator_set_is_shared(pool->mp_private_alloc, 1);
@ -57,7 +53,6 @@ void lam_mp_destruct(lam_mem_pool_t *pool)
OBJ_RELEASE(pool->mp_dev_alloc); OBJ_RELEASE(pool->mp_dev_alloc);
OBJ_RELEASE(pool->mp_private_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, 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", "lam_fixed_mpool_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_fmp_construct, (lam_construct_t) lam_fmp_construct,
(lam_destruct_t) lam_fmp_destruct (lam_destruct_t) lam_fmp_destruct
}; };
void lam_fmp_construct(lam_fixed_mpool_t *pool) 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); pool->fmp_private_alloc = OBJ_NEW(lam_allocator_t);
lam_allocator_set_is_shared(pool->fmp_private_alloc, 1); lam_allocator_set_is_shared(pool->fmp_private_alloc, 1);
lam_allocator_set_mem_prot(pool->fmp_private_alloc, MMAP_SHARED_PROT); lam_allocator_set_mem_prot(pool->fmp_private_alloc, MMAP_SHARED_PROT);
@ -319,7 +312,6 @@ void lam_fmp_destruct(lam_fixed_mpool_t *pool)
if ( pool->fmp_n_segs_in_array ) if ( pool->fmp_n_segs_in_array )
free(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; } lam_mem_pool_t;
/* process-private mem pool class */ /* 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 */ /* 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_construct(lam_mem_pool_t *pool);
void lam_mp_shared_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; int fmp_apply_affinity;
} lam_fixed_mpool_t; } 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_construct(lam_fixed_mpool_t *pool);
void lam_fmp_destruct(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 * Public variable
*/ */
lam_class_info_t lam_seg_list_t_class_info = { lam_class_t lam_seg_list_t_class = {
"lam_seg_list_t", "lam_seg_list_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_sgl_construct, (lam_construct_t) lam_sgl_construct,
(lam_destruct_t) lam_sgl_destruct (lam_destruct_t) lam_sgl_destruct
}; };
void lam_sgl_construct(lam_seg_list_t *slist) void lam_sgl_construct(lam_seg_list_t *slist)
{ {
OBJ_CONSTRUCT_SUPER(slist, lam_object_t);
OBJ_CONSTRUCT(&slist->sgl_list, lam_list_t); OBJ_CONSTRUCT(&slist->sgl_list, lam_list_t);
lam_mutex_init(&slist->sgl_lock); lam_mutex_init(&slist->sgl_lock);
slist->sgl_min_bytes_pushed = 0; 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) void lam_sgl_destruct(lam_seg_list_t *slist)
{ {
OBJ_DESTRUCT(&(slist->sgl_list)); 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; 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_construct(lam_seg_list_t *slist);
void lam_sgl_destruct(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 #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", "lam_reactor_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t)lam_reactor_construct, (lam_construct_t)lam_reactor_construct,
(lam_destruct_t)lam_reactor_destruct (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", "lam_reactor_descriptor_t",
CLASS_INFO(lam_list_item_t), OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_reactor_descriptor_construct, (lam_construct_t)lam_reactor_descriptor_construct,
(lam_destruct_t)lam_reactor_descriptor_destruct (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) 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) 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) void lam_reactor_construct(lam_reactor_t* r)
{ {
OBJ_CONSTRUCT_SUPER(r, lam_object_t);
lam_mutex_init(&r->r_mutex); lam_mutex_init(&r->r_mutex);
OBJ_CONSTRUCT(&r->r_active, lam_list_t); OBJ_CONSTRUCT(&r->r_active, lam_list_t);
OBJ_CONSTRUCT(&r->r_free, 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_free);
OBJ_DESTRUCT(&r->r_pending); OBJ_DESTRUCT(&r->r_pending);
OBJ_DESTRUCT(&r->r_hash); 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_SEND;
extern const int LAM_REACTOR_NOTIFY_EXCEPT; extern const int LAM_REACTOR_NOTIFY_EXCEPT;
extern lam_class_info_t lam_reactor_t_class_info; extern lam_class_t lam_reactor_t_class;
extern lam_class_info_t lam_reactor_descriptor_t_class_info; 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" #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", "mca_pml_base_request_t",
CLASS_INFO(lam_request_t), OBJ_CLASS(lam_request_t),
(lam_construct_t) mca_pml_base_request_construct, (lam_construct_t) mca_pml_base_request_construct,
(lam_destruct_t) mca_pml_base_request_destruct (lam_destruct_t) mca_pml_base_request_destruct
}; };
void mca_pml_base_request_construct(mca_pml_base_request_t* req) 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); lam_mutex_init(&req->req_lock);
} }
void mca_pml_base_request_destruct(mca_pml_base_request_t* req) void mca_pml_base_request_destruct(mca_pml_base_request_t* req)
{ {
lam_mutex_destroy(&req->req_lock); 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/datatype/datatype.h"
#include "mpi/communicator/communicator.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 */ /* MPI request status */
typedef enum { typedef enum {

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

@ -6,9 +6,9 @@
#include "pml_ptl_array.h" #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", "mca_ptl_array_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) mca_ptl_array_construct, (lam_construct_t) mca_ptl_array_construct,
(lam_destruct_t) mca_ptl_array_destruct (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) void mca_ptl_array_construct(mca_ptl_array_t* array)
{ {
OBJ_CONSTRUCT_SUPER(array, lam_object_t);
array->ptl_procs = 0; array->ptl_procs = 0;
array->ptl_size = 0; array->ptl_size = 0;
array->ptl_index = 0; array->ptl_index = 0;
@ -28,7 +27,6 @@ void mca_ptl_array_destruct(mca_ptl_array_t* array)
{ {
if(array->ptl_procs != 0) if(array->ptl_procs != 0)
free(array->ptl_procs); 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 "lam/util/output.h"
#include "mca/mpi/ptl/ptl.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 { struct mca_ptl_proc_t {
double ptl_weight; /* PTL weight for scheduling */ 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( lam_free_list_init(
&mca_pml_teg.teg_recv_requests, &mca_pml_teg.teg_recv_requests,
sizeof(mca_ptl_base_recv_request_t), 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_num,
mca_pml_teg.teg_free_list_max, mca_pml_teg.teg_free_list_max,
mca_pml_teg.teg_free_list_inc, 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_teg_proc.h"
#include "pml_ptl_array.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", "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_construct_t) mca_pml_teg_proc_construct,
(lam_destruct_t) mca_pml_teg_proc_destruct (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) 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_first);
mca_ptl_array_construct(&proc->proc_ptl_next); 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); THREAD_LOCK(&mca_pml_teg.teg_lock);
lam_list_remove_item(&mca_pml_teg.teg_procs, (lam_list_item_t*)proc); lam_list_remove_item(&mca_pml_teg.teg_procs, (lam_list_item_t*)proc);
THREAD_UNLOCK(&mca_pml_teg.teg_lock); 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; 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; 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); 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", "mca_pml_comm_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t)mca_pml_ptl_comm_construct, (lam_construct_t)mca_pml_ptl_comm_construct,
(lam_destruct_t)mca_pml_ptl_comm_destruct (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) 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); OBJ_CONSTRUCT(&comm->c_wild_receives, lam_list_t);
lam_mutex_init(&comm->c_wild_lock); 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_frags_cant_match);
free(comm->c_specific_receives); free(comm->c_specific_receives);
OBJ_DESTRUCT(&comm->c_wild_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. * 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 { struct mca_pml_comm_t {
lam_object_t super; 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); 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", "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_construct_t) mca_ptl_base_frag_construct,
(lam_destruct_t) mca_ptl_base_frag_destruct (lam_destruct_t) mca_ptl_base_frag_destruct
}; };
static void mca_ptl_base_frag_construct(mca_ptl_base_frag_t* frag) 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) 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" #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 { struct mca_ptl_base_frag_t {
lam_list_item_t super; 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); 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", "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_construct_t) mca_ptl_base_recv_frag_construct,
(lam_destruct_t) mca_ptl_base_recv_frag_destruct (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) 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) 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_recvreq.h"
#include "mca/mpi/ptl/base/ptl_base_match.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 { 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); 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", "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_construct_t) mca_ptl_base_recv_request_construct,
(lam_destruct_t) mca_ptl_base_recv_request_destruct (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) 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) 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/ptl/ptl.h"
#include "mca/mpi/pml/base/pml_base_request.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; 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); 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", "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_construct_t) mca_ptl_base_send_frag_construct,
(lam_destruct_t) mca_ptl_base_send_frag_destruct (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) 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) 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/ptl.h"
#include "mca/mpi/ptl/base/ptl_base_fragment.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 { 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); 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", "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_construct_t) mca_ptl_base_send_request_construct,
(lam_destruct_t) mca_ptl_base_send_request_destruct (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) 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); OBJ_CONSTRUCT(&req->req_unacked_frags, lam_list_t);
} }
static void mca_ptl_base_send_request_destruct(mca_ptl_base_send_request_t* req) static void mca_ptl_base_send_request_destruct(mca_ptl_base_send_request_t* req)
{ {
OBJ_DESTRUCT(&req->req_unacked_frags); 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" #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; 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 */ /* initialize free lists */
lam_free_list_init(&mca_ptl_tcp_module.tcp_send_requests, lam_free_list_init(&mca_ptl_tcp_module.tcp_send_requests,
sizeof(mca_ptl_tcp_send_request_t), 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_num,
mca_ptl_tcp_module.tcp_free_list_max, mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc, 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, lam_free_list_init(&mca_ptl_tcp_module.tcp_send_frags,
sizeof(mca_ptl_tcp_send_frag_t), 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_num,
mca_ptl_tcp_module.tcp_free_list_max, mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc, 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, lam_free_list_init(&mca_ptl_tcp_module.tcp_recv_frags,
sizeof(mca_ptl_tcp_recv_frag_t), 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_num,
mca_ptl_tcp_module.tcp_free_list_max, mca_ptl_tcp_module.tcp_free_list_max,
mca_ptl_tcp_module.tcp_free_list_inc, 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); 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", "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_construct_t)mca_ptl_tcp_peer_construct,
(lam_destruct_t)mca_ptl_tcp_peer_destruct (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) 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_ptl = 0;
ptl_peer->peer_proc = 0; ptl_peer->peer_proc = 0;
ptl_peer->peer_addr = 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_proc_remove(ptl_peer->peer_proc, ptl_peer);
mca_ptl_tcp_peer_close_i(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; 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; typedef struct mca_ptl_base_peer_t mca_ptl_tcp_peer_t;
void mca_ptl_tcp_peer_close(mca_ptl_base_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 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); 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", "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_construct_t)mca_ptl_tcp_proc_construct,
(lam_destruct_t)mca_ptl_tcp_proc_destruct (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) 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_lam = 0;
proc->proc_addrs = 0; proc->proc_addrs = 0;
proc->proc_addr_count = 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); free(proc->proc_peers);
if(NULL != proc->proc_guid) if(NULL != proc->proc_guid)
free(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.h"
#include "ptl_tcp_peer.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); 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", "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_construct_t)mca_ptl_tcp_recv_frag_construct,
(lam_destruct_t)mca_ptl_tcp_recv_frag_destruct (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) 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) 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" #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 { 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); 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", "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_construct_t)mca_ptl_tcp_send_frag_construct,
(lam_destruct_t)mca_ptl_tcp_send_frag_destruct (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) 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) 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 "mca/mpi/ptl/base/ptl_base_sendfrag.h"
#include "ptl_tcp.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 { 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*); 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", "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_construct_t)mca_ptl_tcp_send_request_construct,
(lam_destruct_t)mca_ptl_tcp_send_request_destruct (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) 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); 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) void mca_ptl_tcp_send_request_destruct(mca_ptl_tcp_send_request_t* request)
{ {
OBJ_DESTRUCT(&request->req_frag); 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" #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 { struct mca_ptl_tcp_send_request_t {
mca_ptl_base_send_request_t super; mca_ptl_base_send_request_t super;

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

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

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

@ -7,9 +7,9 @@
/* /*
* lam_info_t classes * lam_info_t classes
*/ */
lam_class_info_t lam_info_t_class_info = { lam_class_t lam_info_t_class = {
"lam_info_t", "lam_info_t",
CLASS_INFO(lam_list_t), OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_info_construct, (lam_construct_t)lam_info_construct,
(lam_destruct_t)lam_info_destruct (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_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", "lam_info_entry_t",
CLASS_INFO(lam_list_item_t), OBJ_CLASS(lam_list_item_t),
(lam_construct_t)lam_info_entry_construct, (lam_construct_t)lam_info_entry_construct,
(lam_destruct_t)lam_info_entry_destruct (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 * lam_info_t interface functions
*/ */
void lam_info_construct(lam_info_t *info) { void lam_info_construct(lam_info_t *info) {
OBJ_CONSTRUCT_SUPER(info, lam_list_t);
info->i_fhandle = -1; info->i_fhandle = -1;
} }
void lam_info_destruct(lam_info_t *info) { void lam_info_destruct(lam_info_t *info) {
OBJ_DESTRUCT_SUPER(info, lam_list_t);
} }
/* /*
* lam_info_entry_t interface functions * lam_info_entry_t interface functions
*/ */
void lam_info_entry_construct(lam_info_entry_t *entry) { 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)); memset(entry->ie_key, 0, sizeof(entry->ie_key));
entry->ie_key[MPI_MAX_INFO_KEY] = 0; 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) { if (NULL != entry->ie_value) {
free(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 * Some declarations needed to use OBJ_NEW and OBJ_DESTRUCT macros
*/ */
extern lam_class_info_t lam_info_t_class_info; extern lam_class_t lam_info_t_class;
extern lam_class_info_t lam_info_entry_t_class_info; extern lam_class_t lam_info_entry_t_class;
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
extern "C" { 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_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", "lam_proc_t",
CLASS_INFO(lam_list_t), OBJ_CLASS(lam_list_t),
(lam_construct_t)lam_proc_construct, (lam_construct_t)lam_proc_construct,
(lam_destruct_t)lam_proc_destruct (lam_destruct_t)lam_proc_destruct
}; };
@ -22,7 +22,6 @@ void lam_proc_construct(lam_proc_t* proc)
lam_mutex_init(&lam_proc_lock); lam_mutex_init(&lam_proc_lock);
} }
OBJ_CONSTRUCT_SUPER(proc, lam_list_t);
proc->proc_job = 0; proc->proc_job = 0;
proc->proc_vpid = 0; proc->proc_vpid = 0;
proc->proc_pml = 0; proc->proc_pml = 0;
@ -38,6 +37,5 @@ void lam_proc_destruct(lam_proc_t* proc)
THREAD_LOCK(&lam_proc_lock); THREAD_LOCK(&lam_proc_lock);
lam_list_remove_item(&lam_proc_list, (lam_list_item_t*)proc); lam_list_remove_item(&lam_proc_list, (lam_list_item_t*)proc);
THREAD_UNLOCK(&lam_proc_lock); 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" #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 { struct lam_proc_t {

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

@ -4,9 +4,9 @@
#include "mpi/request/request.h" #include "mpi/request/request.h"
lam_class_info_t lam_request_t_class_info = { lam_class_t lam_request_t_class = {
"lam_request_t", "lam_request_t",
CLASS_INFO(lam_object_t), OBJ_CLASS(lam_object_t),
(lam_construct_t) lam_request_construct, (lam_construct_t) lam_request_construct,
(lam_destruct_t) lam_request_destruct, (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) void lam_request_construct(lam_request_t* rq)
{ {
OBJ_CONSTRUCT_SUPER(rq, lam_object_t);
} }
void lam_request_destruct(lam_request_t* rq) 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" #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 { typedef enum {
LAM_REQUEST_PML, LAM_REQUEST_PML,