C++ Coder
C++ Coder

Test latency for clEnqueueNDRangeKernel

Test latency for clEnqueueNDRangeKernel
http://pastebin.com/fije3CKf

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <CL/opencl.h>
  5.  
  6. cl_int cl_error ; // OpenCL error code
  7. cl_device_id device_id ; // The chosen device
  8. cl_program program ; // OpenCL program
  9.  
  10.  
  11. /** Formats the standard MACROS  __FILE__ and __LINE__ for message print.
  12.  */
  13. #define STRINGIFY(x) #x
  14. #define TOSTRING(x) STRINGIFY(x)
  15. #define AT __FILE__ ":" TOSTRING(__LINE__)
  16.  
  17.  
  18. #define DEBUG_BUFFER_SIZE 4096
  19. char * OpenCL_error_to_string ( int error ) ;
  20.  
  21. #define dump(msg,...) \
  22.     fprintf(stderr, AT msg,##__VA_ARGS__)
  23.  
  24.  
  25. #define OpenCL_test_execution(msg,error)         \
  26.   do {                  \
  27.     if(CL_SUCCESS != error) {           \
  28.       dump("The runtime error is %s\n",    \
  29.         (char *)OpenCL_error_to_string(error));      \
  30.       exit(EXIT_FAILURE);            \
  31.     }                 \
  32.   } while (0)
  33.  
  34.  
  35.  
  36.  
  37. static double t_start , t_end ; // Timing
  38. double timer_get_time ( )
  39. {
  40.     struct timeval t ;
  41.     if (gettimeofday ( &t , NULL ) != 0 ) {
  42.       perror ( "Error gettimeofday !\n" ) ;
  43.       exit ( 1 ) ;
  44.     }
  45.     return (t. tv_sec + t. tv_usec * 1.0e-6 ) ;
  46. }
  47.  
  48. void timer_start ( ) {
  49.   t_start = timer_get_time ( ) ;
  50. }
  51.  
  52. void timer_stop_display ( char *msg ) {
  53.   t_end = timer_get_time ( ) ;
  54.   printf ( "%s : %0.1lf\n" , msg , (t_end - t_start ) * 1000 ) ;
  55. }
  56.  
  57.  
  58.  
  59. void openclSimpleCopy (cl_context context , cl_command_queue queue , cl_kernel kernel , size_t n ) {
  60.   // Host data
  61.   int a [n ] ,b [n ] ;
  62.   int _i ;
  63.  
  64.   // Init
  65.   for (_i = 0 ;_i <n ;_i ++ ) {
  66.     a [_i ] =n -_i ;
  67.     b [_i ] = 0 ;
  68.   }
  69.  
  70.   // Buffers on the device
  71.   cl_mem a_dev = clCreateBuffer (context ,
  72.                                 CL_MEM_READ_WRITE ,
  73.                                 n * sizeof ( int ) ,
  74.                                 NULL ,
  75.                                 &cl_error ) ;
  76.   OpenCL_test_execution ( "Create Buffer" ,cl_error ) ;
  77.  
  78.   cl_mem b_dev = clCreateBuffer (context ,
  79.                                 CL_MEM_READ_WRITE ,
  80.                                 n * sizeof ( int ) ,
  81.                                 NULL ,
  82.                                 &cl_error ) ;
  83.   OpenCL_test_execution ( "Create Buffer" ,cl_error ) ;
  84.  
  85.  
  86.   // 3 events is enough here
  87.   cl_event event1 ;
  88.   cl_event event2 ;
  89.   cl_event event3 ;
  90.  
  91.  
  92.  
  93.  
  94.   // Initialize buffer on the device
  95.   cl_error =  clEnqueueWriteBuffer (queue ,
  96.                        a_dev ,
  97.                        CL_TRUE ,
  98.                         0 ,
  99.                        n * sizeof ( int ) ,
  100.                        a ,
  101.                         0 ,
  102.                        NULL ,
  103.                         &event1 ) ;
  104.   OpenCL_test_execution ( "Write to Buffer" ,cl_error ) ;
  105.  
  106.   // Shouldn't be useful, I used a blocking write !
  107.   clFlush (queue ) ;
  108.   clWaitForEvents ( 1 ,&event1 ) ;
  109.  
  110.  
  111.   // Arguments for the kernel
  112.   cl_error = clSetKernelArg (kernel , 0 , sizeof (a_dev ) , &a_dev ) ;
  113.   OpenCL_test_execution ( "Set argument 0 " ,cl_error ) ;
  114.  
  115.   cl_error = clSetKernelArg (kernel , 1 , sizeof (b_dev ) , &b_dev ) ;
  116.   OpenCL_test_execution ( "Set argument 1" ,cl_error ) ;
  117.  
  118.   timer_start ( ) ;
  119.   cl_error = clEnqueueNDRangeKernel (queue ,
  120.                                     kernel ,
  121.                                     1 ,
  122.                                     NULL ,
  123.                                     &n ,
  124.                                     NULL ,
  125.                                     1 ,
  126.                                     &event1 ,
  127.                                     &event2 ) ;
  128.  
  129.   timer_stop_display ( "Time for Enqueue" ) ;
  130.   OpenCL_test_execution ( "Enqueue kernel" ,cl_error ) ;
  131.  
  132.   OpenCL_test_execution ( "clWaitForEvents" ,clWaitForEvents ( 1 ,&event2 ) ) ;
  133.  
  134.   cl_error =  clEnqueueReadBuffer (queue ,
  135.                        b_dev ,
  136.                        CL_TRUE ,
  137.                         0 ,
  138.                        n * sizeof ( int ) ,
  139.                        b ,
  140.                         1 ,
  141.                         &event2 ,
  142.                         &event3 ) ;
  143.   OpenCL_test_execution ( "Read from buffer" ,cl_error ) ;
  144.  
  145.   OpenCL_test_execution ( "clWaitForEvents" ,clWaitForEvents ( 1 ,&event3 ) ) ;
  146.  
  147.  
  148.   // Check result
  149.   for (_i = 0 ;_i <n ;_i ++ ) {
  150.     if (a [_i ] !=b [_i ] ) {
  151.       printf ( "Error %d : %d!=%d\n" ,_i ,a [_i ] ,b [_i ] ) ;
  152.       exit ( - 1 ) ;
  153.     }
  154.   }
  155.   OpenCL_test_execution ( "Release mem object" ,clReleaseMemObject (a_dev ) ) ;
  156.   OpenCL_test_execution ( "Release mem object" ,clReleaseMemObject (b_dev ) ) ;
  157.  
  158. }
  159.  
  160.  
  161.  
  162. int main ( int argc , char **argv ) {
  163.  
  164.   int platform_num = 0 ; // Platform number
  165.   int device_num = 0 ; // Device number
  166. #define DEVICE_TYPE CL_DEVICE_TYPE_ALL
  167.  
  168.   cl_int cl_error ; // OpenCL error code
  169.   cl_kernel kernel = NULL ;
  170.  
  171.  
  172.   // Chosing platform
  173.   cl_uint num_platforms ;
  174.   clGetPlatformIDs ( 0 , NULL , &num_platforms ) ;
  175.   if (num_platforms <= 0 ) {
  176.     dump ( "No OpenCL platforms found :-(\n" ) ;
  177.     exit ( - 1 ) ;
  178.   }
  179.  
  180.   cl_platform_id platform_ids [num_platforms ] ;
  181.   clGetPlatformIDs (num_platforms , platform_ids , NULL ) ;
  182.  
  183.   if (platform_num < 0 || platform_num >= num_platforms ) {
  184.     dump ( "Invalid platform: %d\n" , platform_num ) ;
  185.     exit (EXIT_FAILURE ) ;
  186.   }
  187.  
  188.   // platform_id hold the chosen platform
  189.   cl_platform_id platform_id = platform_ids [platform_num ] ;
  190.  
  191.   // Chosing the device
  192.  
  193.   cl_uint num_devices ;
  194.   OpenCL_test_execution ( "Get number of devices" , clGetDeviceIDs (platform_id , DEVICE_TYPE , 0 , NULL , &num_devices ) ) ;
  195.  
  196.   if (num_devices <= 0 ) {
  197.     dump ( "No devices found associated to this OpenCL platform :-(\n" ) ;
  198.     exit ( - 1 ) ;
  199.   }
  200.  
  201.   // Allocate spaces for devices
  202.   cl_device_id devices [num_devices ] ;
  203.  
  204.   // Get devices list
  205.   OpenCL_test_execution ( "Get devices list" , clGetDeviceIDs (platform_id , DEVICE_TYPE , num_devices , devices , NULL ) ) ;
  206.  
  207.   /* Create a context for all devices */
  208.   cl_context context = clCreateContext ( 0 ,
  209.                                        num_devices ,
  210.                                        devices ,
  211.                                        NULL ,
  212.                                         "from 'context'" ,
  213.                                         &cl_error ) ;
  214.   OpenCL_test_execution ( "Context creation" ,cl_error ) ;
  215.  
  216.   // Here is the device ID
  217.   device_id = devices [device_num ] ;
  218.  
  219.   /* Create an in-order queue for this device */
  220.   cl_command_queue queue = clCreateCommandQueue (context , device_id , 0 , &cl_error ) ;
  221.   OpenCL_test_execution ( "Create command queue" ,cl_error ) ;
  222.  
  223.   // END OF OPENCL INITIALIZATION
  224.   const char *kernel_str = " __kernel void copy(__global int *a, __global int *b) {"
  225.                             " int i = get_global_id(0);"
  226.                             " b[i]=a[i];"
  227.                             "}" ;
  228.  
  229.   program = clCreateProgramWithSource (context ,
  230.                                       1 ,
  231.                                       &kernel_str ,
  232.                                       NULL ,
  233.                                       &cl_error ) ;
  234.   OpenCL_test_execution ( "Create program with source" ,cl_error ) ;
  235.  
  236.   cl_error = clBuildProgram (program , 0 , NULL , NULL , NULL , NULL ) ;
  237.   OpenCL_test_execution ( "Build Program" ,cl_error ) ;
  238.  
  239.   kernel = clCreateKernel (program , "copy" , &cl_error ) ;
  240.   OpenCL_test_execution ( "Create kernel" ,cl_error ) ;
  241.  
  242.  
  243.  
  244.  
  245.   // Size of problem, 10^5 will give me 1.5ms for the enqueue, 10^6 up to 30ms!
  246.   size_t n = 10000000 ;
  247.   int _i ;
  248.   // Run the sequence many times
  249.   printf ( "Run with n = %zu\n" ,n ) ;
  250.   for (_i = 0 ;_i < 10 ;_i ++ ) {
  251.     openclSimpleCopy (context , queue , kernel ,n ) ;
  252.   }
  253.  
  254.   // Run the same sequence with a smaller problem size
  255.   n = n / 100 ;
  256.   printf ( "Run with n = %zu\n" ,n ) ;
  257.   for (_i = 0 ;_i < 10 ;_i ++ ) {
  258.     openclSimpleCopy (context , queue , kernel ,n ) ;
  259.   }
  260.  
  261.  
  262. }
  263.  
  264.  
  265.  
  266. char * OpenCL_error_to_string ( int error ) {
  267.   switch (error )
  268.     {
  269.     case CL_SUCCESS :
  270.       return ( char * ) "Success" ;
  271.     case CL_DEVICE_NOT_FOUND :
  272.       return ( char * ) "Device Not Found" ;
  273.     case CL_DEVICE_NOT_AVAILABLE :
  274.       return ( char * ) "Device Not Available" ;
  275.     case CL_COMPILER_NOT_AVAILABLE :
  276.       return ( char * ) "Compiler Not Available" ;
  277.     case CL_MEM_OBJECT_ALLOCATION_FAILURE :
  278.       return ( char * ) "Mem Object Allocation Failure" ;
  279.     case CL_OUT_OF_RESOURCES :
  280.       return ( char * ) "Out Of Ressources" ;
  281.     case CL_OUT_OF_HOST_MEMORY :
  282.       return ( char * ) "Out Of Host Memory" ;
  283.     case CL_PROFILING_INFO_NOT_AVAILABLE :
  284.       return ( char * ) "Profiling Info Not Available" ;
  285.     case CL_MEM_COPY_OVERLAP :
  286.       return ( char * ) "Mem Copy Overlap" ;
  287.     case CL_IMAGE_FORMAT_MISMATCH :
  288.       return ( char * ) "Image Format Mismatch" ;
  289.     case CL_IMAGE_FORMAT_NOT_SUPPORTED :
  290.       return ( char * ) "Image Format Not Supported" ;
  291.     case CL_BUILD_PROGRAM_FAILURE : {
  292.   #define CL_BUILD_PROGRAM_FAILURE_MSG "Build Program Failure : "
  293.   static char debug_buffer [DEBUG_BUFFER_SIZE ] ; // Static to be returned
  294.   strncat (debug_buffer ,CL_BUILD_PROGRAM_FAILURE_MSG ,DEBUG_BUFFER_SIZE ) ;
  295.   clGetProgramBuildInfo (program ,
  296.           device_id ,
  297.           CL_PROGRAM_BUILD_LOG ,
  298.           DEBUG_BUFFER_SIZE ,
  299.           debug_buffer + strlen (CL_BUILD_PROGRAM_FAILURE_MSG ) ,
  300.           NULL ) ;
  301.       return ( char * )debug_buffer ;
  302.     }
  303.     case CL_MAP_FAILURE :
  304.       return ( char * ) "Map Failure" ;
  305.     case CL_INVALID_VALUE :
  306.       return ( char * ) "Invalid Value" ;
  307.     case CL_INVALID_DEVICE_TYPE :
  308.       return ( char * ) "Invalid Device Type" ;
  309.     case CL_INVALID_PLATFORM :
  310.       return ( char * ) "Invalid Platform" ;
  311.     case CL_INVALID_DEVICE :
  312.       return ( char * ) "Invalid Device" ;
  313.     case CL_INVALID_CONTEXT :
  314.       return ( char * ) "Invalid Context" ;
  315.     case CL_INVALID_QUEUE_PROPERTIES :
  316.       return ( char * ) "Invalid Queue Properties" ;
  317.     case CL_INVALID_COMMAND_QUEUE :
  318.       return ( char * ) "Invalid Command Queue" ;
  319.     case CL_INVALID_HOST_PTR :
  320.       return ( char * ) "Invalid Host Ptr" ;
  321.     case CL_INVALID_MEM_OBJECT :
  322.       return ( char * ) "Invalid Mem Object" ;
  323.     case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR :
  324.       return ( char * ) "Invalid Image Format Descriptor" ;
  325.     case CL_INVALID_IMAGE_SIZE :
  326.       return ( char * ) "Invalid Image Size" ;
  327.     case CL_INVALID_SAMPLER :
  328.       return ( char * ) "Invalid Sampler" ;
  329.     case CL_INVALID_BINARY :
  330.       return ( char * ) "Invalid Binary" ;
  331.     case CL_INVALID_BUILD_OPTIONS :
  332.       return ( char * ) "Invalid Build Options" ;
  333.     case CL_INVALID_PROGRAM :
  334.       return ( char * ) "Invalid Program" ;
  335.     case CL_INVALID_PROGRAM_EXECUTABLE :
  336.       return ( char * ) "Invalid Program Executable" ;
  337.     case CL_INVALID_KERNEL_NAME :
  338.       return ( char * ) "Invalid Kernel Name" ;
  339.     case CL_INVALID_KERNEL_DEFINITION :
  340.       return ( char * ) "Invalid Kernel Definition" ;
  341.     case CL_INVALID_KERNEL :
  342.       return ( char * ) "Invalid Kernel" ;
  343.     case CL_INVALID_ARG_INDEX :
  344.       return ( char * ) "Invalid Arg Index" ;
  345.     case CL_INVALID_ARG_VALUE :
  346.       return ( char * ) "Invalid Arg Value" ;
  347.     case CL_INVALID_ARG_SIZE :
  348.       return ( char * ) "Invalid Arg Size" ;
  349.     case CL_INVALID_KERNEL_ARGS :
  350.       return ( char * ) "Invalid Kernel Args" ;
  351.     case CL_INVALID_WORK_DIMENSION :
  352.       return ( char * ) "Invalid Work Dimension" ;
  353.     case CL_INVALID_WORK_GROUP_SIZE :
  354.       return ( char * ) "Invalid Work Group Size" ;
  355.     case CL_INVALID_WORK_ITEM_SIZE :
  356.       return ( char * ) "Invalid Work Item Size" ;
  357.     case CL_INVALID_GLOBAL_OFFSET :
  358.       return ( char * ) "Invalid Global Offset" ;
  359.     case CL_INVALID_EVENT_WAIT_LIST :
  360.       return ( char * ) "Invalid Event Wait List" ;
  361.     case CL_INVALID_EVENT :
  362.       return ( char * ) "Invalid Event" ;
  363.     case CL_INVALID_OPERATION :
  364.       return ( char * ) "Invalid Operation" ;
  365.     case CL_INVALID_GL_OBJECT :
  366.       return ( char * ) "Invalid GL Object" ;
  367.     case CL_INVALID_BUFFER_SIZE :
  368.       return ( char * ) "Invalid Buffer Size" ;
  369.     case CL_INVALID_MIP_LEVEL :
  370.       return ( char * ) "Invalid Mip Level" ;
  371.     case CL_INVALID_GLOBAL_WORK_SIZE :
  372.       return ( char * ) "Invalid Global Work Size" ;
  373.     default :
  374.       break ;
  375.     }
  376.   return "Unknown" ;
  377. }



#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <CL/opencl.h>

cl_int cl_error; // OpenCL error code
cl_device_id device_id; // The chosen device
cl_program program; // OpenCL program


/**//** Formats the standard MACROS  __FILE__ and __LINE__ for message print.
 */
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define AT __FILE__ ":" TOSTRING(__LINE__)


#define DEBUG_BUFFER_SIZE 4096
char * OpenCL_error_to_string(int error);

#define dump(msg,) \
    fprintf(stderr, AT msg,##__VA_ARGS__)


#define OpenCL_test_execution(msg,error)         \
  do {                  \
    if(CL_SUCCESS != error) {           \
      dump("The runtime error is %s\n",    \
        (char *)OpenCL_error_to_string(error));      \
      exit(EXIT_FAILURE);            \
    }                 \
  } while (0)




static double t_start, t_end; // Timing
double timer_get_time()
{
    struct timeval t;
    if (gettimeofday (&t, NULL) != 0) {
      perror("Error gettimeofday !\n");
      exit(1);
    }
    return (t.tv_sec + t.tv_usec * 1.0e-6);
}

void timer_start() {
  t_start = timer_get_time();
}

void timer_stop_display( char *msg ) {
  t_end = timer_get_time();
  printf ("%s : %0.1lf\n", msg, (t_end - t_start)*1000);
}



void openclSimpleCopy(cl_context context, cl_command_queue queue, cl_kernel kernel, size_t n) {
  // Host data
  int a[n],b[n];
  int _i;

  // Init
  for(_i=0;_i<n;_i++) {
    a[_i]=n-_i;
    b[_i]=0;
  }

  // Buffers on the device
  cl_mem a_dev = clCreateBuffer(context,
                                CL_MEM_READ_WRITE,
                                n * sizeof(int),
                                NULL,
                                &cl_error);
  OpenCL_test_execution("Create Buffer",cl_error);

  cl_mem b_dev = clCreateBuffer(context,
                                CL_MEM_READ_WRITE,
                                n * sizeof(int),
                                NULL,
                                &cl_error);
  OpenCL_test_execution("Create Buffer",cl_error);


  // 3 events is enough here
  cl_event event1;
  cl_event event2;
  cl_event event3;




  // Initialize buffer on the device
  cl_error =  clEnqueueWriteBuffer(queue,
                       a_dev,
                       CL_TRUE,
                       0,
                       n * sizeof(int),
                       a,
                       0,
                       NULL,
                       &event1);
  OpenCL_test_execution("Write to Buffer",cl_error);

  // Shouldn't be useful, I used a blocking write !
  clFlush(queue);
  clWaitForEvents(1,&event1);


  // Arguments for the kernel
  cl_error = clSetKernelArg(kernel,0,sizeof(a_dev), &a_dev);
  OpenCL_test_execution("Set argument 0 ",cl_error);

  cl_error = clSetKernelArg(kernel,1,sizeof(b_dev), &b_dev);
  OpenCL_test_execution("Set argument 1",cl_error);

  timer_start();
  cl_error = clEnqueueNDRangeKernel(queue,
                                    kernel,
                                    1,
                                    NULL,
                                    &n,
                                    NULL,
                                    1,
                                    &event1,
                                    &event2);

  timer_stop_display("Time for Enqueue");
  OpenCL_test_execution("Enqueue kernel",cl_error);

  OpenCL_test_execution("clWaitForEvents",clWaitForEvents(1,&event2));

  cl_error =  clEnqueueReadBuffer(queue,
                       b_dev,
                       CL_TRUE,
                       0,
                       n * sizeof(int),
                       b,
                       1,
                       &event2,
                       &event3);
  OpenCL_test_execution("Read from buffer",cl_error);

  OpenCL_test_execution("clWaitForEvents",clWaitForEvents(1,&event3));


  // Check result
  for(_i=0;_i<n;_i++) {
    if(a[_i]!=b[_i]) {
      printf("Error %d : %d!=%d\n",_i,a[_i],b[_i]);
      exit(-1);
    }
  }
  OpenCL_test_execution("Release mem object",clReleaseMemObject (a_dev));
  OpenCL_test_execution("Release mem object",clReleaseMemObject (b_dev));

}



int main(int argc, char **argv) {

  int platform_num = 0; // Platform number
  int device_num = 0; // Device number
#define DEVICE_TYPE CL_DEVICE_TYPE_ALL

  cl_int cl_error; // OpenCL error code
  cl_kernel kernel = NULL;


  // Chosing platform
  cl_uint num_platforms;
  clGetPlatformIDs(0, NULL, &num_platforms);
  if(num_platforms <= 0) {
    dump("No OpenCL platforms found :-(\n");
    exit(-1);
  }

  cl_platform_id platform_ids[num_platforms];
  clGetPlatformIDs(num_platforms, platform_ids, NULL);

  if(platform_num < 0 || platform_num >= num_platforms) {
    dump("Invalid platform: %d\n", platform_num);
    exit(EXIT_FAILURE);
  }

  // platform_id hold the chosen platform
  cl_platform_id platform_id = platform_ids[platform_num];

  // Chosing the device

  cl_uint num_devices;
  OpenCL_test_execution("Get number of devices", clGetDeviceIDs(platform_id, DEVICE_TYPE, 0, NULL, &num_devices));

  if(num_devices <= 0) {
    dump("No devices found associated to this OpenCL platform :-(\n");
    exit(-1);
  }

  // Allocate spaces for devices
  cl_device_id devices[num_devices];

  // Get devices list
  OpenCL_test_execution("Get devices list", clGetDeviceIDs(platform_id, DEVICE_TYPE, num_devices, devices, NULL));

  /**//* Create a context for all devices */
  cl_context context = clCreateContext(0,
                                       num_devices,
                                       devices,
                                       NULL,
                                       "from 'context'",
                                       &cl_error);
  OpenCL_test_execution("Context creation",cl_error);

  // Here is the device ID
  device_id = devices[device_num];

  /**//* Create an in-order queue for this device */
  cl_command_queue queue = clCreateCommandQueue(context, device_id, 0, &cl_error);
  OpenCL_test_execution("Create command queue",cl_error);

  // END OF OPENCL INITIALIZATION
  const char *kernel_str = " __kernel void copy(__global int *a, __global int *b) {"
                           " int i = get_global_id(0);"
                           " b[i]=a[i];"
                           "}";

  program = clCreateProgramWithSource(context,
                                      1,
                                      &kernel_str,
                                      NULL,
                                      &cl_error);
  OpenCL_test_execution("Create program with source",cl_error);

  cl_error = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
  OpenCL_test_execution("Build Program",cl_error);

  kernel = clCreateKernel(program, "copy", &cl_error);
  OpenCL_test_execution("Create kernel",cl_error);




  // Size of problem, 10^5 will give me 1.5ms for the enqueue, 10^6 up to 30ms!
  size_t n = 10000000;
  int _i;
  // Run the sequence many times
  printf("Run with n = %zu\n",n);
  for(_i=0;_i<10;_i++) {
    openclSimpleCopy(context, queue, kernel,n);
  }

  // Run the same sequence with a smaller problem size
  n = n/100;
  printf("Run with n = %zu\n",n);
  for(_i=0;_i<10;_i++) {
    openclSimpleCopy(context, queue, kernel,n);
  }


}



char * OpenCL_error_to_string(int error) {
  switch (error)
    {
    case CL_SUCCESS:
      return (char *)"Success";
    case CL_DEVICE_NOT_FOUND:
      return (char *)"Device Not Found";
    case CL_DEVICE_NOT_AVAILABLE:
      return (char *)"Device Not Available";
    case CL_COMPILER_NOT_AVAILABLE:
      return (char *)"Compiler Not Available";
    case CL_MEM_OBJECT_ALLOCATION_FAILURE:
      return (char *)"Mem Object Allocation Failure";
    case CL_OUT_OF_RESOURCES:
      return (char *)"Out Of Ressources";
    case CL_OUT_OF_HOST_MEMORY:
      return (char *)"Out Of Host Memory";
    case CL_PROFILING_INFO_NOT_AVAILABLE:
      return (char *)"Profiling Info Not Available";
    case CL_MEM_COPY_OVERLAP:
      return (char *)"Mem Copy Overlap";
    case CL_IMAGE_FORMAT_MISMATCH:
      return (char *)"Image Format Mismatch";
    case CL_IMAGE_FORMAT_NOT_SUPPORTED:
      return (char *)"Image Format Not Supported";
    case CL_BUILD_PROGRAM_FAILURE: {
  #define CL_BUILD_PROGRAM_FAILURE_MSG "Build Program Failure : "
  static char debug_buffer[DEBUG_BUFFER_SIZE]; // Static to be returned
  strncat(debug_buffer,CL_BUILD_PROGRAM_FAILURE_MSG,DEBUG_BUFFER_SIZE);
  clGetProgramBuildInfo(program,
          device_id,
          CL_PROGRAM_BUILD_LOG ,
          DEBUG_BUFFER_SIZE,
          debug_buffer+strlen(CL_BUILD_PROGRAM_FAILURE_MSG),
          NULL);
      return (char *)debug_buffer;
    }
    case CL_MAP_FAILURE:
      return (char *)"Map Failure";
    case CL_INVALID_VALUE:
      return (char *)"Invalid Value";
    case CL_INVALID_DEVICE_TYPE:
      return (char *)"Invalid Device Type";
    case CL_INVALID_PLATFORM:
      return (char *)"Invalid Platform";
    case CL_INVALID_DEVICE:
      return (char *)"Invalid Device";
    case CL_INVALID_CONTEXT:
      return (char *)"Invalid Context";
    case CL_INVALID_QUEUE_PROPERTIES:
      return (char *)"Invalid Queue Properties";
    case CL_INVALID_COMMAND_QUEUE:
      return (char *)"Invalid Command Queue";
    case CL_INVALID_HOST_PTR:
      return (char *)"Invalid Host Ptr";
    case CL_INVALID_MEM_OBJECT:
      return (char *)"Invalid Mem Object";
    case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
      return (char *)"Invalid Image Format Descriptor";
    case CL_INVALID_IMAGE_SIZE:
      return (char *)"Invalid Image Size";
    case CL_INVALID_SAMPLER:
      return (char *)"Invalid Sampler";
    case CL_INVALID_BINARY:
      return (char *)"Invalid Binary";
    case CL_INVALID_BUILD_OPTIONS:
      return (char *)"Invalid Build Options";
    case CL_INVALID_PROGRAM:
      return (char *)"Invalid Program";
    case CL_INVALID_PROGRAM_EXECUTABLE:
      return (char *)"Invalid Program Executable";
    case CL_INVALID_KERNEL_NAME:
      return (char *)"Invalid Kernel Name";
    case CL_INVALID_KERNEL_DEFINITION:
      return (char *)"Invalid Kernel Definition";
    case CL_INVALID_KERNEL:
      return (char *)"Invalid Kernel";
    case CL_INVALID_ARG_INDEX:
      return (char *)"Invalid Arg Index";
    case CL_INVALID_ARG_VALUE:
      return (char *)"Invalid Arg Value";
    case CL_INVALID_ARG_SIZE:
      return (char *)"Invalid Arg Size";
    case CL_INVALID_KERNEL_ARGS:
      return (char *)"Invalid Kernel Args";
    case CL_INVALID_WORK_DIMENSION:
      return (char *)"Invalid Work Dimension";
    case CL_INVALID_WORK_GROUP_SIZE:
      return (char *)"Invalid Work Group Size";
    case CL_INVALID_WORK_ITEM_SIZE:
      return (char *)"Invalid Work Item Size";
    case CL_INVALID_GLOBAL_OFFSET:
      return (char *)"Invalid Global Offset";
    case CL_INVALID_EVENT_WAIT_LIST:
      return (char *)"Invalid Event Wait List";
    case CL_INVALID_EVENT:
      return (char *)"Invalid Event";
    case CL_INVALID_OPERATION:
      return (char *)"Invalid Operation";
    case CL_INVALID_GL_OBJECT:
      return (char *)"Invalid GL Object";
    case CL_INVALID_BUFFER_SIZE:
      return (char *)"Invalid Buffer Size";
    case CL_INVALID_MIP_LEVEL:
      return (char *)"Invalid Mip Level";
    case CL_INVALID_GLOBAL_WORK_SIZE:
      return (char *)"Invalid Global Work Size";
    default:
      break;
    }
  return "Unknown";
}

你可能感兴趣的:(Test latency for clEnqueueNDRangeKernel)

  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • webpack图片等资源的处理 dmengmeng
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • 多线程之——ExecutorCompletionService 阿福德
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • [Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring 黄小二哥 swift
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • Dockerfile（1） - FROM 指令详解 小菠萝测试笔记 dockerpythonjavacmd大数据
    FROM指明当前的镜像基于哪个镜像构建dockerfile必须以FROM开头，除了ARG命令可以在FROM前面FROM[--platform=][AS]FROM[--platform=][:][AS]FROM[--platform=][@][AS]小栗子FROMalpine:latest一个dockerfile可以有多个FROM可以有多个FROM来创建多个镜像，或区分构建阶段，将一个构建阶段作为另
  • 详解mybatis的一二级缓存以及缓存失效原因 仰望天花板 缓存数据库mybatisjavamysql
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
  • [移动端自动化] AppAgent介绍 大卫软件测试 自动化
    AUITestAgentAUITestAgent/README_zh.mdatmain·bz-lab/AUITestAgent(github.com)1/MobileAgentX-PLUG/MobileAgent:Mobile-Agent:ThePowerfulMobileDeviceOperationAssistantFamily(github.com)2/AppAgentAppAgent/RE
  • python比较字符串是否一样,Python如何确定两个字符串是否相同 鲁东学子 python比较字符串是否一样
    I'vetriedtounderstandwhenPythonstringsareidentical(akasharingthesamememorylocation).Howeverduringmytests,thereseemstobenoobviousexplanationwhentwostringvariablesthatareequalsharethesamememory:importsy
  • UI 自动化的页面对象管理神器 PO-Manager TesterHome
    原文由alex发表于TesterHome社区网站，点击原文链接可于作者直接交流。做UI自动化的同学都知道，UI自动化一个难点就是页面元素的变化，让自动化维护成为一个痛点。在此，为了减轻这个痛点，我在基于Page-Object模式的基础上开发了页面对象维护的工具。该工具为vscode的一个插件，可以通过vscode插件市场搜索PO-Manager来下载安装本文中的页面对象库文件基于json.一个元素
  • 【C#Mutex】 initiallyOwned错误引起的缺陷 闻缺陷则喜何志丹 c#互斥量进程同步WaitOneinitiallyOwned临界区
    临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
  • python读写CSV文件 bcbobo21cn .Netpython开发语言机器学习CSV
    做数据分析，有时候要分析的数据在CSV文件里；先看一下python读写CSV文件；importpandasaspddf=pd.read_csv('test1.csv')print(df)print('')print(df.head(2))companyname=["A1","B2","E3","F4"]legperson=["lier","yanqi","wangwu","zhangsan"]le
  • 基于Python执行lua脚本 xu-jssy Python自动化脚本pythonlua自动化rpa
    一、依赖安装pipinstalllupa二、源码将lua文件存放在base_path路径，将lua文件名称（不包含后缀名）传递给lua_runner函数即可importmultiprocessingimportlupa#lua文件存放位置base_path='D:\\test\\lua'classLuaFuncion:#创建Lua运行时环境lua=lupa.LuaRuntime(unpack_re
  • Presto【基础 01】简介+架构+数据源+数据模型 2401_84254343 程序员架构
    一个Catalog包含Schema和Connector。例如，配置JMX的Catalog，通过JXMConnector访问JXM信息。当执行一条SQL语句时，可以同时运行在多个Catalog。Presto处理table时，是通过表的完全限定（fully-qualified）名来找到Catalog。例如，一个表的权限定名是hive.test_data.test，则test是表名，test_data是
  • 安装依赖时报错：npm ERR! code ERESOLVE npm ERR! ERESOLVE could not resolve npm ERR! npm ERR! While resolving 帅气绝非偶然 npm前端node.js
    这里我在npmivant@latest-v2或者其他依赖包的时候出现以上错误可能是npm版本问题报错解决方法：在安装命令后边加上1|--legacy-peer-deps或者--force如图中的指令：
  • HALTT4LLM：大型语言模型的幻觉检测指标 谢忻含Norma
    HALTT4LLM：大型语言模型的幻觉检测指标haltt4llmThisprojectisanattempttocreateacommonmetrictotestLLM'sforprogressineliminatinghallucinationswhichisthemostseriouscurrentprobleminwidespreadadoptionofLLM'sformanyrealpur
  • 5-【JavaWeb】JUnit 单元测试及JUL 日志系统 weixin_44329069 JavaWebjunit单元测试
    1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
  • Python OS模块操作文件 小丫头呀 #Python随笔python
    在Python中，可以使用os模块主要对文件进行重命名，删除等一些操作以下为os模块常用的方法示例:重命名操作importosos.rename('Test.txt','Test_重命名.txt')#参数1：要重命名的源文件#参数2：对源文件要重新命名的名称删除文件importosos.remove('Test_重命名.txt')#参数为要删除的源文件名称，如果该文件不存在则抛出异常创建空文件夹i
  • 学生管理系统 wu1113_ java
    文章目录1.案例需求2.编程思路3.运行效果4.案例源码5.小结1.案例需求上次我们完成了一个酒店管理系统，这次我们使用面向对象思维，完成一个学生管理系统。实现一个简单的学生管理系统，它具备5个功能，分别为显示所有的学生信息添加学生修改学生信息删除学生退出本系统功能2.编程思路首先我们要额外定义一个Studnet类，包括学生的学号、姓名、年龄、性别等属性。其次我们定义一个测试类Test，在测试类的
  • VUE实现大小缩放轮播图 书边事. vue.js前端javascript
    效果图import{ref,computed,reactive,watch,onMounted}from'vue';exportdefault{props:{/***轮播数据来源*/source:{type:Array,default:()=>[{img:require('@/assets/imgs/test/1.png')},{img:require('@/assets/imgs/test/1.
  • python 判断 ‘NoneType’的方法 cuisidong1997 文本转换python
    的错误时说明需要进行判断，而对‘NoneType’进行判断时直接使用‘isNone’即可，如下：iftextisNone:print('testis’+None)else:print('testisnot’+None)a=re.match(r’主叫号码(.*)客户姓名’,r’2、主叫号码：15558191990;3、客户姓名：韩东远;')print(type(a))ifaisNone:print(
  • Unity3D多线程UI之ScrollYExtand 胡强_79a4
    先附上git地址https://github.com/huqiang0204/huqiang.UnitySubThreadUI示例代码请看ScrollExTestPage可以绑定三种模型，头部，尾部，和中间数据部分这里只用到了中间数据模型和头部模型Listdatas=newList();ScrollYExtand.DataTemplatetmp=newScrollYExtand.DataTempl
  • Ihandy Unity开发 面试题 2024 z2014z 面试职场和发展
    1.当i>10时，调用test是否会出现死锁？原因是什么？voidtest(inti){lock(this){if(i>10){i--;test(i);}}}2.有一个表有n条记录，每条记录有两个字段，weight和id，写出程序保证id出现的概率与权重相同3.从1到n，一共有多少个14.二叉树的层次遍历5.给定两个链表，将对应数值相加6.检查两棵树是否相同
  • PCIe进阶之Gen3 Physical Layer Transmit Logic（二） 芯芯之火，可以燎原 PCIe进阶硬件工程信息与通信
    1文章概述本文是接着上面一篇文章《Gen3PhysicalLayerTransmitLogic（一）》继续对Gen3PhysicalLayerTransmitLogic做进一步的解析，具体包含ByteStriping和Scrambling以及Serializer。1.1ByteStripingGen3x1OrderedSetConstruction如下所示：OrderedSetBlock由一个Sy
  • 避免 PyCharm 将该 Python 脚本作为测试运行 MonkeyKing.sun pythonpycharmide
    为了避免PyCharm将该Python脚本作为测试运行（即pytest自动捕获），你可以做以下几步来确保该脚本作为普通的Python程序执行，而不是作为pytest运行。解决方案：1.确保文件名不以test_开头：Pytest会自动检测以test_开头的文件，并尝试将其作为测试运行。如果你的文件名是test_milvus.py，pytest会尝试收集并运行它。可以重命名文件为不包含test_的前缀
  • PostgreSQL | 生成UUID 报错：HINT: No function matches the given name and argument types 慌途L PostgreSQLpostgresqluuiduuid_generategen_random_uuid
    在PG数据库上新建表结构：CREATETABLE"public"."t_test"("guid"uuidNOTNULLDEFAULTuuid_generate_v4(),"data"jsonb,"create_time"timestamptz(6)DEFAULTnow(),CONSTRAINT"test_pkey"PRIMARYKEY("guid"));报错：ERROR:functionuuid_
  • vue3 + vite + js 配置Eslint + prettier 菜鸡的崛起 vuejavascriptvue
    第一步安装ESlintnpmieslint@latest-D或pnpmaddeslint@latest-D/pnpminstalleslint@latest-D或yarnaddeslint@latest-D第二步初始化Eslintnpxeslint--init执行npxeslint--init控制台会出现以下步骤1）你想如何使用ESLint（选择最后一个）Youcanalsorunthiscomm
  • oracle实验-RMAN的PIPE接口 congqingm32098 数据库
    RMAN的PIPE接口RMAN除了支持交互式和批处理式，还支持一种PIPE的接口，通过这种PIPE接口，可以在ORACLE中将各种命令发送给RMAN。首先，以PIPE方式启动RMAN，其中P1是管道的名称：F:>RMANPIPEP1TARGET/@TESTNOCATALOG恢复管理器:版本9.2.0.4.0-ProductionCopyright(c)1995,2002,OracleCorpora
  • 多线程编程之卫生间 周凡杨 java并发卫生间线程厕所
    如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
  • How to Install GUI to Centos Minimal sunjing linuxInstallDesktopGUI
    http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html   I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
  • Shell 函数 daizj shell函数
    Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
  • Linux服务器新手操作之一 周凡杨 Linux 简单 操作
    1.whoami      当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。      此时可以使用whoami命令。      [ecuser@HA5-DZ05 ~]$ whoami       e
  • 浅谈Socket通信（一） 朱辉辉33 socket
    在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。    首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包    ServerSock
  • 关于框架的简单认识 西蜀石兰 框架
    入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 都说学前端的要知道三大框架，目前node.
  • You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
    You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
  • MySQL5.6的my.ini配置 aigo mysql
    注意：以下配置的服务器硬件是：8核16G内存    [client]   port=3306   [mysql]   default-character-set=utf8     [mysqld]   port=3306   basedir=D:/mysql-5.6.21-win
  • mysql 全文模糊查找 便捷解决方案 alxw4616 mysql
    mysql 全文模糊查找 便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
  • 自定义数据结构 链表(单项 ,双向,环形) 百合不是茶 单项链表双向链表
         链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的       单项链表;数据从第一个指向最后一个   实现代码:        //定义动态链表 clas
  • threadLocal实例 bijian1013 javathreadjava多线程threadLocal
    实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
  • activemq安全设置—设置admin的用户名和密码 bijian1013 javaactivemq
            ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
  • 【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
    本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。   范型内容 范型集合类 范型类
  • 【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
    在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证   1. 建立一个有两个列族的表   create 'members','colfam1','colfam2'   2. 在members表中的colfam1中插入50*5
  • Nginx 官方一个配置实例 ronin47 nginx 配置实例
    user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
  • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环 bylijinnan java
    //use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
  • 返回null还是empty bylijinnan javaapachespring编程
    第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 第二个问题，函数输入参数不当时，是异常还是返回null？ 先看第一个问题 有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》） 理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
  • [科技与项目]工作流厂商的战略机遇期 comsci 工作流
          在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。         在微软，甲骨文，谷歌，IBM,SONY
  • 过度设计-举例 cuityang 过度设计
    过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 再举一个例子，对闰年的判断逻辑： 　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if (   ($Year%4==0  &am
  • java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
    记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
  • 网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
      协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定 　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。 　　两类服务： 　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。 　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
  • mac中用命令行运行mysql dcj3sjt126com mysqllinuxmac
    参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
  • MongDB查询（1）——基本查询[五] eksliang mongodbmongodb 查询mongodb find
    MongDB查询 转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....}  参数含义： query:查询参数 fie
  • base64，加密解密 经融加密，对接 y806839048 经融加密对接
    String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
  • JavaWeb之JSP概述 ihuning javaweb
      什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。   JSP起源    在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  如果使用Servl
  • apple watch 指南 啸笑天 apple
    1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina） 译文 译者 原文 概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
  • java经典的基础题目 macroli java编程
    1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
  • 你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象regex
    var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
  • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hivehive分析表hive统计信息hive Statistics
    关键字：Hive统计信息、分析Hive表、Hive Statistics   类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。   表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等；   14.1 新表的统计信息 对于一个新创建
  • Spring Boot 1.2.5 发布 wiselyman spring boot
        Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。   这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。   官方建议所有的Spring Boot用户升级这个版本。   项目首页 | 源
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他