25521106662

Committed 07 May 2026 08:45PM UTC coverage: 56.776%. First build

Build # 25521106662

Build Type

Pull #2099

github

Committed by

web-flow

Commit Message

Merge 5bba2b086 into 9b86789c4

Pull Request Pull Request #2099: Fixes to MSSharedMem class

Coverage Stats

0 of 9 new or added lines in 2 files covered. (0.0%)

12916 of 22749 relevant lines covered (56.78%)

299013.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/trick_source/sim_services/MasterSlave/MSSharedMem.cpp


#include <iostream>
#include <sstream>
#include <cstring> // for memcpy
#include <unistd.h>

#include "trick/MSSharedMem.hh"
#include "trick/tsm_proto.h"
#include "trick/command_line_protos.h"

Trick::MSSharedMem::MSSharedMem() : tsm_dev() {
    tsm_dev.default_val = -1;

    // default is a non-zero sync wait limit; helpful when slave reading initial data from master
    sync_wait_limit = 5.0 ;
}

Trick::MSSharedMem::~MSSharedMem() {
    // detach shared memory
    tsm_disconnect(&tsm_dev);
}

int Trick::MSSharedMem::set_sync_wait_limit(double in_limit) {
    /** @par Detailed Design */
    if ( in_limit > 0.0 ) {
        /** @li if the incoming limit time is greater than zero, we will use it
                as the timeout value during read and write */
        sync_wait_limit = in_limit ;
    } else {
        /** @li if the incoming limit time is less than or equal to zero, wait forever */
        sync_wait_limit = TSM_MAX_TIMEOUT_LIMIT;
    }
    return(0) ;
}

std::string Trick::MSSharedMem::add_sim_args(std::string slave_type __attribute__((unused))) {

    /** @par Detailed Design */

    /** @li nothing to do here for shared memory. */
    return("");
}

int Trick::MSSharedMem::process_sim_args() {

    //int ii ;
    //int argc ;
    //char ** argv ;

    //argc = command_line_args_get_argc() ;
    //argv = command_line_args_get_argv() ;

    /** @par Detailed Design */

    /** @li no shared memory arguments to search for, return 1 to enable slave */
    //for (ii = 2; ii < argc; ii++) {
    //}
    return(1) ;
}

int Trick::MSSharedMem::accept() {

    int ret ;
    /** @par Detailed Design */
    /** @li Call tsm_init to create shared memory for master. */
    tsm_dev.size = sizeof(MSSharedMemData);
    ret = tsm_init(&tsm_dev);
    shm_addr = (MSSharedMemData*) tsm_dev.addr;
    /** @li Save master process id so we can keep master and slave data seperate. */
    // (the master calls accept)
    if (ret==TSM_SUCCESS) {
        shm_addr->master_pid = getpid();
//fprintf(stderr, "====accept master=%d\n", getpid());
        MSQ_INIT(shm_addr->master_time);
        MSQ_INIT(shm_addr->master_command);
        MSQ_INIT(shm_addr->slave_command);
        shm_addr->slave_port = MS_ERROR_PORT;
        shm_addr->chkpnt_name[0] = MS_ERROR_NAME;
    } else {
//fprintf(stderr, "====accept SHARED MEMORY ERROR\n");
    }
    return(ret) ;
}

int Trick::MSSharedMem::connect() {
    int ret ;
    /** @par Detailed Design */
    /** @li Call tsm_init to create shared memory for slave. */
    if (tsm_dev.size == 0) {
        tsm_dev.size = sizeof(MSSharedMemData);
        ret = tsm_init(&tsm_dev);
    } else {
        ret = tsm_reconnect(&tsm_dev);
    }
    shm_addr = (MSSharedMemData*) tsm_dev.addr;
    return(ret) ;
}

int Trick::MSSharedMem::disconnect() {
    return(0) ;
}


double Trick::MSSharedMem::read_wait(struct timespec *in_start) {
    struct timespec ts_Current, ts_Difference;

    RELEASE();
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Current);
    if ((ts_Current.tv_nsec - in_start->tv_nsec) < 0) {
        ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec - 1;
        ts_Difference.tv_nsec = 1000000000 + ts_Current.tv_nsec - in_start->tv_nsec;
    } else {
        ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec;
        ts_Difference.tv_nsec = ts_Current.tv_nsec - in_start->tv_nsec;
    }
    // return the total elapsed time we've waited since in_start
    return ((double)ts_Difference.tv_nsec / 1000000000.0) + ts_Difference.tv_sec;
}

