/*
* Using DISABLED_ to run this test separately, because the thread weight can only
* be set once. Later changes to omrthread_global("thread_weight") are ignored.
*/
TEST_F(ThreadCreateTest, DISABLED_SetAttrThreadWeight)
{
uintptr_t status = 0;
const char **weight;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
weight = (const char **)omrthread_global((char *)"thread_weight");
*weight = "heavy";
expected.osThreadweight = OS_HEAVY_WEIGHT;
if (J9THREAD_VERBOSE(omrthread_attr_init(&attr)) != J9THREAD_SUCCESS) {
status |= INIT_FAILED;
omrTestEnv->log(LEVEL_ERROR, "failed to init heavyweight thread\n");
}
status |= isAttrOk(&expected, attr);
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
END_IF_FAILED(status);
*weight = "medium";
expected.osThreadweight = OS_HEAVY_WEIGHT;
if (J9THREAD_VERBOSE(omrthread_attr_init(&attr)) != J9THREAD_SUCCESS) {
status |= INIT_FAILED;
omrTestEnv->log(LEVEL_ERROR, "failed to init mediumweight thread\n");
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrDefault)
{
uintptr_t status = 0;
uintptr_t rc = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
rc = J9THREAD_VERBOSE(omrthread_attr_init(&attr));
if (rc != J9THREAD_SUCCESS) {
status |= INIT_FAILED;
}
status |= isAttrOk(&expected, attr);
rc = J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
if (rc != J9THREAD_SUCCESS) {
status |= DESTROY_FAILED;
}
if (attr != NULL) {
omrTestEnv->log(LEVEL_ERROR, "destroy didn't NULL attr\n");
status |= DESTROY_FAILED;
}
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrStacksize)
{
uintptr_t status = 0;
uintptr_t rc = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
rc = J9THREAD_VERBOSE(omrthread_attr_set_stacksize(&attr, STACK_DEFAULT_SIZE));
if (rc != J9THREAD_SUCCESS) {
status |= EXPECTED_VALID;
omrTestEnv->log(LEVEL_ERROR, "failed to set STACK_DEFAULT_SIZE %x (%d)\n", STACK_DEFAULT_SIZE, STACK_DEFAULT_SIZE);
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_stacksize(&attr, 0x6000)))) {
expected.stacksize = 0x6000;
expected.osStacksize = getOsStacksize(expected.stacksize);
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_stacksize(&attr, 0x7000)))) {
expected.stacksize = 0x7000;
expected.osStacksize = getOsStacksize(expected.stacksize);
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_stacksize(&attr, 0x8000)))) {
expected.stacksize = 0x8000;
expected.osStacksize = getOsStacksize(expected.stacksize);
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
rc = J9THREAD_VERBOSE(omrthread_attr_set_stacksize(&attr, 0));
if (rc != J9THREAD_SUCCESS) {
status |= EXPECTED_VALID;
omrTestEnv->log(LEVEL_ERROR, "failed to set 0 (default)\n");
}
expected.stacksize = STACK_DEFAULT_SIZE;
expected.osStacksize = getOsStacksize(STACK_DEFAULT_SIZE);
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrDestroynull)
{
uintptr_t status = 0;
uintptr_t rc = 0;
rc = J9THREAD_VERBOSE(omrthread_attr_destroy(NULL));
if (rc != J9THREAD_ERR_INVALID_ATTR) {
status |= DESTROY_FAILED;
}
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
static void
createThread(omrthread_t *newThread, uintptr_t suspend, omrthread_detachstate_t detachstate,
omrthread_entrypoint_t entryProc, void *entryArg)
{
omrthread_attr_t attr = NULL;
intptr_t rc = 0;
ASSERT_EQ(J9THREAD_SUCCESS, omrthread_attr_init(&attr));
ASSERT_EQ(J9THREAD_SUCCESS, omrthread_attr_set_detachstate(&attr, detachstate));
EXPECT_EQ(J9THREAD_SUCCESS,
rc = omrthread_create_ex(newThread, &attr, suspend, entryProc, entryArg));
if (rc & J9THREAD_ERR_OS_ERRNO_SET) {
printf("omrthread_create_ex() returned os_errno=%d\n", (int)omrthread_get_os_errno());
}
ASSERT_EQ(J9THREAD_SUCCESS, omrthread_attr_destroy(&attr));
}
TEST_F(ThreadCreateTest, SetAttrBadPriority)
{
uintptr_t status = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
/* set the schedpolicy to explicit so that priorities are used by thread creation */
expected.policy = J9THREAD_SCHEDPOLICY_OTHER;
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
expected.osInheritsched = OS_PTHREAD_EXPLICIT_SCHED;
J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_OTHER));
expected.priority = 4;
expected.osPriority = getOsPriority(expected.priority);
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_priority(&attr, 4)))) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_priority(&attr, -1)))) {
status |= EXPECTED_INVALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_priority(&attr, 90)))) {
status |= EXPECTED_INVALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_priority(&attr, 12)))) {
status |= EXPECTED_INVALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrBadPolicy)
{
uintptr_t status = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
/* invalid value */
if (!INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, omrthread_schedpolicy_LastEnum)))) {
status |= EXPECTED_INVALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrName)
{
uintptr_t status = 0;
uintptr_t rc = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
const char *testname = "TheTestThread";
const char *testname2 = "another name";
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
expected.name = testname;
rc = J9THREAD_VERBOSE(omrthread_attr_set_name(&attr, testname));
if (INVALID_VALUE(rc)) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
expected.name = testname2;
rc = J9THREAD_VERBOSE(omrthread_attr_set_name(&attr, testname2));
if (INVALID_VALUE(rc)) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
expected.name = NULL;
rc = J9THREAD_VERBOSE(omrthread_attr_set_name(&attr, NULL));
if (INVALID_VALUE(rc)) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrInheritSched)
{
uintptr_t status = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_INHERIT)))) {
status |= EXPECTED_VALID;
}
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_priority(&attr, 6)))) {
status |= EXPECTED_VALID;
}
expected.policy = J9THREAD_SCHEDPOLICY_INHERIT;
expected.priority = 6;
expected.osPriority = getOsPriority(expected.priority);
/* expected.osPolicy is unchanged */
if (!omrthread_lib_use_realtime_scheduling()) {
expected.osInheritsched = OS_PTHREAD_INHERIT_SCHED;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_OTHER)))) {
status |= EXPECTED_VALID;
}
expected.policy = J9THREAD_SCHEDPOLICY_OTHER;
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
expected.osInheritsched = OS_PTHREAD_EXPLICIT_SCHED;
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrBadDestroy)
{
uintptr_t status = 0;
uintptr_t rc = 0;
uintptr_t *ptr = NULL;
omrthread_attr_t attr = NULL;
ptr = (uintptr_t *)malloc(sizeof(uintptr_t));
ASSERT(ptr);
*ptr = 3; /* invalid size */
attr = (omrthread_attr_t)ptr;
rc = J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
if (rc != J9THREAD_ERR_INVALID_ATTR) {
status |= DESTROY_FAILED;
}
if ((uintptr_t *)attr != ptr) {
omrTestEnv->log(LEVEL_ERROR, "destroy modified ptr\n");
status |= DESTROY_MODIFIED_PTR;
}
free(ptr);
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
TEST_F(ThreadCreateTest, SetAttrPolicy)
{
uintptr_t status = 0;
omrthread_attr_t attr = NULL;
create_attr_t expected;
initDefaultExpected(&expected);
J9THREAD_VERBOSE(omrthread_attr_init(&attr));
/*
* On Linux non-RT, RR and FIFO will fail thread creation because the
* thread priority isn't set properly. Our VM->OS mapping converts all priorities to 0
* because some versions of Linux support only priority 0 for SCHED_OTHER.
* TODO We need a different priority mapping for other scheduling policies.
*/
/*
* On AIX, one needs root permissions to create threads with RR or FIFO.
*/
expected.policy = J9THREAD_SCHEDPOLICY_RR;
if (!omrthread_lib_use_realtime_scheduling()) {
expected.osInheritsched = OS_PTHREAD_EXPLICIT_SCHED;
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
}
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_RR)))) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
#if (defined(LINUX) || defined(AIXPPC))
omrTestEnv->log(LEVEL_ERROR, " ignoring omrthread_create failure\n");
status &= ~CREATE_FAILED;
#endif /* (defined(LINUX) || defined(AIXPPC)) */
END_IF_FAILED(status);
expected.policy = J9THREAD_SCHEDPOLICY_FIFO;
if (!omrthread_lib_use_realtime_scheduling()) {
expected.osInheritsched = OS_PTHREAD_EXPLICIT_SCHED;
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
}
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_FIFO)))) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
#if (defined(LINUX) || defined(AIXPPC))
omrTestEnv->log(LEVEL_ERROR, " ignoring omrthread_create failure\n");
status &= ~CREATE_FAILED;
#endif /* (defined(LINUX) || defined(AIXPPC)) */
END_IF_FAILED(status);
expected.policy = J9THREAD_SCHEDPOLICY_INHERIT;
if (!omrthread_lib_use_realtime_scheduling()) {
expected.osInheritsched = OS_PTHREAD_INHERIT_SCHED;
}
/* expected.osPolicy unchanged */
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_INHERIT)))) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
expected.policy = J9THREAD_SCHEDPOLICY_OTHER;
if (!omrthread_lib_use_realtime_scheduling()) {
expected.osInheritsched = OS_PTHREAD_EXPLICIT_SCHED;
expected.osPolicy = getOsPolicy(expected.policy, expected.priority);
}
if (INVALID_VALUE(J9THREAD_VERBOSE(omrthread_attr_set_schedpolicy(&attr, J9THREAD_SCHEDPOLICY_OTHER)))) {
status |= EXPECTED_VALID;
}
status |= isAttrOk(&expected, attr);
END_IF_FAILED(status);
endtest:
J9THREAD_VERBOSE(omrthread_attr_destroy(&attr));
ASSERT_EQ((uintptr_t)0, status) << "Failed with Code: " << std::hex << status;
}
