int tc_against_gold_v(struct ut_suite *suite, struct ut_tcase *tcase)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(out1); i++) {
ut_assert_msg(check_data(test_out1[i], out1[i], MAX_REL_DIFF) == OK,
"p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
i, out1[i], test_out1[i], test_out1[i]/out1[i]);
}
for (i = 0; i < ARRAY_SIZE(out2); i++) {
ut_assert_msg(check_data(test_out2[i], out2[i], MAX_REL_DIFF) == OK,
"p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
i, out2[i], test_out2[i], test_out2[i]/out2[i]);
}
#if 0
// This test is not used, since the code today requires nx >= ny
for (i = 0; i < ARRAY_SIZE(out3); i++) {
ut_assert_msg(check_data(test_out3[i], out3[i], MAX_REL_DIFF) == OK,
"p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
i, out3[i], test_out3[i], test_out3[i]/out3[i]);
}
#endif
return 0;
}
int main(int argc, char *argv[])
{
// Stack variables
float test_out[500];
int testFail = 0;
int i;
printf("Running test program p_xcorr_test...\n");
// Execution setup
// Run test 1 on Arm
p_xcorr_f32(in11, in12, test_out, in11_size, in12_size);
// Check data
for ( i = 0; i < out_size1; i++ ) {
if (check_data(test_out[i],out1[i], MAX_REL_DIFF) == NOK ) {
testFail = 1;
printf("Test 1: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out1[i],test_out[i], test_out[i]/out1[i]);
}
}
// Run test 2 on Arm
p_xcorr_f32(in21, in22, test_out, in21_size, in22_size);
// Check data
for ( i = 0; i < out_size2; i++ ) {
if (check_data(test_out[i],out2[i], MAX_REL_DIFF) == NOK ) {
testFail = 1;
printf("Test 2: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out2[i],test_out[i], test_out[i]/out2[i]);
}
}
/* // This test is not used, since the code today requires nx >= ny
// Run test 3 on Arm
p_xcorr_f32(in31, in32, test_out, in31_size, in32_size, 1, team0);
// Check data
for ( i = 0; i < out_size3; i++ ) {
if (check_data(test_out[i],out3[i], MAX_REL_DIFF) == NOK ) {
testOK = 0;
printf("Test 3: Large diff for index %d, ref:%f test: %f rel:%f \n",i,out3[i],test_out[i], test_out[i]/out3[i]);
}
}
*/
if (testFail) {
printf("Xcorr ARM test FAILED!!\n");
} else {
printf("Xcorr ARM test OK\n");
}
return testFail;
}
static int remote_read(apacket *p, atransport *t)
{
if(readx(t->sfd, &p->msg, sizeof(amessage))){
D("remote local: read terminated (message)\n");
return -1;
}
fix_endians(p);
#if 0 && defined __ppc__
D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n",
p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic);
#endif
if(check_header(p)) {
D("bad header: terminated (data)\n");
return -1;
}
if(readx(t->sfd, p->data, p->msg.data_length)){
D("remote local: terminated (data)\n");
return -1;
}
if(check_data(p)) {
D("bad data: terminated (data)\n");
return -1;
}
return 0;
}
int get_map(t_glob *g)
{
t_temp_list *node;
node = g->data;
while (node->next != NULL)
{
ft_putstr(node->str);
ft_putchar('\n');
test_alpha(node->str);
((g->lines == 0) && (test_digit(node->str) == 0)) ? g->ant_flag = 1 : 0;
((ft_strcmp("##start", node->str)) == 0) ? g->start_flag = 1 : 0;
((ft_strcmp("##end", node->str)) == 0) ? g->end_flag = 1 : 0;
if ((ft_strncmp("#", node->str, 1)) == 0)
{
node = node->next;
continue;
}
if (node->str == NULL)
error();
check_data(g, node->str);
node = node->next;
}
if (validate(g))
return (1);
free(node);
return (0);
}
int main(int argc, char *argv[])
{
// Stack variables
int i;
float test_out[out_size];
int testOK = 1;
// Run the test on Arm
p_rgb2grayscale_f32(in, test_out, in_rows, in_cols);
// Check data
for ( i = 0; i < out_size; i++ ) {
if (check_data(test_out[i],out[i], MAX_REL_DIFF) == NOK ) {
testOK = 0;
printf("Large diff for index %d, ref:%f test: %f rel:%f \n",i,out[i],test_out[i], test_out[i]/out[i]);
}
}
if ( testOK ){
printf("RGB2Grayscale ARM test OK\n");
} else {
printf("RGB2Grayscale ARM test FAILED!!\n");
}
}
// Implement response to initiator
tlm::tlm_sync_enum initiator::nb_transport_bw( PAYLOAD_TYPE& trans, tlm::tlm_phase& phase, sc_time& delay ) {
cout << "[SC "<<sc_time_stamp()<<"] Starting nb_transport_bw of " << this->name() << endl;
sc_assert(check_data(trans_count,&trans)==true);
trans_count++;
cout << "[SC "<<sc_time_stamp()<<"] End of nb_transport_bw of " << this->name() << endl;
return tlm::TLM_ACCEPTED;
}
static int remote_read(apacket *p, atransport *t)
{
if(usb_read(t->usb, &p->msg, sizeof(amessage))){
D("remote usb: read terminated (message)\n");
return -1;
}
fix_endians(p);
if(check_header(p)) {
D("remote usb: check_header failed\n");
return -1;
}
if(p->msg.data_length) {
if(usb_read(t->usb, p->data, p->msg.data_length)){
D("remote usb: terminated (data)\n");
return -1;
}
}
if(check_data(p)) {
D("remote usb: check_data failed\n");
return -1;
}
return 0;
}
static void do_write_wait(int len)
{
uint64_t old_w_cnt, new_w_cnt;
uint64_t old_r_cnt, new_r_cnt;
ssize_t sz;
const int iters = 100;
int i;
init_data(source, len, 0xab);
init_data(target, len, 0);
old_w_cnt = fi_cntr_read(write_cntr);
old_r_cnt = fi_cntr_read(read_cntr);
for (i = 0; i < iters; i++) {
sz = fi_write(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
}
fi_cntr_wait(write_cntr, old_w_cnt+iters, -1);
new_w_cnt = fi_cntr_read(write_cntr);
cr_assert(old_w_cnt + iters == new_w_cnt);
cr_assert(check_data(source, target, len), "Data mismatch");
new_r_cnt = fi_cntr_read(read_cntr);
/*
* no fi_read called so old and new read cnts should be equal
*/
cr_assert(new_r_cnt == old_r_cnt);
}
void do_writedata(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe, dcqe;
#define WRITE_DATA 0x5123da1a145
init_data(source, len, 0x23);
init_data(target, len, 0);
sz = fi_writedata(ep[0], source, len, loc_mr, WRITE_DATA,
gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(1, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
while ((ret = fi_cq_read(recv_cq, &dcqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert(ret != FI_SUCCESS, "Missing remote data");
rdm_rma_check_tcqe(&dcqe, NULL,
(FI_RMA | FI_REMOTE_WRITE | FI_REMOTE_CQ_DATA),
WRITE_DATA);
}
static void do_read(int len)
{
ssize_t sz;
uint64_t old_w_cnt, new_w_cnt;
uint64_t old_r_cnt, new_r_cnt;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
old_w_cnt = fi_cntr_read(write_cntr);
old_r_cnt = fi_cntr_read(read_cntr);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
do {
new_r_cnt = fi_cntr_read(read_cntr);
if (new_r_cnt == (old_r_cnt + 1))
break;
pthread_yield();
} while (1);
cr_assert(check_data(source, target, len), "Data mismatch");
new_w_cnt = fi_cntr_read(write_cntr);
/*
* no fi_read called so old and new read cnts should be equal
*/
cr_assert(new_w_cnt == old_w_cnt);
}
static int zynqmp_validate_bitstream(xilinx_desc *desc, const void *buf,
size_t bsize, u32 blocksize, u32 *swap)
{
ulong *buf_start;
ulong diff;
buf_start = check_data((u8 *)buf, blocksize, swap);
if (!buf_start)
return FPGA_FAIL;
/* Check if data is postpone from start */
diff = (ulong)buf_start - (ulong)buf;
if (diff) {
printf("%s: Bitstream is not validated yet (diff %lx)\n",
__func__, diff);
return FPGA_FAIL;
}
if ((ulong)buf < SZ_1M) {
printf("%s: Bitstream has to be placed up to 1MB (%px)\n",
__func__, buf);
return FPGA_FAIL;
}
return 0;
}
void do_readv(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct iovec iov;
iov.iov_base = source;
iov.iov_len = len;
init_data(target, len, 0x25);
init_data(source, len, 0);
sz = fi_readv(ep[0], &iov, (void **)&loc_mr, 1,
gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_READ, 0);
rdm_rma_check_cntrs(0, 1, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
void do_write_autoreg_uncached(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
init_data(uc_source, len, 0xab);
init_data(target, len, 0);
sz = fi_write(ep[0], uc_source, len,
NULL, gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(1, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(uc_source, target, len), "Data mismatch");
}
int main(int argc, char **argv)
{
if(sizeof(int) != 4) {
fprintf(stderr, "Your machine's ints are not 4 bytes. "
"You need to adjust generate_data() and check_data().\n");
exit(2);
}
process_args(argc, argv);
init_genrand(opt_seed);
if(opt_check) {
check_data(0, opt_size);
} else {
generate_data(1, opt_size);
}
/*
int i;
printf("1000 outputs of genrand_int32()\n");
for (i=0; i<1000; i++) {
printf("%10lu ", genrand_int32());
if (i%5==4) printf("\n");
}
*/
return 0;
}
void do_read(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
rdm_rma_check_cntrs(0, 1, 0, 0);
dbg_printf("got read context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
static void do_read_wait(int len)
{
int i, iters = 100;
ssize_t sz;
uint64_t old_w_cnt, new_w_cnt;
uint64_t old_r_cnt;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
old_w_cnt = fi_cntr_read(write_cntr);
old_r_cnt = fi_cntr_read(read_cntr);
for (i = 0; i < iters; i++) {
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target,
mr_key, (void *)READ_CTX);
cr_assert_eq(sz, 0);
}
fi_cntr_wait(read_cntr, old_r_cnt + iters, -1);
cr_assert(check_data(source, target, len), "Data mismatch");
new_w_cnt = fi_cntr_read(write_cntr);
/*
* no fi_read called so old and new read cnts should be equal
*/
cr_assert(new_w_cnt == old_w_cnt);
}
int main(int argc, char *argv[]) {
const int n = 1000000, nr_steps = 1000;
int num_threads = 1, step;
int *data;
#pragma omp parallel
{
#ifdef _OPENMP
#pragma omp master
num_threads = omp_get_num_threads();
if (n % num_threads != 0) {
errx(EXIT_FAILURE, "number of threads should divide %d", n);
}
#endif
init_data(&data, n);
}
printf("initialized with %d threads\n", num_threads);
printf("processing...\n");
#pragma omp parallel private(step)
{
{
for (step = 0; step < nr_steps; step++) {
process_data(data, n);
}
}
}
printf("processed with %d threads\n", num_threads);
printf("testing...\n");
check_data(data, n, num_threads, 1 + nr_steps);
printf("tested\n");
return EXIT_SUCCESS;
}
int
example_main(int argc, char **argv)
{
int rc = EXIT_FAILURE;
db_t hdb; // db to create and insert rows
trans_stat_t stat = { 0, 0 };
hdb = create_database( EXAMPLE_DATABASE, &db_schema, NULL );
if (!hdb) {
goto exit;
}
// Start transactions generation. Part of transactions commit with DB_LAZY_COMPLETION flag to make them to be deferred
rc = perform_transactions( hdb, &stat );
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
if( rc != EXIT_SUCCESS ) {goto exit; }
rc = EXIT_FAILURE;
// Reopen DB and check if all transactions are really there
hdb = db_open_file_storage(EXAMPLE_DATABASE, NULL);
if (!hdb) {
goto exit;
}
rc = check_data( hdb, &stat );
exit:
return rc;
}
static int test_truncate(int len)
{
const char *data = testdata;
int datalen = testdatalen;
int res;
start_test("truncate(%u)", (int) len);
res = create_file(testfile, data, datalen);
if (res == -1)
return -1;
res = truncate(testfile, len);
if (res == -1) {
PERROR("truncate");
return -1;
}
res = check_size(testfile, len);
if (res == -1)
return -1;
if (len > 0) {
if (len <= datalen) {
res = check_data(testfile, data, 0, len);
if (res == -1)
return -1;
} else {
res = check_data(testfile, data, 0, datalen);
if (res == -1)
return -1;
res = check_data(testfile, zerodata, datalen,
len - datalen);
if (res == -1)
return -1;
}
}
res = unlink(testfile);
if (res == -1) {
PERROR("unlink");
return -1;
}
res = check_nonexist(testfile);
if (res == -1)
return -1;
success();
return 0;
}
static int test_link2(void)
{
const char *data = testdata;
int datalen = testdatalen;
int err = 0;
int res;
start_test("link-unlink-link");
res = create_file(testfile, data, datalen);
if (res == -1)
return -1;
unlink(testfile2);
res = link(testfile, testfile2);
if (res == -1) {
PERROR("link");
return -1;
}
res = unlink(testfile);
if (res == -1) {
PERROR("unlink");
return -1;
}
res = check_nonexist(testfile);
if (res == -1)
return -1;
res = link(testfile2, testfile);
if (res == -1) {
PERROR("link");
}
res = check_type(testfile, S_IFREG);
if (res == -1)
return -1;
err += check_mode(testfile, 0644);
err += check_nlink(testfile, 2);
err += check_size(testfile, datalen);
err += check_data(testfile, data, 0, datalen);
res = unlink(testfile2);
if (res == -1) {
PERROR("unlink");
return -1;
}
err += check_nlink(testfile, 1);
res = unlink(testfile);
if (res == -1) {
PERROR("unlink");
return -1;
}
res = check_nonexist(testfile);
if (res == -1)
return -1;
if (err)
return -1;
success();
return 0;
}
void do_write_fence(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct iovec iov;
struct fi_msg_rma msg;
struct fi_rma_iov rma_iov;
iov.iov_base = source;
iov.iov_len = len;
rma_iov.addr = (uint64_t)target;
rma_iov.len = sizeof(target);
rma_iov.key = mr_key;
msg.msg_iov = &iov;
msg.desc = (void **)&loc_mr;
msg.iov_count = 1;
msg.addr = gni_addr[1];
msg.rma_iov = &rma_iov;
msg.rma_iov_count = 1;
msg.context = target;
msg.data = (uint64_t)target;
init_data(source, len, 0xef);
init_data(target, len, 0);
/* write A */
sz = fi_writemsg(ep[0], &msg, 0);
cr_assert_eq(sz, 0);
/* write B */
sz = fi_writemsg(ep[0], &msg, FI_FENCE);
cr_assert_eq(sz, 0);
/* event A */
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
/* event B */
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(2, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
/** check if tree of data in zone is valid */
static void checkzonetree(struct val_neg_zone* zone)
{
struct val_neg_data* d;
/* check all data in tree */
RBTREE_FOR(d, struct val_neg_data*, &zone->tree) {
check_data(zone, d);
}
}
void
testmain (int argc, char *argv[])
{
check_data ();
check_onebits ();
check_low_z_one ();
check_one_2exp ();
check_infinity ();
}
/******************************************************************************
* @fn modbus_uart_data_process
*
* @brief Process the message from UART
*
* @param uint8 - the pointer the buffer that to be process
* uint8 - length
*
* @return none
*/
void modbus_uart_data_process( uint8 *data_buffer, uint8 len)
{
P2_1 = 0;
if( TRUE == check_data( data_buffer, len))
{
initCRC16();
modbus_process_msg( data_buffer, len);
}
P2_1 = 1;
}
int
main (void)
{
tests_start ();
check_data ();
tests_end ();
exit (0);
}
int
main (int argc, char *argv[])
{
tests_start ();
check_data ();
tests_end ();
exit (0);
}
int
main (void)
{
tests_start ();
mp_trace_base = -16;
check_data ();
tests_end ();
exit (0);
}
int
main (void)
{
tests_start ();
check_data ();
unlink (FILENAME);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
tests_start ();
check_data ();
check_rand (argc, argv);
tests_end ();
exit (0);
}
int main(int argc, char **argv) {
char* shmname = NULL;
void* shmptr;
int rcnt = -1, wcnt = -1;
#ifndef _WIN32
struct timeval tv;
#endif
unsigned long long start_ms, end_ms;
if(argc==4) {
shmname = argv[1];
rcnt = atol(argv[2]);
wcnt = atol(argv[3]);
}
if(rcnt<0 || wcnt<0) {
fprintf(stderr, "usage: %s <shmname> <readers> <writers>\n", argv[0]);
exit(1);
}
shmptr=wg_attach_database(shmname,DBSIZE);
if (shmptr==NULL)
exit(2);
if(prepare_data(shmptr)) {
wg_delete_database(shmname);
exit(3);
}
#ifdef _WIN32
start_ms = (unsigned long long) GetTickCount();
#else
gettimeofday(&tv, NULL);
start_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
run_workers(shmptr, rcnt, wcnt);
#ifdef _WIN32
end_ms = (unsigned long long) GetTickCount();
#else
gettimeofday(&tv, NULL);
end_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
check_data(shmptr, wcnt);
fprintf(stdout, "elapsed: %d ms\n", (int) (end_ms - start_ms));
wg_delete_database(shmname);
exit(0);
}
