Esempio n. 1
0
/* 
 * EXECUTE TEST
 * 
 */
extern int execute_test(	struct hmcsim_t *hmc, 
				uint64_t *addr, 
				uint32_t *req, 
				long num_req )
{
	/* vars */
	uint32_t z		= 0x00;
	long iter		= 0x00l;
	uint64_t head		= 0x00ll;
	uint64_t tail		= 0x00ll;
	uint64_t payload[8]	= {0x00ll,0x00ll,0x00ll,0x00ll,
				   0x00ll,0x00ll,0x00ll,0x00ll};
	uint64_t packet[HMC_MAX_UQ_PACKET];
	uint8_t	cub		= 0;
	uint16_t tag		= 0;
	uint8_t link		= 0;
	int ret			= HMC_OK;
	int stall_sig		= 0;

	uint64_t resp_head 	= 0;
	uint64_t resp_tail	= 0;
	hmc_response_t resp_type;
	uint8_t resp_length	= 0;
	uint16_t resp_tag	= 0;
	uint8_t resp_return_tag	= 0;
	uint8_t resp_src_link	= 0;
	uint8_t resp_rrp	= 0;
	uint8_t resp_frp	= 0;
	uint8_t resp_seq	= 0;
	uint8_t resp_dinv	= 0;
	uint8_t resp_errstat	= 0;
	uint8_t resp_rtc	= 0;
	uint32_t resp_crc	= 0;
	
	FILE *ofile		= NULL;
	int *rtns		= NULL;
	long all_sent		= 0;
	long all_recv		= 0;
	int done		= 0;
	/* ---- */

	rtns = malloc( sizeof( int ) * hmc->num_links );
	memset( rtns, 0, sizeof( int ) * hmc->num_links );

	/* 
	 * Setup the tracing mechanisms
	 * 
	 */
	ofile = fopen( "physrand.out", "w" );	
	if( ofile == NULL ){ 
		printf( "FAILED : COULD NOT OPEN OUTPUT FILE physrand.out\n" );
		return -1;
	}

	hmcsim_trace_handle( hmc, ofile );
	hmcsim_trace_level( hmc, (HMC_TRACE_BANK|
				HMC_TRACE_QUEUE|
				HMC_TRACE_CMD|
				HMC_TRACE_STALL|
				HMC_TRACE_LATENCY) );

	printf( "SUCCESS : INITIALIZED TRACE HANDLERS\n" );				
	

	/* 
	 * zero the packet
	 * 
	 */
	zero_packet( &(packet[0]) );

	printf( "SUCCESS : ZERO'D PACKETS\n" );
	printf( "SUCCESS : BEGINNING TEST EXECUTION\n" );

	/* 
	 * Attempt to execute all the requests
	 * Push requests into the device
	 * until we get a stall signal 
 	 */ 
	while( done != 1 ){


		/* 
	 	 * attempt to push a request in 
		 * as long as we don't stall
		 *
	 	 */		
		if( iter >= num_req ){ 
			/* everything is sent, go to receive side */
			goto packet_recv;
		}

		printf( "....sending packets\n" );
		while( ret != HMC_STALL ){

			/* 
			 * try to push another request 
			 * 
			 * Step 1: Build the Request
			 * 
			 */		
			if( req[(int)(iter)] == 1 ){
				/* 
			 	 * read request
				 *
				 */
				printf( "...building read request for device : %d\n", cub );
				hmcsim_build_memrequest( hmc, 
							cub, 
							addr[iter], 
							tag, 
							RD64, 
							link, 
							&(payload[0]), 
							&head, 
							&tail );
				/* 
				 * read packets have: 
				 * head + 
				 * tail
				 * 
				 */
				packet[0] = head;
				packet[1] = tail;
			}else {
				/* 
				 * write request
				 *
				 */
				printf( "...building write request for device : %d\n", cub );
				hmcsim_build_memrequest( hmc, 
							cub, 
							addr[iter], 
							tag, 
							WR64, 
							link, 
							&(payload[0]), 
							&head, 
							&tail );
				/* 
				 * write packets have: 
				 * head + 
				 * data + 
				 * data + 
				 * data + 
				 * data + 
				 * data + 
				 * data + 
				 * data + 
				 * data + 
				 * tail
				 * 
				 */
				packet[0] = head;
				packet[1] = 0x05ll;
				packet[2] = 0x06ll;
				packet[3] = 0x07ll;
				packet[4] = 0x08l;
				packet[5] = 0x09ll;
				packet[6] = 0x0All;
				packet[7] = 0x0Bll;
				packet[8] = 0x0Cll;
				packet[9] = tail;
			}
			
			/* 
			 * Step 2: Send it 
			 *
			 */
			printf( "...sending packet : base addr=0x%016llx\n", addr[iter] );

#if 0
			for( i=0; i<HMC_MAX_UQ_PACKET; i++){ 
				printf( "packet[%" PRIu64 "] = 0x%016llx\n", i, packet[i] );
			}
#endif
	
			ret = hmcsim_send( hmc, &(packet[0]) );

			switch( ret ){ 
				case 0: 
					printf( "SUCCESS : PACKET WAS SUCCESSFULLY SENT\n" );
					printf( "        : TAG = %" PRIu16 "\n", tag );
					all_sent++;
					iter++;
					tag++;

					/* increment the tag */
					if( tag == (UINT8_MAX-1) ){
						tag = 0;
					}	

					break;
				case HMC_STALL:
					printf( "STALLED : PACKET WAS STALLED IN SENDING\n" );
					/* reuse the current tag */
					break;
				case -1:
				default:
					printf( "FAILED : PACKET SEND FAILED\n" );
					goto complete_failure;
					break;
			}

			/* 
			 * zero the packet 
			 * 
			 */
			zero_packet( &(packet[0]) );

			link++;
			if( link == hmc->num_links ){
				/* -- TODO : look at the number of connected links
				 * to the host processor
				 */
				link = 0;
			}

			/* 
			 * check to see if we're at the end of the packet queue
			 *
			 */
			if( iter >= num_req ){ 
				goto packet_recv;
			}

			/* DONE SENDING REQUESTS */
		}

packet_recv:
		/* 
		 * reset the return code for receives
		 * 
		 */
		ret = HMC_OK;

		/* 
		 * We hit a stall or an error
		 * 
		 * Try to drain the responses off all the links
		 * 
		 */
		printf( "...reading responses\n" );
		while( ret != HMC_STALL ){ 

			for( z=0; z<hmc->num_links; z++){ 
				
				rtns[z] = hmcsim_recv( hmc, cub, z, &(packet[0]) );

				if( rtns[z] == HMC_STALL ){ 
					stall_sig++;
				}else{ 
					/* successfully received a packet */
					/* Decode the Packet and print the relevant items */ 

					/* 
				 	 * decode the response packet
					 * 
					 */
					ret = hmcsim_decode_memresponse( 
								hmc, 
								&(packet[0]), 
								&resp_head, 
								&resp_tail, 
								&resp_type, 
								&resp_length, 
								&resp_tag, 
								&resp_return_tag, 
								&resp_src_link, 
								&resp_rrp, 
								&resp_frp, 
								&resp_seq, 
								&resp_dinv, 
								&resp_errstat, 
								&resp_rtc, 
								&resp_crc );	
					if( ret == HMC_OK ){ 
						printf( "Response Packet:: Tag=%" PRIu16 "\n", resp_tag );
					}else{ 
						printf( "ERROR IN RESPONSE PACKET: %d\n", ret );
					}

					zero_packet( &(packet[0]) );

					all_recv++;
				}

				/* 
				 * zero the packet 
				 * 
				 */
				zero_packet( &(packet[0]) );
			}

			/* count the number of stall signals received */
			if( stall_sig == hmc->num_links ){ 
				/* 
				 * if all links returned stalls, 
				 * then we're done receiving packets
				 *
				 */
				
				printf( "STALLED : STALLED IN RECEIVING\n" );
				ret = HMC_STALL;
			}

			/* reset the return values */
			stall_sig = 0;
			for( z=0; z<hmc->num_links; z++){
				rtns[z] = HMC_OK;
			}
		}

		/* 
		 * reset the return code
		 * 
		 */
		stall_sig = 0;
		for( z=0; z<hmc->num_links; z++ ){ 
			rtns[z] = HMC_OK;
		}
		ret = HMC_OK;
	

		/* 
	 	 * done with sending/receiving packets
		 * update the clock 
		 */
		printf( "SIGNALING HMCSIM TO CLOCK\n" );
		hmcsim_clock( hmc );

		printf( "ALL_SENT = %ld\n", all_sent );
		printf( "ALL_RECV = %ld\n", all_recv );
		fflush( stdout );


		if( all_sent == num_req ){ 
			if( all_recv == num_req ){ 
				done = 1;
			}
		}
	}


complete_failure:

	fclose( ofile );
	ofile = NULL;

	free( rtns ); 
	rtns = NULL;

	return 0;
}
Esempio n. 2
0
/* 
 * EXECUTE TEST
 * 
 */
