void
nkn_init_pool_mem(void)
{
initialize_sizes();
mem_slot_queue_t *pslot = &mem_slot_q[0];
init_slot_mem(&pslot);
}
int main(int argc, char **argv)
{
DATATYPE *x;
long *sizes;
double *times, *bws, *percents;
type = usage(argc, argv);
assert(sizes = (long *)malloc(timeslots*sizeof(long)));
memset(sizes,0x00,(timeslots*sizeof(long)));
assert(times = (double *)malloc(timeslots*repeat_count*sizeof(double)));
memset(times,0x00,(timeslots*repeat_count*sizeof(double)));
assert(bws = (double *)malloc(timeslots*repeat_count*sizeof(double)));
memset(bws,0x00,(timeslots*repeat_count*sizeof(double)));
assert(percents = (double *)malloc(timeslots*repeat_count*sizeof(double)));
memset(percents,0x00,(timeslots*repeat_count*sizeof(double)));
assert(x = (DATATYPE *)malloc((size_t)memsize));
memset((void *)x,0x00,memsize);
initialize_sizes(sizes);
/* Measure cache */
if (type & MEMORYSET)
{
do_memory_set(sizes,x,times,bws,percents);
}
if (type & MEMORYCOPY)
{
do_memory_copy(sizes,x,times,bws,percents);
}
if (type & READONLY)
{
do_read_only(sizes,x,times,bws,percents);
}
if (type & WRITEONLY)
{
do_write_only(sizes,x,times,bws,percents);
}
if (type & READWRITE)
{
do_read_write(sizes,x,times,bws,percents);
}
FLUSHALL(0);
exit(0);
}
int
main(int argc, char * argv[])
{
RT_MODEL * S;
const char * status;
int_T count;
int exit_code = exit_success;
boolean_T parseError = FALSE;
real_T final_time = -2; /* Let model select final time */
int scheduling_priority;
struct qsched_param scheduling;
t_period timeout;
t_timer_notify notify;
t_error result;
/*
* Make controller threads higher priority than external mode threads:
* ext_priority = priority of lowest priority external mode thread
* min_priority = minimum allowable priority of lowest priority model task
* max_priority = maximum allowable priority of lowest priority model task
*/
int ext_priority = qsched_get_priority_min(QSCHED_FIFO);
int min_priority = ext_priority + 2;
int max_priority = qsched_get_priority_max(QSCHED_FIFO) - 0;
qsigset_t signal_set;
qsigaction_t action;
int_T stack_size = 0; /* default stack size */
(void) ssPrintf("Entered main(argc=%d, argv=%p)\n", argc, argv);
for (count = 0; count < argc; count++) {
(void) ssPrintf(" argv[%d] = %s\n", count, argv[count]);
}
scheduling_priority = 2; /* default priority */
if (scheduling_priority < min_priority)
scheduling_priority = min_priority;
else if (scheduling_priority > max_priority)
scheduling_priority = max_priority;
/*
* Parse the standard RTW parameters. Let all unrecognized parameters
* pass through to external mode for parsing. NULL out all args handled
* so that the external mode parsing can ignore them.
*/
for (count = 1; count < argc; ) {
const char *option = argv[count++];
char extraneous_characters[2];
if ((strcmp(option, "-tf") == 0) && (count != argc)) {/* final time */
const char * tf_argument = argv[count++];
double time_value; /* use a double for the sscanf since real_T may be a float or a double depending on the platform */
if (strcmp(tf_argument, "inf") == 0) {
time_value = RUN_FOREVER;
} else {
int items = sscanf(tf_argument, "%lf%1s", &time_value,
extraneous_characters);
if ((items != 1) || (time_value < 0.0) ) {
(void) fprintf(stderr,
"final_time must be a positive, real value or inf.\n");
parseError = true;
break;
}
}
final_time = (real_T) time_value;
argv[count-2] = NULL;
argv[count-1] = NULL;
} else if ((strcmp(option, "-pri") == 0) && (count != argc)) {/* base priority */
const char * tf_argument = argv[count++];
int priority; /* use an int for the sscanf since int_T may be the wrong size depending on the platform */
int items = sscanf(tf_argument, "%d%1s", &priority, extraneous_characters);
if ((items != 1) || (priority < min_priority) ) {
(void) fprintf(stderr,
"priority must be a greater than or equal to %d.\n",
min_priority);
parseError = true;
break;
}
if (priority > max_priority) {
(void) fprintf(stderr, "priority must be less than or equal to %d.\n",
max_priority);
parseError = true;
break;
}
scheduling_priority = priority;
argv[count-2] = NULL;
argv[count-1] = NULL;
} else if ((strcmp(option, "-ss") == 0) && (count != argc)) {/* stack size */
const char * stack_argument = argv[count++];
int stack; /* use an int for the sscanf since int_T may be the wrong size depending on the platform */
int items = sscanf(stack_argument, "%d%1s", &stack, extraneous_characters);
if ((items != 1) || (stack < QTHREAD_STACK_MIN) ) {
(void) fprintf(stderr,
"stack size must be a integral value greater than or equal to %d.\n",
QTHREAD_STACK_MIN);
parseError = true;
break;
}
stack_size = (int_T)stack;
argv[count-2] = NULL;
argv[count-1] = NULL;
} else if ((strcmp(option, "-d") == 0) && (count != argc)) {/* current directory */
const char * path_name = argv[count++];
_chdir(path_name);
argv[count-2] = NULL;
argv[count-1] = NULL;
}
}
rtExtModeQuarcParseArgs(argc, (const char **) argv, "shmem://Crane:1");
/*
* Check for unprocessed ("unhandled") args.
*/
for (count = 1; count < argc; count++) {
if (argv[count] != NULL) {
(void) fprintf(stderr, "Unexpected command line argument: \"%s\".\n",
argv[count]);
parseError = TRUE;
}
}
if (parseError) {
(void) fprintf(stderr,
"\nUsage: Crane -option1 val1 -option2 val2 -option3 ...\n\n");
(void) fprintf(stderr,
"\t-tf 20 - sets final time to 20 seconds\n");
(void) fprintf(stderr,
"\t-d C:\\data - sets current directory to C:\\data\n");
(void) fprintf(stderr,
"\t-pri 5 - sets the minimum thread priority\n");
(void) fprintf(stderr,
"\t-ss 65536 - sets the stack size for model threads\n");
(void) fprintf(stderr,
"\t-w - wait for host to connect before starting\n");
(void) fprintf(stderr,
"\t-uri shmem://mymodel - set external mode URL to \"shmem://mymodel\"\n");
(void) fprintf(stderr, "\n");
return (exit_failure);
}
/****************************
* Initialize global memory *
****************************/
(void)memset(&GBLbuf, 0, sizeof(GBLbuf));
/************************
* Initialize the model *
************************/
rt_InitInfAndNaN(sizeof(real_T));
S = Crane();
if (rtmGetErrorStatus(S) != NULL) {
(void) fprintf(stderr, "Error during model registration: %s\n",
rtmGetErrorStatus(S));
return (exit_failure);
}
if (final_time >= 0.0 || final_time == RUN_FOREVER) {
rtmSetTFinal(S, final_time);
} else {
rtmSetTFinal(S, rtInf);
}
action.sa_handler = control_c_handler;
action.sa_flags = 0;
qsigemptyset(&action.sa_mask);
qsigaction(SIGINT, &action, NULL);
qsigaction(SIGBREAK, &action, NULL);
qsigemptyset(&signal_set);
qsigaddset(&signal_set, SIGINT);
qsigaddset(&signal_set, SIGBREAK);
qthread_sigmask(QSIG_UNBLOCK, &signal_set, NULL);
initialize_sizes(S);
initialize_sample_times(S);
status = rt_SimInitTimingEngine(rtmGetNumSampleTimes(S),
rtmGetStepSize(S),
rtmGetSampleTimePtr(S),
rtmGetOffsetTimePtr(S),
rtmGetSampleHitPtr(S),
rtmGetSampleTimeTaskIDPtr(S),
rtmGetTStart(S),
&rtmGetSimTimeStep(S),
&rtmGetTimingData(S));
if (status != NULL) {
(void) fprintf(stderr, "Failed to initialize sample time engine: %s\n",
status);
return (exit_failure);
}
rt_CreateIntegrationData(S);
fflush(stdout);
if (rtExtModeQuarcStartup(rtmGetRTWExtModeInfo(S),
rtmGetNumSampleTimes(S),
&rtmGetStopRequested(S),
ext_priority, /* external mode thread priority */
stack_size,
SS_HAVESTDIO)) {
(void) ssPrintf("\n** starting the model **\n");
start(S);
if (rtmGetErrorStatus(S) == NULL) {
/*************************************************************************
* Execute the model.
*************************************************************************/
if (rtmGetTFinal(S) == RUN_FOREVER) {
(void) ssPrintf("\n**May run forever. Model stop time set to infinity.**\n");
}
timeout.seconds = (t_long) (rtmGetStepSize(S));
timeout.nanoseconds = (t_int) ((rtmGetStepSize(S) - timeout.seconds) *
1000000000L);
result = qtimer_event_create(¬ify.notify_value.event);
if (result == 0) {
t_timer timer;
scheduling.sched_priority = scheduling_priority;
qthread_setschedparam(qthread_self(), QSCHED_FIFO, &scheduling);
notify.notify_type = TIMER_NOTIFY_EVENT;
result = qtimer_create(¬ify, &timer);
if (result == 0) {
result = qtimer_begin_resolution(timer, &timeout);
if (result == 0) {
t_period actual_timeout;
(void) ssPrintf("Creating main thread with priority %d and period %g...\n",
scheduling_priority, rtmGetStepSize(S));
result = qtimer_get_actual_period(timer, &timeout, &actual_timeout);
if (result == 0 && (timeout.nanoseconds !=
actual_timeout.nanoseconds || timeout.seconds !=
actual_timeout.seconds))
(void) ssPrintf("*** Actual period will be %g ***\n",
actual_timeout.seconds + 1e-9 *
actual_timeout.nanoseconds);
fflush(stdout);
result = qtimer_set_time(timer, &timeout, true);
if (result == 0) {
/* Enter the periodic loop */
while (result == 0) {
if (GBLbuf.stopExecutionFlag || rtmGetStopRequested(S)) {
break;
}
if (rtmGetTFinal(S) != RUN_FOREVER && rtmGetTFinal(S) - rtmGetT
(S) <= rtmGetT(S)*DBL_EPSILON) {
break;
}
if (qtimer_get_overrun(timer) > 0) {
(void) fprintf(stderr,
"Sampling rate is too fast for base rate\n");
fflush(stderr);
}
rt_OneStep(S);
result = qtimer_event_wait(notify.notify_value.event);
}
/* disarm the timer */
qtimer_cancel(timer);
if (rtmGetStopRequested(S) == false && rtmGetErrorStatus(S) ==
NULL) {
/* Execute model last time step if final time expired */
rt_OneStep(S);
}
(void) ssPrintf("Main thread exited\n");
} else {
msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof
(GBLbuf.submessage));
string_format(GBLbuf.message, sizeof(GBLbuf.message),
"Unable to set base rate. %s", GBLbuf.submessage);
rtmSetErrorStatus(S, GBLbuf.message);
}
qtimer_end_resolution(timer);
} else {
msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof
(GBLbuf.submessage));
string_format(GBLbuf.message, sizeof(GBLbuf.message),
"Sampling period of %lg is too fast for the system clock. %s",
rtmGetStepSize(S), GBLbuf.submessage);
rtmSetErrorStatus(S, GBLbuf.message);
}
qtimer_delete(timer);
} else {
msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof
(GBLbuf.submessage));
string_format(GBLbuf.message, sizeof(GBLbuf.message),
"Unable to create timer for base rate. %s",
GBLbuf.submessage);
rtmSetErrorStatus(S, GBLbuf.message);
}
} else {
msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof
(GBLbuf.submessage));
string_format(GBLbuf.message, sizeof(GBLbuf.message),
"Unable to create timer event for base rate. %s",
GBLbuf.submessage);
rtmSetErrorStatus(S, GBLbuf.message);
}
GBLbuf.stopExecutionFlag = 1;
}
} else {
rtmSetErrorStatus(S, "Unable to initialize external mode.");
}
rtExtSetReturnStatus(rtmGetErrorStatus(S));
rtExtModeQuarcCleanup(rtmGetNumSampleTimes(S));
/********************
* Cleanup and exit *
********************/
if (rtmGetErrorStatus(S) != NULL) {
(void) fprintf(stderr, "%s\n", rtmGetErrorStatus(S));
exit_code = exit_failure;
}
(void) ssPrintf("Invoking model termination function...\n");
terminate(S);
(void) ssPrintf("Exiting real-time code\n");
return (exit_code);
}
