int
clientMethod(int* arg) {
char responseBuffer1[10];
char responseBuffer2[10];
minithread_fork(serverMethod, NULL);
network_address_t my_address;
network_get_my_address(my_address);
minisocket_error error;
//create client
client = minisocket_client_create(my_address, PORT_NUM, &error);
assert(client != NULL);
assert(error == SOCKET_NOERROR);
//receive first 10 bytes
int response = minisocket_receive(client, responseBuffer1, 10, &error);
assert(response == 10);
assert(strcmp(responseBuffer1, "aaaaaaaaaa") == 0);
//receive second 10 bytes
response = minisocket_receive(client, responseBuffer2, 10, &error);
assert(response == 10);
assert(strcmp(responseBuffer2, "aaaaaaaaaa") == 0);
minithread_sleep_with_timeout(15000);
//Make sure that the port does not exist
response = minisocket_send(client, aText, strlen(aText), &error);
assert(response == -1);
assert(error == SOCKET_INVALIDPARAMS);
error = SOCKET_NOERROR;
fprintf(stderr, "Test Part 1 Passed \n");
//recreate client
client = minisocket_client_create(my_address, PORT_NUM, &error);
assert(client != NULL);
assert(error == SOCKET_NOERROR);
//send from client
int packets_sent = minisocket_send(client, bText, strlen(bText), &error);
assert(packets_sent == strlen(bText));
assert(error == SOCKET_NOERROR);
minisocket_close(client);
minithread_sleep_with_timeout(15000);
//assert that minisocket has closed
response = minisocket_send(client, aText, strlen(aText), &error);
assert(response == -1);
assert(error == SOCKET_INVALIDPARAMS);
return 0;
}
int thread1(int* arg) {
minithread_fork(thread2, NULL);
printf("Thread 1 starts.\n");
minithread_sleep_with_timeout(500); /* five seconds */
printf("Thread 1 just woke up, and is going to sleep again.\n");
minithread_sleep_with_timeout(1500); /* fifteen seconds */
printf("Thread 1 just woke up and finishes\n");
return 0;
}
int
run_sleep_threads(int* arg){
if ((long)arg == 1){
minithread_sleep_with_timeout((long)arg * 1000);
printf("Thread %li woke up!\n", (long)arg);
return 0;
}
minithread_fork(run_sleep_threads, (void*)(((long)arg)-1));
minithread_sleep_with_timeout((long)arg * 1000);
printf("Thread %li woke up!\n", (long)arg);
return 0;
}
int
transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
network_address_t addr;
miniport_t port;
miniport_t dest;
AbortOnCondition(network_translate_hostname(hostname, addr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(0);
dest = miniport_create_bound(addr, 1);
for (i=0; i<MAX_COUNT/2; i++) {
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Count is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
}
minithread_sleep_with_timeout(5000);// 5 second sleep
for (i=MAX_COUNT/2; i<MAX_COUNT; i++) {
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Count is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
}
return 0;
}
int
transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t write_port1;
miniport_t write_port2;
network_address_t my_address;
network_get_my_address(my_address);
port1 = miniport_create_unbound(0);
port2 = miniport_create_unbound(1);
write_port1 = miniport_create_bound(my_address, 0);
write_port2 = miniport_create_bound(my_address, 1);
minithread_fork(receive1, NULL);
minithread_fork(receive2, NULL);
for (i=0; i<MAX_COUNT; i++) {
printf("Sending packet %d to receiver 1.\n", i+1);
sprintf(buffer, "Count for receiver 1 is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port1, write_port1, buffer, length);
minithread_yield();
printf("Sending packet %d to receiver 2.\n", i+1);
sprintf(buffer, "Count for receiver 2 is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port2, write_port2, buffer, length);
minithread_sleep_with_timeout(200);
}
return 0;
}
int
serverMethod(int* arg) {
char responseBuffer[30];
minisocket_error error;
//create server
server = minisocket_server_create(PORT_NUM, &error);
assert(error == SOCKET_NOERROR);
assert(server != NULL);
//send from server
int packets_sent = minisocket_send(server, aText, strlen(aText), &error);
assert(packets_sent == strlen(aText));
assert(error == SOCKET_NOERROR);
minisocket_close(server);
minithread_sleep_with_timeout(15000);
int response = minisocket_send(server, aText, strlen(aText), &error);
assert(response == -1);
assert(error == SOCKET_INVALIDPARAMS);
error = SOCKET_NOERROR;
//recreate server
server = minisocket_server_create(PORT_NUM, &error);
assert(error == SOCKET_NOERROR);
assert(server != NULL);
response = minisocket_receive(server, responseBuffer, 30, &error);
assert(response == 20);
assert(strcmp(responseBuffer, "bbbbbbbbbbbbbbbbbbbb") == 0);
minithread_sleep_with_timeout(15000);
//Assert that minisocket has closed
response = minisocket_send(server, aText, strlen(aText), &error);
assert(response == -1);
assert(error == SOCKET_INVALIDPARAMS);
fprintf(stderr, "Full Test Passed \n");
return 0;
}
int thread2(int* arg) {
/*minithread_t thread =*/ minithread_fork(thread3, NULL);
printf("Thread 2 starts.\n");
minithread_sleep_with_timeout(1000); /* ten seconds */
printf("Thread 2 just woke up and finishes\n");
// printf("Curr time: %llu\n", ((unsigned long long) clk_count) * clk_period);
return 0;
}
int thread3(int *arg)
{
printf("I am thread3...\n");
printf("I am going to sleep for 2 second...\n");
printf("hu lu lu...\n");
minithread_sleep_with_timeout(2000);
printf("fired at %ld ticks.\n", ticks);
printf("thread3 woke up...\n");
return 0;
}
int
thread0(int *arg)
{
printf("I am thread0...\n");
printf("I am going to sleep for 1 second...\n");
printf("hu hu hu...\n");
minithread_sleep_with_timeout(1000);
printf("fired at %ld ticks.\n", ticks);
printf("thread0 woke up...\n");
return 0;
}
/* sleepy thread that takes its time */
int sleepy(int* arg) {
last = SLEEPY;
while ( !sinkDone ) {
last = SLEEPY;
minithread_sleep_with_timeout(1000);
last = SLEEPY;
}
printf("Sleepy takes a 3 second nap.\n");
minithread_sleep_with_timeout(3000);
last = SLEEPY;
sleepyDone = 1;
printf("Sleepy wakes. All done.\n");
minithread_sleep_with_timeout(1000);
printf("Sleepy exits.\n");
return 0;
}
int
thread(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
miniport_t from;
network_address_t my_address;
network_get_my_address(my_address);
receive_port = miniport_create_unbound(0);
send_port = miniport_create_bound(my_address, 0);
minimsg_send(receive_port, send_port, text, textlen);
minithread_sleep_with_timeout(1000);
miniport_destroy(receive_port);
receive_port = miniport_create_unbound(0);
printf("waiting\n");
minimsg_receive(receive_port, &from, buffer, &length);
printf("%s", buffer); //should not print
return 0;
}
int sink(int* arg) {
channel_t* p = (channel_t *) malloc(sizeof(channel_t));
int value;
filter_t* f;
int i;
minithread_t sleepy_t;
last = SINK;
sinkDone = 0;
sleepyDone = 0;
printf("Will begin in 5 seconds");
for(i=0; i * 500 < 5000; i++) {
minithread_sleep_with_timeout(250);
printf(".");
}
minithread_sleep_with_timeout(250);
printf("Started.\n");
sleepy_t = minithread_fork(sleepy, NULL);
minithread_fork(greedy, NULL);
p->produce = semaphore_create();
semaphore_initialize(p->produce, 0);
p->consume = semaphore_create();
semaphore_initialize(p->consume, 0);
minithread_fork(source, (int *) p);
last = SINK;
semaphore_P(p->consume);
last = SINK;
value = p->value;
semaphore_V(p->produce);
last = SINK;
while ( value != -1 ) {
last = SINK;
spin(1000, SINK);
printf("%d is prime.\n", value);
f = (filter_t *) malloc(sizeof(filter_t));
f->left = p;
f->prime = value;
p = (channel_t *) malloc(sizeof(channel_t));
p->produce = semaphore_create();
semaphore_initialize(p->produce, 0);
p->consume = semaphore_create();
semaphore_initialize(p->consume, 0);
f->right = p;
minithread_fork(filter, (int *) f);
last = SINK;
semaphore_P(p->consume);
last = SINK;
value = p->value;
semaphore_V(p->produce);
}
last = SINK;
semaphore_P(p->consume);
last = SINK;
// cleanup last channel
semaphore_destroy(p->consume);
semaphore_destroy(p->produce);
free(p);
sinkDone = 1;
spin(1000, SINK);
printf("Sink Exits.\n");
return 0;
}