long long Trick::MSSharedMem::read_time() {

    long long in_time;
    double readtry_time = 0.0;
    struct timespec ts_Start;

    /** @par Detailed Design */
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);

    /** @li Get time from shared memory */
    while (MSQ_ISEMPTY(shm_addr->master_time)) {
        if (readtry_time >= sync_wait_limit) {
            break;
        }
        readtry_time = read_wait(&ts_Start);
    }
    if (!MSQ_ISEMPTY(shm_addr->master_time)) {
        in_time = MSQ_FRONT(shm_addr->master_time);
//fprintf(stderr, "+++++read_time pid=%d time=%lld readtry=%f\n", getpid(), in_time, readtry_time);
        MSQ_POP(shm_addr->master_time);
        return (in_time) ;
    /** @li If no new data before timeout limit, return "error" time */
    } else {
//fprintf(stderr, "+++++read_time pid=%d time=%lld ERROR readtry=%f\n", getpid(), in_time, readtry_time,); fflush(stderr);
        return (MS_ERROR_TIME) ;
    }
}

MS_SIM_COMMAND Trick::MSSharedMem::read_command() {

    MS_SIM_COMMAND command;
    double readtry_time = 0.0;
    struct timespec ts_Start;

    /** @par Detailed Design */
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);

    if (getpid() == shm_addr->master_pid) {
    /** @li Get slave command from shared memory */
    // I am master, so read slave command
        while (MSQ_ISEMPTY(shm_addr->slave_command)) {
            if (readtry_time >= sync_wait_limit) {
                break;
            }
            readtry_time = read_wait(&ts_Start);
        }
        if (!MSQ_ISEMPTY(shm_addr->slave_command)) {
            command = (MS_SIM_COMMAND)MSQ_FRONT(shm_addr->slave_command);
//fprintf(stderr, "+++++read_command pid=%d command=%d (from slave)\n", getpid(), command);
            MSQ_POP(shm_addr->slave_command);
            return (command) ;
        /** @li If no new data before timeout limit, return "error" command */
        } else {
//fprintf(stderr, "+++++read_command pid=%d command=%d (from slave) ERROR readtry=%f\n", getpid(), command, readtry_time);
            return (MS_ErrorCmd) ;
        }
    } else {
    /** @li Get master command from shared memory */
    // I am slave, so read master command
        while (MSQ_ISEMPTY(shm_addr->master_command)) {
            if (readtry_time >= sync_wait_limit) {
                break;
            }
            readtry_time = read_wait(&ts_Start);
        }
        if (!MSQ_ISEMPTY(shm_addr->master_command)) {
            command = (MS_SIM_COMMAND)MSQ_FRONT(shm_addr->master_command);
//fprintf(stderr, "+++++read_command pid=%d command=%d (from master)\n", getpid(), command);
            MSQ_POP(shm_addr->master_command);
            return (command) ;
        /** @li If no new data before timeout limit, return "error" command */
        } else {
//fprintf(stderr, "+++++read_command pid=%d command=%d (from master) ERROR readtry=%f\n", getpid(), command, readtry_time);
            return (MS_ErrorCmd) ;
        }
    }
}

int Trick::MSSharedMem::read_port() {

    int in_port;
    double readtry_time = 0.0;
    struct timespec ts_Start;

    /** @par Detailed Design */
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);

    /** @li Get port number from shared memory */
    while (shm_addr->slave_port == MS_ERROR_PORT) {
        if (readtry_time >= sync_wait_limit) {
            break;
        }
        readtry_time = read_wait(&ts_Start);
    }
    if (shm_addr->slave_port != MS_ERROR_PORT) {
        in_port = shm_addr->slave_port;
        shm_addr->slave_port = MS_ERROR_PORT; // default value
        return (in_port) ;
    /** @li If no new data before timeout limit, return "error" port */
    } else {
        return (MS_ERROR_PORT) ;
    }
}

char Trick::MSSharedMem::read_name(char * read_data, size_t size) {

    double readtry_time = 0.0;
    struct timespec ts_Start;

    /** @par Detailed Design */
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);

    /** @li Get name (character array) from shared memory */
    while (shm_addr->chkpnt_name[0] == MS_ERROR_NAME) {
        if (readtry_time >= sync_wait_limit) {
            break;
        }
        readtry_time = read_wait(&ts_Start);
    }
    if (shm_addr->chkpnt_name[0] != MS_ERROR_NAME) {
        memcpy(read_data, shm_addr->chkpnt_name, size);
        shm_addr->chkpnt_name[0] = MS_ERROR_NAME; // default value
        return (0) ;
    /** @li If no new data before timeout limit, return "error" name */
    } else {
        return (MS_ERROR_NAME) ;
    }
}

