void* parent(void* n)
{
int i = *(int*)n;
printf("--Entered parent thread--\n");
int m = 2 * i;
int child_id = uthread_create(proc3, &m);
if(id3 != -1)
{
printf("--Created child thread--\n");
}
else
{
printf("--Creation of child thread failed--\n");
}
for(; i > 0; i--)
{
printf("Parent: %d\n", i);
uthread_yield();
}
return NULL;
}
int
main ()
{
int i = 0;
uthread_init ();
uthread_create (threadFunc, 1, 0);
uthread_create (threadFunc, 2, 0);
uthread_create (threadFunc, 3, 0);
uthread_create (threadFunc, 4, 0);
//uthread_create (threadFunc, 5, 5);
//uthread_create (threadFunc, 6, 3);
//uthread_create (threadFunc, 7, 3);
//uthread_create (threadFunc, 8, 2);
// uncomment to test uthread_exit() on main earlier than others
//uthread_exit();
while( 1 ) printf("Waiting for interrupt.\n");
for (i = 0; i < 10; i++)
{
printf ("This is the main function\n");
uthread_yield ();
}
printf ("I am main and I am exiting\n");
uthread_exit ();
printf ("You shall not reach this line\n");
return 0;
}
void func2(void * arg)
{
puts("22");
puts("22");
uthread_yield(*(schedule_t *)arg);
puts("22");
puts("22");
}
void* ping (void* x) {
int i,j;
for (i=0; i<NUM_ITERATIONS; i++) {
printf ("I");
for (j=0; j<10000; j++) {}
uthread_yield();
}
}
static void *run_vm(void *arg)
{
struct vmctl *vmctl = (struct vmctl*)arg;
assert(vmctl->command == REG_RSP_RIP_CR3);
/* We need to hack our context, so that next time we run, we're a VM ctx */
uthread_yield(FALSE, __build_vm_ctx_cb, arg);
}
void func3(void *arg)
{
puts("3333");
puts("3333");
uthread_yield(*(schedule_t *)arg);
puts("3333");
puts("3333");
}
/* Run a specific sighandler from the top of the sigdata stack. The 'info'
* struct is prepopulated before the call is triggered as the result of a
* reflected fault. */
static void __run_sighandler()
{
struct pthread_tcb *me = pthread_self();
__sigdelset(&me->sigpending, me->sigdata->info.si_signo);
trigger_posix_signal(me->sigdata->info.si_signo,
&me->sigdata->info,
&me->sigdata->u_ctx);
uthread_yield(FALSE, __exit_sighandler_cb, 0);
}
void sanityMethod(){
int i;
uthread_t t = uthread_self();
for (i = 0; i<numOfIterations; i++){
printf(2, "thread %d iteration %d\n",t.tid, i);
uthread_yield();
}
printf(3, "killing %d, with %d and %d iters", t.tid, t.priority, numOfIterations);
uthread_exit();
}
void *func2(void *arg)
{
int *ti=(int*)arg;
printf("func2: started\n");
printf("func2: %d\n",*(int*)arg);
for ( ; *ti<10; (*ti)++) {
printf ("func2 i = %d \n",*ti);
uthread_yield();
}
printf("func2: %d - returning\n",*(int*)arg);
return NULL;
}
int main(int argc, char **argv) {
printf("Testing uthread_create\n");
uthread_init();
uthread_create(thread_start, 1, 0);
uthread_yield();
printf("back in main\n");
uthread_exit();
return 0;
}
/* Run through all pending sighandlers and trigger them with a NULL info field.
* These handlers are triggered as the result of a pthread_kill(), and thus
* don't require individual 'info' structs. */
static void __run_pending_sighandlers()
{
struct pthread_tcb *me = pthread_self();
sigset_t andset = me->sigpending & (~me->sigmask);
for (int i = 1; i < _NSIG; i++) {
if (__sigismember(&andset, i)) {
__sigdelset(&me->sigpending, i);
trigger_posix_signal(i, NULL, &me->sigdata->u_ctx);
}
}
uthread_yield(FALSE, __exit_sighandler_cb, 0);
}
void* child(void* n)
{
int i = *(int*)n;
printf("--Entered child thread--\n");
for(; i > 0; i--)
{
printf("Child: %d\n", i);
uthread_yield();
}
return NULL;
}
int upthread_cond_wait(upthread_cond_t *c, upthread_mutex_t *m)
{
if(c == NULL)
return EINVAL;
if(m == NULL)
return EINVAL;
mcs_lock_qnode_t qnode = {0};
mcs_pdr_lock(&c->lock, &qnode);
c->waiting_mutex = m;
c->waiting_qnode = &qnode;
uthread_yield(true, block, c);
return upthread_mutex_lock(m);
}
void *func1(void *arg)
{
int *ti=(int*)arg;
printf("func1: started\n");
printf("func1: %d\n",*(int*)arg);
//Testando comunicacao entre threads, atraves da variavel i
for ( ; *ti<10; (*ti)++) {
printf ("func1 i = %d\n",*ti);
uthread_yield();
}
printf("func1: %d - returning\n",*(int*)arg);
return NULL;
}
static inline int futex_wait(int *uaddr, int val, uint64_t ms_timeout)
{
// Atomically do the following...
mcs_pdr_lock(&__futex.lock);
// If the value of *uaddr matches val
if(*uaddr == val) {
// Create a new futex element and initialize it.
struct futex_element e;
bool enable_timer = false;
e.uaddr = uaddr;
e.pthread = NULL;
e.ms_timeout = ms_timeout;
e.timedout = false;
if(e.ms_timeout != (uint64_t)-1) {
e.ms_timeout += __futex.time;
// If we are setting the timeout, get ready to
// enable the timer if it is currently disabled.
if(__futex.timer_enabled == false) {
__futex.timer_enabled = true;
enable_timer = true;
}
}
// Insert the futex element into the queue
TAILQ_INSERT_TAIL(&__futex.queue, &e, link);
mcs_pdr_unlock(&__futex.lock);
// Enable the timer if we need to outside the lock
if(enable_timer)
futex_wake(&__futex.timer_enabled, 1);
// Yield the current uthread
uthread_yield(TRUE, __futex_block, &e);
// After waking, if we timed out, set the error
// code appropriately and return
if(e.timedout) {
errno = ETIMEDOUT;
return -1;
}
}
else {
mcs_pdr_unlock(&__futex.lock);
}
return 0;
}
void* proc1(void* n)
{
int i = *(int*)n;
printf("--Hello from proc1--\n");
for(; i > 0; i--)
{
printf("i=%d\n", i);
if(i % 5 == 0)
{
uthread_yield();
}
}
return NULL;
}
void do_something()
{
int id;
id=myid;
myid++;
printf("This is ult %d\n", id);
if(n_threads<10){
uthread_create(do_something,2);
n_threads++;
uthread_create(do_something,2);
n_threads++;
}
printf("This is ult %d again\n",id);
uthread_yield(1);
printf("This is ult %d once more\n",id);
uthread_exit();
}
/* Lame user thread */
void
threadFunc (int val)
{
int i, j;
//if( val%2 == 0 ) uthread_exit();
for (i = 0; i < 5; i++)
{
printf ("Thread: %d Count: %d\n", val, i);
for(j=0;j<10000000;j++)
{
if( j%1000000 == 0 ) printf("%i*", val);
}
printf("\n");
uthread_yield ();
}
uthread_exit ();
}
int upthread_mutex_lock(upthread_mutex_t* mutex)
{
if(mutex == NULL)
return EINVAL;
spin_pdr_lock(&mutex->lock);
if(mutex->attr.type == UPTHREAD_MUTEX_RECURSIVE &&
mutex->owner == upthread_self()) {
mutex->locked++;
}
else {
while(mutex->locked) {
uthread_yield(true, block, mutex);
spin_pdr_lock(&mutex->lock);
}
mutex->owner = upthread_self();
mutex->locked++;
}
spin_pdr_unlock(&mutex->lock);
return 0;
}
void do_something()
{
int id;
id = myid;
myid++;
printf("This is ult %d\n", id); //just for demo purpose
if(n_threads < 5){
uthread_create(do_something);
n_threads++;
printf("ult %d yields \n",id );
uthread_yield();
printf("ult %d resumes \n",id);
uthread_create(do_something);
n_threads++;
}
printf("ult %d starts I/O \n",id);
uthread_startIO();
sleep(2); //simulate some long−time I/O operation
uthread_endIO();
printf("ult %d returns from I/O \n",id);
uthread_exit();
}
void thread_start(int val) {
printf("In thread_start %d , control transfered\n", val);
uthread_yield();
}
int pthread_yield(void)
{
uthread_yield();
return 0;
}
static void pth_switch_to(struct pthread_tcb *target)
{
uthread_yield(TRUE, __pth_switch_cb, target);
}
void uthread_sleep(void)
{
threadTable.runningThread->state = T_SLEEPING;
uthread_yield();
}
