drlvm/vm/tests/unit/thread/test_native_basic.c - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 #include <stdio.h>
 #include "testframe.h"
 #include "thread_unit_test_utils.h"
 #include "thread_manager.h"


 typedef struct proc_param {
     hythread_group_t group;
     UDATA stacksize;
     jint priority;
     hylatch_t start;
     hylatch_t end;
 } proc_param;


 static int start_proc(void *args) {
     proc_param *attrs = (proc_param *)args;
     tf_assert_same(hythread_get_priority(hythread_self()), attrs->priority);
     tf_assert_same(hythread_self()->group, attrs->group);
     hylatch_count_down(attrs->end);
     return 0;
 } // start_proc

 static int start_proc_empty(void *args) {
     proc_param *attrs = (proc_param *)args;
     hylatch_count_down(attrs->start);
     hylatch_wait(attrs->end);
     return 0;
 } // start_proc_empty


 int test_hythread_self_base(void) {
     hythread_t thread;

     // check that this thread is attached to VM
     tf_assert(thread = hythread_self());

     return 0;
 } // test_hythread_self_base

 /*
 * Test tm_create(..)
 */
 int test_hythread_create(void) {
     proc_param *args;
     hythread_t thread;
     IDATA status;

     args = (proc_param*)calloc(1, sizeof(proc_param));
     tf_assert(args && "alloc proc_params failed");

     status = hythread_group_create(&args->group);
     tf_assert(status == TM_ERROR_NONE && "thread group creation failed");

     status = hylatch_create(&args->end, 1);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     args->priority  = 1;

     thread = (hythread_t)calloc(1, hythread_get_struct_size());
     assert(thread);
     status = hythread_create_ex(thread, args->group, 1024000, 1, NULL,
         (hythread_entrypoint_t)start_proc, (void*)args);
     tf_assert(status == TM_ERROR_NONE && "thread creation failed");

     // Wait util tested thread have finished.
     status = hylatch_wait(args->end);
     tf_assert(status == TM_ERROR_NONE && "thread finished failed");

     status = hylatch_destroy(args->end);
     tf_assert(status == TM_ERROR_NONE && "latch destroy failed");

     hythread_sleep(SLEEP_TIME);
     hythread_group_release(args->group);

     free(args);

     return TEST_PASSED;
 }

 /**
 * Waits until count of running threads in specified group
 * reaches 'count' or less
 */
 static void wait_for_all_treads_are_terminated(hythread_group_t group, int count)
 {
     int max_tries = 1000; // Maximum count of iterations

     while (max_tries--)
     {
         int n = 0;
         hythread_t thread;

         hythread_iterator_t iterator = hythread_iterator_create(group);

         while(hythread_iterator_has_next(iterator)) {
             thread = hythread_iterator_next(&iterator);

             if (!hythread_is_terminated(thread))
                 ++n;
         }

         hythread_iterator_release(&iterator);

         if (n <= count)
             break;

         hythread_yield();
     }

     // 0.1s to let system threads finish their work
     hythread_sleep(100);
 } // wait_for_all_treads_are_terminated

 int test_hythread_iterator(void) {
     int i;
     const int n = 100;
     IDATA status;
     proc_param *args;
     hythread_t thread = NULL;
     hythread_iterator_t iterator;

     args = (proc_param*)calloc(1, sizeof(proc_param));
     tf_assert(args && "alloc proc_params failed");

     status = hythread_group_create(&args->group);
     tf_assert(status == TM_ERROR_NONE && "create group failed");

     status = hylatch_create(&args->start, n);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     status = hylatch_create(&args->end, 1);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     for (i = 0; i < n; i++) {
         thread = (hythread_t)calloc(1, hythread_get_struct_size());
         assert(thread);
         status = hythread_create_ex(thread, args->group, 0, 0, NULL,
             (hythread_entrypoint_t)start_proc_empty, (void*)args);
         tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
     }

     // Wait util all threads have started.
     status = hylatch_wait(args->start);
     tf_assert(status == TM_ERROR_NONE && "start waiting failed");

     iterator = hythread_iterator_create(args->group);
     tf_assert(iterator && "interator creation failed");

     printf ("iterator size: %d\n", (int)hythread_iterator_size(iterator));
     tf_assert(hythread_iterator_size(iterator) == n && "iterator size");

     i = 0;
     while(hythread_iterator_has_next(iterator)) {
         i++;
         thread = hythread_iterator_next(&iterator);
         tf_assert(hythread_is_alive(thread) && "thread is not alive!");
     }

     tf_assert(i == n && "wrong number of tested threads");

     status = hythread_iterator_release(&iterator);
     tf_assert(status == TM_ERROR_NONE && "release iterator failed");

     // Notify all threads
     status = hylatch_count_down(args->end);
     tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

     wait_for_all_treads_are_terminated(args->group, i - n);

     status = hylatch_destroy(args->start);
     tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

     status = hylatch_destroy(args->end);
     tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

     hythread_sleep(SLEEP_TIME);
     hythread_group_release(args->group);

     free(args);

     return TEST_PASSED;
 } // test_hythread_iterator

 int test_hythread_iterator_default(void) {
     int i;
     const int n = 100;
     IDATA status;
     proc_param *args;
     hythread_t thread = NULL;
     hythread_iterator_t iterator;

     args = (proc_param*)calloc(1, sizeof(proc_param));
     tf_assert(args && "alloc proc_params failed");

     status = hylatch_create(&args->start, n);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     status = hylatch_create(&args->end, 1);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     for (i = 0; i < n; i++) {
         status = hythread_create(NULL, 0, 0, 0,
             (hythread_entrypoint_t)start_proc_empty, (void*)args);
         tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
     }

     // Wait util all threads have started.
     status = hylatch_wait(args->start);
     tf_assert(status == TM_ERROR_NONE && "start waiting failed");

     iterator = hythread_iterator_create(args->group);
     tf_assert(iterator && "interator creation failed");

     printf ("default group iterator size: %d\n", (int)hythread_iterator_size(iterator));
     tf_assert(hythread_iterator_size(iterator) >= n && "iterator size");

     i = 0;
     while(hythread_iterator_has_next(iterator)) {
         thread = hythread_iterator_next(&iterator);
         if (hythread_is_alive(thread)) {
             i++;
         }
     }
     tf_assert(i >= n && "wrong number of tested threads");

     status = hythread_iterator_release(&iterator);
     tf_assert(status == TM_ERROR_NONE && "release iterator failed");

     // Notify all threads
     status = hylatch_count_down(args->end);
     tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

     wait_for_all_treads_are_terminated(NULL, i - n);

     status = hylatch_destroy(args->start);
     tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

     status = hylatch_destroy(args->end);
     tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

     free(args);

     return TEST_PASSED;
 } // test_hythread_iterator_default

 /*
 * Test tm_create(..)
 */
 int test_hythread_create_many(void){
     int i;
     const int n = 10;
     IDATA status;
     proc_param *args;
     hythread_t thread;

     args = (proc_param*)calloc(1, sizeof(proc_param));
     tf_assert(args && "alloc proc_params failed");

     status = hythread_group_create(&args->group);
     tf_assert(status == TM_ERROR_NONE && "create group failed");

     status = hylatch_create(&args->start, n);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     status = hylatch_create(&args->end, 1);
     tf_assert(status == TM_ERROR_NONE && "latch creation failed");

     for (i = 0; i < n; i++) {
         thread = (hythread_t)calloc(1, hythread_get_struct_size());
         assert(thread);
         status = hythread_create_ex(thread, args->group, 0, 0, NULL,
             (hythread_entrypoint_t)start_proc_empty, (void*)args);
         tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
     }

     // Wait util all threads have started.
     status = hylatch_wait(args->start);
     tf_assert(status == TM_ERROR_NONE && "start waiting failed");

     // huck to get group_count from hythread_group_t structure
     i = hythread_iterator_size((hythread_iterator_t)thread);
     tf_assert(i == n && "incorrect threads count");

     // Notify all threads
     status = hylatch_count_down(args->end);
     tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

     wait_for_all_treads_are_terminated(args->group, i - n);

     status = hylatch_destroy(args->start);
     tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

     status = hylatch_destroy(args->end);
     tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

     hythread_sleep(SLEEP_TIME);
     hythread_group_release(args->group);

     free(args);

     return TEST_PASSED;
 } // test_hythread_create_many

 TEST_LIST_START
     TEST(test_hythread_self_base)
     TEST(test_hythread_create)
     TEST(test_hythread_create_many)
     TEST(test_hythread_iterator)
     TEST(test_hythread_iterator_default)
 TEST_LIST_END;
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <stdio.h>
	#include "testframe.h"
	#include "thread_unit_test_utils.h"
	#include "thread_manager.h"


	typedef struct proc_param {
	hythread_group_t group;
	UDATA stacksize;
	jint priority;
	hylatch_t start;
	hylatch_t end;
	} proc_param;


	static int start_proc(void *args) {
	proc_param attrs = (proc_param )args;
	tf_assert_same(hythread_get_priority(hythread_self()), attrs->priority);
	tf_assert_same(hythread_self()->group, attrs->group);
	hylatch_count_down(attrs->end);
	return 0;
	} // start_proc

	static int start_proc_empty(void *args) {
	proc_param attrs = (proc_param )args;
	hylatch_count_down(attrs->start);
	hylatch_wait(attrs->end);
	return 0;
	} // start_proc_empty


	int test_hythread_self_base(void) {
	hythread_t thread;

	// check that this thread is attached to VM
	tf_assert(thread = hythread_self());

	return 0;
	} // test_hythread_self_base

	/*
	* Test tm_create(..)
	*/
	int test_hythread_create(void) {
	proc_param *args;
	hythread_t thread;
	IDATA status;

	args = (proc_param*)calloc(1, sizeof(proc_param));
	tf_assert(args && "alloc proc_params failed");

	status = hythread_group_create(&args->group);
	tf_assert(status == TM_ERROR_NONE && "thread group creation failed");

	status = hylatch_create(&args->end, 1);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	args->priority = 1;

	thread = (hythread_t)calloc(1, hythread_get_struct_size());
	assert(thread);
	status = hythread_create_ex(thread, args->group, 1024000, 1, NULL,
	(hythread_entrypoint_t)start_proc, (void*)args);
	tf_assert(status == TM_ERROR_NONE && "thread creation failed");

	// Wait util tested thread have finished.
	status = hylatch_wait(args->end);
	tf_assert(status == TM_ERROR_NONE && "thread finished failed");

	status = hylatch_destroy(args->end);
	tf_assert(status == TM_ERROR_NONE && "latch destroy failed");

	hythread_sleep(SLEEP_TIME);
	hythread_group_release(args->group);

	free(args);

	return TEST_PASSED;
	}

	/**
	* Waits until count of running threads in specified group
	* reaches 'count' or less
	*/
	static void wait_for_all_treads_are_terminated(hythread_group_t group, int count)
	{
	int max_tries = 1000; // Maximum count of iterations

	while (max_tries--)
	{
	int n = 0;
	hythread_t thread;

	hythread_iterator_t iterator = hythread_iterator_create(group);

	while(hythread_iterator_has_next(iterator)) {
	thread = hythread_iterator_next(&iterator);

	if (!hythread_is_terminated(thread))
	++n;
	}

	hythread_iterator_release(&iterator);

	if (n <= count)
	break;

	hythread_yield();
	}

	// 0.1s to let system threads finish their work
	hythread_sleep(100);
	} // wait_for_all_treads_are_terminated

	int test_hythread_iterator(void) {
	int i;
	const int n = 100;
	IDATA status;
	proc_param *args;
	hythread_t thread = NULL;
	hythread_iterator_t iterator;

	args = (proc_param*)calloc(1, sizeof(proc_param));
	tf_assert(args && "alloc proc_params failed");

	status = hythread_group_create(&args->group);
	tf_assert(status == TM_ERROR_NONE && "create group failed");

	status = hylatch_create(&args->start, n);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	status = hylatch_create(&args->end, 1);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	for (i = 0; i < n; i++) {
	thread = (hythread_t)calloc(1, hythread_get_struct_size());
	assert(thread);
	status = hythread_create_ex(thread, args->group, 0, 0, NULL,
	(hythread_entrypoint_t)start_proc_empty, (void*)args);
	tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
	}

	// Wait util all threads have started.
	status = hylatch_wait(args->start);
	tf_assert(status == TM_ERROR_NONE && "start waiting failed");

	iterator = hythread_iterator_create(args->group);
	tf_assert(iterator && "interator creation failed");

	printf ("iterator size: %d\n", (int)hythread_iterator_size(iterator));
	tf_assert(hythread_iterator_size(iterator) == n && "iterator size");

	i = 0;
	while(hythread_iterator_has_next(iterator)) {
	i++;
	thread = hythread_iterator_next(&iterator);
	tf_assert(hythread_is_alive(thread) && "thread is not alive!");
	}

	tf_assert(i == n && "wrong number of tested threads");

	status = hythread_iterator_release(&iterator);
	tf_assert(status == TM_ERROR_NONE && "release iterator failed");

	// Notify all threads
	status = hylatch_count_down(args->end);
	tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

	wait_for_all_treads_are_terminated(args->group, i - n);

	status = hylatch_destroy(args->start);
	tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

	status = hylatch_destroy(args->end);
	tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

	hythread_sleep(SLEEP_TIME);
	hythread_group_release(args->group);

	free(args);

	return TEST_PASSED;
	} // test_hythread_iterator

	int test_hythread_iterator_default(void) {
	int i;
	const int n = 100;
	IDATA status;
	proc_param *args;
	hythread_t thread = NULL;
	hythread_iterator_t iterator;

	args = (proc_param*)calloc(1, sizeof(proc_param));
	tf_assert(args && "alloc proc_params failed");

	status = hylatch_create(&args->start, n);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	status = hylatch_create(&args->end, 1);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	for (i = 0; i < n; i++) {
	status = hythread_create(NULL, 0, 0, 0,
	(hythread_entrypoint_t)start_proc_empty, (void*)args);
	tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
	}

	// Wait util all threads have started.
	status = hylatch_wait(args->start);
	tf_assert(status == TM_ERROR_NONE && "start waiting failed");

	iterator = hythread_iterator_create(args->group);
	tf_assert(iterator && "interator creation failed");

	printf ("default group iterator size: %d\n", (int)hythread_iterator_size(iterator));
	tf_assert(hythread_iterator_size(iterator) >= n && "iterator size");

	i = 0;
	while(hythread_iterator_has_next(iterator)) {
	thread = hythread_iterator_next(&iterator);
	if (hythread_is_alive(thread)) {
	i++;
	}
	}
	tf_assert(i >= n && "wrong number of tested threads");

	status = hythread_iterator_release(&iterator);
	tf_assert(status == TM_ERROR_NONE && "release iterator failed");

	// Notify all threads
	status = hylatch_count_down(args->end);
	tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

	wait_for_all_treads_are_terminated(NULL, i - n);

	status = hylatch_destroy(args->start);
	tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

	status = hylatch_destroy(args->end);
	tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

	free(args);

	return TEST_PASSED;
	} // test_hythread_iterator_default

	/*
	* Test tm_create(..)
	*/
	int test_hythread_create_many(void){
	int i;
	const int n = 10;
	IDATA status;
	proc_param *args;
	hythread_t thread;

	args = (proc_param*)calloc(1, sizeof(proc_param));
	tf_assert(args && "alloc proc_params failed");

	status = hythread_group_create(&args->group);
	tf_assert(status == TM_ERROR_NONE && "create group failed");

	status = hylatch_create(&args->start, n);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	status = hylatch_create(&args->end, 1);
	tf_assert(status == TM_ERROR_NONE && "latch creation failed");

	for (i = 0; i < n; i++) {
	thread = (hythread_t)calloc(1, hythread_get_struct_size());
	assert(thread);
	status = hythread_create_ex(thread, args->group, 0, 0, NULL,
	(hythread_entrypoint_t)start_proc_empty, (void*)args);
	tf_assert(status == TM_ERROR_NONE && "test thread creation failed");
	}

	// Wait util all threads have started.
	status = hylatch_wait(args->start);
	tf_assert(status == TM_ERROR_NONE && "start waiting failed");

	// huck to get group_count from hythread_group_t structure
	i = hythread_iterator_size((hythread_iterator_t)thread);
	tf_assert(i == n && "incorrect threads count");

	// Notify all threads
	status = hylatch_count_down(args->end);
	tf_assert(status == TM_ERROR_NONE && "all threads notify failed");

	wait_for_all_treads_are_terminated(args->group, i - n);

	status = hylatch_destroy(args->start);
	tf_assert(status == TM_ERROR_NONE && "start latch destroy failed");

	status = hylatch_destroy(args->end);
	tf_assert(status == TM_ERROR_NONE && "end latch destroy failed");

	hythread_sleep(SLEEP_TIME);
	hythread_group_release(args->group);

	free(args);

	return TEST_PASSED;
	} // test_hythread_create_many

	TEST_LIST_START
	TEST(test_hythread_self_base)
	TEST(test_hythread_create)
	TEST(test_hythread_create_many)
	TEST(test_hythread_iterator)
	TEST(test_hythread_iterator_default)
	TEST_LIST_END;