Centre Blaise Pascal » Bench4GPU

    start_time=time.time()

    Splutter[:]=0

    SplutterCU = cuda.InOut(Splutter)

                         grid=(jobs,1),

                         block=(1,1,1))

    elif ParaStyle=='Hybrid':

      threads=BestThreadsNumber(jobs)

      MetropolisHybridCU(SplutterCU,

                         numpy.uint32(nprnd(2**30/jobs)),

                         grid=(jobs,1),

                         block=(threads,1,1))

    else:

      MetropolisThreadsCU(SplutterCU,

                       numpy.uint32(len(Splutter)),

                       numpy.uint32(nprnd(2**30/jobs)),

                       grid=(1,1),

                       block=(jobs,1,1))

    stop.record()

    stop.synchronize()

#    elapsed = start.time_till(stop)*1e-3

    elapsed = time.time()-start_time

    MySplutter[i]=numpy.median(Splutter)

    MyDuration[i]=elapsed

    #print MyPi[i],numpy.std(AllPi),MyDuration[i]

  return(numpy.mean(MyDuration),numpy.median(MyDuration),numpy.std(MyDuration))

  MinMemoryXPU=0

  if Device==0:

    HasXPU=False

    # Default Device selection based on ALU Type

    for platform in cl.get_platforms():

          MinMemoryXPU=deviceMemory

        if not HasXPU:        

          XPU=device

          HasXPU=True

          MemoryXPU=deviceMemory

  else:

    Id=1

    HasXPU=False

    # Primary Device selection based on Device Id

          MinMemoryXPU=deviceMemory

        if Id==Device  and HasXPU==False:

          XPU=device

          HasXPU=True

          MemoryXPU=deviceMemory

        Id=Id+1

    if HasXPU==False:

      return(0,0,0)

  # Je cree le contexte et la queue pour son execution

  ctx = cl.Context([XPU])

  MySplutter=numpy.zeros(steps)

  MaxWorks=2**(int)(numpy.log2(MinMemoryXPU/4))

  #Splutter=numpy.zeros((MaxWorks/jobs)*jobs).astype(numpy.uint32)

  #Splutter=numpy.zeros(jobs*16).astype(numpy.uint32)

    Splutter[:]=0

    h2d_time=time.time()

    SplutterCL = cl.Buffer(ctx, mf.WRITE_ONLY|mf.COPY_HOST_PTR,hostbuf=Splutter)

                                           numpy.uint32(nprnd(2**30/jobs)),

                                           numpy.uint32(nprnd(2**30/jobs)))

    elif ParaStyle=='Hybrid':

      #threads=BestThreadsNumber(jobs)

      threads=BestThreadsNumber(256)

      # en OpenCL, necessaire de mettre un Global_id identique au local_id

      CLLaunch=MetropolisCL.SplutterHybrid(queue,(jobs,),(threads,),

                                           SplutterCL,

                                           numpy.uint32(nprnd(2**30/jobs)),

                                           numpy.uint32(nprnd(2**30/jobs)))

    else:

      # en OpenCL, necessaire de mettre un global_id identique au local_id

      CLLaunch=MetropolisCL.SplutterLocal(queue,(jobs,),(jobs,),

                                          numpy.uint32(nprnd(2**30/jobs)))

    CLLaunch.wait()

    d2h_time=time.time()

    print('Elapsed compute time %f' % elapsed)

    MyDuration[i]=elapsed

    #MySplutter[i]=numpy.median(Splutter)

  SplutterCL.release()

  return(numpy.mean(MyDuration),numpy.median(MyDuration),numpy.std(MyDuration))

    coeffs_Amdahl[1]=coeffs_Amdahl[1]*coeffs_Amdahl[0]/D[0]

    coeffs_Amdahl[2]=coeffs_Amdahl[2]*coeffs_Amdahl[0]/D[0]

    coeffs_Amdahl[0]=D[0]

  except:

  try:

    coeffs_AmdahlR, matcov_AmdahlR = curve_fit(AmdahlR, N, D)

    D_AmdahlR=AmdahlR(N,coeffs_AmdahlR[0],coeffs_AmdahlR[1])

    coeffs_AmdahlR[1]=coeffs_AmdahlR[1]*coeffs_AmdahlR[0]/D[0]

    coeffs_AmdahlR[0]=D[0]

  except:

  try:

    coeffs_Mylq, matcov_Mylq = curve_fit(Mylq, N, D)

    # coeffs_Mylq[2]=coeffs_Mylq[2]*coeffs_Mylq[0]/D[0]

    coeffs_Mylq[3]=coeffs_Mylq[3]*coeffs_Mylq[0]/D[0]

    coeffs_Mylq[0]=D[0]

                                                            coeffs_Mylq[1],

                                                            coeffs_Mylq[3],

    D_Mylq=Mylq(N,coeffs_Mylq[0],coeffs_Mylq[1],coeffs_Mylq[2],

                coeffs_Mylq[3])

  except:

  try:

    coeffs_Mylq2, matcov_Mylq2 = curve_fit(Mylq2, N, D)

    # coeffs_Mylq2[3]=coeffs_Mylq2[3]*coeffs_Mylq2[0]/D[0]

    coeffs_Mylq2[4]=coeffs_Mylq2[4]*coeffs_Mylq2[0]/D[0]

    coeffs_Mylq2[0]=D[0]

  except:

  if Curves:

    plt.xlabel("Number of Threads/work Items")

      pAmdahl,=plt.plot(N,D_Amdahl,label="Loi de Amdahl")    

      pMylq,=plt.plot(N,D_Mylq,label="Loi de Mylq")

    except:

    plt.legend()

    plt.show()

  try:

    opts, args = getopt.getopt(sys.argv[1:],"hocfa:g:p:i:s:e:t:r:d:m:",["alu=","gpustyle=","parastyle=","iterations=","jobstart=","jobend=","jobstep=","redo=","device="])

  except getopt.GetoptError:

    sys.exit(2)

  for opt, arg in opts:

    if opt == '-h':

      # For PyOpenCL import

      try:

        import pyopencl as cl

          for device in platform.get_devices():

            #deviceType=cl.device_type.to_string(device.type)

            deviceMemory=device.max_mem_alloc_size

            Id=Id+1

        sys.exit()

      except ImportError:

    elif opt == '-o':

      OutMetrology=True

      Memory = int(arg)

  if Alu=='CPU' and GpuStyle=='CUDA':

    Alu='GPU'

  if ParaStyle not in ('Blocks','Threads','Hybrid'):

    ParaStyle='Blocks'

  if GpuStyle=='CUDA':

    try:

      import pycuda.autoinit

      from pycuda.compiler import SourceModule

    except ImportError:

  if GpuStyle=='OpenCL':

    try:

      for platform in cl.get_platforms():

        for device in platform.get_devices():

          #deviceType=cl.device_type.to_string(device.type)

          if Id == Device:

            # Set the Alu as detected Device Type

            Alu='xPU'

          Id=Id+1

    except ImportError:

  average=numpy.array([]).astype(numpy.float32)

  median=numpy.array([]).astype(numpy.float32)

            a,m,s=MetropolisCuda(circle,Iterations,1,Jobs,ParaStyle,

                                 Memory)

          except:

        elif GpuStyle=='OpenCL':

          try:

            a,m,s=MetropolisOpenCL(circle,Iterations,1,Jobs,ParaStyle,

                                   Alu,Device,Memory)

          except:

        duration=numpy.append(duration,time.time()-start)

      if (a,m,s) != (0,0,0):

        avg=numpy.mean(duration)

        med=numpy.median(duration)

        std=numpy.std(duration)

      else:

    else:

      if GpuStyle=='CUDA':

        try:

          avg,med,std=MetropolisCuda(circle,Iterations,Redo,

                                     Jobs,ParaStyle,Memory)

        except:

      elif GpuStyle=='OpenCL':

        try:

          avg,med,std=MetropolisOpenCL(circle,Iterations,Redo,Jobs,

                                       ParaStyle,Alu,Device,Memory)

        except:

    if (avg,med,std) != (0,0,0):

      average=numpy.append(average,avg)

      median=numpy.append(median,med)

      stddev=numpy.append(stddev,std)

    else:

    #THREADS*=2

    if len(average)!=0:

      numpy.savez("Splutter_%s_%s_%s_%i_%i_%.8i_Device%i_%s_%s" % (Alu,GpuStyle,ParaStyle,JobStart,JobEnd,Iterations,Device,Metrology,gethostname()),(ExploredJobs,average,median,stddev))