Esempio n. 1
0
  def free_remote(self, arr):
    if not (isinstance(arr, extarray.extarray) and hasattr(arr, "gpu_mem_handle")):
      raise Exception("Not a register or extarray with a GPU memory handle")

    cal_exec.free_remote(arr.gpu_mem_handle)

    del arr.gpu_mem_handle
    del arr.gpu_device
    del arr.gpu_width
    del arr.gpu_pitch

    arr.set_memory(0, 0)
    arr.data_len = 0
    return
Esempio n. 2
0
def TestCompileExec():
  import time
  SIZE = 1024
  kernel = ("il_ps_2_0\n" +
            "dcl_input_position_interp(linear_noperspective) v0\n" +
            "dcl_output_generic o0\n" +
            "dcl_output_generic o1\n" +
            #"dcl_output_generic o2\n" +
            "dcl_resource_id(0)_type(2d,unnorm)_fmtx(float)_fmty(float)_fmtz(float)_fmtw(float)\n" +
            #"mov r0, g[0]\n" +
            "sample_resource(0)_sampler(0) o0, v0.xyxx\n" +
            "mov g[0], r0\n" +
            "end\n")

  t1 = time.time()
  image = cal_exec.compile(kernel)
  t2 = time.time()
  print "compile time", t2 - t1

  input = cal_exec.alloc_remote(cal_exec.FMT_FLOAT32_4, SIZE, SIZE, 0)
  output = cal_exec.alloc_remote(cal_exec.FMT_FLOAT32_4, SIZE, SIZE, 0)
  #glob = cal_exec.alloc_remote(cal_exec.FMT_FLOAT32_4, 4096, 4096, cal_exec.GLOBAL_BUFFER)
  print "input", input
  print "output", output

  remote = {"o0": output, "i0": input}
  local = {"o1": (SIZE, SIZE, cal_exec.FMT_FLOAT32_4),
           "g[]": (4096, 4096, cal_exec.FMT_FLOAT32_4)}
  domain = (0, 0, SIZE, SIZE)
  print "remote bindings", remote
  print "local bindings", local

  # image, dev num, (x, y, w, h)
  t1 = time.time()
  cal_exec.run_stream(image, 0, domain, local, remote)
  t2 = time.time()
  print "run time", t2 - t1

  cal_exec.free_remote(input)
  cal_exec.free_remote(output)
  #cal_exec.free_remote(glob)
  cal_exec.free_image(image)
  return
Esempio n. 3
0
  def free(self, hdl):
    #if not (isinstance(arr, extarray.extarray) and hasattr(arr, "gpu_mem_handle")):
    #  raise Exception("Not a register or extarray with a GPU memory handle")

    if isinstance(hdl, extarray.extarray):
      if not hasattr(hdl, "gpu_mem_handle"):
        raise TypeError("Not an extarray with a GPU memory handle")

      cal_exec.free_remote(hdl.gpu_mem_handle)

      del hdl.gpu_mem_handle
      del hdl.gpu_device
      del hdl.gpu_width
      del hdl.gpu_pitch

      hdl.set_memory(0, 0)
      hdl.data_len = 0
    elif isinstance(hdl, LocalMemory):
      cal_exec.free_local(hdl.binding)
      hdl.res = None
    else:
      raise TypeError("Unknown handle type %s" % (type(hdl)))
    return
Esempio n. 4
0
def TestRemoteAlloc():
  mem_handle = cal_exec.alloc_remote(cal_exec.FMT_FLOAT32_4, 1024, 1024, 0)
  print "mem handle", mem_handle
  cal_exec.free_remote(mem_handle)
  return