extern int execute_test(	struct hmcsim_t *hmc, 
				uint64_t *addr, 
                uint64_t imgsize, //In bytes ??
				uint64_t width, //In pixels ??
                uint32_t stride )
{
	/* vars */
	uint32_t z		= 0x00;
	long iter		= 0x00l;
	uint64_t head		= 0x00ll;
	uint64_t tail		= 0x00ll;
	uint64_t payload[8]	= {0x00ll,0x00ll,0x00ll,0x00ll,
				   0x00ll,0x00ll,0x00ll,0x00ll};
	uint64_t packet[HMC_MAX_UQ_PACKET];
	uint8_t	cub		= 0;
	uint16_t tag		= 0;
	uint8_t link		= 0;
	int ret			= HMC_OK;
	int stall_sig		= 0;
	
	FILE *ofile		= NULL;
	int *rtns		= NULL;
    long total_sent     =0;
    long total_recv     =0;
	int done		= 0;


    uint64_t d_response_head;
    uint64_t d_response_tail;
    hmc_response_t d_type;
    uint8_t d_length;
    uint16_t d_tag;
    uint8_t d_rtn_tag;
    uint8_t d_src_link;
    uint8_t d_rrp;
    uint8_t d_frp;
    uint8_t d_seq;
    uint8_t d_dinv;
    uint8_t d_errstat;
    uint8_t d_rtc;
    uint32_t d_crc;



    //Size of strided image
//    uint64_t stridedsize = imgsize / (stride * stride);
    uint64_t rows_processed = imgsize/(width * 4 * stride);
    long row_req = (((width * 4) / stride) / 8) + (((width * 4) / stride) % 8); //How many packets does it take to transfer one row of strided reads?
    long num_req = rows_processed * row_req * 4; //( stridedsize / (8 * 4)) + (2 * row_req); //We will have an overhead of three  packets: setup, release, and one 32 bytes read in addition to fil  
    long setup_req = rows_processed * row_req;
    long setups_sent = 0;



    //FSM Control variables
    uint64_t rowbase = addr[0];
    long setup_packet = 0;
    uint64_t row = 0;
    uint64_t base_address = 0;
    uint8_t pixels = 0;


    uint8_t SETUP = 0;
    uint8_t SWAIT = 1; 
    uint8_t FILL  = 2;
    uint8_t READ  = 3;
    uint8_t RELEASE = 4;    

    //short * waiting = NULL;
    uint8_t * dre_id = NULL; 
    uint64_t * dre_addr = NULL;
    uint64_t * seg_addr = NULL; 
    uint8_t * status = NULL;
    uint16_t * tags = NULL;



    uint64_t newhead        = 0x00ll;
    uint64_t newtail        = 0x00ll;
    

    status = malloc( sizeof( uint8_t ) * hmc->num_links );
    memset( status, SETUP, sizeof( uint8_t ) * hmc->num_links );

    dre_id = malloc( sizeof( uint8_t ) * hmc->num_links );
    memset( dre_id, 5, sizeof( uint8_t ) * hmc->num_links );

    dre_addr = malloc( sizeof( uint64_t ) * hmc->num_links );
    memset( dre_addr, 0, sizeof( uint64_t ) * hmc->num_links );

    seg_addr = malloc( sizeof( uint64_t ) * hmc->num_links );
    memset( seg_addr, 0, sizeof( uint64_t ) * hmc->num_links );

    tags = malloc( sizeof( uint16_t ) * hmc->num_links );
    memset( tags, 0, sizeof( uint16_t ) * hmc->num_links );


    int w;
    for (w = 0; w < 4; w++){
        printf("Status for link %d = %d\n", w, status[w]);
    }


	/* ---- */

	rtns = malloc( sizeof( int ) * hmc->num_links );
	memset( rtns, 0, sizeof( int ) * hmc->num_links );

	/* 
	 * Setup the tracing mechanisms
	 * 
	 */
	ofile = fopen( "imgdiff.out", "w" );	
	if( ofile == NULL ){ 
		printf( "FAILED : COULD NOT OPEN OUTPUT FILE imgdiff.out\n" );
		return -1;
	}


    FILE * afile = fopen( "imgdiff_addresses.out", "w" );
    if( afile == NULL ){
        printf( "FAILED : COULD NOT OPEN OUTPUT FILE imgdiff.out\n" );
        return -1;
    }




	hmcsim_trace_handle( hmc, ofile );
	hmcsim_trace_level( hmc, (HMC_TRACE_BANK|
				HMC_TRACE_QUEUE|
				HMC_TRACE_CMD|
				HMC_TRACE_STALL|
				HMC_TRACE_LATENCY) );

	printf( "SUCCESS : INITIALIZED TRACE HANDLERS\n" );				
	

	/* 
	 * zero the packet
	 * 
	 */
	zero_packet( &(packet[0]) );

	printf( "SUCCESS : ZERO'D PACKETS\n" );
	printf( "SUCCESS : BEGINNING TEST EXECUTION\n" );




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


    // Attempt to execute all the requests, Push requests into the device  until we get a stall signal 

    while (!done){
        printf("still not done\n");
		// attempt to push a request in as long as we don't stall 		
		if( iter >= num_req ){  
            printf("nothing to send\n");
			/* everything is sent, go to receive side */
			goto packet_recv;
		}

		printf( "....sending packets\n" );
		while( ret != HMC_STALL ){

				printf( "...building read request for device : %d\n", cub );                


                if(status[link] == SETUP && setups_sent < setup_req){
                    printf("setup\n");                    
                 //   if (! busy[link]) {
                    hmcsim_build_memrequest( hmc,
                                            cub,
                                            rowbase, //addr[iter],
                                            tag,
                                            DRE_SETUP,
                                            link,
                                            &(payload[0]),
                                            &head,
                                            &tail );


                    if (setup_packet < row_req-1)
                        pixels = 8;
                    else 
                        pixels = width % 8;            
                    
                    rowbase = addr[0] + (row * width * 4); 
                    base_address = rowbase + (setup_packet * stride * 4 * pixels);
                    


                        /* CMD field - Hard coded to dre stetup */
                        newhead |= (0x38 & 0x3F);
                        /* LNG field in flits */
                        newhead |= ( (uint64_t)(3 & 0xF) << 7 );
                        /* Duplicate LNG field in flits */
                        newhead |= ( (uint64_t)(3 & 0xF) << 11 );
                        /* Tag field, duplicating the tag on the original fill */
                        newhead |= ( (uint64_t)(tag & 0x1FF) << 15 );
                        /* Address based on calculated base and stride */
                        newhead |= ( (uint64_t)(base_address & 0x3FFFFFFFF) << 24 );

                        /* RRP value */
                        newtail |= 0x03;
                        /* FRP value */
                        newtail |= ( (uint64_t)(0x02 & 0xFF) << 8 );
                        /* Sequence number */
                        newtail |= ( (uint64_t)(0x01 & 0x7) << 16 );
                        /* Set bit 23 to 1 for DRE internal request */
                        newtail |= ( (uint64_t)(1 & 0x1) << 23 );
                        /* Source link ID */
                        newtail |= ( (uint64_t)(link & 0x7) << 24 );
                        /* Return token count */
                        newtail |= ( (uint64_t)(0x01 & 0x1F) << 27 );;
                        /* CRC (Not checked for sim) */
                        newtail |= ( (uint64_t)(0x11111111 & 0xFFFFFFFF) << 32 );

                    packet[0] = newhead;
                    packet[1] = base_address;
                    packet[2] = stride * 4; // Striding accounts for pixels occupying 4 bytes 
                    packet[3] = pixels;    //Number of elements (pixels) to be retrieved
                    packet[4] = 0; //other;
                    packet[5] = newtail;//UPDATE


                    
                    seg_addr[link] = base_address;
                    

                    fprintf(afile, "Image address: %ld. Row address %ld. Setup msg \n", (long) addr[0], (long) rowbase );
                    fprintf(afile, "Setup seq %d requesting %d pixels from base address %d. \n", (int) setup_packet, (int) pixels, (int) base_address);
                 
                
                }


               else if(status[link] == FILL){
                        printf("Ready to fill\n");
                        hmcsim_build_memrequest( hmc,
                                                cub,
                                                addr[iter],
                                                tag,
                                                DRE_FILL,
                                                link,
                                                &(payload[0]),
                                                &head,
                                                &tail );

                        /* CMD field - Hard coded to dre stetup */
                        newhead |= (0x39 & 0x3F);
                        /* LNG field in flits */
                        newhead |= ( (uint64_t)(2 & 0xF) << 7 );
                        /* Duplicate LNG field in flits */
                        newhead |= ( (uint64_t)(2 & 0xF) << 11 );
                        /* Tag field, duplicating the tag on the original fill */
                        newhead |= ( (uint64_t)(tag & 0x1FF) << 15 );
                        /* Address based on calculated base and stride */
                        newhead |= ( (uint64_t)(base_address & 0x3FFFFFFFF) << 24 );




                      /* RRP value */
                        newtail |= 0x03;
                        /* FRP value */
                        newtail |= ( (uint64_t)(0x02 & 0xFF) << 8 );
                        /* Sequence number */
                        newtail |= ( (uint64_t)(0x01 & 0x7) << 16 );
                        /* Set bit 23 to 1 for DRE internal request */
                        newtail |= ( (uint64_t)(1 & 0x1) << 23 );
                        /* Source link ID */
                        newtail |= ( (uint64_t)(link & 0x7) << 24 );
                        /* Return token count */
                        newtail |= ( (uint64_t)(0x01 & 0x1F) << 27 );;
                        /* CRC (Not checked for sim) */
                        newtail |= ( (uint64_t)(0x11111111 & 0xFFFFFFFF) << 32 );



                        packet[0] = newhead;
                        packet[1] = dre_id[link];
                        packet[2] = 0;//other;
                        packet[3] = newtail;

                }

                else if (status[link] == READ){
                    hmcsim_build_memrequest( hmc,
                                            cub,
                                            dre_addr[link],
                                            tag,
                                            RD32,
                                            link,
                                            &(payload[0]),
                                            &head,
                                            &tail );
     
                    packet[0] = head;
                    packet[1] = tail;

                    fprintf(afile, "Reading from DRE %d, address %d. \n", (int) dre_id[link], (int) dre_addr[link] );
                }


               else if(status[link] == RELEASE){
                    hmcsim_build_memrequest( hmc,
                                            cub,
                                            addr[iter],
                                            tag,
                                            DRE_RELEASE,
                                            link,
                                            &(payload[0]),
                                            &head,
                                            &tail );

                packet[0] = head;
                packet[1] = dre_id[link];
                packet[2] = 0;//other;
                packet[3] = tail;

                   fprintf(afile, "Releasing DRE %d. \n", (int) dre_id[link]);
                }
                        
                else {
                    printf("Unknown cmd %d , SETUP is %d\n", status[link], SETUP);
                   fprintf(afile, "Unidentified state \n" );

                }

			
			// Step 2: Send it 
			 
			printf( "...sending packet base addr=0x%016llx\n", (long long int )addr[iter] );

#if 0
			for( i=0; i<HMC_MAX_UQ_PACKET; i++){ 
				printf( "packet[%" PRIu64 "] = 0x%016llx\n", i, packet[i] );
			}
#endif
	
            if (status[link] == SWAIT){
                ret = HMC_STALL;
            }
            else{
			    ret = hmcsim_send( hmc, &(packet[0]) );
                printf( "RET = %d \n", ret);
            }


		switch( ret ){ 
				case 0: 
					printf( "SUCCESS : PACKET WAS SUCCESSFULLY SENT\n" );
					iter++;
                     
                    if(status[link] == SETUP){
                        setups_sent++;
                        status[link] = SWAIT;
                        tags[link] = tag;
                        seg_addr[link] = base_address;
                        if (setup_packet == row_req-1){
                            row += stride;
                            setup_packet = 0;
                        }
                        else
                            setup_packet++;
                    }

                    else if(status[link] == FILL){
                            status[link] = READ;
                    }

                    else if(status[link] == READ){
                            status[link] = RELEASE;
                    }

                    else if(status[link] == RELEASE){
                        status[link] = SETUP;//IDLE;
                        dre_addr[link] = 0;
                        dre_id[link] = 5;
                        tags[link] = 0;
                        seg_addr[link] = 0;   
                    }
                    else
                        fprintf(afile, "Unidentified msg \n" );
   
                    total_sent++;
					break;
				case HMC_STALL:
					printf( "STALLED : PACKET WAS STALLED IN SENDING\n" );
					break;
				case -1:
				default:
					printf( "FAILED : PACKET SEND FAILED\n" );
					goto complete_failure;
					break;
			}

			/* 
			 * zero the packet 
			 * 
			 */
			zero_packet( &(packet[0]) );

			tag++;
			if( tag == 2048 ){
				tag = 1;
			}	

			link++;
			if( link == hmc->num_links ){
				/* -- TODO : look at the number of connected links
				 * to the host processor
				 */
				link = 0;
			}

			
			// check to see if we're at the end of the packet queue
			if( iter >= num_req ){ 
				goto packet_recv;
			}

			/* DONE SENDING REQUESTS */
		}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



packet_recv:
		
 for (w=0; w<4; w++){
                        printf("Tag[%d]=%d\n ", w, tags[w]);

                    }


/* 
		 * reset the return code for receives
		 * 
		 */
		ret = HMC_OK;

		/* 
		 * We hit a stall or an error
		 * 
		 * Try to drain the responses off all the links
		 * 
		 */
		printf( "...reading responses\n" );
		while( ret != HMC_STALL ){ 

			for( z=0; z< hmc->num_links; z++){ 
				
				rtns[z] = hmcsim_recv( hmc, cub, z, &(packet[0]) );

				if( rtns[z] == HMC_STALL ){ 
					stall_sig++;
				}else{ 
					/* successfully received a packet */
					printf( "SUCCESS : RECEIVED A SUCCESSFUL PACKET RESPONSE\n" );	
                                        hmcsim_decode_memresponse( hmc,
                                                                  &(packet[0]), 
                                                                  &d_response_head,
                                                                  &d_response_tail,
                                                                  &d_type,
                                                                  &d_length,
                                                                  &d_tag,
                                                                  &d_rtn_tag,
                                                                  &d_src_link,
                                                                  &d_rrp,
                                                                  &d_frp,
                                                                  &d_seq,
                                                                  &d_dinv,
                                                                  &d_errstat,
                                                                  &d_rtc,
                                                                  &d_crc );
                                        printf( "RECV tag=%d; rtn_tag=%d\n", d_tag, d_rtn_tag );
				
                    total_recv++;
                    printf("Tag received %d, tag of link %d\n", d_tag, tags[z]);

                    if (tags[z] == d_tag)
                        status[z] = FILL;
                        dre_id[z]  = packet[1];
                        dre_addr[z] = packet[2]; 
				}

				/* 
				 * zero the packet 
				 * 
				 */
				zero_packet( &(packet[0]) );
			}

			/* count the number of stall signals received */
			if( stall_sig == hmc->num_links ){ 
				/* 
				 * if all links returned stalls, 
				 * then we're done receiving packets
				 *
				 */
				
				printf( "STALLED : STALLED IN RECEIVING \n");
				ret = HMC_STALL;
			}

			stall_sig = 0;
			for( z=0; z<hmc->num_links; z++){
				rtns[z] = HMC_OK;
			}
		}

		/* 
		 * reset the return code
		 * 
		 */
		stall_sig = 0;
		for( z=0; z<hmc->num_links; z++ ){ 
			rtns[z] = HMC_OK;
		}
		ret = HMC_OK;
	

		/* 
	 	 * done with sending/receiving packets
		 * update the clock 
		 */
		printf( "SIGNALING HMCSIM TO CLOCK\n" );
		hmcsim_clock( hmc );
        printf("signalling done\n");
		fflush( stdout );


		if( total_sent == num_req ){ 
			if( total_recv == num_req ){ 
                done = 1;
			}
		}
	}


        printf( "TOTAL_SENT = %ld\n", total_sent );
        printf( "TOTAL_RECV = %ld\n", total_recv );
        fflush( stdout );




complete_failure:

	fclose( ofile );
	ofile = NULL;

    fclose( afile );
    afile = NULL;

	free( rtns ); 
	rtns = NULL;

	return 0;
}
Esempio n. 3
0
/* 
 * EXECUTE_TEST
 * 
 * Executes a Stream Triad : 
 * 
 * a[j] = b[j] + scalar * c[j];
 * where, 0 <= j < num_req
 * 
 */
