main.cpp

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <map>
#include <vector>
#include <set>
#include <sys/time.h>
#include "code_helper.h"
extern "C" {
#include "computesi.h"
};
#include "ati_chip.h"


using namespace std;


int64_t get_time_usec()
{
    struct timeval tv;
    struct timezone tz;

    gettimeofday(&tv, &tz);

    return int64_t(tv.tv_sec) * 1000000 + int64_t(tv.tv_usec);
}



int main(int argc, char* argv[])
{
	std::vector<AtiDeviceData> devices = getAllAtiDevices();
	
	for (AtiDeviceData devData : devices)
	{
		std::cout << devData.vendorName << " : " << devData.deviceName << " : " << devData.busid << " " << devData.devpath << std::endl;
	}
	
	if (devices.empty())
	{
		std::cerr << "No available GPU devices" << std::endl;
		return 1;
	}
	
	compute_context* ctx = nullptr;
	
	if (argc == 1)
	{
		ctx = compute_create_context(devices.front().devpath.c_str(), devices.front().busid.c_str());
	}
	else
	{
		for (AtiDeviceData devData : devices)
		{
			if (argv[1] == devData.devpath)
			{
				ctx = compute_create_context(argv[1], devData.busid.c_str());
				break;
			}
		}
	}
	
	if (not ctx)
	{
		std::cerr << "Cannot create GPU context" << std::endl;
		return 1;
	}
	
  int test_data_size = 1024*1024*16;
  gpu_buffer* code_bo = compute_alloc_gpu_buffer(ctx, 1024*1024*4, RADEON_DOMAIN_GTT, 4096);
  gpu_buffer* trap_code_bo = compute_alloc_gpu_buffer(ctx, 1024*4, RADEON_DOMAIN_GTT, 4096);
	
  gpu_buffer* data_bo = compute_alloc_gpu_buffer(ctx, test_data_size*4, RADEON_DOMAIN_GTT, 4096);
  
	printf("code_bo->va: %08lX\n", code_bo->va);
	printf("trap_code_bo->va: %08lX\n", trap_code_bo->va);
	
  uint32_t prog[1024*1024*1];
  uint32_t trap_handler_code[1024];
  unsigned *p;
  for (int i = 0; i < sizeof(prog) / sizeof(prog[0]); i++)
  {
    prog[i] = 0xBF800000; //sopp: NOP
  }
  
  p = &trap_handler_code[0];
  
	s_nop(p);
	s_nop(p);
	s_nop(p);
	s_nop(p);
	s_add_i32(p, 112, 112, 255); *p=4; p++;
	
	
// 	v_mov_imm32(p, 4, 0x42);
	v_mov_b32(p, 4, 113);
	
// 	if (0)
  mtbuf(p,
           4,//int nfmt,
           4,//int dfmt,
           TBUFFER_STORE_FORMAT_X,//int op,
           0,//int addr64,
           0,//int glc,
           1,//int idxen,
           0,//int offen,
           0,//int offset,
           128,//int soffset, set to zero
           0,//int tfe,
           0,//int slc,
           0,//int srsrc,
           4,//int vdata,
           2//int vaddr
          );
  s_waitcnt(p);

	s_and_b32(p, 113, 113, 255); *p=0xFFFF; p++; ///fix PC, TTMP1 contains more than the PC, this might be rendundant
	
	s_swappc_b64(p, 116, 112);
//  	s_rfe_b64(p);
	s_endpgm(p);
	s_endpgm(p);
	s_endpgm(p);
	
	
	p = &prog[0];
  
	s_mov_imm32(p, 108, trap_code_bo->va & 0xFFFFFFFF);
	s_mov_imm32(p, 109, trap_code_bo->va >> 32);
	
  buffer_resource bufres;
  
  bufres.base_addr = data_bo->va;
  bufres.stride = 4;
  bufres.num_records = 1024*100;
  bufres.dst_sel_x = 4;
  bufres.dst_sel_y = 4;
  bufres.dst_sel_z = 4;
  bufres.dst_sel_w = 4;
  bufres.num_format = 4;
  bufres.data_format = 4;
  bufres.element_size = 1;
  bufres.add_tid_en = 0;

  printf("buf addr%lx, code addr: %lx\n", data_bo->va, code_bo->va);
//  printf("buf addr%p\n", data_bo->va >> 11);

/*
rak_adam: bit 0-4 are the fault type (bit 0 - range, bit 1 - pde, bit 2 - valid, bit 3 - read, bit 4 - write), 19:12 is the GPU client id, bit 24 is client r/w bit (0 - read, 1 - write), and 28-25 is the vmid
rak_adam: 0x48 is the TC (texture cache)

*/
  printf("resource: %.8x %.8x %.8x %.8x\n", bufres.data[0], bufres.data[1], bufres.data[2], bufres.data[3]);
  

/*
  s_mov_imm32(p, 4, bufres.data[0]);
  s_mov_imm32(p, 5, bufres.data[1]);
  s_mov_imm32(p, 6, bufres.data[2]);
  s_mov_imm32(p, 7, bufres.data[3]);
  */
//  s_getreg_b32(p, 4, 31, 0, 4);

//  v_mov_imm32(p, 0, 0x00000006);
//  v_mov_b32(p, 0, 4);
//  s_getpc_b64(p, 4);
//  v_mov_b32(p, 0, 4);

/*  v_mov_imm32(p, 2, 0x00000002);
  v_mov_imm32(p, 3, 0x00000042);
  v_mov_imm32(p, 4, 0x00000000);
  v_mov_imm32(p, 5, 0x00000000);
  v_mov_imm32(p, 6, 0x00000000);
  v_mov_imm32(p, 7, 0x00000000);

  s_mov_imm32(p, 0, code_bo->va+(1+start+21+1)*4);
*/

  v_mov_imm32(p, 1, 0x0002);
  v_mov_imm32(p, 2, 0x0001);

  s_mov_imm32(p, 126, 0x00000001); //EXECLO
  s_mov_imm32(p, 127, 0x00000000); //EXECHI

//  s_mov_imm32(p, 0, data_bo->va);
  //s_getreg_b32(p, 4, 3, 0, 4);
  v_mov_b32(p, 1, 4);
  v_mov_b32(p, 2, 4);
  v_mul_i32_i24_imm32(p, 1, 1, 64);

/*
  mtbuf(p,
           4,//int nfmt,
           4,//int dfmt,
           TBUFFER_STORE_FORMAT_X,//int op,
           0,//int addr64,
           0,//int glc,
           1,//int idxen,
           0,//int offen,
           0,//int offset,
           128,//int soffset, set to zero
           0,//int tfe,
           0,//int slc,
           0,//int srsrc,
           2,//int vdata,
           1//int vaddr
          );
*/

  v_mov_imm32(p, 1, 0x00000000);
  v_mov_imm32(p, 2, 0x00000007);

  mubuf(p, 
    128, //int soffset, 
    0,//int tfe, 
    0,//int slc, 
    0,//int srsrc, 
    2,//int vdata, 
    0,//int vaddr, UNUSED HERE
    BUFFER_ATOMIC_ADD,//int op, 
    0, //int lds, 
    0, //int addr64, 
    1, //int glc, 
    0, //int idxen, NO index in vaddr
    0, //int offen, NO offset in vaddr
    0 //int offset
  );
  
  s_waitcnt(p);

//  s_getreg_b32(p, 4, 31, 0, 4);
  v_mov_b32(p, 1, 4);

  s_mov_imm32(p, 6, 0x42);
  s_memtime(p, 6);
  s_waitcnt(p);
  v_mov_b32(p, 4, 6);
  v_mov_b32(p, 5, 7);

  mtbuf(p,
           4,//int nfmt,
           11,//int dfmt,
           TBUFFER_STORE_FORMAT_XY,//int op,
           0,//int addr64,
           0,//int glc,
           1,//int idxen,
           0,//int offen,
           0,//int offset,
           128,//int soffset, set to zero
           0,//int tfe,
           0,//int slc,
           0,//int srsrc,
           4,//int vdata,
           2//int vaddr
          );
  s_waitcnt(p);

////////////////////////////////////////
  int iternum = 10000;
  int elem_flopcount = 1;
  int ii2 = 1024*4;
  s_mov_imm32(p, 126, 0xFFFFFFFF); //EXECLO
  s_mov_imm32(p, 127, 0xFFFFFFFF); //EXECHI

  s_mov_imm32(p, 8, 0);

  v_mov_imm32(p, 4, floatconv(2));
  v_mov_imm32(p, 5, floatconv(1));

  unsigned * eleje = p;

  for (int i = 0; i < ii2; i++)
  {
		
//     s_mov_b32(p, 6, 6);
//    v_sin_f32(p, 4, 256+4);
   v_add_f32(p, 4, 4, 256+4);
//      v_fma_f32(p, 4, 0, 0, 256+5, 256+4, 256+4, 0, 0);
//   s_memtime(p, 6);
//   s_memtime(p, 6);
//   s_waitcnt(p);

//      s_sleep(p, 7);
//    v_add_f32_imm32(p, 4, 4, 1.1);
//    v_sqrt_f64(p, 4, 256+4);
//    v_bfrev(p, 4, 256+4);
//    v_rcp_f64(p, 4, 256+4);
//    v_mov_b32(p, 5, 256+4);
  }

  if (iternum > 1)
	{
		s_add_i32(p, 8, 8, 255); p[0] = 1; p++;
		s_cmp_lt_i32(p, 8, 255); p[0] = iternum; p++;
		s_cbranch_scc0(p, eleje-p);
	}
	
  s_mov_imm32(p, 126, 0x00000001); //EXECLO
  s_mov_imm32(p, 127, 0x00000000); //EXECHI
///////////////////////////////////////
  s_memtime(p, 6);
  s_waitcnt(p);


  s_getreg_b32(p, 8, 31, 0, 4); //hwid

	
  s_getreg_b32(p, 9, 31, 0, 5); //status
//   printf("getreg: %08X\n", p[-1]);

// 	s_mov_imm32(p, 110, 0x43);
	
// 	s_mov_b32(p, 9, 109);
	
// 	s_getpc_b64(p, 9);
	
  v_mov_b32(p, 4, 6);
  v_mov_b32(p, 5, 7);
  v_mov_b32(p, 6, 4);
  v_mov_b32(p, 7, 8);
  v_add_i32_imm32(p, 2, 2, 2);

  mtbuf(p,
           4,//int nfmt,
           14,//int dfmt,
           TBUFFER_STORE_FORMAT_XYZW,//int op,
           0,//int addr64,
           0,//int glc,
           1,//int idxen,
           0,//int offen,
           0,//int offset,
           128,//int soffset, set to zero
           0,//int tfe,
           0,//int slc,
           0,//int srsrc,
           4,//int vdata,
           2//int vaddr
          );

  s_waitcnt(p);
	
  v_mov_b32(p, 4, 9);
  v_add_i32_imm32(p, 2, 2, 4);

  mtbuf(p,
           4,//int nfmt,
           4,//int dfmt,
           TBUFFER_STORE_FORMAT_X,//int op,
           0,//int addr64,
           0,//int glc,
           1,//int idxen,
           0,//int offen,
           0,//int offset,
           128,//int soffset, set to zero
           0,//int tfe,
           0,//int slc,
           0,//int srsrc,
           4,//int vdata,
           2//int vaddr
          );
  s_waitcnt(p);
	
	
//  prog[100] = 0xBF800000 | (0x2 << 16) | 0x0001; //sopp: JUMP next
//  prog[101] = 0xBF800000 | (0x2 << 16) | 0xFFFF; //sopp: JUMP self
  
//   prog[255] = 0xBF800000 | (0x1 << 16); //sopp: ENDPGM
  
//s_trap(p, 255);
  s_endpgm(p);
  s_endpgm(p);
  s_endpgm(p);
  
/*  printf("code:\n");

  for (unsigned* i = &prog[0]; i != p; i++)
  {
    printf(">%.8X\n", *i);
  }*/

/*
  for (unsigned *i = &prog[0]; i < p; i++)
  {
    printf("%.8x\n", *i);
  }
*/
  compute_copy_to_gpu(code_bo, 0, &prog[0], sizeof(prog));
  compute_copy_to_gpu(trap_code_bo, 0, &trap_handler_code[0], sizeof(trap_handler_code));
  
  unsigned* test_data = new unsigned[test_data_size];
  
  for (int i = 0; i < 1024; i++)
  {
    test_data[i] = 0xDEADBEEF;
  }
  
  test_data[0] = 1;

//  compute_copy_to_gpu(data_bo, 0, &test_data[0], test_data_size*4);
  compute_copy_to_gpu(data_bo, 0, &test_data[0], 256);
  
  compute_state state;
  
  printf("%lx\n", code_bo->va);
 
  state.id = 0;
  state.user_data_length = 4;
  
  state.user_data[0] = bufres.data[0];
  state.user_data[1] = bufres.data[1];
  state.user_data[2] = bufres.data[2];
  state.user_data[3] = bufres.data[3];
  
  state.dim[0] = 32;
  state.dim[1] = 1;
  state.dim[2] = 1;
  state.start[0] = 0;
  state.start[1] = 0;
  state.start[2] = 0;
  state.num_thread[0] = 256*1;
  state.num_thread[1] = 1;
  state.num_thread[2] = 1;
  
  state.sgpr_num = 11; //8x
  state.vgpr_num = 10; //4x
  state.priority = 0;
  state.debug_mode = 0;
	state.priv_mode = 0;
	state.trap_en = 0;
  state.ieee_mode = 0;
  state.scratch_en = 0;
  state.lds_size = 0; ///32K
  state.excp_en = 0;
  state.waves_per_sh = 0;//256 / ((state.vgpr_num+1)*4);
  state.thread_groups_per_cu = 1;
  state.lock_threshold = 0;
  state.simd_dest_cntl = 0;
  state.se0_sh0_cu_en = 0xFF;
  state.se0_sh1_cu_en = 0xFF;
  state.se1_sh0_cu_en = 0xFF;
  state.se1_sh1_cu_en = 0xFF;
  state.tmpring_waves = 0;
  state.tmpring_wavesize = 0;
  state.binary = code_bo;

  int e;

  cout << "prestart1" << endl;
  sleep(1);
  cout << "prestart2" << endl;

  int64_t start_time = get_time_usec();

  cout << "start" << endl;
  e = compute_emit_compute_state(ctx, &state);

  compute_bo_wait(code_bo);
  cout << "stop" << endl;
  int64_t stop_time = get_time_usec();

  cout << e << " " << strerror(errno) << endl;
  
  compute_flush_caches(ctx);

//  gpu_buffer* data2_bo = compute_alloc_gpu_buffer(ctx, test_data_size*4, RADEON_DOMAIN_VRAM, 4096);
  //compute_copy_to_gpu(data_bo, 0, &test_data[0], 1024);

// 	compute_send_sync_dma_req(ctx, data2_bo, 0, data_bo, 0, 1*1024, 0, 0, 0);
//	compute_send_async_dma_req(ctx, data2_bo, 0, data_bo, 0, 1*1024);
	
  compute_copy_from_gpu(data_bo, 0, &test_data[0], test_data_size*4);
  
// 	if(0)
  for (int i = 0; i < 64; i++)
  {
    printf("%i : %.8x\n", i, test_data[i]);
  }


  int global_size = state.dim[0]*state.dim[1]*state.dim[2]*state.num_thread[0]*state.num_thread[1]*state.num_thread[2];
  int datalen = global_size / 64 * 7;

  std::cout << test_data[0] << " " << datalen << std::endl;

   datalen = test_data[0];

  uint64_t firststart = *(uint64_t*)&test_data[1];

  uint64_t laststop = firststart;

  for (int i = 1; i < datalen; i += 7)
  {
    uint64_t start = *(uint64_t*)&test_data[i];
    uint64_t stop = *(uint64_t*)&test_data[i+2];
    int group_id = test_data[i+4];

    firststart = std::min(firststart, start);
    laststop = std::max(laststop, stop);
  }

  std::set<std::pair<std::vector<uint32_t>, std::string> > ordered;

  for (int i = 1; i < datalen; i += 7)
  {
    uint64_t start = *(uint64_t*)&test_data[i];
    uint64_t stop = *(uint64_t*)&test_data[i+2];
    int group_id = test_data[i+4];
    uint32_t hwid = test_data[i+5];
    uint32_t odata = test_data[i+6];
		
    int cu_id = (hwid >> 8) & 15;
    int sh_id = (hwid >> 12) & 1;
    int se_id = (hwid >> 13) & 3;

    char buf[64*1024];
    sprintf(buf, "start: %10lu diff:%10lu clocks gid:%3i wave_id: %i simd_id: %i cu_id: %i, sh_id: %i se_id: %i cu_num:%3i tg_id: %i hwid:%08X data:%08X\n", 
            start-firststart, stop-start, group_id, hwid & 15, (hwid >> 4) & 3, cu_id, sh_id, se_id,  cu_id+sh_id*8+se_id*16, (hwid >> 16) & 15, hwid, odata);
    ordered.insert(make_pair(vector<uint32_t>{(hwid >> 13) & 3, (hwid >> 12) & 1, (hwid >> 8) & 15, (hwid >> 4) & 3}, std::string(buf)));
  }

//   if(0)
  for (auto n : ordered)
  {
    cout << n.second;
  }

  cout << "run time: " << double(stop_time-start_time)/1000.0 << "ms" << endl;
  cout << "run cycles: " << double(laststop - firststart) << endl;
  cout << "Core freq: " << double(laststop - firststart)/double(stop_time-start_time) << "MHz" << endl;
  cout << double(ii2*iternum)*global_size / double(stop_time-start_time) * 1E-3 << "Giter/s" << endl;
  cout << double(ii2*iternum)*global_size / double(stop_time-start_time) * 1E-3 * double(elem_flopcount)<< "Gflops" << endl;
  cout << double(laststop - firststart) / double(ii2*iternum) << " cycles / iter" << endl;
  compute_free_context(ctx);
}