Beispiel #1
0
// sort thread shall behave the same as hw thread:
// - get pointer to data buffer
// - if valid address: sort data and post answer
// - if exit command: issue thread exit os call
void *sort_thread(void* data)
{
    unsigned int ret;
    unsigned int dummy = 23;
    struct reconos_resource *res  = (struct reconos_resource*) data;
    struct mbox *mb_start = res[0].ptr;
    struct mbox *mb_stop  = res[1].ptr;
    //pthread_t self = pthread_self();
    //printf("SW Thread %lu: Started with mailbox addresses %p and %p ...\n", self,  mb_start, mb_stop);
    while ( 1 ) {
        ret = mbox_get(mb_start);
        //printf("SW Thread %lu: Got address %p from mailbox %p.\n", self, (void*)ret, mb_start);
        if (ret == UINT_MAX)
        {
            //  printf("SW Thread %lu: Got exit command from mailbox %p.\n", self, mb_start);
            pthread_exit((void*)0);
        }
        else
        {
            bubblesort( (unsigned int*) ret, N);
        }

        mbox_put(mb_stop, dummy);
    }

    return (void*)0;
}
Beispiel #2
0
int main(int argc, char ** argv)
{
	uint32 ret = 0;
	assert(argc == 1);

	res[0].type = RECONOS_TYPE_MBOX;
	res[0].ptr  = &mb_1;
	
	mbox_init(&mb_1,3);
	
	reconos_init_autodetect();
	
	reconos_hwt_setresources(&hwt,res,2);
	reconos_hwt_setinitdata(&hwt,(void *) init_data);
	reconos_hwt_create(&hwt,0,NULL);
	
	ret = mbox_get(&mb_1);

	if (ret==init_data)
		printf("get_init_data: success (%X=%X)\n", init_data,ret);
	else
		printf("get_init_data: failure (%X!=%X)\n",init_data,ret);

	pthread_join(hwt.delegate,NULL);
	
	return 0;
}
Beispiel #3
0
uint32_t hwt_delegate_mbox_get(struct reconos_hwt *hwt) {
	uint32_t handle = reconos_osif_read(hwt->osif);

	//printf("RECONOS DELEGATE THREAD %d: RES %d: MBOX_GET\n", hwt->slot, handle);

	resource_check_type(hwt, handle, RECONOS_RESOURCE_TYPE_MBOX);

	//printf("RECONOS DELEGATE THREAD %d: RES %d: MBOX_GET DONE: %x\n", hwt->slot, handle, data);

	return mbox_get(hwt->cfg->resource[handle].ptr);
}
void mbox_get_data(struct mbox *mb, void* p, size_t size)
{
    int i;
    uint32_t* parts = (uint32_t*)p;

    assert((size%sizeof(uint32_t)) == 0);

    for (i=0; i<size/sizeof(uint32_t); i++)
    {
        parts[i] = mbox_get(mb);
    }
}
Beispiel #5
0
void SawtoothSoundComponent_HW::process(){
    if (this->m_active) {
        m_HWTParams[2] = (uint32_t) (m_PhaseIncr * SOUNDGATES_FIXED_PT_SCALE); //(uint32_t) (m_PhaseIncr *  SOUNDGATES_FIXED_PT_SCALE);

		mbox_put(&m_CtrlStart, SINUS_HWT_START);
		mbox_get(&m_CtrlStop);                   /* Blocks until thread ready */

		memcpy(m_SoundOut_1_Port->getWriteBuffer(), &m_LocalBuffer[0], Synthesizer::config::bytesPerBlock);
    }
    else {
    	m_SoundOut_1_Port->clearWriteBuffer();
   	}
}
Beispiel #6
0
ssize_t rq_receive(rqueue *rq, uint32_t *msg, size_t size)
{
	uint32_t *clone;
	ssize_t __size;

	clone = (uint32_t *) mbox_get((struct mbox *) rq);
	__size = clone[0];

	if (__size == 0 || __size > size)
		return -ENOMEM;

	__builtin_memcpy(msg, &clone[1], __size);
	free(clone);

	return __size;
}
void *ctrl_mmul_thread(void *data) {
	int i;
	int m;

	for (i = 0; i < NUM_HWT; i++) {
		printf("putting into mmul mbox: %x\n", (unsigned int)&matrix_ptr[3 * i]);
		mbox_put(&mbox_mmul_recv, (unsigned int)&matrix_ptr[3 * i]);
	}

	while (1) {
		m = mbox_get(&mbox_mmul_send);
		matrix_done_count++;
		m = (m - (int)&matrix_data[0][0][0]) / (4 * MATRIX_SIZE * MATRIX_SIZE);
		//printf("putting into mmul mbox: %x\n", (unsigned int)&matrix_ptr[m % 2]);
		mbox_put(&mbox_mmul_recv, (unsigned int)&matrix_ptr[m % 2]);
	}
}
void *ctrl_sort_thread(void *data) {
	int i;
	int m;

	for (i = 0; i < NUM_HWT; i++) {
		printf("putting into sort mbox: %x\n", (unsigned int)&sort_data[i][0]);
		mbox_put(&mbox_sort_recv, (unsigned int)&sort_data[i][0]);
	}

	while (1) {
		m = mbox_get(&mbox_sort_send);
		sort_request_count_active--;
		sort_done_count++;
		m = (m - (int)&sort_data) / (4 * SORT_SIZE);
		//printf("putting into sort mbox: %x\n", (unsigned int)&sort_data[m][0]);
		mbox_put(&mbox_sort_recv, (unsigned int)&sort_data[m][0]);
	}
}
Beispiel #9
0
// sort thread shall behave the same as hw thread:
// - get pointer to data buffer
// - if valid address: sort data and post answer
// - if exit command: issue thread exit os call
void *sort_thread(void* data)
{
	unsigned int ret;
	unsigned int dummy = 23;
	struct reconos_resource *res  = (struct reconos_resource*) data;
	struct mbox *mb_start = res[0].ptr;
	struct mbox *mb_stop  = res[1].ptr;

	while ( 1 ) {
		ret = mbox_get(mb_start);
		if(ret == UINT_MAX){
			pthread_exit((void*)0);
		} else {
			bubblesort( (unsigned int*) ret, BLOCK_WORDS);
		}
		mbox_put(mb_stop, dummy);
	}
	return NULL;
}
Beispiel #10
0
static int __init init_reconos_test_module(void)
{
	uint32_t ret = 0;

	mbox_init(&mb, 3);

	reconos_init_autodetect();
	reconos_hwt_setresources(&hwt, &res, 1);
	reconos_hwt_setinitdata(&hwt, (void *) init_data);
	reconos_hwt_create(&hwt, 0, NULL);

	ret = mbox_get(&mb);
	if (ret == init_data)
		printk(KERN_INFO "[reconos-test] get_init_data: "
		       "success (%X=%X)\n", init_data, ret);
	else
		printk(KERN_INFO "[reconos-test] get_init_data: "
		       "failure (%X!=%X)\n", init_data, ret);

	printk("[reconos-test] loaded, test done\n");
	return 0;
}
Beispiel #11
0
int main(int argc, char ** argv)
{
    int i;
    int ret;
    int hw_threads;
    int sw_threads;
    int running_threads;
    int buffer_size;
    int slice_size;
    unsigned int *data, *copy;

    timing_t t_start, t_stop;
    ms_t t_generate;
    ms_t t_sort;
    ms_t t_merge;
    ms_t t_check;

    if ((argc < 4) || (argc > 4))
    {
        print_help();
        exit(1);
    }
    // we have exactly 3 arguments now...
    hw_threads = atoi(argv[1]);
    sw_threads = atoi(argv[2]);

    // Base unit is bytes. Use macros TO_WORDS, TO_PAGES and TO_BLOCKS for conversion.
    buffer_size = atoi(argv[3])*PAGE_SIZE*PAGES_PER_THREAD;
    slice_size  = PAGE_SIZE*PAGES_PER_THREAD;

    running_threads = hw_threads + sw_threads;

    //int gettimeofday(struct timeval *tv, struct timezone *tz);

    // init mailboxes
    mbox_init(&mb_start,TO_BLOCKS(buffer_size));
    mbox_init(&mb_stop ,TO_BLOCKS(buffer_size));

    // init reconos and communication resources
    reconos_init(14,15);

    res[0].type = RECONOS_TYPE_MBOX;
    res[0].ptr  = &mb_start;
    res[1].type = RECONOS_TYPE_MBOX;
    res[1].ptr  = &mb_stop;

    printf("Creating %i hw-threads: ", hw_threads);
    fflush(stdout);
    for (i = 0; i < hw_threads; i++)
    {
        printf(" %i",i);
        fflush(stdout);
        reconos_hwt_setresources(&(hwt[i]),res,2);
        reconos_hwt_create(&(hwt[i]),i,NULL);
    }
    printf("\n");

    // init software threads
    printf("Creating %i sw-threads: ",sw_threads);
    fflush(stdout);
    for (i = 0; i < sw_threads; i++)
    {
        printf(" %i",i);
        fflush(stdout);
        pthread_attr_init(&swt_attr[i]);
        pthread_create(&swt[i], &swt_attr[i], sort_thread, (void*)res);
    }
    printf("\n");


    //print_mmu_stats();

    // create pages and generate data
    t_start = gettime();

    printf("malloc page aligned ...\n");
    data = malloc_page_aligned(TO_PAGES(buffer_size));
    copy = malloc_page_aligned(TO_PAGES(buffer_size));
    printf("generate data ...\n");
    generate_data( data, TO_WORDS(buffer_size));
    memcpy(copy,data,TO_WORDS(buffer_size)*4);

    t_stop = gettime();
    t_generate = calc_timediff_ms(t_start,t_stop);

    // print data of first page
    printf("Printing of generated data skipped. \n");
    //print_data(data, TO_WORDS(buffer_size));


    // Start sort threads
    t_start = gettime();

    printf("Putting %i blocks into job queue: ", TO_BLOCKS(buffer_size));
    fflush(stdout);
    for (i=0; i<TO_BLOCKS(buffer_size); i++)
    {
        printf(" %i",i);
        fflush(stdout);
        mbox_put(&mb_start,(unsigned int)data+(i*BLOCK_SIZE));
    }
    printf("\n");

    // Wait for results
    printf("Waiting for %i acknowledgements: ", TO_BLOCKS(buffer_size));
    fflush(stdout);
    for (i=0; i<TO_BLOCKS(buffer_size); i++)
    {
        printf(" %i",i);
        fflush(stdout);
        ret = mbox_get(&mb_stop);
    }
    printf("\n");

    t_stop = gettime();
    t_sort = calc_timediff_ms(t_start,t_stop);


    // merge data
    t_start = gettime();

    printf("Merging sorted data slices...\n");
    unsigned int * temp = malloc_page_aligned(TO_PAGES(buffer_size));
    //printf("Data buffer at address %p \n", (void*)data);
    //printf("Address of temporary merge buffer: %p\n", (void*)temp);
    //printf("Total size of data in bytes: %i\n",buffer_size);
    //printf("Size of a sorting block in bytes: %i\n",BLOCK_SIZE);
    data = recursive_merge( data,
                            temp,
                            TO_WORDS(buffer_size),
                            TO_WORDS(BLOCK_SIZE),
                            simple_merge
                          );

    t_stop = gettime();
    t_merge = calc_timediff_ms(t_start,t_stop);

    // check data
    //data[0] = 6666; // manual fault
    t_start = gettime();

    printf("Checking sorted data: ... ");
    fflush(stdout);
    ret = check_data( data, copy, TO_WORDS(buffer_size));
    if (ret >= 0)
    {
        printf("failure at word index %i\n", -ret);
        printf("expected 0x%08X    found 0x%08X\n",copy[ret],data[ret]);
        printf("dumping the first 2048 words:\n");
        for(i = 0; i < 2048; i++) {
            printf("%08X ",data[i]);
            if((i % 8) == 7) printf("\n");
        }
    }
    else
    {
        printf("success\n");
        //print_data(data, TO_WORDS(buffer_size));
    }

    t_stop = gettime();
    t_check = calc_timediff_ms(t_start,t_stop);

    // terminate all threads
    printf("Sending terminate message to %i threads:", running_threads);
    fflush(stdout);
    for (i=0; i<running_threads; i++)
    {
        printf(" %i",i);
        fflush(stdout);
        mbox_put(&mb_start,UINT_MAX);
    }
    printf("\n");

    printf("Waiting for termination...\n");
    for (i=0; i<hw_threads; i++)
    {
        pthread_join(hwt[i].delegate,NULL);
    }
    for (i=0; i<sw_threads; i++)
    {
        pthread_join(swt[i],NULL);
    }

    printf("\n");
    print_mmu_stats();
    printf( "Running times (size: %d words, %d hw-threads, %d sw-threads):\n"
            "\tGenerate data: %lu ms\n"
            "\tSort data    : %lu ms\n"
            "\tMerge data   : %lu ms\n"
            "\tCheck data   : %lu ms\n"
            "Total computation time (sort & merge): %lu ms\n",
            TO_WORDS(buffer_size), hw_threads, sw_threads,
            t_generate, t_sort, t_merge, t_check, t_sort + t_merge );


    //free(data);
    // Memory Leak on variable data!!!

    return 0;
}
Beispiel #12
0
static int __init init_reconos_test_module(void)
{
	char * shared_mem_h2s;
	char * shared_mem_s2h;
	int i, j;
	long unsigned jiffies_before;
	long unsigned jiffies_after;
	int len_array[13] = {64, 128, 256, 512, 1024, 1280, 1500, 3000, 6000, 9000, 15000, 30000, 50000};

	printk(KERN_INFO "[reconos-interface] Init.\n");

	mbox_init(&e_mb_put, 2);
    	mbox_init(&e_mb_get, 2);
	mbox_init(&a_mb_put, 2);
    	mbox_init(&a_mb_get, 2);
	mbox_init(&b_mb_put, 2);
    	mbox_init(&b_mb_get, 2);
	mbox_init(&c_mb_put, 2);
    	mbox_init(&c_mb_get, 2);
	printk(KERN_INFO "[reconos-interface] mbox_init done, starting autodetect.\n");

	reconos_init_autodetect();

	printk(KERN_INFO "[reconos-interface] Creating hw-thread.\n");
	e_res[0].type = RECONOS_TYPE_MBOX;
	e_res[0].ptr  = &e_mb_put;	  	
    	e_res[1].type = RECONOS_TYPE_MBOX;
	e_res[1].ptr  = &e_mb_get;

	a_res[0].type = RECONOS_TYPE_MBOX;
	a_res[0].ptr  = &a_mb_put;	  	
    	a_res[1].type = RECONOS_TYPE_MBOX;
	a_res[1].ptr  = &a_mb_get;

	s_res[0].type = RECONOS_TYPE_MBOX;
	s_res[0].ptr  = &s_mb_put;	  	
    	s_res[1].type = RECONOS_TYPE_MBOX;
	s_res[1].ptr  = &s_mb_get;

	b_res[0].type = RECONOS_TYPE_MBOX;
	b_res[0].ptr  = &b_mb_put;	  	
    	b_res[1].type = RECONOS_TYPE_MBOX;
	b_res[1].ptr  = &b_mb_get;

	c_res[0].type = RECONOS_TYPE_MBOX;
	c_res[0].ptr  = &c_mb_put;	  	
    	c_res[1].type = RECONOS_TYPE_MBOX;
	c_res[1].ptr  = &c_mb_get;


	reconos_hwt_setresources(&e_hwt,e_res,2);
	reconos_hwt_create(&e_hwt,E_HWT_SLOT_NR,NULL);

    	reconos_hwt_setresources(&a_hwt,a_res,2);
	reconos_hwt_create(&a_hwt,A_HWT_SLOT_NR,NULL);

	reconos_hwt_setresources(&b_hwt,b_res,2);
	reconos_hwt_create(&b_hwt,B_HWT_SLOT_NR,NULL);

	reconos_hwt_setresources(&c_hwt,c_res,2);
	reconos_hwt_create(&c_hwt,C_HWT_SLOT_NR,NULL);

	//setup the hw -> sw thread
	printk(KERN_INFO "[reconos-interface] Allocate memory\n");
	shared_mem_h2s = __get_free_pages(GFP_KERNEL | __GFP_NOWARN, 4); //allocate 2² pages get_zeroed_page(GFP_KERNEL);
	printk(KERN_INFO "[reconos-interface] h2s memory %p\n", shared_mem_h2s);
	mbox_put(&b_mb_put, shared_mem_h2s);

	//setup the sw -> hw thread
	shared_mem_s2h = __get_free_pages(GFP_KERNEL | __GFP_NOWARN, 4); //allocate 2² pages get_zeroed_page(GFP_KERNEL);
	printk(KERN_INFO "[reconos-interface] s2h memory %p\n", shared_mem_s2h);
	mbox_put(&c_mb_put, shared_mem_s2h);
	printk(KERN_INFO "[reconos-interface] HZ= %d\n", HZ);
	jiffies_before = jiffies;

	printk(KERN_INFO "[reconos-interface] Setting up AES slot \n");
	
	u32 config_data_start=1;
	u32 config_rcv=0;
	u32 config_data_mode=0;	//"....1100"=12=mode128, mode192=13, mode256=14,15
	u32 config_data_key0=0x16157e2b; // 50462976;	//X"03020100"
	u32 config_data_key1=0xa6d2ae28; //117835012;	//X"07060504"
	u32 config_data_key2=0x8815f7ab; //185207048;	//X"0b0a0908"
	u32 config_data_key3=0x3c4fcf09; //252579084;	//X"0f0e0d0c"

	u32 config_data_key4=319951120;	//X"13121110"
	u32 config_data_key5=387323156;	//X"17161514"
	u32 config_data_key6=454695192;	//X"1b1a1918"
	u32 config_data_key7=522067228;	//X"1f1e1d1c"
	u32 exit_sig=4294967295;
//	config_data_mode=16; //key length 128 bit, send everything to eth
	config_data_mode=20; //key length 128 bit, send everything to sw
	mbox_put(&e_mb_put, config_data_start);
	mbox_put(&e_mb_put, config_data_mode);
	mbox_put(&e_mb_put, config_data_key0);
	mbox_put(&e_mb_put, config_data_key1);
	mbox_put(&e_mb_put, config_data_key2);
	mbox_put(&e_mb_put, config_data_key3);

	mbox_put(&e_mb_put, config_data_key4);
	mbox_put(&e_mb_put, config_data_key5);
	mbox_put(&e_mb_put, config_data_key6);
	mbox_put(&e_mb_put, config_data_key7);
	config_rcv=mbox_get(&e_mb_get);
	printk(KERN_INFO "[reconos-interface] AES Setup done\n");

	while(1){
		printk(KERN_INFO "waiting for hw packets \n");
		int ret = mbox_get(&b_mb_get);
		int i;
		for (i = 0; i < 100; i+=4)
			printk(KERN_INFO "%x %x %x %x\n", shared_mem_h2s[i], shared_mem_h2s[i+1],  shared_mem_h2s[i+2],  shared_mem_h2s[i+3]);
		printk(KERN_INFO "received packet of len %u\n", ret);
		mbox_put(&b_mb_put, shared_mem_h2s );
		printk(KERN_INFO "setting up hash table \n");
		//config eth
		u32 config_eth_hash_1 = 0xabababab;
		u32 config_eth_hash_2 = 0xabababab;
		u32 config_eth_idp = 0x12341234;
		u32 config_eth_address = 1; //global 0, local 1 -> aes

		mbox_put(&a_mb_put, config_eth_hash_1 ); 
		mbox_put(&a_mb_put, config_eth_hash_2);
		mbox_put(&a_mb_put, config_eth_idp);
		mbox_put(&a_mb_put, config_eth_address);

		ret = mbox_get(&a_mb_get);
		printk(KERN_INFO "hwt_ethernet configured - 1\n");

		config_eth_hash_1 = 0xabababab;
		config_eth_hash_2 = 0xababab01;
		config_eth_idp = 0x56785678;
		config_eth_address = 5; //global 1, local 1 -> h2s

		mbox_put(&a_mb_put, config_eth_hash_1 );
		mbox_put(&a_mb_put, config_eth_hash_2);
		mbox_put(&a_mb_put, config_eth_idp);
		mbox_put(&a_mb_put, config_eth_address);

		ret = mbox_get(&a_mb_get);
		printk(KERN_INFO "hwt_ethernet configured - 2\n");
		
		ret = mbox_get(&b_mb_get);
		
		for (i = 0; i < 100; i+=4)
			printk(KERN_INFO "%x %x %x %x\n", shared_mem_h2s[i], shared_mem_h2s[i+1],  shared_mem_h2s[i+2],  shared_mem_h2s[i+3]);
		printk(KERN_INFO "received packet of len %u\n", ret);
		mbox_put(&b_mb_put, shared_mem_h2s );
//config eth
		config_eth_hash_1 = 0xabababab;
		config_eth_hash_2 = 0xabababab;
		config_eth_idp = 0x12341234;
		config_eth_address = 5; //global 1, local 1 -> h2s

		mbox_put(&a_mb_put, config_eth_hash_1 ); 
		mbox_put(&a_mb_put, config_eth_hash_2);
		mbox_put(&a_mb_put, config_eth_idp);
		mbox_put(&a_mb_put, config_eth_address);

		ret = mbox_get(&a_mb_get);
		printk(KERN_INFO "hwt_ethernet configured - 3\n");




	}


#ifdef ADD	//get interrupt time
	mbox_put(&e_mb_put, shared_mem_s2h);
	/**************************************
	 * only interrupts
	 **************************************/
	u32 data = 2147483648;
	int iterations = 1;
	jiffies_before = jiffies;
	for(i= data; i < data + iterations; i++){
		mbox_put(&e_mb_put, i);
		int ret = mbox_get(&e_mb_get);
		jiffies_after = jiffies;
//		printk(KERN_INFO "put %d, ret %d\n", i, ret);
	}
	jiffies_after = jiffies;
	printk(KERN_INFO "[reconos-interface] only interrupts: delta (in jiffies) = %lu for %d iterations", jiffies_after - jiffies_before, iterations);

	/***********************************************************************
	 * len = 64, 128, 512, 1024, 1280, 1518, 3000, 6000, 9000, 12000, 15000
	 **********************************************************************/
	for (j = 11; j < 13; j++){
		int len = len_array[j];
		printk(KERN_INFO "len = %d %p\n", len, shared_mem_s2h);
		memset(shared_mem_s2h, 0, 2*len);
		printk(KERN_INFO "len = %d\n", len);

		iterations = 1000000;

		jiffies_before = jiffies;
		for(i=0; i < iterations; i++){
			mbox_put(&e_mb_put, len);
			mbox_get(&e_mb_get);
		}
		jiffies_after = jiffies;
		int ret = memcmp(shared_mem_s2h, shared_mem_s2h+len, len);
		if (ret == 0)
			printk(KERN_INFO "copy success\n");
		else
			printk(KERN_INFO " copy failed\n");
		printk(KERN_INFO "[reconos-interface] len = %d: delta = %lu", len, jiffies_after - jiffies_before);
	
	}

//#endif
		/****************************************
		 * Reconfigure ETH to send data to dummy
		 ****************************************/
		u32 config_data = 1; //global=0, local=1
		mbox_put(&a_mb_put, config_data);

#endif


#ifdef SW_APP
//	for(i = 0; i < 10000; i++)
{
		for (j = 0; j < 7; j++){

		int packet_len = len_array[j];
		int iterations = 100000;
		int j = 0;
		int result = 0;
		memset(shared_mem_s2h, 0, 2 * packet_len);
		/************************************
		 * send packet to hardware
		 ************************************/
               	copy_packet(packet_len, 1, shared_mem_s2h, 1, 0);
		jiffies_before = jiffies;
		for(i = 0; i < iterations; i++){
                	mbox_put(&c_mb_put, packet_len + 12);
			result = mbox_get(&c_mb_get);
		}
		jiffies_after = jiffies;
		printk(KERN_INFO "[reconos-interface] iterations = %d len = %d: delta = %lu", iterations, packet_len, jiffies_after - jiffies_before);
		}
}
#endif	
#ifdef old
		/************************************
		 * send packet to hardware
		 ************************************/
                copy_packet(packet_len, 2, shared_mem_s2h, 1, 1);
		struct noc_pkt * snd_pkt = (struct noc_pkt *)shared_mem_s2h;
                mbox_put(&c_mb_put, packet_len);
		//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
                result = mbox_get(&c_mb_get);
         	printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);

	
		/************************************
		 * receive packet from hardware
		 ************************************/
		//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
		result = mbox_get(&b_mb_get);
		struct noc_pkt * rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
	//	packet_len = *(int *)shared_mem_h2s;
		printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);

		printk(KERN_INFO "packet sent\n");
		print_packet(snd_pkt);		
		printk(KERN_INFO "packet received\n");
		print_packet(rcv_pkt);


		for (j = 0; j < packet_len + 12; j++){ 
			unsigned char written_val = shared_mem_s2h[j];
			unsigned char read_val = shared_mem_h2s[j];
			printk(KERN_INFO "%x %x", written_val, read_val);
			if ((j + 1) % 8 == 0){
				printk(KERN_INFO "    ");
			}
			if ((j + 1) % 16 == 0){
				printk(KERN_INFO "\n");
			}
		}
		printk(KERN_INFO "\n");
	
		mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario
		


		/**********************************************
		 * send packet to hardware (s2h -> ADD -> eth)
		 **********************************************/
                copy_packet(packet_len, 3, shared_mem_s2h, 0, 1);
                mbox_put(&c_mb_put, packet_len);
		//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
         
	        result = mbox_get(&c_mb_get);
         	printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);

		/***************************************
		 * reconfigure ADD to send packet to SW
		 ***************************************/
		u32 config_data = 5; //global=1, local=1
		mbox_put(&e_mb_put, config_data);

		config_data = mbox_get(&e_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
		config_data = mbox_get(&e_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
		config_data = mbox_get(&e_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
		config_data = mbox_get(&e_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
		config_data = mbox_get(&e_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);


		/**********************************************
		 * send packet to hardware (s2h -> ADD -> h2s)
		 **********************************************/
                copy_packet(packet_len, 4, shared_mem_s2h, 0, 1);
                mbox_put(&c_mb_put, packet_len);
		//printk(KERN_INFO "[reconos-interface] packet sent to hw\n");
                result = mbox_get(&c_mb_get);
         	printk(KERN_INFO "[reconos-interface] packet sent received ack from hw, total packet len %d \n", result);


		/************************************
		 * receive packet from hardware (ADD)
		 ************************************/
		//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
		result = mbox_get(&b_mb_get);
		rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
	//	packet_len = *(int *)shared_mem_h2s;
		printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);

		printk(KERN_INFO "packet sent\n");
		print_packet(snd_pkt);		
		printk(KERN_INFO "packet received\n");
		print_packet(rcv_pkt);


		for (j = 0; j < packet_len + 12; j++){ 
			unsigned char written_val = shared_mem_s2h[j];
			unsigned char read_val = shared_mem_h2s[j];
			printk(KERN_INFO "%x %x", written_val, read_val);
			if ((j + 1) % 8 == 0){
				printk(KERN_INFO "    ");
			}
			if ((j + 1) % 16 == 0){
				printk(KERN_INFO "\n");
			}
		}
		printk(KERN_INFO "\n");
	
		mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario

		/************************************
		 * receive packet from hardware (ETH -> h2s)
		 ************************************/
		//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
		result = mbox_get(&b_mb_get);
		rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
	//	packet_len = *(int *)shared_mem_h2s;
		printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);

		printk(KERN_INFO "packet sent\n");
		print_packet(snd_pkt);		
		printk(KERN_INFO "packet received\n");
		print_packet(rcv_pkt);


		for (j = 0; j < packet_len + 12; j++){ 
			unsigned char written_val = shared_mem_s2h[j];
			unsigned char read_val = shared_mem_h2s[j];
			printk(KERN_INFO "%x %x", written_val, read_val);
			if ((j + 1) % 8 == 0){
				printk(KERN_INFO "    ");
			}
			if ((j + 1) % 16 == 0){
				printk(KERN_INFO "\n");
			}
		}
		printk(KERN_INFO "\n");
	
		mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario

		/*****************************************
		 * Reconfigure ETH to send packets to ADD
		 *****************************************/
		struct config_data config;
		config.dst_idp = 170;
		config.src_idp = 187;
		config.latency_critical = 1;
		config.direction = 0; //0 = ingress
		config.priority = 1;
		config.global_addr = 0;
		config.local_addr = 1;
		mbox_put(&a_mb_put, config_data);

		config_data = mbox_get(&a_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
		config_data = mbox_get(&a_mb_get);
		printk(KERN_INFO "ADD replies : %d\n", config_data);
	

		/************************************
		 * receive packet from hardware (ETH -> ADD -> h2s)
		 ************************************/
		//printk(KERN_INFO "[reconos-interface] wait for packet from hw\n");
		result = mbox_get(&b_mb_get);
		rcv_pkt = (struct noc_pkt *)shared_mem_h2s;
	//	packet_len = *(int *)shared_mem_h2s;
		printk(KERN_INFO "[reconos-interface] packet received with len from mbox %d, from memory %d\n", result, rcv_pkt->payload_len);

		printk(KERN_INFO "packet sent\n");
		print_packet(snd_pkt);		
		printk(KERN_INFO "packet received\n");
		print_packet(rcv_pkt);


		for (j = 0; j < packet_len + 12; j++){ 
			unsigned char written_val = shared_mem_s2h[j];
			unsigned char read_val = shared_mem_h2s[j];
			printk(KERN_INFO "%x %x", written_val, read_val);
			if ((j + 1) % 8 == 0){
				printk(KERN_INFO "    ");
			}
			if ((j + 1) % 16 == 0){
				printk(KERN_INFO "\n");
			}
		}
		printk(KERN_INFO "\n");
	
		mbox_put(&b_mb_put, shared_mem_h2s); //dummy_value. it will be the amount of data read in a ring buffer scenario



		
	}
Beispiel #13
0
void* sort_main(void * arg)
{
	int i;
	int hw_threads;
	int sw_threads;
	unsigned int *data, *copy;

	logging_init();

	unsigned int generate_ms;
	unsigned int sort_ms;
	unsigned int merge_ms;
	unsigned int check_ms;

	hw_threads = NUM_HWTS;
	sw_threads = NUM_SWTS;

	// init mailboxes
	mbox_init(&mb_start,NUM_BLOCKS);
    mbox_init(&mb_stop ,NUM_BLOCKS);

	// init reconos and communication resources
	reconos_init();

	res[0].type = RECONOS_TYPE_MBOX;
	res[0].ptr  = &mb_start;
    res[1].type = RECONOS_TYPE_MBOX;
	res[1].ptr  = &mb_stop;

	INFO("Creating %i hw-threads: ", hw_threads);
	for (i = 0; i < hw_threads; i++)
	{
		INFO(" %i",i);
	  reconos_hwt_setresources(&(hwt[i]),res,2);
	  reconos_hwt_create(&(hwt[i]),i,NULL);
	}
	INFO("\n");

	// init software threads
	INFO("Creating %i sw-threads: ",sw_threads);
	for (i = 0; i < sw_threads; i++)
	{
		INFO(" %i",i);
	  pthread_attr_init(&swt_attr[i]);
	  pthread_create(&swt[i], &swt_attr[i], sort_thread, (void*)res);
	}
	INFO("\n");

	// create pages and generate data
	generate_ms = time_ms();

	INFO("malloc page aligned ...\n");
	data = malloc(NUM_BLOCKS*BLOCK_WORDS*sizeof*data);
	copy = malloc(NUM_BLOCKS*BLOCK_WORDS*sizeof*data);;
	INFO("generate data ...\n");
	generate_data(data,NUM_BLOCKS*BLOCK_WORDS);
	memcpy(copy,data,NUM_BLOCKS*BLOCK_WORDS*sizeof*data);

	generate_ms = time_ms() - generate_ms;

	// Start sort threads
	sort_ms = time_ms();

	INFO("Putting %i blocks into job queue: ", NUM_BLOCKS);
	for (i = 0; i < NUM_BLOCKS; i++)
	{
		INFO(" %i",i);
		mbox_put(&mb_start,(unsigned int)data+(i*BLOCK_WORDS));
	}

	// Wait for results
	INFO("\nWaiting for %i acknowledgements: ", NUM_BLOCKS);
	for (i = 0; i < NUM_BLOCKS; i++)
	{
		INFO(" %i",i);
		mbox_get(&mb_stop);
	}
	INFO("\n");

	sort_ms = time_ms() - sort_ms;

	// merge data
	merge_ms = time_ms();

	INFO("Merging sorted data slices...\n");


	unsigned int * temp = malloc(NUM_BLOCKS*BLOCK_WORDS*sizeof*temp);
	mergesort(data,temp,BLOCK_WORDS,NUM_BLOCKS);
	data = temp;
	/*
	data = recursive_merge( data,
				temp,
				NUM_BLOCKS*BLOCK_WORDS,
				BLOCK_WORDS,
				simple_merge
				);
	*/
	merge_ms = time_ms() - merge_ms;

	// check data
	check_ms = time_ms();

	INFO("Quick check sorted data (checksum = %d): ... ",generate_checksum(copy,NUM_BLOCKS*BLOCK_WORDS));

	if(quick_check_data(data,NUM_BLOCKS*BLOCK_WORDS,generate_checksum(copy,NUM_BLOCKS*BLOCK_WORDS)) != 0){
		INFO("FAILURE\r\n");
	} else {
		INFO("success\n");
	}
	/*

  	INFO("Checking sorted data: ... ");

	ret = check_data( data, copy, TO_WORDS(buffer_size));
	if (ret >= 0)
	  {
		INFO("failure at word index %i\n", -ret);
		INFO("expected 0x%08X    found 0x%08X\n",copy[ret],data[ret]);
		INFO("dumping the first 2048 words:\n");
            for(i = 0; i < 2048; i++){
            	INFO("%08X ",data[i]);
              if((i % 8) == 7) INFO("\n");
            }
	  }
	else
	  {
		INFO("success\n");
	    //print_data(data, TO_WORDS(buffer_size));
	  }
	*/
	check_ms = time_ms() - check_ms;

	// terminate all threads
	INFO("Sending terminate message to %i threads:", hw_threads + sw_threads);

	for (i = 0; i < hw_threads + sw_threads; i++)
	{
		INFO(" %i",i);
		mbox_put(&mb_start,UINT_MAX);
	}

	INFO("\n");

	INFO("Waiting for termination...\n");
	for (i=0; i<hw_threads; i++)
	{
	  pthread_join(hwt[i].delegate,NULL);
	}
	for (i=0; i<sw_threads; i++)
	{
	  pthread_join(swt[i],NULL);
	}

	INFO("done\n");
	INFO("Running times (size: %d words, %d hw-threads, %d sw-threads):\n", NUM_BLOCKS*BLOCK_WORDS, hw_threads, sw_threads);
	INFO("\tGenerate data: %lu ms\n",generate_ms);
	INFO("\tSort data    : %lu ms\n",sort_ms);
	INFO("\tMerge data   : %lu ms\n",merge_ms);
	INFO("\tCheck data   : %lu ms\n",check_ms);
	INFO("Total computation time (sort & merge): %lu ms\n",sort_ms + merge_ms);



	//free(data);
	// Memory Leak on variable data!!!
	while(1);
	return NULL;
}
Beispiel #14
0
int main(int argc, char ** argv)
{
	int i;
	int hw_threads;

	// we have exactly 3 arguments now...
	hw_threads = 4;

	// init mailboxes
	mbox_init(&mb_start,MBOX_SIZE);
	mbox_init(&mb_stop ,MBOX_SIZE);

	// init reconos and communication resources
	reconos_init_autodetect();

	res[0].type = RECONOS_TYPE_MBOX;
	res[0].ptr  = &mb_start;
	res[1].type = RECONOS_TYPE_MBOX;
	res[1].ptr  = &mb_stop;

	printf("Creating %i hw-threads: ", hw_threads);
	fflush(stdout);
	for (i = 0; i < hw_threads; i++)
	{
	  printf(" %i",i);fflush(stdout);
	  reconos_hwt_setresources(&(hwt[i]),res,2);
	  reconos_hwt_create(&(hwt[i]),i,NULL);
	}
	printf("\n");

	int addresses[4];
	addresses[0] = 0;
	addresses[1] = 1;
	addresses[2] = 16;
	addresses[3] = 17;
	i = 0;
	while(1)
	{
		i = (i+1) % 4;

		printf("Waiting");
		fflush(stdout);
		int j;
		for(j=0; j<5; j++)
		{
			printf(".");
			fflush(stdout);
			sleep(1);
		}
		printf("\n");

		printf("Sending command\n");
		fflush(stdout);
		mbox_put(&mb_start,addresses[i]);

		printf("Waiting for answer\n");
		fflush(stdout);
		mbox_get(&mb_stop);
		printf("Answer received\n");

		printf("Waiting for answer\n");
		fflush(stdout);
		mbox_get(&mb_stop);
		printf("Answer received\n");
	}
	
	return 0;
}