void
memory_stress_rand(perf_counter_t *pc,
long *working_area,
long working_size)
{
register unsigned long i;
register long *ptr;
long *ptr_start;
unsigned long *shufflearray;
const unsigned long niter = 2 << 10;
struct timespec stime, ftime;
register uintptr_t t0, t1;
{
// initialize shuffled pointer loop
const unsigned long ncacheline = working_size / CACHELINE_SIZE;
const unsigned long step = CACHELINE_SIZE / sizeof(long);
unsigned long offset, tmp;
if ((shufflearray = (unsigned long *)calloc(ncacheline, sizeof(long))) == NULL) {
perror("calloc()");
exit(EXIT_FAILURE);
}
for (i = 0; i < ncacheline; i++){ shufflearray[i] = i; }
for (i = 0; i < ncacheline; i++){
offset = drand48() * ncacheline;
tmp = shufflearray[i];
shufflearray[i] = shufflearray[offset];
shufflearray[offset] = tmp;
}
ptr_start = working_area + (shufflearray[0] * step);
for (i = 1, ptr = ptr_start; i < ncacheline; i++, ptr = (long *)*ptr){
*ptr = (long)(working_area + (shufflearray[i] * step));
}
*ptr = (long)ptr_start;
free(shufflearray);
// check loop
for (i = 1, ptr = (long *)*ptr_start; i < ncacheline; i++, ptr = (long *)*ptr) { }
if (ptr != ptr_start) {
fprintf(stderr, "initialization failed : broken loop\n");
exit(EXIT_FAILURE);
}
}
CLOCK_GETTIME(&stime);
CLOCK_GETTIME(&ftime);
while (TIMEINTERVAL_SEC(stime, ftime) < option.timeout) {
t0 = read_tsc();
ptr = ptr_start;
for (i = 0; i < niter; i++){
#include "membench-inner-rand.c"
}
t1 = read_tsc();
pc->clk += t1 - t0;
pc->ops += niter * MEM_INNER_LOOP_RANDOM_NUM_OPS;
CLOCK_GETTIME(&ftime);
}
pc->wallclocktime = TIMEINTERVAL_SEC(stime, ftime);
}
/*
* Initialize the time of day register, based on the time base which is, e.g.
* from a filesystem.
*/
void
inittodr(time_t base)
{
struct timespec ts;
int error;
if (clock_dev == NULL) {
printf("warning: no time-of-day clock registered, system time "
"will not be set accurately\n");
goto wrong_time;
}
/* XXX: We should poll all registered RTCs in case of failure */
mtx_lock(&resettodr_lock);
error = CLOCK_GETTIME(clock_dev, &ts);
mtx_unlock(&resettodr_lock);
if (error != 0 && error != EINVAL) {
printf("warning: clock_gettime failed (%d), the system time "
"will not be set accurately\n", error);
goto wrong_time;
}
if (error == EINVAL || ts.tv_sec < 0) {
printf("Invalid time in real time clock.\n"
"Check and reset the date immediately!\n");
goto wrong_time;
}
ts.tv_sec += utc_offset();
timespecadd(&ts, &clock_adj);
tc_setclock(&ts);
#ifdef FFCLOCK
ffclock_reset_clock(&ts);
#endif
return;
wrong_time:
if (base > 0) {
ts.tv_sec = base;
ts.tv_nsec = 0;
tc_setclock(&ts);
}
}
bool openavbAvdeccMsgSrvrHndlChangeNotificationFromClient(int avdeccMsgHandle, openavbAvdeccMsgStateType_t currentState)
{
AVB_TRACE_ENTRY(AVB_TRACE_AVDECC_MSG);
avdecc_msg_state_t *pState = AvdeccMsgStateListGet(avdeccMsgHandle);
if (!pState) {
AVB_LOGF_ERROR("avdeccMsgHandle %d not valid", avdeccMsgHandle);
AVB_TRACE_EXIT(AVB_TRACE_AVDECC_MSG);
return false;
}
// Save the updated state.
if (currentState != pState->lastReportedState) {
openavbAvdeccMsgStateType_t previousState = pState->lastReportedState;
pState->lastReportedState = currentState;
AVB_LOGF_INFO("Notified of client %d state change from %s to %s (Last requested: %s)",
avdeccMsgHandle, GetStateString(previousState), GetStateString(currentState), GetStateString(pState->lastRequestedState));
// If AVDECC did not yet set the client state, set the client state to the desired state.
if (pState->lastRequestedState == OPENAVB_AVDECC_MSG_UNKNOWN) {
if (pState->stream->initial_state == TL_INIT_STATE_RUNNING && pState->lastReportedState != OPENAVB_AVDECC_MSG_RUNNING) {
// Have the client be running if the user explicitly requested it to be running.
openavbAvdeccMsgSrvrChangeRequest(avdeccMsgHandle, OPENAVB_AVDECC_MSG_RUNNING);
}
else if (pState->stream->initial_state != TL_INIT_STATE_RUNNING && pState->lastReportedState == OPENAVB_AVDECC_MSG_RUNNING) {
// Have the client not be running if the user didn't explicitly request it to be running.
openavbAvdeccMsgSrvrChangeRequest(avdeccMsgHandle, OPENAVB_AVDECC_MSG_STOPPED);
}
else if (gAvdeccCfg.bFastConnectSupported &&
!(pState->bTalker) &&
pState->lastReportedState == OPENAVB_AVDECC_MSG_STOPPED) {
// Listener started as not running, and is not configured to start in the running state.
// See if we should do a fast connect using the saved state.
openavb_tl_data_cfg_t *pCfg = pState->stream;
if (pCfg) {
U16 flags, talker_unique_id;
U8 talker_entity_id[8], controller_entity_id[8];
bool bAvailable = openavbAvdeccGetSaveStateInfo(pCfg, &flags, &talker_unique_id, &talker_entity_id, &controller_entity_id);
if (bAvailable) {
openavbAcmpSMListenerSet_doFastConnect(pCfg, flags, talker_unique_id, talker_entity_id, controller_entity_id);
}
}
}
}
else if (currentState == OPENAVB_AVDECC_MSG_STOPPED_UNEXPECTEDLY) {
if (previousState != OPENAVB_AVDECC_MSG_STOPPED_UNEXPECTEDLY &&
pState->lastRequestedState == OPENAVB_AVDECC_MSG_RUNNING &&
gAvdeccCfg.bFastConnectSupported) {
// The Talker disappeared. Use fast connect to assist with reconnecting if it reappears.
openavb_tl_data_cfg_t *pCfg = pState->stream;
if (pCfg) {
U16 flags, talker_unique_id;
U8 talker_entity_id[8], controller_entity_id[8];
bool bAvailable = openavbAvdeccGetSaveStateInfo(pCfg, &flags, &talker_unique_id, &talker_entity_id, &controller_entity_id);
if (bAvailable) {
// Set the timed-out status for the Listener's descriptor.
// The next time the Talker advertises itself, openavbAcmpSMListenerSet_talkerTestFastConnect() should try to reconnect.
openavb_aem_descriptor_stream_io_t *pDescriptor;
U16 listenerUniqueId;
for (listenerUniqueId = 0; listenerUniqueId < 0xFFFF; ++listenerUniqueId) {
pDescriptor = openavbAemGetDescriptor(openavbAemGetConfigIdx(), OPENAVB_AEM_DESCRIPTOR_STREAM_INPUT, listenerUniqueId);
if (pDescriptor && pDescriptor->stream &&
strcmp(pDescriptor->stream->friendly_name, pCfg->friendly_name) == 0) {
// We found a match.
AVB_LOGF_INFO("Listener %s waiting to fast connect to flags=0x%04x, talker_unique_id=0x%04x, talker_entity_id=" ENTITYID_FORMAT ", controller_entity_id=" ENTITYID_FORMAT,
pCfg->friendly_name,
flags,
talker_unique_id,
ENTITYID_ARGS(talker_entity_id),
ENTITYID_ARGS(controller_entity_id));
pDescriptor->fast_connect_status = OPENAVB_FAST_CONNECT_STATUS_TIMED_OUT;
memcpy(pDescriptor->fast_connect_talker_entity_id, talker_entity_id, sizeof(pDescriptor->fast_connect_talker_entity_id));
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &pDescriptor->fast_connect_start_time);
pDescriptor->fast_connect_start_time.tv_sec += 5; // Give the Talker some time to shutdown or stabilize
break;
}
}
}
}
}
// Now that we have handled this, treat this state as a normal stop.
pState->lastReportedState = OPENAVB_AVDECC_MSG_STOPPED;
}
}
AVB_TRACE_EXIT(AVB_TRACE_AVDECC_MSG);
return true;
}
void openavbAcmpSMController_txCommand(U8 messageType, openavb_acmp_ACMPCommandResponse_t *command, bool retry)
{
AVB_TRACE_ENTRY(AVB_TRACE_ACMP);
openavb_list_node_t node = NULL;
openavbRC rc = openavbAcmpMessageSend(messageType, command, OPENAVB_ACMP_STATUS_SUCCESS);
if (IS_OPENAVB_SUCCESS(rc)) {
if (!retry) {
node = openavbListNew(openavbAcmpSMControllerVars.inflight, sizeof(openavb_acmp_InflightCommand_t));
if (node) {
openavb_acmp_InflightCommand_t *pInFlightCommand = openavbListData(node);
if (pInFlightCommand) {
memcpy(&pInFlightCommand->command, command, sizeof(pInFlightCommand->command));
pInFlightCommand->command.message_type = messageType;
pInFlightCommand->retried = FALSE;
pInFlightCommand->original_sequence_id = command->sequence_id; // AVDECC_TODO - is this correct?
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &pInFlightCommand->timer);
switch (messageType) {
case OPENAVB_ACMP_MESSAGE_TYPE_GET_TX_STATE_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_TX_STATE_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_CONNECT_RX_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_CONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_DISCONNECT_RX_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_DISCONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_GET_RX_STATE_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_RX_STATE_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_TX_CONNECTION_COMMAND * MICROSECONDS_PER_MSEC);
break;
default:
AVB_LOGF_ERROR("Unsupported command %u in openavbAcmpSMController_txCommand", messageType);
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_CONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
}
}
}
}
else {
// Retry case
node = openavbAcmpSMController_findInflightNodeFromCommand(command);
if (node) {
openavb_acmp_InflightCommand_t *pInFlightCommand = openavbListData(node);
if (pInFlightCommand) {
pInFlightCommand->retried = TRUE;
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &pInFlightCommand->timer);
switch (messageType) {
case OPENAVB_ACMP_MESSAGE_TYPE_GET_TX_STATE_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_TX_STATE_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_CONNECT_RX_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_CONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_DISCONNECT_RX_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_DISCONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_GET_RX_STATE_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_RX_STATE_COMMAND * MICROSECONDS_PER_MSEC);
break;
case OPENAVB_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_RESPONSE:
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_GET_TX_CONNECTION_COMMAND * MICROSECONDS_PER_MSEC);
break;
default:
AVB_LOGF_ERROR("Unsupported command %u in openavbAcmpSMController_txCommand", messageType);
openavbTimeTimespecAddUsec(&pInFlightCommand->timer, OPENAVB_ACMP_COMMAND_TIMEOUT_CONNECT_RX_COMMAND * MICROSECONDS_PER_MSEC);
break;
}
}
}
}
}
else {
// Failed to send command
openavbAcmpMessageSend(messageType, command, OPENAVB_ACMP_STATUS_COULD_NOT_SEND_MESSAGE);
if (retry) {
node = openavbAcmpSMController_findInflightNodeFromCommand(command);
if (node) {
openavbListDelete(openavbAcmpSMControllerVars.inflight, node);
}
}
}
AVB_TRACE_EXIT(AVB_TRACE_ACMP);
}
void openavbAcmpSMControllerStateMachine()
{
AVB_TRACE_ENTRY(AVB_TRACE_ACMP);
openavb_acmp_InflightCommand_t *pInflightActive = NULL; // The inflight command for the current state
openavb_acmp_sm_controller_state_t state = OPENAVB_ACMP_SM_CONTROLLER_STATE_WAITING;
// Lock such that the mutex is held unless waiting for a semaphore. Synchronous processing of command responses.
ACMP_SM_LOCK();
while (bRunning) {
switch (state) {
case OPENAVB_ACMP_SM_CONTROLLER_STATE_WAITING:
AVB_TRACE_LINE(AVB_TRACE_ACMP);
AVB_LOG_DEBUG("State: OPENAVB_ACMP_SM_CONTROLLER_STATE_WAITING");
openavbAcmpSMControllerVars.rcvdResponse = FALSE;
// Calculate timeout for inflight commands
// Start is a arbitrary large time out.
struct timespec timeout;
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &timeout);
timeout.tv_sec += 60; // At most will timeout after 60 seconds
// Look for soonest inflight command timeout
openavb_list_node_t node = openavbListIterFirst(openavbAcmpSMControllerVars.inflight);
while (node) {
openavb_acmp_InflightCommand_t *pInflight = openavbListData(node);
if ((openavbTimeTimespecCmp(&pInflight->timer, &timeout) < 0)) {
timeout.tv_sec = pInflight->timer.tv_sec;
timeout.tv_nsec = pInflight->timer.tv_nsec;
}
node = openavbListIterNext(openavbAcmpSMControllerVars.inflight);
}
ACMP_SM_UNLOCK();
U32 timeoutMSec = 0;
struct timespec now;
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &now);
timeoutMSec = openavbTimeUntilMSec(&now, &timeout);
SEM_ERR_T(err);
SEM_TIMEDWAIT(openavbAcmpSMControllerSemaphore, timeoutMSec, err);
ACMP_SM_LOCK();
if (!SEM_IS_ERR_NONE(err)) {
if (SEM_IS_ERR_TIMEOUT(err)) {
struct timespec now;
CLOCK_GETTIME(OPENAVB_CLOCK_REALTIME, &now);
// Look for a timed out inflight command
openavb_list_node_t node = openavbListIterFirst(openavbAcmpSMControllerVars.inflight);
while (node) {
openavb_acmp_InflightCommand_t *pInflight = openavbListData(node);
if ((openavbTimeTimespecCmp(&now, &pInflight->timer) >= 0)) {
// Found a timed out command
state = OPENAVB_ACMP_SM_CONTROLLER_STATE_TIMEOUT;
pInflightActive = pInflight;
break;
}
node = openavbListIterNext(openavbAcmpSMControllerVars.inflight);
}
}
}
else {
if (openavbAcmpSMControllerVars.doTerminate) {
bRunning = FALSE;
}
else if (openavbAcmpSMControllerVars.rcvdResponse &&
memcmp(pRcvdCmdResp->controller_entity_id, openavbAcmpSMGlobalVars.my_id, sizeof(openavbAcmpSMGlobalVars.my_id)) == 0) {
// Look for a corresponding inflight command
openavb_list_node_t node = openavbListIterFirst(openavbAcmpSMControllerVars.inflight);
while (node) {
openavb_acmp_InflightCommand_t *pInflight = openavbListData(node);
if (pRcvdCmdResp->sequence_id == pInflight->command.sequence_id &&
pRcvdCmdResp->message_type == pInflight->command.message_type + 1) {
// Found a corresponding command
state = OPENAVB_ACMP_SM_CONTROLLER_STATE_RESPONSE;
pInflightActive = pInflight;
break;
}
node = openavbListIterNext(openavbAcmpSMControllerVars.inflight);
}
}
break;
case OPENAVB_ACMP_SM_CONTROLLER_STATE_TIMEOUT:
{
AVB_TRACE_LINE(AVB_TRACE_ACMP);
AVB_LOG_DEBUG("State: OPENAVB_ACMP_SM_CONTROLLER_STATE_TIMEOUT");
if (pInflightActive) {
if (pInflightActive->retried) {
openavbAcmpSMController_removeInflight(&pInflightActive->command);
}
else {
openavbAcmpSMController_txCommand(pInflightActive->command.message_type, &pInflightActive->command, TRUE);
}
}
pInflightActive = NULL;
state = OPENAVB_ACMP_SM_CONTROLLER_STATE_WAITING;
}
break;
case OPENAVB_ACMP_SM_CONTROLLER_STATE_RESPONSE:
{
AVB_TRACE_LINE(AVB_TRACE_ACMP);
AVB_LOG_DEBUG("State: OPENAVB_ACMP_SM_CONTROLLER_STATE_RESPONSE");
if (pInflightActive) {
openavbAcmpSMController_cancelTimeout(pRcvdCmdResp);
openavbAcmpSMController_processResponse(pRcvdCmdResp);
openavbAcmpSMController_removeInflight(pRcvdCmdResp);
}
pInflightActive = NULL;
state = OPENAVB_ACMP_SM_CONTROLLER_STATE_WAITING;
}
break;
}
}
}
ACMP_SM_UNLOCK();
AVB_TRACE_EXIT(AVB_TRACE_ACMP);
}