/* -----------------------------------------------------------------------------------*/
void Process1(void){
char sal_code[MAX_CAD];
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainId2;
PROCESS_ID_TYPE procMainId3;
printf("Process 1 starts ... \n");
/* To get the procMainId2 value */
GET_PROCESS_ID("tProc2", &procMainId2, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 2", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId2, &retCode);
CHECK_CODE(": START Process 2", retCode, sal_code);
printf("%s\n", sal_code);
/* To get the procMainId3 value */
GET_PROCESS_ID("tProc3", &procMainId3, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 3", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId3, &retCode);
CHECK_CODE(": START Process 3", retCode, sal_code);
printf("%s\n", sal_code);
/* Process P1 pre-empts Process P3 */
STOP_SELF();
}
/* -----------------------------------------------------------------------------------*/
void Process1(void){
PROCESS_ID_TYPE procMainId2;
struct suspend_error_type s_e;
RETURN_CODE_TYPE retCode;
char sal_code[MAX_CAD];
printf("Process 1 starts ...\n");
/* To get the procMainId2 value */
GET_PROCESS_ID("tProc2", &procMainId2, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 2", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId2 ,&retCode);
CHECK_CODE(": START Process 2", retCode, sal_code);
printf("%s\n", sal_code);
/* TIMED_WAIT(REGULAR_TIME_WAIT, &retCode);
CHECK_CODE(": TIMED_WAIT", retCode, sal_code);
printf("%s\n", sal_code); */
s_e = checksuspend(procMainId2, NO_ERROR);
show_result(s_e);
STOP_SELF();
}
/* Entry point */
void main(void){
PROCESS_ID_TYPE procMainIdMT;
PROCESS_ID_TYPE procMainId1;
PROCESS_ID_TYPE procMainId2;
RETURN_CODE_TYPE retCode;
char sal_code[MAX_CAD];
CREATE_PROCESS (&processTable[0], /* process attribute */
&procMainIdMT, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Master Test", retCode, sal_code);
printf("%s\n", sal_code);
CREATE_PROCESS (&processTable[1], /* process attribute */
&procMainId1, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 1", retCode, sal_code);
printf("%s\n", sal_code);
CREATE_PROCESS (&processTable[2], /* process attribute */
&procMainId2, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 2", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainIdMT, &retCode);
CHECK_CODE(": START Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* To set the partition in a Normal State */
SET_PARTITION_MODE(NORMAL, &retCode);
CHECK_CODE(": SET_PARTITION_MODE", retCode, sal_code);
printf("%s\n", sal_code);
}
/* Inicio de rutina para inicializar el entorno de accion */
void main(void){
struct get_process_status_type g_p_s;
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainIdMT;
PROCESS_ID_TYPE procMainId1;
char sal_code[MAX_CAD];
PROCESS_STATUS_TYPE status;
CREATE_PROCESS (&processTable[0], /* process attribute */
&procMainIdMT, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
CREATE_PROCESS (&processTable[1], /* process attribute */
&procMainId1, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 1", retCode, sal_code);
printf("%s\n", sal_code);
/* To get the init values of Process 1*/
status = initStatus();
/* check process 1 status */
g_p_s = checkget_process_status(status, procMainId1, NO_ERROR);
show_resultget_p(g_p_s);
SET_PARTITION_MODE(NORMAL, &retCode);
CHECK_CODE(": SET_PARTITION_MODE", retCode, sal_code);
printf("%s\n", sal_code);
}
/* -----------------------------------------------------------------------------------*/
void main(void){
struct create_process_error_type c_p_e;
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainIdMT;
PROCESS_ID_TYPE procMainId1;
char sal_code[MAX_CAD];
/* Create Process Master Test */
CREATE_PROCESS (&processTable[0], /* process attribute */
&procMainIdMT, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* Create Process 1 */
CREATE_PROCESS (&processTable[1], /* process attribute */
&procMainId1, /* process Id */
&retCode);
c_p_e = checkcreate_process(processTable[1], procMainId1, retCode, NO_ERROR);
show_result(c_p_e);
/* Create Process 1 again */
CREATE_PROCESS (&processTable[1], /* process attribute */
&procMainId1, /* process Id */
&retCode);
c_p_e = checkcreate_process(processTable[1], procMainId1, retCode, NO_ACTION);
show_result(c_p_e);
}
/*
1. Checks the returned error code against the expected one.
2. If the returned error code is ok, call the GET_PROCESS_STATUS service using the returned
process parameter as input parameter.
3. Check that the return code of the method is equal to NO_ERROR.
4. If no error occurred, compare the attribute values returned by the method against the
expected values for them.
5. Return the returned processId, the process status returned by the GET_PROCESS_STATUS service,
the error code and one structure indicating the results of the comparisons between the expected values
passed as parameters and the actual values, returned by the invoked services.
*/
struct get_process_status_type checkget_process_status(PROCESS_STATUS_TYPE statusComp, PROCESS_ID_TYPE idP, RETURN_CODE_TYPE code){
struct get_process_status_type g_p_e;
RETURN_CODE_TYPE retCode;
PROCESS_STATUS_TYPE status;
char sal_code[MAX_CAD];
BOOL sonIgualesSt;
g_p_e = initGet();
if (retCode == code){
GET_PROCESS_STATUS(idP, &status, &retCode);
if (retCode == code){
sonIgualesSt = compararAtributos(status.ATTRIBUTES, statusComp.ATTRIBUTES);
if (sonIgualesSt==FALSE){
g_p_e.test_attributes = TRUE;
}else if (status.CURRENT_PRIORITY != statusComp.CURRENT_PRIORITY){
g_p_e.test_current_priority = TRUE;
}else if (status.DEADLINE_TIME != statusComp.DEADLINE_TIME){
printf("STATUS: %d.\n", status.DEADLINE_TIME);
printf("STATUSCOMP: %d.\n", statusComp.DEADLINE_TIME);
g_p_e.test_deadline_time = TRUE;
}else if (status.PROCESS_STATE != statusComp.PROCESS_STATE){
g_p_e.test_process_state = TRUE;
}
}else{
CHECK_CODE(": GET_PROCESS_STATUS", retCode, sal_code);
printf("%s\n", sal_code);
}
}
return g_p_e;
}
/*
1. Call STOP service, using as argument the received value for the process ID.
2. Check the output return code against the expected return code, received as argument.
3. If service call gave no error, call service GET_PROCESS_STATUS, using as argument the
received value for the process ID.
4. If no error occurred, check that process state is equal to Dormant.
5. Return a bit structure holding information about any of the following errors:
a. Expected error code different from the output one.
b. Process state different from Dormant.
c. GET_PROCESS_STATUS invocation gave an error.
6. Output the process status returned from the GET_PROCESS_STATUS service and the return code
returned from the STOP service.
*/
struct stop_error_type check_stop(PROCESS_ID_TYPE id, RETURN_CODE_TYPE code){
struct stop_error_type c_s;
RETURN_CODE_TYPE retCode;
PROCESS_STATUS_TYPE status;
char sal_code[MAX_CAD];
c_s = initStruct();
STOP(id, &retCode);
CHECK_CODE(": STOP", retCode, sal_code);
printf("%s Process with ID: %d\n", sal_code, id);
if (code==retCode){
GET_PROCESS_STATUS(id, &status, &retCode);
if (retCode==NO_ERROR){
if (status.PROCESS_STATE != DORMANT){
c_s.test_state = TRUE;
}
}else
c_s.test_code_get = TRUE;
}else
c_s.test_code_exp = TRUE;
return c_s;
}
/*
1. Invokes the CREATE_PROCESS service, using the process attributes as input parameter.
2. Checks the returned error code against the expected one.
3. If the returned error code is ok, call the GET_PROCESS_STATUS service using the returned process
parameter as input parameter.
4. Check that the return code of the method is equal to NO_ERROR.
5. If no error occurred, compare the attribute values returned by the method against the expected values
for them.
6. Return the returned processId, the process status returned by the GET_PROCESS_STATUS service,
the error code and one structure indicating the results of the comparisons between the expected values
passed as parameters and the actual values, returned by the invoked services.
*/
struct create_process_error_type checkcreate_process(PROCESS_ATTRIBUTE_TYPE a, PROCESS_ID_TYPE id, RETURN_CODE_TYPE retCode, RETURN_CODE_TYPE code){
struct create_process_error_type c_p_e;
PROCESS_STATUS_TYPE status;
char sal_code[MAX_CAD];
c_p_e = initCreate();
if (code == retCode){
GET_PROCESS_STATUS(id, &status, &retCode);
if (retCode == NO_ERROR){
if (strcmp(a.NAME, status.ATTRIBUTES.NAME)!=0){
c_p_e.test_name = TRUE;
}else if (a.ENTRY_POINT != status.ATTRIBUTES.ENTRY_POINT){
c_p_e.test_entry_p = TRUE;
}else if (a.STACK_SIZE != status.ATTRIBUTES.STACK_SIZE){
c_p_e.test_stack_s = TRUE;
}else if (a.BASE_PRIORITY != status.ATTRIBUTES.BASE_PRIORITY){
c_p_e.test_base_p = TRUE;
}else if (a.PERIOD != status.ATTRIBUTES.PERIOD){
c_p_e.test_period = TRUE;
}else if (a.TIME_CAPACITY != status.ATTRIBUTES.TIME_CAPACITY){
c_p_e.test_time_c = TRUE;
}else if (a.DEADLINE != status.ATTRIBUTES.DEADLINE){
c_p_e.test_deadline = TRUE;
}
}else{
CHECK_CODE(": GET_PROCESS_STATUS in subfunction checkcreate_process", retCode, sal_code);
printf("%s\n", sal_code);
}
}else
c_p_e.test_code = TRUE;
return c_p_e;
}
/* -----------------------------------------------------------------------------------*/
void ProcessMT_Master(void){
LOCK_LEVEL_TYPE lock;
APEX_BYTE data[MAX_LENGTH];
long int len;
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainId1;
char sal_code[MAX_CAD];
PARTITION_STATUS_TYPE statusp;
BLACKBOARD_ID_TYPE bbId;
printf("Process Master starts ...\n");
GET_PARTITION_STATUS(&statusp, &retCode);
CHECK_CODE(": GET_PARTITION_STATUS", retCode, sal_code);
printf("%s\n", sal_code);
/* Make sure the preemption is enabled, lock == 0 */
if (statusp.LOCK_LEVEL>0){
UNLOCK_PREEMPTION(&lock, &retCode);
while (lock!=0){
UNLOCK_PREEMPTION(&lock, &retCode);
}
}else if (statusp.LOCK_LEVEL<0){
LOCK_PREEMPTION(&lock, &retCode);
while (lock!=0){
LOCK_PREEMPTION(&lock, &retCode);
}
}
/* To get the procMainId1 value */
GET_PROCESS_ID("tProc1", &procMainId1, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 1", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId1 ,&retCode);
CHECK_CODE(": START Process 1 ", retCode, sal_code);
printf("%s\n", sal_code);
/* Process P1 pre-empts Master_Test */
/* Call service READ_BLACKBOARD B1 */
GET_BLACKBOARD_ID(BLACKBOARD_NAME_0, &bbId, &retCode);
CHECK_CODE(": GET_BLACKBOARD_ID_0 by ProcessMT_Master", retCode, sal_code);
printf("%s\n", sal_code);
READ_BLACKBOARD (bbId, 0, data, &len, &retCode);
CHECK_CODE(": READ_BLACKBOARD B1", retCode, sal_code);
printf("%s Read data: %s\n", sal_code, data);
/* Call service READ_BLACKBOARD B2 */
GET_BLACKBOARD_ID(BLACKBOARD_NAME_1, &bbId, &retCode);
CHECK_CODE(": GET_BLACKBOARD_ID_1 by ProcessMT_Master", retCode, sal_code);
printf("%s\n", sal_code);
READ_BLACKBOARD (bbId, 0, data, &len, &retCode);
CHECK_CODE(": READ_BLACKBOARD B2", retCode, sal_code);
printf("%s Read data: %s\n", sal_code, data);
STOP_SELF();
}
/* -----------------------------------------------------------------------------------*/
void ProcessMT_Master(void){
struct replenish_error_type r_e;
SYSTEM_TIME_TYPE s_t;
SYSTEM_TIME_TYPE budg;
PROCESS_ID_TYPE procMainIdMT;
char sal_code[MAX_CAD];
RETURN_CODE_TYPE retCode;
PROCESS_STATUS_TYPE status0;
PROCESS_STATUS_TYPE status1;
printf("Main Process starts... \n");
/* To get the procMainIdMT value */
GET_PROCESS_ID("tProcessMasterT", &procMainIdMT, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
GET_PROCESS_STATUS(procMainIdMT, &status0, &retCode);
CHECK_CODE(": GET_PROCESS_STATUS Status0", retCode, sal_code);
printf("%s\n", sal_code);
GET_TIME(&s_t, &retCode);
CHECK_CODE(": GET_TIME ", retCode, sal_code);
printf("%s\n", sal_code);
budg = status0.DEADLINE_TIME - 1 - s_t;
r_e = checkreplenish(procMainIdMT, budg, NO_ERROR);
GET_PROCESS_STATUS(procMainIdMT, &status1, &retCode);
CHECK_CODE(": GET_PROCESS_STATUS Status1 ", retCode, sal_code);
printf("%s\n", sal_code);
if ((s_t + budg) != (status0.DEADLINE_TIME - 1)){
printf("Deadline time was not decreased by one between the two calls to GET_PROCESS_STATUS \n");
printf("BUDGET: %ld \n", budg);
printf("status0: %ld \n", status0.DEADLINE_TIME);
printf("status1: %ld \n", status1.DEADLINE_TIME);
printf("current system clock: %ld \n", s_t);
}
show_result(r_e);
}
/* -----------------------------------------------------------------------------------*/
void Process2(void){
APEX_BYTE data[MAX_LENGTH];
RETURN_CODE_TYPE retCode;
char sal_code[MAX_CAD];
BLACKBOARD_ID_TYPE bbId;
printf("Process 2 starts ... \n");
strcpy(data, "OK");
GET_BLACKBOARD_ID(BLACKBOARD_NAME_1, &bbId, &retCode);
CHECK_CODE(": GET_BLACKBOARD_ID_1 by Process2", retCode, sal_code);
printf("%s\n", sal_code);
DISPLAY_BLACKBOARD (bbId, data, 3, &retCode);
CHECK_CODE(": DISPLAY_BLACKBOARD B2 in Process 2", retCode, sal_code);
printf("%s\n", sal_code);
STOP_SELF();
}
int
edb_txn_abort(edb *db) {
LOG_HERE;
int err = 0;
CHECK_CODE(db->readonly == 0, EDB_ERROR_READ_ONLY);
CHECK(txn_abort(db));
err:
return err;
}
/* -----------------------------------------------------------------------------------*/
void ProcessMT_Master(void){
/* LOCK_LEVEL_TYPE lock; */
PARTITION_STATUS_TYPE statusp;
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainId1;
char sal_code[MAX_CAD];
printf("Process Master starts ...\n");
GET_PARTITION_STATUS(&statusp, &retCode);
CHECK_CODE(": GET_PARTITION_STATUS", retCode, sal_code);
printf("%s\n", sal_code);
/* Make sure the preemption is enabled, lock == 0 */
/* if (statusp.LOCK_LEVEL>0){
UNLOCK_PREEMPTION(&lock, &retCode);
while (lock!=0){
UNLOCK_PREEMPTION(&lock, &retCode);
}
}else if (statusp.LOCK_LEVEL<0){
LOCK_PREEMPTION(&lock, &retCode);
while (lock!=0){
LOCK_PREEMPTION(&lock, &retCode);
}
}*/
/* To get the procMainId1 value */
GET_PROCESS_ID("tProc1", &procMainId1, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 1", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId1 ,&retCode);
CHECK_CODE(": START Process 1", retCode, sal_code);
printf("%s\n", sal_code);
/* TIMED_WAIT(REGULAR_TIME_WAIT, &retCode); */
/* Master_Test is pre-empted by P1 */
}
int
edb_close(edb *const db) {
int err = 0;
LOG_DEBUG("edb_close: %p\n", db);
CHECK_CODE(db->txn == NULL, EDB_ERROR_OPEN_TXN);
CHECK(io_close(db));
free(db);
err:
return err;
}
/* Entry point */
void main(void){
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainIdMT;
char sal_code[MAX_CAD];
CREATE_PROCESS (&(processTable [0]), /* process attribute */
&procMainIdMT, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* Start main process ... */
START(procMainIdMT, &retCode);
CHECK_CODE(": START Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* To set the partition in a Normal State */
SET_PARTITION_MODE(NORMAL, &retCode);
CHECK_CODE(": SET_PARTITION_MODE ", retCode, sal_code);
printf("%s\n", sal_code);
}
/* -----------------------------------------------------------------------------------*/
void Process3(void){
struct stop_error_type c_s;
APEX_BYTE data[MAX_LENGTH];
char sal_code[MAX_CAD];
PROCESS_ID_TYPE procMainId2;
RETURN_CODE_TYPE retCode;
BLACKBOARD_ID_TYPE bbId;
printf("Process 3 starts ... \n");
strcpy(data, "OK");
/* To get the procMainId2 value */
GET_PROCESS_ID("tProc2", &procMainId2, &retCode);
CHECK_CODE(": GET_PROCESS_ID Process 2", retCode, sal_code);
printf("%s\n", sal_code);
/* To check stop process 2 */
c_s = check_stop(procMainId2, NO_ERROR);
GET_BLACKBOARD_ID(BLACKBOARD_NAME_0, &bbId, &retCode);
CHECK_CODE(": GET_BLACKBOARD_ID_0 by Process3", retCode, sal_code);
printf("%s\n", sal_code);
DISPLAY_BLACKBOARD (bbId, data, 3, &retCode);
CHECK_CODE(": DISPLAY_BLACKBOARD B1 in Process 3", retCode, sal_code);
printf("%s\n", sal_code);
START(procMainId2, &retCode);
CHECK_CODE(": START Process 2", retCode, sal_code);
printf("%s\n", sal_code);
show_results(c_s);
STOP_SELF ();
}
/* Entry point */
void main(void){
int cnt;
char sal_code[MAX_CAD];
RETURN_CODE_TYPE retCode;
PROCESS_ID_TYPE procMainIdMT;
PROCESS_ID_TYPE procMainId1;
PROCESS_ID_TYPE procMainId2;
PROCESS_ID_TYPE procMainId3;
/* Blackboard definitions and identifier */
BLACKBOARD_DEFINITION blackboardDefinitions[NUM_BLACKBOARDS];
BLACKBOARD_ID_TYPE bbId[NUM_BLACKBOARDS];
/* Process Master_Test is created */
CREATE_PROCESS (&(processTable [0]), /* process attribute */
&procMainIdMT, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* Process P1 is created */
CREATE_PROCESS (&(processTable [1]), /* process attribute */
&procMainId1, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 1", retCode, sal_code);
printf("%s\n", sal_code);
/* Process P2 is created*/
CREATE_PROCESS (&(processTable [2]), /* process attribute */
&procMainId2, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 2", retCode, sal_code);
printf("%s\n", sal_code);
/* Process P2 is created*/
CREATE_PROCESS (&(processTable [3]), /* process attribute */
&procMainId3, /* process Id */
&retCode);
CHECK_CODE(": CREATE_PROCESS Process 3", retCode, sal_code);
printf("%s\n", sal_code);
/* To init blackboards */
strcpy (BLACKBOARD_NAME_0, "blackboard1");
strcpy(blackboardDefinitions[0].name, BLACKBOARD_NAME_0);
blackboardDefinitions[0].msgSize = 3;
strcpy(BLACKBOARD_NAME_1, "blackboard2");
strcpy(blackboardDefinitions[1].name, BLACKBOARD_NAME_1);
blackboardDefinitions[1].msgSize = 3;
/* Blackboard B1 and B2 are created and clear */
for (cnt = 0; cnt < NUM_BLACKBOARDS; cnt++){
bbId [cnt] = -1;
retCode = -1;
CREATE_BLACKBOARD (blackboardDefinitions[cnt].name,
blackboardDefinitions[cnt].msgSize,
&bbId[cnt],
&retCode);
CHECK_CODE(": CREATE_BLACKBOARD", retCode, sal_code);
printf("%s %s\n", sal_code, blackboardDefinitions [cnt].name);
CLEAR_BLACKBOARD(bbId [cnt], &retCode);
CHECK_CODE(": CREAR_BLACKBOARD", retCode, sal_code);
printf("%s %s\n", sal_code, blackboardDefinitions [cnt].name);
}
/* Start main process ... */
START(procMainIdMT, &retCode);
CHECK_CODE(": START Process Master Test", retCode, sal_code);
printf("%s\n", sal_code);
/* To set the partition in a Normal State */
SET_PARTITION_MODE(NORMAL, &retCode);
CHECK_CODE(": SET_PARTITION_MODE ", retCode, sal_code);
printf("%s\n", sal_code);
return;
}
