/* -----------------------------------------------------------------------------------*/
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 test1b(void)
{
static char process_name[16];
// Try to create a process with an illegal priority.
printf("This is Release %s: Test 1b\n", CURRENT_REL);
CREATE_PROCESS("test1b_a", test1x, ILLEGAL_PRIORITY, &Z502_REG1,
&Z502_REG9);
ErrorExpected(Z502_REG9, "CREATE_PROCESS");
// Create two processes with same name - 1st succeeds, 2nd fails
// Then terminate the process that has been created
CREATE_PROCESS("two_the_same", test1x, LEGAL_PRIORITY, &Z502_REG2,
&Z502_REG9);
SuccessExpected(Z502_REG9, "CREATE_PROCESS");
CREATE_PROCESS("two_the_same", test1x, LEGAL_PRIORITY, &Z502_REG1,
&Z502_REG9);
ErrorExpected(Z502_REG9, "CREATE_PROCESS");
TERMINATE_PROCESS(Z502_REG2, &Z502_REG9);
SuccessExpected(Z502_REG9, "TERMINATE_PROCESS");
// Loop until an error is found on the create_process.
// Since the call itself is legal, we must get an error
// because we exceed some limit.
Z502_REG9 = ERR_SUCCESS;
while (Z502_REG9 == ERR_SUCCESS)
{
Z502_REG3++; /* Generate next unique program name*/
sprintf(process_name, "Test1b_%ld", Z502_REG3);
printf("Creating process \"%s\"\n", process_name);
CREATE_PROCESS(process_name, test1x, LEGAL_PRIORITY, &Z502_REG1,
&Z502_REG9);
}
// When we get here, we've created all the processes we can.
// So the OS should have given us an error
ErrorExpected(Z502_REG9, "CREATE_PROCESS");
printf("%ld processes were created in all.\n", Z502_REG3);
// Now test the call GET_PROCESS_ID for ourselves
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9); // Legal
SuccessExpected(Z502_REG9, "GET_PROCESS_ID");
printf("The PID of this process is %ld\n", Z502_REG2);
// Try GET_PROCESS_ID on another existing process
strcpy(process_name, "Test1b_1");
GET_PROCESS_ID(process_name, &Z502_REG1, &Z502_REG9); /* Legal */
SuccessExpected(Z502_REG9, "GET_PROCESS_ID");
printf("The PID of target process is %ld\n", Z502_REG1);
// Try GET_PROCESS_ID on a non-existing process
GET_PROCESS_ID("bogus_name", &Z502_REG1, &Z502_REG9); // Illegal
ErrorExpected(Z502_REG9, "GET_PROCESS_ID");
GET_TIME_OF_DAY(&Z502_REG4);
printf("Test1b, PID %ld, Ends at Time %ld\n", Z502_REG2, Z502_REG4);
TERMINATE_PROCESS(-2, &Z502_REG9)
} // End of test1b
/* -----------------------------------------------------------------------------------*/
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 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();
}
void test1g(void)
{
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
printf("Release %s:Test 1g: Pid %ld\n", CURRENT_REL, Z502_REG2);
// Make a legal target
CREATE_PROCESS("test1g_a", test1x, LEGAL_PRIORITY_1G, &Z502_REG1,
&Z502_REG9);
SuccessExpected(Z502_REG9, "CREATE_PROCESS");
// Target Illegal PID
CHANGE_PRIORITY((INT32) 9999, LEGAL_PRIORITY_1G, &Z502_REG9);
ErrorExpected(Z502_REG9, "CHANGE_PRIORITY");
// Use illegal priority
CHANGE_PRIORITY(Z502_REG1, ILLEGAL_PRIORITY_1G, &Z502_REG9);
ErrorExpected(Z502_REG9, "CHANGE_PRIORITY");
// Use legal priority on legal process
CHANGE_PRIORITY(Z502_REG1, LEGAL_PRIORITY_1G, &Z502_REG9);
SuccessExpected(Z502_REG9, "CHANGE_PRIORITY");
// Terminate all existing processes
TERMINATE_PROCESS(-2, &Z502_REG9);
} // End of test1g
void test1d(void)
{
static long sleep_time = 1000;
printf("This is Release %s: Test 1d\n", CURRENT_REL);
CREATE_PROCESS("test1d_1", test1x, PRIORITY1, &Z502_REG1, &Z502_REG9);
SuccessExpected(Z502_REG9, "CREATE_PROCESS");
CREATE_PROCESS("test1d_2", test1x, PRIORITY2, &Z502_REG2, &Z502_REG9);
CREATE_PROCESS("test1d_3", test1x, PRIORITY3, &Z502_REG3, &Z502_REG9);
CREATE_PROCESS("test1d_4", test1x, PRIORITY4, &Z502_REG4, &Z502_REG9);
CREATE_PROCESS("test1d_5", test1x, PRIORITY5, &Z502_REG5, &Z502_REG9);
// Now we sleep, see if one of the five processes has terminated, and
// continue the cycle until one of them is gone. This allows the test1x
// processes to exhibit scheduling.
// We know that the process terminated when we do a GET_PROCESS_ID and
// receive an error on the system call.
Z502_REG9 = ERR_SUCCESS;
while (Z502_REG9 == ERR_SUCCESS)
{
SLEEP(sleep_time);
GET_PROCESS_ID("test1d_4", &Z502_REG6, &Z502_REG9);
}
TERMINATE_PROCESS(-2, &Z502_REG9);
} // End test1d
void test2g(void)
{
static long sleep_time = 1000;
printf("This is Release %s: Test 2g\n", CURRENT_REL);
CREATE_PROCESS("test2g_a", test2f, PRIORITY2G, &Z502_REG1, &Z502_REG9);
CREATE_PROCESS("test2g_b", test2f, PRIORITY2G, &Z502_REG2, &Z502_REG9);
CREATE_PROCESS("test2g_c", test2f, PRIORITY2G, &Z502_REG3, &Z502_REG9);
CREATE_PROCESS("test2g_d", test2f, PRIORITY2G, &Z502_REG4, &Z502_REG9);
CREATE_PROCESS("test2g_e", test2f, PRIORITY2G, &Z502_REG5, &Z502_REG9);
SuccessExpected(Z502_REG9, "CREATE_PROCESS");
// In these next three cases, we will loop until the target
// process ( test2g_e ) has terminated. We know it
// terminated because for a while we get success on the call
// GET_PROCESS_ID, and then we get failure when the process
// no longer exists.
Z502_REG9 = ERR_SUCCESS;
while (Z502_REG9 == ERR_SUCCESS)
{
SLEEP(sleep_time);
GET_PROCESS_ID("test2g_e", &Z502_REG6, &Z502_REG9);
}
TERMINATE_PROCESS(-2, &Z502_REG9); // Terminate all
} // End test2g
void
JNIHelper :: waitForDebugger(JNIEnv* env)
{
// Find the System class.
jclass cls = 0;
jstring jDebugKey = 0;
jstring jDebugVal = 0;
const char* debugKey = "io.humble.ferry.WaitForDebugger";
const char* debugVal = 0;
try
{
cls = env->FindClass("java/lang/System");
if (!cls)
throw std::runtime_error("could not find System class");
jmethodID getProperty = env->GetStaticMethodID(cls, "getProperty",
"(Ljava/lang/String;)Ljava/lang/String;");
if (!getProperty)
throw std::runtime_error("could not find getProperty class");
jDebugKey = env->NewStringUTF(debugKey);
if (!jDebugKey)
throw std::runtime_error("could not create java string for the debug key");
jDebugVal = (jstring) env->CallStaticObjectMethod(cls, getProperty, jDebugKey);
if (jDebugVal)
{
debugVal = env->GetStringUTFChars(jDebugVal, 0);
if (debugVal && *debugVal)
{
// It's set to some out put value. Sit and spin waiting
// for a debugger.
int32_t pid = GET_PROCESS_ID();
std::cerr << "Process " << pid << " waiting for a debugger. Please attach and set \"JNIHelper::sDebuggerAttached\" to true"
<< " (" << __FILE__ << ":" << __LINE__+1 <<")" << std::endl;
while (!sDebuggerAttached) ;
}
}
}
catch (std::exception & e)
{
std::cerr << "Got exception while checking for debugger: "
<< e.what()
<< std::endl;
}
// And do the clean up here.
if (jDebugKey)
env->DeleteLocalRef(jDebugKey);
if (jDebugVal && debugVal)
env->ReleaseStringUTFChars(jDebugVal, debugVal);
if (cls)
env->DeleteLocalRef(cls);
}
void test1e(void)
{
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
printf("Release %s:Test 1e: Pid %ld\n", CURRENT_REL, Z502_REG2);
// Make a legal target process
CREATE_PROCESS("test1e_a", test1x, LEGAL_PRIORITY_1E, &Z502_REG1,
&Z502_REG9);
SuccessExpected(Z502_REG9, "CREATE_PROCESS");
// Try to Suspend an Illegal PID
SUSPEND_PROCESS((INT32) 9999, &Z502_REG9);
ErrorExpected(Z502_REG9, "SUSPEND_PROCESS");
// Try to Resume an Illegal PID
RESUME_PROCESS((INT32) 9999, &Z502_REG9);
ErrorExpected(Z502_REG9, "RESUME_PROCESS");
// Suspend alegal PID
SUSPEND_PROCESS(Z502_REG1, &Z502_REG9);
SuccessExpected(Z502_REG9, "SUSPEND_PROCESS");
// Suspend already suspended PID
SUSPEND_PROCESS(Z502_REG1, &Z502_REG9);
ErrorExpected(Z502_REG9, "SUSPEND_PROCESS");
// Do a legal resume of the process we have suspended
RESUME_PROCESS(Z502_REG1, &Z502_REG9);
SuccessExpected(Z502_REG9, "RESUME_PROCESS");
// Resume an already resumed process
RESUME_PROCESS(Z502_REG1, &Z502_REG9);
ErrorExpected(Z502_REG9, "RESUME_PROCESS");
// Try to resume ourselves
RESUME_PROCESS(Z502_REG2, &Z502_REG9);
ErrorExpected(Z502_REG9, "RESUME_PROCESS");
// It may or may not be legal to suspend ourselves;
// architectural decision. It can be a useful technique
// as a way to pass off control to another process.
SUSPEND_PROCESS(-1, &Z502_REG9);
/* If we returned "SUCCESS" here, then there is an inconsistency;
* success implies that the process was suspended. But if we
* get here, then we obviously weren't suspended. Therefore
* this must be an error. */
ErrorExpected(Z502_REG9, "SUSPEND_PROCESS");
GET_TIME_OF_DAY(&Z502_REG4);
printf("Test1e, PID %ld, Ends at Time %ld\n", Z502_REG2, Z502_REG4);
TERMINATE_PROCESS(-2, &Z502_REG9);
} // End of test1e
void test1f(void)
{
static long sleep_time = 300;
int iterations;
// Get OUR PID
Z502_REG1 = 0; // Initialize
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
// Make legal targets
printf("Release %s:Test 1f: Pid %ld\n", CURRENT_REL, Z502_REG2);
CREATE_PROCESS("test1f_a", test1x, PRIORITY_1F1, &Z502_REG3, &Z502_REG9);
CREATE_PROCESS("test1f_b", test1x, PRIORITY_1F2, &Z502_REG4, &Z502_REG9);
CREATE_PROCESS("test1f_c", test1x, PRIORITY_1F3, &Z502_REG5, &Z502_REG9);
CREATE_PROCESS("test1f_d", test1x, PRIORITY_1F4, &Z502_REG6, &Z502_REG9);
CREATE_PROCESS("test1f_e", test1x, PRIORITY_1F5, &Z502_REG7, &Z502_REG9);
// Let the 5 processes go for a while
SLEEP(sleep_time);
// Do a set of suspends/resumes four times
for (iterations = 0; iterations < 4; iterations++)
{
// Suspend 3 of the pids and see what happens - we should see
// scheduling behavior where the processes are yanked out of the
// ready and the waiting states, and placed into the suspended state.
SUSPEND_PROCESS(Z502_REG3, &Z502_REG9);
SUSPEND_PROCESS(Z502_REG5, &Z502_REG9);
SUSPEND_PROCESS(Z502_REG7, &Z502_REG9);
// Sleep so we can watch the scheduling action
SLEEP(sleep_time);
RESUME_PROCESS(Z502_REG3, &Z502_REG9);
RESUME_PROCESS(Z502_REG5, &Z502_REG9);
RESUME_PROCESS(Z502_REG7, &Z502_REG9);
}
// Wait for children to finish, then quit
SLEEP((INT32) 10000);
TERMINATE_PROCESS(-2, &Z502_REG9);
} // End of test1f
void test1h(void)
{
long ourself;
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
// Make our priority high
printf("Release %s:Test 1h: Pid %ld\n", CURRENT_REL, Z502_REG2);
ourself = -1;
CHANGE_PRIORITY(ourself, MOST_FAVORABLE_PRIORITY, &Z502_REG9);
// Make legal targets
CREATE_PROCESS("test1h_a", test1x, NORMAL_PRIORITY, &Z502_REG3,
&Z502_REG9);
CREATE_PROCESS("test1h_b", test1x, NORMAL_PRIORITY, &Z502_REG4,
&Z502_REG9);
CREATE_PROCESS("test1h_c", test1x, NORMAL_PRIORITY, &Z502_REG5,
&Z502_REG9);
// Sleep awhile to watch the scheduling
SLEEP(200);
// Now change the priority - it should be possible to see
// that the priorities have been changed for processes that
// are ready and for processes that are sleeping.
CHANGE_PRIORITY(Z502_REG3, FAVORABLE_PRIORITY, &Z502_REG9);
CHANGE_PRIORITY(Z502_REG5, LEAST_FAVORABLE_PRIORITY, &Z502_REG9);
// Sleep awhile to watch the scheduling
SLEEP(200);
// Now change the priority - it should be possible to see
// that the priorities have been changed for processes that
// are ready and for processes that are sleeping.
CHANGE_PRIORITY(Z502_REG3, LEAST_FAVORABLE_PRIORITY, &Z502_REG9);
CHANGE_PRIORITY(Z502_REG4, FAVORABLE_PRIORITY, &Z502_REG9);
// Sleep awhile to watch the scheduling
SLEEP(600);
// Terminate everyone
TERMINATE_PROCESS(-2, &Z502_REG9);
} // End of test1h
void test2e(void)
{
int Iterations;
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG9);
printf("\n\nRelease %s:Test 2e: Pid %ld\n", CURRENT_REL, Z502_REG4);
for (Iterations = 0; Iterations < VIRTUAL_MEM_PGS; Iterations +=
STEP_SIZE)
{
Z502_REG3 = PGSIZE * Iterations; // Generate address
Z502_REG1 = Z502_REG3 + Z502_REG4; // Generate data
MEM_WRITE(Z502_REG3, &Z502_REG1); // Write the data
MEM_READ(Z502_REG3, &Z502_REG2); // Read back data
if (Iterations % DISPLAY_GRANULARITY2e == 0)
printf("PID= %ld address= %ld written= %ld read= %ld\n",
Z502_REG4, Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1) // Written = read?
printf("AN ERROR HAS OCCURRED.\n");
// It makes life more fun!! to write the data again
MEM_WRITE(Z502_REG3, &Z502_REG1); // Write the data
} // End of for loop
// Now read back the data we've written and paged
printf("Reading back data: test 2e, PID %ld.\n", Z502_REG4);
for (Iterations = 0; Iterations < VIRTUAL_MEM_PGS; Iterations +=
STEP_SIZE)
{
Z502_REG3 = PGSIZE * Iterations; // Generate address
Z502_REG1 = Z502_REG3 + Z502_REG4; // Data expected
MEM_READ(Z502_REG3, &Z502_REG2); // Read back data
if (Iterations % DISPLAY_GRANULARITY2e == 0)
printf("PID= %ld address= %ld written= %ld read= %ld\n",
Z502_REG4, Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1) // Written = read?
printf("AN ERROR HAS OCCURRED.\n");
} // End of for loop
TERMINATE_PROCESS(-2, &Z502_REG5); // Added 12/1/2013
} // End of test2e
//****************************************************************************
void mytestx(void)
{
int i;
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
printf("Release %s: mytestx: Pid %ld\n", CURRENT_REL, Z502_REG2);
for( i = 0; i < 50; i++ )
{
printf("PID: %d is printing.\n", Z502_REG2);
SLEEP(2);
}
TERMINATE_PROCESS(-1, &Z502_REG9);
printf("ERROR: mytestx should be terminated but isn't.\n");
}
/* -----------------------------------------------------------------------------------*/
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 test2d(void)
{
static INT32 trash;
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG5);
printf("\n\nRelease %s:Test 2d: Pid %ld\n", CURRENT_REL, Z502_REG4);
CHANGE_PRIORITY(-1, MOST_FAVORABLE_PRIORITY, &Z502_REG9);
CREATE_PROCESS("first", test2c, 5, &trash, &Z502_REG5);
CREATE_PROCESS("second", test2c, 5, &trash, &Z502_REG5);
CREATE_PROCESS("third", test2c, 7, &trash, &Z502_REG5);
CREATE_PROCESS("fourth", test2c, 7, &trash, &Z502_REG5);
CREATE_PROCESS("fifth", test2c, 7, &trash, &Z502_REG5);
SLEEP(50000);
TERMINATE_PROCESS(-2, &Z502_REG5);
} // End of test2d
/**************************************************************************
Test2a exercises a simple memory write and read
Use: Z502_REG1 data_written
Z502_REG2 data_read
Z502_REG3 address
Z502_REG4 process_id
Z502_REG9 error
In global.h, there's a variable DO_MEMORY_DEBUG. Switching it to
TRUE will allow you to see what the memory system thinks is happening.
WARNING - it's verbose -- and I don't want to see such output - it's
strictly for your debugging pleasure.
**************************************************************************/
void test2a(void)
{
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG9);
printf("Release %s:Test 2a: Pid %ld\n", CURRENT_REL, Z502_REG4);
Z502_REG3 = 412;
Z502_REG1 = Z502_REG3 + Z502_REG4;
MEM_WRITE(Z502_REG3, &Z502_REG1);
MEM_READ(Z502_REG3, &Z502_REG2);
printf("PID= %ld address= %ld written= %ld read= %ld\n", Z502_REG4,
Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1)
printf("AN ERROR HAS OCCURRED.\n");
TERMINATE_PROCESS(-1, &Z502_REG9);
} // End of test2a
/* -----------------------------------------------------------------------------------*/
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 */
}
void test2b(void)
{
static INT32 test_data[TEST_DATA_SIZE ] = {0, 4, PGSIZE - 2, PGSIZE, 3
* PGSIZE - 2, (VIRTUAL_MEM_PGS - 1) * PGSIZE, VIRTUAL_MEM_PGS
* PGSIZE - 2};
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG9);
printf("\n\nRelease %s:Test 2b: Pid %ld\n", CURRENT_REL, Z502_REG4);
Z502_REG8 = 5 * PGSIZE;
Z502_REG6 = Z502_REG8 + Z502_REG4 + 7;
MEM_WRITE(Z502_REG8, &Z502_REG6);
// Loop through all the memory addresses defined
while (TRUE)
{
Z502_REG3 = test_data[(INT16) Z502_REG5];
Z502_REG1 = Z502_REG3 + Z502_REG4 + 27;
MEM_WRITE(Z502_REG3, &Z502_REG1);
MEM_READ(Z502_REG3, &Z502_REG2);
printf("PID= %ld address= %ld written= %ld read= %ld\n", Z502_REG4,
Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1)
printf("AN ERROR HAS OCCURRED.\n");
// Go back and check earlier write
MEM_READ(Z502_REG8, &Z502_REG7);
printf("PID= %ld address= %ld written= %ld read= %ld\n",
Z502_REG4, Z502_REG8, Z502_REG6, Z502_REG7);
if (Z502_REG6 != Z502_REG7)
printf("AN ERROR HAS OCCURRED.\n");
Z502_REG5++;
}
} // End of test2b
void test1x(void)
{
long RandomSleep = 17;
int Iterations;
GET_PROCESS_ID("", &Z502_REG2, &Z502_REG9);
printf("Release %s:Test 1x: Pid %ld\n", CURRENT_REL, Z502_REG2);
for (Iterations = 0; Iterations < NUMBER_OF_TEST1X_ITERATIONS;
Iterations++)
{
GET_TIME_OF_DAY(&Z502_REG3);
RandomSleep = (RandomSleep * Z502_REG3) % 143;
SLEEP(RandomSleep);
GET_TIME_OF_DAY(&Z502_REG4);
printf("Test1X: Pid = %d, Sleep Time = %ld, Latency Time = %d\n",
(int) Z502_REG2, RandomSleep, (int) (Z502_REG4 - Z502_REG3));
}
printf("Test1x, PID %ld, Ends at Time %ld\n", Z502_REG2, Z502_REG4);
TERMINATE_PROCESS(-1, &Z502_REG9);
printf("ERROR: Test1x should be terminated but isn't.\n");
} /* End of test1x */
/* -----------------------------------------------------------------------------------*/
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 ();
}
void test2c(void)
{
DISK_DATA *data_written;
DISK_DATA *data_read;
long disk_id;
INT32 sanity = 1234;
long sector;
int Iterations;
data_written = (DISK_DATA *) calloc(1, sizeof (DISK_DATA));
data_read = (DISK_DATA *) calloc(1, sizeof (DISK_DATA));
if (data_read == 0)
printf("Something screwed up allocating space in test2c\n");
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG9);
sector = Z502_REG4;
printf("\n\nRelease %s:Test 2c: Pid %ld\n", CURRENT_REL, Z502_REG4);
for (Iterations = 0; Iterations < TEST2C_LOOPS; Iterations++)
{
// Pick some location on the disk to write to
disk_id = (Z502_REG4 / 2) % MAX_NUMBER_OF_DISKS + 1;
sector = (sector * 177) % NUM_LOGICAL_SECTORS;
data_written->int_data[0] = disk_id;
data_written->int_data[1] = sanity;
data_written->int_data[2] = sector;
data_written->int_data[3] = (int) Z502_REG4;
DISK_WRITE(disk_id, sector, (char*) (data_written->char_data));
// Now read back the same data. Note that we assume the
// disk_id and sector have not been modified by the previous
// call.
DISK_READ(disk_id, sector, (char*) (data_read->char_data));
if ((data_read->int_data[0] != data_written->int_data[0])
|| (data_read->int_data[1] != data_written->int_data[1])
|| (data_read->int_data[2] != data_written->int_data[2])
|| (data_read->int_data[3] != data_written->int_data[3]))
{
printf("AN ERROR HAS OCCURRED.\n");
}
else if (Z502_REG6 % DISPLAY_GRANULARITY2c == 0)
{
printf("SUCCESS READING PID= %ld disk_id =%ld, sector = %ld\n",
Z502_REG4, disk_id, sector);
}
} // End of for loop
// Now read back the data we've written and paged
printf("Reading back data: test 2c, PID %ld.\n", Z502_REG4);
sector = Z502_REG4;
for (Iterations = 0; Iterations < TEST2C_LOOPS; Iterations++)
{
disk_id = (Z502_REG4 / 2) % MAX_NUMBER_OF_DISKS + 1;
sector = (sector * 177) % NUM_LOGICAL_SECTORS;
data_written->int_data[0] = disk_id;
data_written->int_data[1] = sanity;
data_written->int_data[2] = sector;
data_written->int_data[3] = Z502_REG4;
DISK_READ(disk_id, sector, (char*) (data_read->char_data));
if ((data_read->int_data[0] != data_written->int_data[0])
|| (data_read->int_data[1] != data_written->int_data[1])
|| (data_read->int_data[2] != data_written->int_data[2])
|| (data_read->int_data[3] != data_written->int_data[3]))
{
printf("AN ERROR HAS OCCURRED.\n");
}
else if (Z502_REG6 % DISPLAY_GRANULARITY2c == 0)
{
printf("SUCCESS READING PID= %ld disk_id =%ld, sector = %ld\n",
Z502_REG4, disk_id, sector);
}
} // End of for loop
GET_TIME_OF_DAY(&Z502_REG8);
printf("Test2c, PID %ld, Ends at Time %ld\n", Z502_REG4, Z502_REG8);
TERMINATE_PROCESS(-1, &Z502_REG9);
} // End of test2c
void test2f(void)
{
MEMORY_TOUCHED_RECORD *mtr;
short Iterations, Index, Loops;
mtr = (MEMORY_TOUCHED_RECORD *) calloc(1, sizeof (MEMORY_TOUCHED_RECORD));
GET_PROCESS_ID("", &Z502_REG4, &Z502_REG9);
printf("\n\nRelease %s:Test 2f: Pid %ld\n", CURRENT_REL, Z502_REG4);
for (Iterations = 0; Iterations < NUMBER_OF_ITERATIONS; Iterations++)
{
for (Index = 0; Index < LOOP_COUNT; Index++) // Bugfix Rel 4.03 12/1/2013
mtr->page_touched[Index] = 0;
for (Loops = 0; Loops < LOOP_COUNT; Loops++)
{
// Get a random page number
get_skewed_random_number(&Z502_REG7, LOGICAL_PAGES_TO_TOUCH);
Z502_REG3 = PGSIZE * Z502_REG7; // Convert page to addr.
Z502_REG1 = Z502_REG3 + Z502_REG4; // Generate data for page
MEM_WRITE(Z502_REG3, &Z502_REG1);
// Write it again, just as a test
MEM_WRITE(Z502_REG3, &Z502_REG1);
// Read it back and make sure it's the same
MEM_READ(Z502_REG3, &Z502_REG2);
if (Loops % DISPLAY_GRANULARITY2 == 0)
printf("PID= %ld address= %ld written= %ld read= %ld\n",
Z502_REG4, Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1)
printf("AN ERROR HAS OCCURRED: READ NOT EQUAL WRITE.\n");
// Record in our data-base that we've accessed this page
mtr->page_touched[(short) Loops] = Z502_REG7;
} // End of for Loops
for (Loops = 0; Loops < LOOP_COUNT; Loops++)
{
// We can only read back from pages we've previously
// written to, so find out which pages those are.
Z502_REG6 = mtr->page_touched[(short) Loops];
Z502_REG3 = PGSIZE * Z502_REG6; // Convert page to addr.
Z502_REG1 = Z502_REG3 + Z502_REG4; // Expected read
MEM_READ(Z502_REG3, &Z502_REG2);
if (Loops % DISPLAY_GRANULARITY2 == 0)
printf("PID= %ld address= %ld written= %ld read= %ld\n",
Z502_REG4, Z502_REG3, Z502_REG1, Z502_REG2);
if (Z502_REG2 != Z502_REG1)
printf("ERROR HAS OCCURRED: READ NOT SAME AS WRITE.\n");
} // End of for Loops
// We've completed reading back everything
printf("TEST 2f, PID %ld, HAS COMPLETED %d ITERATIONS\n", Z502_REG4,
Iterations);
} // End of for Iterations
TERMINATE_PROCESS(-1, &Z502_REG9);
} // End of test2f