int Trick::MSSharedMem::write_time(long long in_time) {

    /** @par Detailed Design */
    /** @li Write time to shared memory */
//fprintf(stderr, "====write_time pid=%d time=%lld\n", getpid(), in_time);
    MSQ_PUSH(shm_addr->master_time, in_time);

    /** @li Return the number of bytes written */
    return(sizeof(long long)) ;
}

int Trick::MSSharedMem::write_command(MS_SIM_COMMAND command) {

    /** @par Detailed Design */
    /** @li Write command to shared memory */
    if (getpid() == shm_addr->master_pid) {
//fprintf(stderr, "====write_command pid=%d command=%d (master)\n", getpid(), command);
        MSQ_PUSH(shm_addr->master_command, command);
    } else {
//fprintf(stderr, "====write_command pid=%d command=%d (slave)\n", getpid(), command);
        MSQ_PUSH(shm_addr->slave_command, command);
    }

    /** @li Return the number of bytes written */
    return(sizeof(MS_SIM_COMMAND)) ;
}

int Trick::MSSharedMem::write_port(int in_port) {

    /** @par Detailed Design */
    /** @li Write port number to shared memory */
    shm_addr->slave_port = in_port;

    /** @li Return the number of bytes written */
    return(sizeof(int)) ;
}

int Trick::MSSharedMem::write_name(char * in_data, size_t size) {

    /** @par Detailed Design */
    /** @li Write name (character array) to shared memory */
    memcpy(shm_addr->chkpnt_name, in_data, size);

    /** @li Return the number of bytes written */
    return(size);
}