extern int execute_test(        struct hmcsim_t *hmc,
                                uint64_t *addr_a,
                                uint64_t *addr_b,
                                uint64_t *addr_c,
                                uint64_t addr_scalar,
                                long num_req,
                                uint32_t num_threads,  
                                uint32_t simd )
{
	/* vars */
	uint64_t head		= 0x00ll;
	uint64_t tail		= 0x00ll;
	uint64_t payload[8]	= {0x00ll, 0x00ll, 0x00ll, 0x00ll,
				   0x00ll, 0x00ll, 0x00ll, 0x00ll };
	uint64_t packet[HMC_MAX_UQ_PACKET];
	uint8_t cub		= 0;
	uint16_t tag		= 1;
	uint8_t link		= 0;
	int ret			= 0;
	
	FILE *ofile		= NULL;
	uint32_t done		= 0;
	uint32_t i		= 0;
	uint64_t niter		= 0x00ll;
	uint64_t *start		= NULL;		/* starting point of each thread */
	uint64_t *end		= NULL;		/* ending point of each thread */
	uint64_t *cur		= NULL;		/* current index of each thread */
	uint64_t *count		= NULL;		/* completed requests per thread */
	uint64_t *status	= NULL;		/* status signals for each thread */
	uint64_t *scalar	= NULL;		/* status signals for scalars */
	/* ---- */

	cur	= malloc( sizeof( uint64_t ) * num_threads );
	count	= malloc( sizeof( uint64_t ) * num_threads );
	start	= malloc( sizeof( uint64_t ) * num_threads );
	end	= malloc( sizeof( uint64_t ) * num_threads );
	status	= malloc( sizeof( uint64_t ) * num_threads );
	scalar	= malloc( sizeof( uint64_t ) * num_threads );

	/* 
	 * setup the address strides for each thread
	 * 
	 */
	niter	= (uint64_t)(num_req)/(uint64_t)(num_threads);


	for( i=0; i<num_threads; i++ ){ 
		count[i] 	= 0x00ll;
		start[i]	= niter * (uint64_t)(i);	
		cur[i]		= start[i];
		status[i]	= 0x00ll;
		scalar[i]	= 0x00ll;

		if( i == (num_threads-1) ){
			/* last thread */
			end[i]	= (uint64_t)(num_req-1);
		}else{
			end[i]	= start[i]+(niter-1);
		}

#if 0
		printf( "start[%"PRIu32"] = %"PRIu64"\n", i, start[i] );
		printf( "end[%"PRIu32"]   = %"PRIu64"\n", i, end[i] );
#endif
	}
		

	/* 
	 * setup the tracing mechanisms
	 * 
	 */
	ofile = fopen( "stream.out", "w" );
	if( ofile == NULL ){ 
		printf( "FAILED : COULD NOT OPEN OUPUT FILE stream.out\n" );
		return -1;
	}

	hmcsim_trace_handle( hmc, ofile );
	hmcsim_trace_level( hmc, (HMC_TRACE_BANK|
				HMC_TRACE_QUEUE|
				HMC_TRACE_CMD|
				HMC_TRACE_STALL|
				HMC_TRACE_LATENCY) );

	printf( "SUCCESS : INITIALIZED TRACE HANDLERS\n" );

	/* 
	 * zero the packet 
	 * 
	 */
	zero_packet( &(packet[0]) );

	printf( "BEGINNING EXECUTION\n" );

	/* -- begin cycle loop */
	while( done < num_threads ){

		/* 
	 	 * each thread needs to push out requests for its given	
		 * simd width worth of loads
		 * 
		 */
		for( i=0; i<num_threads; i++ ){ 

			/* 
			 * for each thread, attempt to push "simd" 
			 * width of requests out on each clock 
			 * 
			 */
			if( cur[i] == end[i] ){ 
				/* this thread is done */
			}else if( scalar[i] == 0 ){
				/* request the scalar */
				
				/* -- build the request */
				hmcsim_build_memrequest( hmc,
                                                        0,
                                                        addr_scalar,
                                                        tag,
                                                        RD64,
                                                        link,
                                                        &(payload[0]),
                                                        &head,
                                                        &tail );
	
				packet[0]	= head;
				packet[1]	= tail;

				ret	= hmcsim_send( hmc, &(packet[0]) );

				/* handle the response */
				switch( ret ){	
					case 0:
						/* success */
						scalar[i]++;
						count[i] = 0x00ll;

						tag++;
						if( tag == (UINT8_MAX-1)) {
							tag = 1;
						}

						link++;
						if( link == hmc->num_links ){ 
							link = 0;
						}

						break;
					case HMC_STALL:
						/* stalled */	
						scalar[i] = 0x00ll;
						break;
					case -1:
					default:
						printf( "FAILED : PACKET SEND FAILED\n" );
						goto complete_failure;
						break;
				}

				/* 
				 * zero the packet 
				 *
				 */
				zero_packet( &(packet[0]) );

				ret = HMC_OK;

			}else if( status[i] == 0 ){
				/* push loads for the current thread at b[j] */

				/* reset the status */			
				ret = HMC_OK;

				while(	(count[i] < (uint64_t)(simd) ) && 
					( ret != HMC_STALL) ){
	
					/* push out a load */

					/* build the request */
					hmcsim_build_memrequest( hmc,
                                                 	       	0,
                                                       	 	addr_b[cur[i]+count[i]],
                                            		        tag,
                                                        	RD64,
                                                        	link,
                                                        	&(payload[0]),
                                                        	&head,
                                                        	&tail );
	
					packet[0]	= head;
					packet[1]	= tail;

					/* send it */
					ret	= hmcsim_send( hmc, &(packet[0]) );

					/* handle the response */
					switch( ret ){	
						case 0:
							/* success */
							count[i]++;
					
							tag++;
							if( tag == (UINT8_MAX-1)) {
								tag = 1;
							}

							link++;
							if( link == hmc->num_links ){ 
								link = 0;
							}
	
							break;
						case HMC_STALL:
							/* stalled */	
							break;
						case -1:
						default:
							printf( "FAILED : PACKET SEND FAILED\n" );
							goto complete_failure;
							break;
					}

					/* 
					 * zero the packet 
					 *
					 */
					zero_packet( &(packet[0]) );

				}

				ret = HMC_OK;

				if( count[i] == simd ){ 	
					/* b[j] loads are done */
					status[i]++;
					count[i] = 0x00ll;
				}


			}else if( status[i] == 1 ){
				/* push the loads for the current thread at c[j] */

				/* reset the status */			
				ret = HMC_OK;

				while(	(count[i] < (uint64_t)(simd) ) && 
					( ret != HMC_STALL) ){
			
					/* push out a load */

					/* build the request */
					hmcsim_build_memrequest( hmc,
                                                 	       	0,
                                                       	 	addr_c[cur[i]+count[i]],
                                            		        tag,
                                                        	RD64,
                                                        	link,
                                                        	&(payload[0]),
                                                        	&head,
                                                        	&tail );
	
					packet[0]	= head;
					packet[1]	= tail;

					/* send it */
					ret	= hmcsim_send( hmc, &(packet[0]) );

					/* handle the response */
					switch( ret ){	
						case 0:
							/* success */
							count[i]++;
					
							tag++;
							if( tag == (UINT8_MAX-1)) {
								tag = 1;
							}

							link++;
							if( link == hmc->num_links ){ 
								link = 0;
							}
	
							break;
						case HMC_STALL:
							/* stalled */	
							break;
						case -1:
						default:
							printf( "FAILED : PACKET SEND FAILED\n" );
							goto complete_failure;
							break;
					}

					/* 
					 * zero the packet 
					 *
					 */
					zero_packet( &(packet[0]) );

				}	

				ret = HMC_OK;

				if( count[i] == simd ){ 	
					/* c[j] loads are done */
					status[i]++;
					count[i] = 0x00ll;
				}

			}else if( status[i] == 2 ){
				/* pause this clock cycle to compute */

				/* reset the status */			
				ret = HMC_OK;
				

				status[i]++;
				count[i] = 0x00ll;	

			}else if( status[i] == 3 ){ 
				/* push stores for the current thread */

				/* reset the status */			
				ret = HMC_OK;
				

				while(	(count[i] < (uint64_t)(simd) ) && 
					( ret != HMC_STALL) ){
			
					/* push out a store */

					/* build the request */
					hmcsim_build_memrequest( hmc,
                                                 	       	0,
                                                       	 	addr_a[cur[i]+count[i]],
                                            		        tag,
                                                        	WR64,
                                                        	link,
                                                        	&(payload[0]),
                                                        	&head,
                                                        	&tail );
	
					packet[0]	= head;
					packet[1]	= 0x02ll;
					packet[2]	= 0x03ll;
					packet[3]	= 0x04ll;
					packet[4]	= 0x05ll;
					packet[5]	= 0x06ll;
					packet[6]	= 0x07ll;
					packet[7]	= 0x08ll;
					packet[8]	= 0x09ll;
					packet[9]	= tail;
					packet[1]	= tail;

					/* send it */
					ret	= hmcsim_send( hmc, &(packet[0]) );

					/* handle the response */
					switch( ret ){	
						case 0:
							/* success */
							count[i]++;
					
							tag++;
							if( tag == (UINT8_MAX-1)) {
								tag = 1;
							}

							link++;
							if( link == hmc->num_links ){ 
								link = 0;
							}
	
							break;
						case HMC_STALL:
							/* stalled */	
							break;
						case -1:
						default:
							printf( "FAILED : PACKET SEND FAILED\n" );
							goto complete_failure;
							break;
					}

					/* 
					 * zero the packet 
					 *
					 */
					zero_packet( &(packet[0]) );

				}

				ret = HMC_OK;

				if( count[i] == simd ){ 	
					/* c[j] loads are done */
					status[i] 	= 0x00ll;
					count[i] 	= 0x00ll;

					cur[i] += (uint64_t)(simd);
					

					if( cur[i] >= end[i] ){ 
						cur[i] = end[i];
						printf( "thread %"PRIu32" done; done = %"PRIu32 "\n", i, done );
						done++;
					}
				}
			
			}/* -- status == 3 */
		}/* -- end threads loop */

		/*
		 * drain all the responses 
		 * 	
		 */
		for( i=0; i<hmc->num_links; i++ ){ 

			ret = HMC_OK;
			while( ret != HMC_STALL ){ 
				ret = hmcsim_recv( hmc, cub, i, &(packet[0]) );
			}

		}

		/* 
		 * clock the sim 
		 * 
	 	 */
		hmcsim_clock( hmc );


	} /* -- end cycle loop */

	printf( "SUCCESS : EXECUTION COMPLETE\n" );

complete_failure:
	fclose( ofile );
	ofile = NULL;

	free( cur ); 
	free( count );	
	free( start );	
	free( end );	
	free( status );	
	free( scalar );	


	return 0;
}