int main(){
mythread_init();
struct mythread_t t1, t2;
mythread_create(&t1, test, 0);
mythread_create(&t2, test2, 0);
fcfs();
printf("all threads completed\n");
}
int main(){
mythread_init();
timer_init();
struct mythread_t t1, t2;
mythread_create(&t1, test, 0);
mythread_create(&t2, test2, 0);
roundrobin();
printf("all threads completed\n");
}
}int main() {
mythread_init();
std::cout << "A" << std::endl;
int thread1 = mythread_fork(MyExampleThread1,NULL);
std::cout << "C" << std::endl;
int thread2 = mythread_fork(MyExampleThread2,NULL);
std::cout << "F" << std::endl;
mythread_join(thread1);
std::cout << "G" << std::endl;
mythread_join(thread2);
std::cout << "I" << std::endl;
return 0;
}
int main()
{
getcontext(&uctx_main); //AMJAD: Added uctx_main
int thread_num = 10;
int j;
char* thread_names[] = {
"thread 0",
"thread 1",
"thread 2",
"thread 3",
"thread 4",
"thread 5",
"thread 6",
"thread 7",
"thread 8",
"thread 9"
};
/* Initialize MyThreads library. */
mythread_init();
/* 250 ms */
set_quantum_size(250);
counter_mutex = create_semaphore(1);
for(j=0; j<thread_num; j++)
{
mythread_create(thread_names[j], (void *) &handler, 6004);
}
/* Print threads informations before run */
mythread_state();
/* When this function returns, all threads should have exited. */
runthreads();
destroy_semaphore(counter_mutex);
/* Print threads informations after run */
mythread_state();
printf("The counter is %d\n", counter);
printf("The result is %f\n", result);
if (counter == 50 &&
(result - 151402.656521) < 0.000001)
printf(">>> Thread library PASSED the Test 1\n");
exit(0);
}
int main()
{
mythread_init();
mythread_create(thread_test, (void *)5);
mythread_create(thread_test, (void *)10);
while (1)
{
mythread_yield();
}
printf("main is going away\n");
return 0;
}
mystatus_t myhtml_stream_create(myhtml_t* myhtml, mystatus_t* status, size_t count, size_t id_increase)
{
if(count == 0) {
myhtml->thread_stream = NULL;
*status = MyHTML_STATUS_OK;
return *status;
}
myhtml->thread_stream = mythread_create();
if(myhtml->thread_stream == NULL)
*status = MyCORE_STATUS_THREAD_ERROR_MEMORY_ALLOCATION;
*status = mythread_init(myhtml->thread_stream, MyTHREAD_TYPE_STREAM, count, id_increase);
if(*status)
myhtml->thread_stream = mythread_destroy(myhtml->thread_stream, NULL, NULL, true);
return *status;
}
int main()
{
unsigned long thread_1;
unsigned long thread_2;
void *result;
mythread_init();
thread_1 = mythread_create(write_thread, (void *)1);
mythread_detach(thread_1);
thread_1 = mythread_create(write_thread, (void *)3);
mythread_detach(thread_1);
thread_2 = mythread_create(read_thread, (void *)10);
mythread_join(thread_2, NULL);
printf("main is going away\n");
//mythread_cleanup();
return 0;
}
myhtml_status_t myhtml_init(myhtml_t* myhtml, enum myhtml_options opt, size_t thread_count, size_t queue_size)
{
myhtml_status_t status;
myhtml_init_marker(myhtml);
myhtml->async_incoming_buf = mcobject_async_create();
if(myhtml->async_incoming_buf == NULL)
return MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
mcobject_async_status_t mcstatus = mcobject_async_init(myhtml->async_incoming_buf, 32, 1024, sizeof(myhtml_incoming_buffer_t));
if(mcstatus != MCOBJECT_ASYNC_STATUS_OK)
return MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
// for tags node and other
myhtml->mchar = mchar_async_create(64, 4096);
myhtml->tag_index = mcobject_async_create();
mcstatus = mcobject_async_init(myhtml->tag_index, 128, 1024, sizeof(myhtml_tag_index_node_t));
if(mcstatus != MCOBJECT_ASYNC_STATUS_OK)
return MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE;
status = myhtml_tokenizer_state_init(myhtml);
if(status) {
myhtml->insertion_func = NULL;
myhtml->thread = NULL;
return status;
}
status = myhtml_rules_init(myhtml);
if(status) {
myhtml->thread = NULL;
return status;
}
myhtml->opt = opt;
myhtml->thread = mythread_create();
#ifdef MyHTML_BUILD_WITHOUT_THREADS
status = mythread_init(myhtml->thread, NULL, thread_count, queue_size);
if(status)
return status;
#else /* MyHTML_BUILD_WITHOUT_THREADS */
switch (opt) {
case MyHTML_OPTIONS_PARSE_MODE_SINGLE:
status = mythread_init(myhtml->thread, "lastmac", 0, queue_size);
if(status)
return status;
break;
case MyHTML_OPTIONS_PARSE_MODE_ALL_IN_ONE:
status = mythread_init(myhtml->thread, "lastmac", 1, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_worker_index_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_WORKER_TREE:
status = mythread_init(myhtml->thread, "lastmac", 2, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_worker_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_WORKER_INDEX:
status = mythread_init(myhtml->thread, "lastmac", 2, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_worker_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_TREE_INDEX:
if(thread_count == 0)
thread_count = 1;
status = mythread_init(myhtml->thread, "lastmac", (thread_count + 1), queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_stream_index, &status);
myhread_create_batch(myhtml->thread, myhtml_parser_worker, &status, thread_count);
break;
default:
// default MyHTML_OPTIONS_PARSE_MODE_SEPARATELY
if(thread_count == 0)
thread_count = 1;
status = mythread_init(myhtml->thread, "lastmac", (thread_count + 2), queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_stream, &status);
myhread_create_batch(myhtml->thread, myhtml_parser_worker, &status, thread_count);
break;
}
#endif /* MyHTML_BUILD_WITHOUT_THREADS */
myhtml_clean(myhtml);
return status;
}
myhtml_status_t myhtml_init(myhtml_t* myhtml, enum myhtml_options opt, size_t thread_count, size_t queue_size)
{
myhtml_status_t status;
myhtml->async_incoming_buf = mcobject_async_create();
if(myhtml->async_incoming_buf == NULL)
return MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
mcobject_async_status_t mcstatus = mcobject_async_init(myhtml->async_incoming_buf, 32, 1024, sizeof(myhtml_incoming_buf_t));
if(mcstatus != MCOBJECT_ASYNC_STATUS_OK)
return MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
myhtml->tags = myhtml_tag_create();
if(myhtml->tags == NULL) {
myhtml->parse_state_func = NULL;
myhtml->insertion_func = NULL;
myhtml->thread = NULL;
return MyHTML_STATUS_TAGS_ERROR_MEMORY_ALLOCATION;
}
status = myhtml_tag_init(myhtml->tags);
if(status) {
myhtml->parse_state_func = NULL;
myhtml->insertion_func = NULL;
myhtml->thread = NULL;
return status;
}
status = myhtml_tokenizer_state_init(myhtml);
if(status) {
myhtml->insertion_func = NULL;
myhtml->thread = NULL;
return status;
}
status = myhtml_rules_init(myhtml);
if(status) {
myhtml->thread = NULL;
return status;
}
myhtml->opt = opt;
myhtml->thread = mythread_create();
switch (opt) {
case MyHTML_OPTIONS_PARSE_MODE_SINGLE:
status = mythread_init(myhtml->thread, "lastmac", 0, queue_size);
if(status)
return status;
break;
case MyHTML_OPTIONS_PARSE_MODE_ALL_IN_ONE:
status = mythread_init(myhtml->thread, "lastmac", 1, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_worker_index_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_WORKER_TREE:
status = mythread_init(myhtml->thread, "lastmac", 2, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_worker_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_WORKER_INDEX:
status = mythread_init(myhtml->thread, "lastmac", 2, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_worker_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_stream, &status);
break;
case MyHTML_OPTIONS_PARSE_MODE_TREE_INDEX:
if(thread_count == 0)
thread_count = 1;
status = mythread_init(myhtml->thread, "lastmac", (thread_count + 1), queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_stream_index, &status);
myhread_create_batch(myhtml->thread, myhtml_parser_worker, &status, thread_count);
break;
default:
// default MyHTML_OPTIONS_PARSE_MODE_SEPARATELY
if(thread_count == 0)
thread_count = 1;
status = mythread_init(myhtml->thread, "lastmac", (thread_count + 2), queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_index, &status);
myhread_create_stream(myhtml->thread, myhtml_parser_stream, &status);
myhread_create_batch(myhtml->thread, myhtml_parser_worker, &status, thread_count);
break;
}
myhtml_clean(myhtml);
return status;
}
myhtml_status_t myhtml_init(myhtml_t* myhtml, enum myhtml_options opt, size_t thread_count, size_t queue_size)
{
myhtml_status_t status;
myhtml_init_marker(myhtml);
status = myhtml_tokenizer_state_init(myhtml);
if(status) {
myhtml->insertion_func = NULL;
myhtml->thread = NULL;
return status;
}
status = myhtml_rules_init(myhtml);
if(status) {
myhtml->thread = NULL;
return status;
}
myhtml->opt = opt;
myhtml->thread = mythread_create();
#ifdef MyHTML_BUILD_WITHOUT_THREADS
status = mythread_init(myhtml->thread, NULL, thread_count, queue_size);
if(status)
return status;
#else /* MyHTML_BUILD_WITHOUT_THREADS */
switch (opt) {
case MyHTML_OPTIONS_PARSE_MODE_SINGLE:
status = mythread_init(myhtml->thread, "lastmac", 0, queue_size);
if(status)
return status;
break;
case MyHTML_OPTIONS_PARSE_MODE_ALL_IN_ONE:
status = mythread_init(myhtml->thread, "lastmac", 1, queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_worker_stream, &status);
break;
default:
// default MyHTML_OPTIONS_PARSE_MODE_SEPARATELY
if(thread_count == 0)
thread_count = 1;
status = mythread_init(myhtml->thread, "lastmac", (thread_count + 1), queue_size);
if(status)
return status;
myhread_create_stream(myhtml->thread, myhtml_parser_stream, &status);
myhread_create_batch(myhtml->thread, myhtml_parser_worker, &status, thread_count);
break;
}
#endif /* MyHTML_BUILD_WITHOUT_THREADS */
myhtml_clean(myhtml);
return status;
}