1
2	#include <iostream>
3	#include <sstream>
4	#include <cstring> // for memcpy
5	#include <unistd.h>
6
7	#include "trick/MSSharedMem.hh"
8	#include "trick/tsm_proto.h"
9	#include "trick/command_line_protos.h"
10
11	Trick::MSSharedMem::MSSharedMem() : tsm_dev() {	×
12	tsm_dev.default_val = -1;	×
13
14	// default is a non-zero sync wait limit; helpful when slave reading initial data from master
15	sync_wait_limit = 5.0 ;	×
16	}	×
17
18	Trick::MSSharedMem::~MSSharedMem() {	×
19	// detach shared memory
20	tsm_disconnect(&tsm_dev);	×
21	}	×
22
23	int Trick::MSSharedMem::set_sync_wait_limit(double in_limit) {	×
24	/** @par Detailed Design */
25	if ( in_limit > 0.0 ) {	×
26	/** @li if the incoming limit time is greater than zero, we will use it
27	as the timeout value during read and write */
28	sync_wait_limit = in_limit ;	×
29	} else {
30	/** @li if the incoming limit time is less than or equal to zero, wait forever */
31	sync_wait_limit = TSM_MAX_TIMEOUT_LIMIT;	×
32	}
33	return(0) ;	×
34	}
35
36	std::string Trick::MSSharedMem::add_sim_args(std::string slave_type __attribute__((unused))) {	×
37
38	/** @par Detailed Design */
39
40	/** @li nothing to do here for shared memory. */
41	return("");	×
42	}
43
44	int Trick::MSSharedMem::process_sim_args() {	×
45
46	//int ii ;
47	//int argc ;
48	//char ** argv ;
49
50	//argc = command_line_args_get_argc() ;
51	//argv = command_line_args_get_argv() ;
52
53	/** @par Detailed Design */
54
55	/** @li no shared memory arguments to search for, return 1 to enable slave */
56	//for (ii = 2; ii < argc; ii++) {
57	//}
58	return(1) ;	×
59	}
60
61	int Trick::MSSharedMem::accept() {	×
62
63	int ret ;
64	/** @par Detailed Design */
65	/** @li Call tsm_init to create shared memory for master. */
66	tsm_dev.size = sizeof(MSSharedMemData);	×
67	ret = tsm_init(&tsm_dev);	×
68	shm_addr = (MSSharedMemData*) tsm_dev.addr;	×
69	/** @li Save master process id so we can keep master and slave data seperate. */
70	// (the master calls accept)
71	if (ret==TSM_SUCCESS) {	×
72	shm_addr->master_pid = getpid();	×
73	//fprintf(stderr, "====accept master=%d\n", getpid());
74	MSQ_INIT(shm_addr->master_time);	×
75	MSQ_INIT(shm_addr->master_command);	×
76	MSQ_INIT(shm_addr->slave_command);	×
77	shm_addr->slave_port = MS_ERROR_PORT;	×
78	shm_addr->chkpnt_name[0] = MS_ERROR_NAME;	×
79	} else {
80	//fprintf(stderr, "====accept SHARED MEMORY ERROR\n");
81	}
82	return(ret) ;	×
83	}
84
85	int Trick::MSSharedMem::connect() {	×
86	int ret ;
87	/** @par Detailed Design */
88	/** @li Call tsm_init to create shared memory for slave. */
89	if (tsm_dev.size == 0) {	×
90	tsm_dev.size = sizeof(MSSharedMemData);	×
91	ret = tsm_init(&tsm_dev);	×
92	} else {
93	ret = tsm_reconnect(&tsm_dev);	×
94	}
95	shm_addr = (MSSharedMemData*) tsm_dev.addr;	×
96	return(ret) ;	×
97	}
98
99	int Trick::MSSharedMem::disconnect() {	×
100	return(0) ;	×
101	}
102
103
104	double Trick::MSSharedMem::read_wait(struct timespec *in_start) {	×
105	struct timespec ts_Current, ts_Difference;
106
107	RELEASE();	×
108	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Current);	×
109	if ((ts_Current.tv_nsec - in_start->tv_nsec) < 0) {	×
110	ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec - 1;	×
111	ts_Difference.tv_nsec = 1000000000 + ts_Current.tv_nsec - in_start->tv_nsec;	×
112	} else {
113	ts_Difference.tv_sec = ts_Current.tv_sec - in_start->tv_sec;	×
114	ts_Difference.tv_nsec = ts_Current.tv_nsec - in_start->tv_nsec;	×
115	}
116	// return the total elapsed time we've waited since in_start
117	return ((double)ts_Difference.tv_nsec / 1000000000.0) + ts_Difference.tv_sec;	×
118	}
119
120	long long Trick::MSSharedMem::read_time() {	×
121
122	long long in_time;
123	double readtry_time = 0.0;	×
124	struct timespec ts_Start;
125
126	/** @par Detailed Design */
127	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);	×
128
129	/** @li Get time from shared memory */
130	while (MSQ_ISEMPTY(shm_addr->master_time)) {	×
131	if (readtry_time >= sync_wait_limit) {	×
132	break;	×
133	}
134	readtry_time = read_wait(&ts_Start);	×
135	}
136	if (!MSQ_ISEMPTY(shm_addr->master_time)) {	×
137	in_time = MSQ_FRONT(shm_addr->master_time);	×
138	//fprintf(stderr, "+++++read_time pid=%d time=%lld readtry=%f\n", getpid(), in_time, readtry_time);
139	MSQ_POP(shm_addr->master_time);	×
140	return (in_time) ;	×
141	/** @li If no new data before timeout limit, return "error" time */
142	} else {
143	//fprintf(stderr, "+++++read_time pid=%d time=%lld ERROR readtry=%f\n", getpid(), in_time, readtry_time,); fflush(stderr);
144	return (MS_ERROR_TIME) ;	×
145	}
146	}
147
148	MS_SIM_COMMAND Trick::MSSharedMem::read_command() {	×
149
150	MS_SIM_COMMAND command;
151	double readtry_time = 0.0;	×
152	struct timespec ts_Start;
153
154	/** @par Detailed Design */
155	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);	×
156
157	if (getpid() == shm_addr->master_pid) {	×
158	/** @li Get slave command from shared memory */
159	// I am master, so read slave command
160	while (MSQ_ISEMPTY(shm_addr->slave_command)) {	×
161	if (readtry_time >= sync_wait_limit) {	×
162	break;	×
163	}
164	readtry_time = read_wait(&ts_Start);	×
165	}
166	if (!MSQ_ISEMPTY(shm_addr->slave_command)) {	×
NEW 167	command = (MS_SIM_COMMAND)MSQ_FRONT(shm_addr->slave_command);	×
168	//fprintf(stderr, "+++++read_command pid=%d command=%d (from slave)\n", getpid(), command);
169	MSQ_POP(shm_addr->slave_command);	×
170	return (command) ;	×
171	/** @li If no new data before timeout limit, return "error" command */
172	} else {
173	//fprintf(stderr, "+++++read_command pid=%d command=%d (from slave) ERROR readtry=%f\n", getpid(), command, readtry_time);
174	return (MS_ErrorCmd) ;	×
175	}
176	} else {
177	/** @li Get master command from shared memory */
178	// I am slave, so read master command
179	while (MSQ_ISEMPTY(shm_addr->master_command)) {	×
180	if (readtry_time >= sync_wait_limit) {	×
181	break;	×
182	}
183	readtry_time = read_wait(&ts_Start);	×
184	}
185	if (!MSQ_ISEMPTY(shm_addr->master_command)) {	×
NEW 186	command = (MS_SIM_COMMAND)MSQ_FRONT(shm_addr->master_command);	×
187	//fprintf(stderr, "+++++read_command pid=%d command=%d (from master)\n", getpid(), command);
188	MSQ_POP(shm_addr->master_command);	×
189	return (command) ;	×
190	/** @li If no new data before timeout limit, return "error" command */
191	} else {
192	//fprintf(stderr, "+++++read_command pid=%d command=%d (from master) ERROR readtry=%f\n", getpid(), command, readtry_time);
193	return (MS_ErrorCmd) ;	×
194	}
195	}
196	}
197
198	int Trick::MSSharedMem::read_port() {	×
199
200	int in_port;
201	double readtry_time = 0.0;	×
202	struct timespec ts_Start;
203
204	/** @par Detailed Design */
205	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);	×
206
207	/** @li Get port number from shared memory */
208	while (shm_addr->slave_port == MS_ERROR_PORT) {	×
209	if (readtry_time >= sync_wait_limit) {	×
210	break;	×
211	}
212	readtry_time = read_wait(&ts_Start);	×
213	}
214	if (shm_addr->slave_port != MS_ERROR_PORT) {	×
215	in_port = shm_addr->slave_port;	×
216	shm_addr->slave_port = MS_ERROR_PORT; // default value	×
217	return (in_port) ;	×
218	/** @li If no new data before timeout limit, return "error" port */
219	} else {
220	return (MS_ERROR_PORT) ;	×
221	}
222	}
223
224	char Trick::MSSharedMem::read_name(char * read_data, size_t size) {	×
225
226	double readtry_time = 0.0;	×
227	struct timespec ts_Start;
228
229	/** @par Detailed Design */
230	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_Start);	×
231
232	/** @li Get name (character array) from shared memory */
233	while (shm_addr->chkpnt_name[0] == MS_ERROR_NAME) {	×
234	if (readtry_time >= sync_wait_limit) {	×
235	break;	×
236	}
237	readtry_time = read_wait(&ts_Start);	×
238	}
239	if (shm_addr->chkpnt_name[0] != MS_ERROR_NAME) {	×
240	memcpy(read_data, shm_addr->chkpnt_name, size);	×
241	shm_addr->chkpnt_name[0] = MS_ERROR_NAME; // default value	×
242	return (0) ;	×
243	/** @li If no new data before timeout limit, return "error" name */
244	} else {
245	return (MS_ERROR_NAME) ;	×
246	}
247	}
248
249	int Trick::MSSharedMem::write_time(long long in_time) {	×
250
251	/** @par Detailed Design */
252	/** @li Write time to shared memory */
253	//fprintf(stderr, "====write_time pid=%d time=%lld\n", getpid(), in_time);
254	MSQ_PUSH(shm_addr->master_time, in_time);	×
255
256	/** @li Return the number of bytes written */
257	return(sizeof(long long)) ;	×
258	}
259
260	int Trick::MSSharedMem::write_command(MS_SIM_COMMAND command) {	×
261
262	/** @par Detailed Design */
263	/** @li Write command to shared memory */
264	if (getpid() == shm_addr->master_pid) {	×
265	//fprintf(stderr, "====write_command pid=%d command=%d (master)\n", getpid(), command);
266	MSQ_PUSH(shm_addr->master_command, command);	×
267	} else {
268	//fprintf(stderr, "====write_command pid=%d command=%d (slave)\n", getpid(), command);
269	MSQ_PUSH(shm_addr->slave_command, command);	×
270	}
271
272	/** @li Return the number of bytes written */
273	return(sizeof(MS_SIM_COMMAND)) ;	×
274	}
275
276	int Trick::MSSharedMem::write_port(int in_port) {	×
277
278	/** @par Detailed Design */
279	/** @li Write port number to shared memory */
280	shm_addr->slave_port = in_port;	×
281
282	/** @li Return the number of bytes written */
283	return(sizeof(int)) ;	×
284	}
285
286	int Trick::MSSharedMem::write_name(char * in_data, size_t size) {	×
287
288	/** @par Detailed Design */
289	/** @li Write name (character array) to shared memory */
290	memcpy(shm_addr->chkpnt_name, in_data, size);	×
291
292	/** @li Return the number of bytes written */
293	return(size);	×
294	}

nasa / trick / 25521106662

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous