void printTime() { char *video = (char *) 0xb8000; int clock_index=(24*80+74)*2; char hour,min; sys_hour(&hour); sys_min(&min); video[clock_index+=2]=(hour/10+'0'); video[clock_index+=2]=(hour%10+'0'); video[clock_index+=2]=(':'); video[clock_index+=2]=(min/10+'0'); video[clock_index+=2]=(min%10+'0'); }
void int_08() { //printf("entre a timer\n"); if(ticks==19*30){ char *video = (char *) 0xb8000; int clock_index=(24*80+74)*2; char hour,min; sys_hour(&hour); sys_min(&min); video[clock_index+=2]=(hour/10+'0'); video[clock_index+=2]=(hour%10+'0'); video[clock_index+=2]=(':'); video[clock_index+=2]=(min/10+'0'); video[clock_index+=2]=(min%10+'0'); ticks=0; } ticks++; //printf("volvi\n"); }
static int test_item9(void) { int rc = TC_PASS; static TYPE_VALUE target_addr[MAX_BUFFER_SIZE * 2]; static TYPE_VALUE source_addr[MAX_BUFFER_SIZE * 2]; TYPE_VALUE source_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; long* pSyncMult = NULL; TYPE_VALUE* pWrkMult = NULL; int pSyncNum = 2; int pWrkNum = 2; num_proc = _num_pes(); my_proc = _my_pe(); pSyncMult = shmalloc(sizeof(*pSyncMult) * pSyncNum * _SHMEM_REDUCE_SYNC_SIZE); if (pSyncMult) { TYPE_VALUE value = DEFAULT_VALUE; int i = 0; int j = 0; long cur_buf_size = 0; for ( j = 0; j < pSyncNum * _SHMEM_REDUCE_SYNC_SIZE; j++ ) { pSyncMult[j] = _SHMEM_SYNC_VALUE; } /* Give some time to all PE for setting their values */ shmem_barrier_all(); pWrkMult = shmalloc(sizeof(*pWrkMult) * pWrkNum * sys_max(MAX_BUFFER_SIZE, _SHMEM_REDUCE_MIN_WRKDATA_SIZE)); if (pWrkMult) { value = DEFAULT_VALUE; source_value = (TYPE_VALUE)(my_proc + 1); fill_buffer((void *)source_addr, MAX_BUFFER_SIZE * 2, (void *)&source_value, sizeof(source_value)); fill_buffer((void *)target_addr, MAX_BUFFER_SIZE * 2, (void *)&value, sizeof(value)); shmem_barrier_all(); for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { cur_buf_size = sys_max(1, (i + 1) * MAX_BUFFER_SIZE / __cycle_count); /* Set initial target value */ value = DEFAULT_VALUE; /* Set my value */ source_value = (TYPE_VALUE)(my_proc + 1); /* Define expected value */ expect_value = 0; if (my_proc % 2) expect_value = DEFAULT_VALUE; else { int k = num_proc; while (k) { if (k % 2) expect_value |= k; k--; } } int in_active_set = check_within_active_set(0, 1, ((num_proc / 2) + (num_proc % 2)), my_proc, num_proc); if ( in_active_set ) { /* Put value to peer */ FUNC_VALUE(target_addr + (i % 2) * MAX_BUFFER_SIZE, source_addr + (i % 2) * MAX_BUFFER_SIZE, cur_buf_size, 0, 1, ((num_proc / 2) + (num_proc % 2)), pWrkMult + (i % pWrkNum) * sys_max(MAX_BUFFER_SIZE, _SHMEM_REDUCE_MIN_WRKDATA_SIZE), pSyncMult + (i % pSyncNum) * _SHMEM_REDUCE_SYNC_SIZE); rc = (!compare_buffer_with_const(target_addr + (i % 2) * MAX_BUFFER_SIZE, cur_buf_size, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my#%d source = %lld expected = %lld actual = %lld buffer size = %lld\n", my_proc, (INT64_TYPE)source_value, (INT64_TYPE)expect_value, (INT64_TYPE)value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = target_addr + (i % 2) * MAX_BUFFER_SIZE; int odd_index = compare_buffer_with_const(check_addr, cur_buf_size, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } fill_buffer((void *)(source_addr + (i % 2) * MAX_BUFFER_SIZE), cur_buf_size, (void *)&source_value, sizeof(source_value)); fill_buffer((void *)(target_addr + (i % 2) * MAX_BUFFER_SIZE ), cur_buf_size, (void *)&value, sizeof(value)); } } shfree(pWrkMult); } else { rc = TC_SETUP_FAIL; } shfree(pSyncMult); } else { rc = TC_SETUP_FAIL; } return rc; }
static int test_item8(void) { int rc = TC_PASS; static TYPE_VALUE target_addr[MAX_BUFFER_SIZE]; static TYPE_VALUE source_addr[MAX_BUFFER_SIZE]; TYPE_VALUE source_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; num_proc = _num_pes(); my_proc = _my_pe(); { TYPE_VALUE value = DEFAULT_VALUE; int i = 0; int j = 0; long cur_buf_size = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { cur_buf_size = sys_max(1, (i + 1) * MAX_BUFFER_SIZE / __cycle_count); pWrk = shmalloc(sizeof(*pWrk) * sys_max(cur_buf_size/2 + 1, _SHMEM_REDUCE_MIN_WRKDATA_SIZE)); if (pWrk) { /* Set initial target value */ value = DEFAULT_VALUE; fill_buffer((void *)target_addr, cur_buf_size, (void *)&value, sizeof(value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Set my value */ source_value = (TYPE_VALUE)(my_proc + 1); fill_buffer((void *)source_addr, cur_buf_size, (void *)&source_value, sizeof(source_value)); /* Define expected value */ expect_value = 0; if (my_proc % 2) expect_value = DEFAULT_VALUE; else { int k = num_proc; while (k) { if (k % 2) expect_value |= k; k--; } } /* This guarantees that PE set initial value before peer change one */ for ( j = 0; j < _SHMEM_REDUCE_SYNC_SIZE; j++ ) { pSync[j] = _SHMEM_SYNC_VALUE; } shmem_barrier_all(); int in_active_set = check_within_active_set(0, 1, ((num_proc / 2) + (num_proc % 2)), my_proc, num_proc); if ( in_active_set ) { /* Put value to peer */ FUNC_VALUE(target_addr, source_addr, cur_buf_size, 0, 1, ((num_proc / 2) + (num_proc % 2)), pWrk, pSync); } /* Get value put by peer: * These routines start the remote transfer and may return before the data * is delivered to the remote PE */ shmem_barrier_all(); { int wait = WAIT_COUNT; while (wait--) { value = *target_addr; if (expect_value == value) break; sleep(1); } } if ( in_active_set ) { rc = (!compare_buffer_with_const(target_addr, cur_buf_size, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my#%d source = %lld expected = %lld actual = %lld buffer size = %lld\n", my_proc, (INT64_TYPE)source_value, (INT64_TYPE)expect_value, (INT64_TYPE)value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = target_addr; int odd_index = compare_buffer_with_const(check_addr, cur_buf_size, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } } shfree(pWrk); } else { rc = TC_SETUP_FAIL; } } } return rc; }
static int test_item6(void) { int rc = TC_PASS; TYPE_VALUE* target_addr = NULL; TYPE_VALUE* source_addr = NULL; TYPE_VALUE source_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; num_proc = _num_pes(); my_proc = _my_pe(); target_addr = (TYPE_VALUE*)shmalloc(sizeof(*target_addr) * __max_buffer_size); source_addr = (TYPE_VALUE*)shmalloc(sizeof(*source_addr) * __max_buffer_size); if (target_addr && source_addr) { TYPE_VALUE value = DEFAULT_VALUE; int i = 0; int j = 0; long cur_buf_size = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { cur_buf_size = sys_max(1, (i + 1) * __max_buffer_size / __cycle_count); pWrk = shmalloc(sizeof(*pWrk) * sys_max(cur_buf_size/2 + 1, _SHMEM_REDUCE_MIN_WRKDATA_SIZE)); if (pWrk) { /* Set initial target value */ value = DEFAULT_VALUE; fill_buffer((void *)target_addr, cur_buf_size, (void *)&value, sizeof(value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Set my value */ source_value = ( my_proc < OVERFLOW_FACTORIAL_LIMIT ? (TYPE_VALUE)(my_proc + 1) : 1); fill_buffer((void *)source_addr, cur_buf_size, (void *)&source_value, sizeof(source_value)); /* Define expected value */ expect_value = 1; { int k = ( num_proc <= OVERFLOW_FACTORIAL_LIMIT ? num_proc : OVERFLOW_FACTORIAL_LIMIT); while (k) expect_value *= k--; } /* This guarantees that PE set initial value before peer change one */ for ( j = 0; j < _SHMEM_REDUCE_SYNC_SIZE; j++ ) { pSync[j] = _SHMEM_SYNC_VALUE; } shmem_barrier_all(); /* Put value to peer */ FUNC_VALUE(target_addr, source_addr, cur_buf_size, 0, 0, num_proc, pWrk, pSync); /* Get value put by peer: * These routines start the remote transfer and may return before the data * is delivered to the remote PE */ shmem_barrier_all(); { int wait = WAIT_COUNT; while (wait--) { value = *target_addr; if (sys_fcompare(expect_value, value)) break; sleep(1); } } rc = (!compare_buffer_with_const_longdouble(target_addr, cur_buf_size, expect_value) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my#%d source = %Lf expected = %Lf actual = %Lf buffer size = %lld\n", my_proc, (long double)source_value, (long double)expect_value, (long double)value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = target_addr; int odd_index = compare_buffer_with_const_longdouble(check_addr, cur_buf_size, expect_value); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } shfree(pWrk); } else { rc = TC_SETUP_FAIL; } } } else { rc = TC_SETUP_FAIL; } if (source_addr) { shfree(source_addr); } if (target_addr) { shfree(target_addr); } return rc; }
static int test_item5(void) { int rc = TC_PASS; static TYPE_VALUE shmem_addr[MAX_BUFFER_SIZE]; static TYPE_VALUE send_addr[MAX_BUFFER_SIZE]; TYPE_VALUE my_value = 0; TYPE_VALUE peer_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; int peer_proc = 0; num_proc = _num_pes(); my_proc = _my_pe(); { INT64_TYPE i = 0; long cur_buf_size = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { cur_buf_size = sys_max(1, (i + 1) * MAX_BUFFER_SIZE / __cycle_count); /* Set my value */ my_value = (-1); fill_buffer((void *)shmem_addr, cur_buf_size, (void *)&my_value, sizeof(my_value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Define peer and it value */ peer_proc = (my_proc + 1) % num_proc; peer_value = (peer_proc % 2 ? 1 : -1) * (i * (MAX_VALUE / __cycle_count)); fill_buffer((void *)send_addr, cur_buf_size, (void *)&peer_value, sizeof(peer_value)); /* Define expected value */ expect_value = (my_proc % 2 ? 1 : -1) * (i * (MAX_VALUE / __cycle_count)); /* Get value put by peer */ FUNC_VALUE(shmem_addr, send_addr, cur_buf_size, peer_proc); /* Get value put by peer: * These routines start the remote transfer and may return before the data * is delivered to the remote PE */ wait_for_put_completion(peer_proc,10 /* wait for 10 secs */); rc = (!compare_buffer_with_const_longdouble(shmem_addr, cur_buf_size, expect_value) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my(#%d:%Lf) peer(#%d:%Lf) expected = %Lf buffer size = %lld\n", my_proc, (long double)my_value, peer_proc, (long double)peer_value, (long double)expect_value, (INT64_TYPE)1); if (rc) { TYPE_VALUE* check_addr = shmem_addr; int odd_index = compare_buffer_with_const_longdouble(check_addr, cur_buf_size, expect_value); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } } } return rc; }
static int test_item5(void) { int rc = TC_PASS; static TYPE_VALUE shmem_addr[MAX_BUFFER_SIZE]; static TYPE_VALUE recv_addr[MAX_BUFFER_SIZE]; TYPE_VALUE my_value = 0; TYPE_VALUE peer_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; int peer_proc = 0; num_proc = _num_pes(); my_proc = _my_pe(); { INT64_TYPE i = 0; long cur_buf_size = 0; my_value = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { /* Set my value */ my_value = (my_proc % 2 ? 1 : -1) * (i * (MAX_VALUE / __cycle_count)); cur_buf_size = sys_max(1, (i + 1) * MAX_BUFFER_SIZE / __cycle_count); fill_buffer((void *)shmem_addr, cur_buf_size, (void *)&my_value, sizeof(my_value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Define peer and it value */ peer_proc = (my_proc + 1) % num_proc; peer_value = (peer_proc % 2 ? 1 : -1) * (i * (MAX_VALUE / __cycle_count)); /* Define expected value */ expect_value = peer_value; /* Get value from peer */ FUNC_VALUE(recv_addr, shmem_addr, cur_buf_size, peer_proc); rc = (!compare_buffer_with_const(recv_addr, cur_buf_size, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my(#%d:%Lf) peer(#%d:%Lf) expected = %Lf buffer size = %lld\n", my_proc, (long double)my_value, peer_proc, (long double)peer_value, (long double)expect_value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = recv_addr; int odd_index = compare_buffer_with_const(check_addr, cur_buf_size, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } shmem_barrier_all(); } } return rc; }
static int test_item3(void) { int rc = TC_PASS; TYPE_VALUE* shmem_addr = NULL; TYPE_VALUE* recv_addr = NULL; TYPE_VALUE my_value = 0; TYPE_VALUE peer_value = 0; TYPE_VALUE expect_value = 0; int my_proc = 0; int peer_proc = 0; my_proc = _my_pe(); shmem_addr = (TYPE_VALUE*)shmalloc(sizeof(*shmem_addr) * __max_buffer_size); recv_addr = (TYPE_VALUE*)sys_malloc(sizeof(*recv_addr) * __max_buffer_size); if (shmem_addr && recv_addr) { INT64_TYPE i = 0; long cur_buf_size = 0; my_value = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { /* Set my value */ my_value = (my_proc % 2 ? 1 : -1) * (i * (MAX_VALUE / __cycle_count)); cur_buf_size = sys_max(1, (i + 1) * __max_buffer_size / __cycle_count); fill_buffer((void *)shmem_addr, cur_buf_size, (void *)&my_value, sizeof(my_value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Define peer and it value */ peer_proc = my_proc; peer_value = my_value; /* Define expected value */ expect_value = peer_value; /* Get value from peer */ FUNC_VALUE(recv_addr, shmem_addr, cur_buf_size, peer_proc); rc = (!compare_buffer_with_const(recv_addr, cur_buf_size, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my(#%d:%lld) peer(#%d:%lld) expected = %lld buffer size = %lld\n", my_proc, (INT64_TYPE)my_value, peer_proc, (INT64_TYPE)peer_value, (INT64_TYPE)expect_value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = recv_addr; int odd_index = compare_buffer_with_const(check_addr, cur_buf_size, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - odd_index - 1); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } shmem_barrier_all(); } } else { rc = TC_SETUP_FAIL; } if (recv_addr) { sys_free(recv_addr); } if (shmem_addr) { shfree(shmem_addr); } return rc; }
static int test_item7(void) { int rc = TC_PASS; static TYPE_VALUE shmem_addr[MAX_BUFFER_SIZE * 2]; static TYPE_VALUE send_addr[MAX_BUFFER_SIZE * 2]; TYPE_VALUE my_value = 0; TYPE_VALUE peer_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; int root_proc = 0; long* pSyncMult = NULL; int pSyncNum = 2; num_proc = _num_pes(); my_proc = _my_pe(); pSyncMult = shmalloc(sizeof(*pSyncMult) * pSyncNum * _SHMEM_COLLECT_SYNC_SIZE); if (!pSyncMult) { rc = TC_SETUP_FAIL; } if (rc == TC_PASS) { int i = 0; int j = 0; for ( j = 0; j < pSyncNum * _SHMEM_COLLECT_SYNC_SIZE; j++ ) { pSyncMult[j] = _SHMEM_SYNC_VALUE; } /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Set root */ root_proc = 0; my_value = DEFAULT_VALUE; peer_value = MAX_VALUE; expect_value = (my_proc == root_proc ? DEFAULT_VALUE : peer_value); fill_buffer((void *)send_addr, MAX_BUFFER_SIZE * 2, (void *)&peer_value, sizeof(peer_value)); fill_buffer((void *)shmem_addr, MAX_BUFFER_SIZE * 2, (void *)&my_value, sizeof(my_value)); shmem_barrier_all(); for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { /* Put value to peer */ FUNC_VALUE(shmem_addr + (i % 2) * MAX_BUFFER_SIZE, send_addr + (i % 2) * MAX_BUFFER_SIZE, MAX_BUFFER_SIZE, root_proc, 0, 0, num_proc, pSyncMult + (i % pSyncNum) * _SHMEM_COLLECT_SYNC_SIZE); rc = (!compare_buffer_with_const(shmem_addr + (i % 2) * MAX_BUFFER_SIZE, MAX_BUFFER_SIZE, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my#%d root(#%d:%lld) expected = %lld actual = %lld buffer size = %lld\n", my_proc, root_proc, (INT64_TYPE)peer_value, (INT64_TYPE)expect_value, (INT64_TYPE)(*shmem_addr), (INT64_TYPE)MAX_BUFFER_SIZE); if (rc) { TYPE_VALUE* check_addr = shmem_addr + (i % 2) * MAX_BUFFER_SIZE; int odd_index = compare_buffer_with_const(check_addr, MAX_BUFFER_SIZE, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, MAX_BUFFER_SIZE - show_index); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } fill_buffer((void *)(send_addr + (i % 2) * MAX_BUFFER_SIZE), MAX_BUFFER_SIZE, (void *)&peer_value, sizeof(peer_value)); fill_buffer((void *)(shmem_addr + (i % 2) * MAX_BUFFER_SIZE ), MAX_BUFFER_SIZE, (void *)&my_value, sizeof(my_value)); } } if (pSyncMult) { shfree(pSyncMult); } return rc; }
static int test_item6(void) { int rc = TC_PASS; static TYPE_VALUE shmem_addr[MAX_BUFFER_SIZE]; static TYPE_VALUE send_addr[MAX_BUFFER_SIZE]; TYPE_VALUE my_value = 0; TYPE_VALUE peer_value = 0; TYPE_VALUE expect_value = 0; int num_proc = 0; int my_proc = 0; int root_proc = 0; num_proc = _num_pes(); my_proc = _my_pe(); { TYPE_VALUE value = DEFAULT_VALUE; int i = 0; int j = 0; long cur_buf_size = 0; for (i = 0; (i < __cycle_count) && (rc == TC_PASS); i++) { cur_buf_size = sys_max(1, (i + 1) * MAX_BUFFER_SIZE / __cycle_count); /* Set my value */ my_value = DEFAULT_VALUE; fill_buffer((void *)shmem_addr, cur_buf_size, (void *)&my_value, sizeof(my_value)); /* Give some time to all PE for setting their values */ shmem_barrier_all(); /* Define peer and it value */ peer_value = (i * (MAX_VALUE / __cycle_count)); fill_buffer((void *)send_addr, cur_buf_size, (void *)&peer_value, sizeof(peer_value)); /* Set root */ root_proc = 0; /* Define expected value */ expect_value = (((my_proc % 2) == 0) && (my_proc != root_proc) ? peer_value : DEFAULT_VALUE); /* This guarantees that PE set initial value before peer change one */ for ( j = 0; j < _SHMEM_COLLECT_SYNC_SIZE; j++ ) { pSync[j] = _SHMEM_SYNC_VALUE; } shmem_barrier_all(); /* Put value to peer */ if ((my_proc % 2) == 0) { FUNC_VALUE(shmem_addr, send_addr, cur_buf_size, root_proc, 0, 1, ((num_proc / 2) + (num_proc % 2)), pSync); } /* Get value put by peer: * These routines start the remote transfer and may return before the data * is delivered to the remote PE */ shmem_barrier_all(); { int wait = WAIT_COUNT; while (wait--) { value = *shmem_addr; if (expect_value == value) break; sleep(1); } } rc = (!compare_buffer_with_const(shmem_addr, cur_buf_size, &expect_value, sizeof(expect_value)) ? TC_PASS : TC_FAIL); log_debug(OSH_TC, "my#%d root(#%d:%lld) expected = %lld actual = %lld buffer size = %lld\n", my_proc, root_proc, (INT64_TYPE)peer_value, (INT64_TYPE)expect_value, (INT64_TYPE)value, (INT64_TYPE)cur_buf_size); if (rc) { TYPE_VALUE* check_addr = shmem_addr; int odd_index = compare_buffer_with_const(check_addr, cur_buf_size, &expect_value, sizeof(expect_value)); int show_index = (odd_index > 1 ? odd_index - 2 : 0); int show_size = sizeof(*check_addr) * sys_min(3, cur_buf_size - show_index); log_debug(OSH_TC, "index of incorrect value: 0x%08X (%d)\n", odd_index - 1, odd_index - 1); log_debug(OSH_TC, "buffer interval: 0x%08X - 0x%08X\n", show_index, show_index + show_size); show_buffer(check_addr + show_index, show_size); } } } return rc; }