Changeset 19346

Timestamp:

Sep 3, 2008, 12:22:54 PM (18 years ago)

Author:

Paul Price

Message:

Threading the concatenation of inspection lists and pmStackReject.

Location:

trunk/ppStack/src

Files:

• ppStack.h (modified) (1 diff)
• ppStackLoop.c (modified) (6 diffs)
• ppStackReadout.c (modified) (1 diff)
• ppStackThread.c (modified) (1 diff)

trunk/ppStack/src/ppStack.h

@@ -96 +96 @@
     );
 
+// Concatenate inspection lists for each input image
+bool ppStackInspect(psThreadJob *job    // Job to process
+    );
+
 // Perform stacking on a readout
 bool ppStackReadoutFinal(const pmConfig *config,   // Configuration

trunk/ppStack/src/ppStackLoop.c

@@ -477 +477 @@
     pmReadout *outRO = NULL;            // Output readout
     pmFPAview *view = NULL;             // View to readout
+    psArray *inspect = NULL;            // Array of arrays of pixels to inspect
     {
         int row0, col0;                 // Offset for readout
@@ -518 +519 @@
 
         bool status;                    // Status of read
-        for (int numChunk = 0; true; numChunk++) {
+        int numChunk;                   // Number of chunks
+        for (numChunk = 0; true; numChunk++) {
             ppStackThread *thread = ppStackThreadRead(&status, stack, config, numChunk, overlap);
             if (!status) {
@@ -567 +569 @@
         }
 
+        // Harvest the jobs, gathering the inspection lists
+        inspect = psArrayAlloc(num);
+        for (int i = 0; i < num; i++) {
+            if (inputMask->data.U8[i]) {
+                continue;
+            }
+            inspect->data[i] = psArrayAllocEmpty(numChunk);
+        }
+        psThreadJob *job;               // Completed job
+        while ((job = psThreadJobGetDone())) {
+            psArray *results = job->results; // Results of job
+            for (int i = 0; i < num; i++) {
+                if (inputMask->data.U8[i]) {
+                    continue;
+                }
+                inspect->data[i] = psArrayAdd(inspect->data[i], 1, results->data[i]);
+            }
+            psFree(job);
+        }
+
         memDump("initial");
     }
@@ -573 +595 @@
     psArray *rejected = psArrayAlloc(num);
     {
-        psArray *inspect = psArrayAlloc(num); // Pixels to inspect
         int numRejected = 0;        // Number of inputs rejected completely
 
@@ -581 +602 @@
                 numRejected++;
             }
-            inspect->data[i] = psPixelsAllocEmpty(PIXELS_BUFFER);
-        }
-
-        // Harvest the jobs, combining the inspection lists
-        psThreadJob *job;           // Completed job
-        while ((job = psThreadJobGetDone())) {
-            psArray *results = job->results; // Results of job
-            psAssert(results && results->n == num, "Results array.");
-            for (int i = 0; i < num; i++) {
-                if (inputMask->data.U8[i]) {
-                    continue;
-                }
-                inspect->data[i] = psPixelsConcatenate(inspect->data[i], results->data[i]);
-            }
-            psFree(job);
         }
 
@@ -602 +608 @@
                 continue;
             }
+
+            psThreadJob *job = psThreadJobAlloc("PPSTACK_INSPECT"); // Job to start
+            psArrayAdd(job->args, 1, inspect);
+            PS_ARRAY_ADD_SCALAR(job->args, i, PS_TYPE_S32);
+            if (!psThreadJobAddPending(job)) {
+                psFree(job);
+                psFree(subKernels);
+                psFree(subRegions);
+                psFree(stack);
+                psFree(inputMask);
+                psFree(view);
+                psFree(outRO);
+                psFree(inspect);
+                psFree(rejected);
+                return false;
+            }
+            psFree(job);
+        }
+
+        if (!psThreadPoolWait(false)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to concatenate inspection lists.");
+            psFree(subKernels);
+            psFree(subRegions);
+            psFree(stack);
+            psFree(inputMask);
+            psFree(view);
+            psFree(outRO);
+            psFree(inspect);
+            psFree(rejected);
+            return false;
+        }
+
+        if (psMetadataLookupS32(NULL, config->arguments, "-threads") > 0) {
+            pmStackRejectThreadsInit();
+        }
+
+        // Reject bad pixels
+        for (int i = 0; i < num; i++) {
 
 #ifdef TESTING

trunk/ppStack/src/ppStackReadout.c

@@ -46 +46 @@
 
     return status;
+}
+
+
+bool ppStackInspect(psThreadJob *job)
+{
+    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
+
+    psArray *args = job->args;  // Input arguments
+    psArray *inspect = args->data[0]; // Array of pixel arrays
+    int index = PS_SCALAR_VALUE(args->data[1], S32); // Index of interest
+
+    psArray *inputs = inspect->data[index]; // Array of interest
+    psPixels *output = NULL;    // Output pixel list
+    for (int i = 0; i < inputs->n; i++) {
+        psPixels *input = inputs->data[i]; // Input pixel list
+        if (!input || input->n == 0) {
+            continue;
+        }
+        output = psPixelsConcatenate(output, input);
+    }
+
+    psFree(inputs);
+    inspect->data[index] = output;
+
+    return true;
 }
 

trunk/ppStack/src/ppStackThread.c

@@ -242 +242 @@
 
     {
+        psThreadTask *task = psThreadTaskAlloc("PPSTACK_INSPECT", 2);
+        task->function = &ppStackInspect;
+        psThreadTaskAdd(task);
+        psFree(task);
+    }
+
+    {
         psThreadTask *task = psThreadTaskAlloc("PPSTACK_FINAL_COMBINE", 4);
         task->function = &ppStackReadoutFinalThread;