ECC-604: Add extra tests

tests/CMakeLists.txt

@@ -218,16 +218,13 @@ if( ENABLE_EXTRA_TESTS AND HAVE_ECCODES_THREADS )
                       COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/grib_encode_pthreads.sh
     )
 
-    ecbuild_add_executable( TARGET    grib_ecc-604-1
+    foreach( test grib_ecc-604-1 grib_ecc-604-2 grib_ecc-604-3 )
+        ecbuild_add_executable( TARGET    ${test}
                                 NOINSTALL
-                            SOURCES   grib_ecc-604-1.c
-                            LIBS      eccodes
-    )
-    ecbuild_add_executable( TARGET    grib_ecc-604-2
-                            NOINSTALL
-                            SOURCES   grib_ecc-604-2.c
+                                SOURCES   ${test}.c
                                 LIBS      eccodes
         )
+    endforeach()
     ecbuild_add_test( TARGET eccodes_t_grib_ecc-604
                       TYPE SCRIPT
                       COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/grib_ecc-604.sh

tests/grib_ecc-604-3.c

@@ -0,0 +1,152 @@
+/*
+ * Test for ECC-604: No output writing
+ */
+#include <time.h>
+#include <pthread.h>
+#include <assert.h>
+
+#include "grib_api.h"
+
+static size_t NUM_THREADS         = 8;
+static size_t FILES_PER_ITERATION = 300;
+static char* INPUT_FILE           = NULL;
+
+static int decode_file(char *template_file)
+{
+    FILE *in;
+    grib_handle *source_handle = NULL;
+    const void *buffer = NULL;
+    size_t size = 0;
+    int err = 0;
+    double *values;
+
+    in = fopen(template_file,"r"); assert(in);
+
+    /* loop over the messages in the source GRIB and clone them */
+    while ((source_handle = grib_handle_new_from_file(0, in, &err))!=NULL) {
+        int i;
+        long count;
+        double d,e;
+        size_t values_len= 0;
+
+        grib_handle *clone_handle = grib_handle_clone(source_handle);
+        assert(clone_handle);
+
+        /*GRIB_CHECK(grib_set_long(clone_handle, "centre", 250),0);*/
+        GRIB_CHECK(grib_get_size(clone_handle, "values", &values_len),0);
+
+        values = (double*)malloc(values_len*sizeof(double));
+        d=10e-8;
+        e=d;
+        count=1;
+        for (i=0;i<values_len;i++) {
+            if (count>100) {e*=10; count=1;}
+            values[i]=d;
+            d+=e;
+            count++;
+        }
+
+        GRIB_CHECK(grib_set_long(clone_handle,"bitsPerValue",16),0);
+
+        /* set data values */
+        GRIB_CHECK(grib_set_double_array(clone_handle,"values",values,values_len),0);
+
+        GRIB_CHECK(grib_get_message(clone_handle,&buffer,&size),0);
+
+        grib_handle_delete(clone_handle);
+        grib_handle_delete(source_handle);
+        free(values);
+    }
+
+    fclose(in);
+
+    return 0;
+}
+
+void do_stuff(void *data);
+
+/* Structure for passing data to threads */
+struct v {
+    size_t number;
+    char *data;
+};
+
+void *runner(void *ptr); /* the thread */
+
+int main(int argc, char **argv)
+{
+    size_t i;
+    int thread_counter = 0;
+    int parallel = 1;
+    const char* prog = argv[0];
+    char* mode;
+    if (argc!=5) {
+        fprintf(stderr, "Usage:\n\t%s seq file numRuns numIter\nOr\n\t%s par file numThreads numIter\n", prog, prog);
+        return 1;
+    }
+    mode = argv[1];
+    INPUT_FILE= argv[2];
+    NUM_THREADS = atol(argv[3]);
+    FILES_PER_ITERATION = atol(argv[4]);
+
+    if (strcmp(mode,"seq")==0) {
+        parallel = 0;
+    }
+    if (parallel) {
+        printf("Running parallel in %ld threads. %ld iterations\n", NUM_THREADS, FILES_PER_ITERATION);
+    } else {
+        printf("Running sequentially in %ld runs. %ld iterations\n", NUM_THREADS, FILES_PER_ITERATION);
+    }
+
+    pthread_t workers[NUM_THREADS];
+    for (i = 0; i < NUM_THREADS; i++) {
+        struct v *data = (struct v *) malloc(sizeof(struct v));
+        data->number = i;
+        data->data = NULL;
+
+        if (parallel) {
+            /* Now we will create the thread passing it data as an argument */
+            pthread_create(&workers[thread_counter], NULL, runner, data);
+            /*pthread_join(workers[thread_counter], NULL);*/
+            thread_counter++;
+        } else {
+            do_stuff(data);
+        }
+    }
+
+    if (parallel) {
+        for (i = 0; i < NUM_THREADS; i++)  {
+            pthread_join(workers[i], NULL);
+        }
+    }
+
+    return 0;
+}
+
+void *runner(void *ptr)
+{
+    do_stuff(ptr);
+    pthread_exit(0);
+}
+
+void do_stuff(void *ptr)
+{
+    /* Cast argument to struct v pointer */
+    struct v *data = ptr;
+    size_t i;
+
+    for (i=0; i<FILES_PER_ITERATION;i++) {
+        decode_file(INPUT_FILE);
+    }
+
+    time_t ltime;
+    struct tm result;
+    char stime[32];
+
+    ltime = time(NULL);
+    localtime_r(&ltime, &result);
+    strftime(stime, 32, "%H:%M:%S", &result); /* Try to get milliseconds here too*/
+    /* asctime_r(&result, stime); */
+
+    printf("%s: Worker %ld finished.\n", stime, data->number);
+}

tests/grib_ecc-604.sh

@@ -31,17 +31,24 @@ rm -fr $temp_dir
 mkdir -p $temp_dir
 cd $temp_dir
 
-# Test 01
+# Test 01: clone + output
+# ------------------------
 mkdir -p $OUTPUT
 time ${test_dir}/grib_ecc-604-1 par $input $NUM_THREADS $NUM_ITER
 validate
 
-# Test 02
+# Test 02: No clone + output
+# --------------------------
 rm -fr $OUTPUT
 mkdir -p $OUTPUT
 time ${test_dir}/grib_ecc-604-2 par $input $NUM_THREADS $NUM_ITER
 validate
 
+# Test 03: clone + no output
+# ---------------------------
+rm -fr $OUTPUT
+time ${test_dir}/grib_ecc-604-3 par $input $NUM_THREADS $NUM_ITER
+
 
 # Clean up
 cd $test_dir