Merge lp:~epics-core/epics-base/compress into lp:~epics-core/epics-base/3.16

[mdavidsaver]

From Kukhee Kim

- Implement LIFO behavior in compress record
- Prepare new field BALG (Buffering Algorithm) to allow to choose FIFO and LIFO

From Michael Davidsaver

I've rebased against the current 3.16 branch and added unit testing of (only) circular buffer mode with FIFO and LIFO ordering.

In the process of writing the test I found that before the buffer is filled (nuse<nsam) the first nsam-nuse elements are visible as zeros. I didn't like this and changed the handling of OFF in compressRecord and in of no_elements in dbGet to avoid it.

So the changes which need the most attention are to dbGet() and the arr filter. These changes switch from wrapping around based on the number of valid elements set by rset::get_array_info to wrapping using the max field size. The actual number of elements copied out is still bounded by the # of valid elements.

This should only be a change where offset>0 and the buffer is not full. Given that this didn't work quite right before (could wrap one element early) I'm guessing that no existing code intentionally depends on this.

[Kim, Kukhee (khkim)]

Revision 12520 - 12523

Add epics thread id validation routine
Modify epicsThreadGetName to check up if the thread id is valid to avoid crash
Modify epicsThreadResume() command to avoid crash when user inputs an invalid thread id

[mdavidsaver (mdavidsaver)]

What should be done about switching between FIFO and LIFO at runtime? At present LIFO -> FIFO clears the buffer. FIFO -> LIFO can't clear the buffer, but could zero it. Alternately, make the BALG field read only somehow.

Otherwise this works as I expect.

To save Andrew the trouble, please add to RELEASE_NOTES.html

review: Needs Fixing

[mdavidsaver (mdavidsaver)]

Zeroing the buffer on reset seems sufficient.

As for epicsThreadValidateId(), it seems reasonable for the current implementation of epicsThreadResume(). IMO epicsThreadResume() is broken by design and should be removed, or epicsThread needs to be reimplemented around it. But this is the subject of another development.

Also, I'm commenting now because I've just noticed that there was activity on this branch. Since launchpad is sparing with email notifications it's a good idea to send a note to core-talk when pushing changes to a branch after a long period of inactivity.

review: Approve

[Ralph Lange (ralph-lange)]

Should have some tests added, shouldn't it?

review: Needs Fixing

[Andrew Johnson (anj)]

Results of AJ+MD+RL discussion about this today:
* This should be a 3.16 change (3.16.0.2 maybe), not 3.15.
* Needs Release Notes entry and POD documentation for the new field (AJ?).
* Remove the epicsThreadValidateId() changes, not ready.
* Automated tests would be nice given the complexity of the record, but we will accept the change without them.

[mdavidsaver (mdavidsaver)]

Rebased only compressRecord changes against 3.16. Added unittest and a change to dbGet().

@AJ/RL I know I was the one pushing to wave the unittest requirement for this change, but on reflection I've changed my mind. Testing recordtype logic is now straightforward. Not doing so is just laziness. I'll save the waiver argument for rsrv interface binding, where unittesting isn't straightforward.

As for the change to dbGet()... I have to admit this was a case of scope creep.

review: Approve

[lp:~epics-core/epics-base/compress]

12708. By mdavidsaver on 2016-01-14

update release notes

[Andrew Johnson (anj)]

Merging after some minor source reformatting.

review: Approve

=== modified file 'documentation/RELEASE_NOTES.html'
--- documentation/RELEASE_NOTES.html	2015-09-07 19:23:04 +0000
+++ documentation/RELEASE_NOTES.html	2016-01-14 02:46:51 +0000
@@ -20,6 +20,12 @@
 
 -->
 
+<h3>compressRecord buffering order</h3>
+
+<p>The compressRecord has a new field <em>BALG</em> which can select between
+FIFO (append) and LIFO (prepend) ordering for insertion of new elements.
+FIFO ordering is the default.</p>
+
 <h3>Database Multi-locking</h3>
 
 <p>dbLock.c is re-written with an expanded API, and the removal of global mutex locks.</p>

=== modified file 'src/ioc/db/dbAccess.c'
--- src/ioc/db/dbAccess.c	2015-09-07 04:15:21 +0000
+++ src/ioc/db/dbAccess.c	2016-01-14 02:46:51 +0000
@@ -816,7 +816,7 @@
     void *pfieldsave;
     db_field_log *pfl = (db_field_log *)pflin;
     short field_type;
-    long no_elements;
+    long no_elements, max_elements;
     long offset;
     struct rset *prset;
     long status = 0;
@@ -828,10 +828,10 @@
 
     if (!pfl || pfl->type == dbfl_type_rec) {
         field_type  = paddr->field_type;
-        no_elements = paddr->no_elements;
+        max_elements = no_elements = paddr->no_elements;
     } else {
         field_type  = pfl->field_type;
-        no_elements = pfl->no_elements;
+        max_elements = no_elements = pfl->no_elements;
     }
 
     if (field_type >= DBF_INLINK && field_type <= DBF_FWDLINK)
@@ -906,7 +906,7 @@
         if (n <= 0) {
             ;/*do nothing*/
         } else if (!pfl || pfl->type == dbfl_type_rec) {
-            status = convert(paddr, pbuf, n, no_elements, offset);
+            status = convert(paddr, pbuf, n, max_elements, offset);
         } else {
             DBADDR localAddr = *paddr; /* Structure copy */
 
@@ -917,7 +917,7 @@
                 localAddr.pfield = (char *) &pfl->u.v.field;
             else
                 localAddr.pfield = (char *)  pfl->u.r.field;
-            status = convert(&localAddr, pbuf, n, no_elements, offset);
+            status = convert(&localAddr, pbuf, n, max_elements, offset);
         }
     }
 done:

=== modified file 'src/std/filters/arr.c'
--- src/std/filters/arr.c	2014-09-30 14:19:13 +0000
+++ src/std/filters/arr.c	2016-01-14 02:46:51 +0000
@@ -95,7 +95,7 @@
     long end = my->end;
     long nTarget = 0;
     long offset = 0;
-    long nSource = chan->addr.no_elements;
+    long nSource = chan->addr.no_elements, maxSource = nSource;
 
     /* Only array data */
     if (pfl->type == dbfl_type_val) {
@@ -126,7 +126,7 @@
                     pfl->u.r.dtor = freeArray;
                     pfl->u.r.pvt = my->arrayFreeList;
                     offset = (offset + start) % chan->addr.no_elements;
-                    dbExtractArrayFromRec(&chan->addr, pdst, nTarget, nSource, offset, my->incr);
+                    dbExtractArrayFromRec(&chan->addr, pdst, nTarget, maxSource, offset, my->incr);
                     pfl->u.r.field = pdst;
                 }
             }

=== modified file 'src/std/rec/compressRecord.c'
--- src/std/rec/compressRecord.c	2013-12-17 18:54:04 +0000
+++ src/std/rec/compressRecord.c	2016-01-14 02:46:51 +0000
@@ -92,6 +92,8 @@
     if (prec->alg == compressALG_Average && prec->sptr == 0){
         prec->sptr = calloc(prec->nsam, sizeof(double));
     }
+
+   if(prec->bptr && prec->nsam) memset(prec->bptr, 0, prec->nsam * sizeof(double));
 }
 
 static void monitor(compressRecord *prec)
@@ -108,29 +110,32 @@
 
 static void put_value(compressRecord *prec, double *psource, int n)
 {
-    epicsInt32 offset = prec->off;
-    epicsInt32 nuse = prec->nuse;
-    epicsInt32 nsam = prec->nsam;
-    double *pdest = prec->bptr + offset;
-    int i;
+    int fifo = prec->balg==bufferingALG_FIFO;
+    epicsUInt32 offset = prec->off;
+    epicsUInt32 nuse = prec->nuse;
+    epicsUInt32 nsam = prec->nsam;
 
-    for (i = 0; i < n; i++) {
-        *pdest = *psource++;
-        if (++offset >= nsam) {
-            pdest = prec->bptr;
-            offset = 0;
-        }
-        else
-            pdest++;
-    }
     nuse += n;
-    if (nuse > nsam)
+    if(nuse>nsam)
         nuse = nsam;
+
+    while(n--) {
+        /* for LIFO, decrement before */
+        if(!fifo)
+            offset = (offset-1)%nsam;
+
+        prec->bptr[offset] = *psource++;
+
+        /* for FIFO, increment after */
+        if(fifo)
+            offset = (offset+1)%nsam;
+    }
+
     prec->off = offset;
     prec->nuse = nuse;
-    return;
 }
-

+
+
 /* qsort comparison function (for median calculation) */
 static int compare(const void *arg1, const void *arg2)
 {
@@ -305,6 +310,7 @@
         prec->bptr = calloc(prec->nsam, sizeof(double));
         reset(prec);
     }
+
     return 0;
 }
 
@@ -388,18 +394,30 @@
     paddr->field_type = DBF_DOUBLE;
     paddr->field_size = sizeof(double);
     paddr->dbr_field_type = DBF_DOUBLE;
+
+    if(prec->balg == bufferingALG_LIFO) paddr->special = SPC_NOMOD;
     return 0;
 }
 
 static long get_array_info(DBADDR *paddr, long *no_elements, long *offset)
 {
+    /* offset indicates the next element which would be written.
+     * In FIFO mode offset-1 is the last valid element
+     * In LIFO mode offset is the first valid element
+     * (*offset) should be set to the index of the first valid element
+     */
     compressRecord *prec = (compressRecord *) paddr->precord;
-
-    *no_elements = prec->nuse;
-    if (prec->nuse == prec->nsam)
-        *offset = prec->off;
-    else
-        *offset = 0;
+    epicsUInt32 off = prec->off;
+    epicsUInt32 nuse = prec->nuse;
+    epicsUInt32 nsam = prec->nsam;
+
+    *no_elements = nuse;
+    if(prec->balg == bufferingALG_FIFO) {
+        *offset = (off-nuse)%nsam;
+    } else {
+        *offset = off;
+    }
+
     return 0;
 }
 
@@ -407,7 +425,8 @@
 {
     compressRecord *prec = (compressRecord *) paddr->precord;
 
-    prec->off = (prec->off + nNew) % prec->nsam;
+    if(prec->balg == bufferingALG_FIFO)
+        prec->off = (prec->off + nNew) % prec->nsam;
     prec->nuse += nNew;
     if (prec->nuse > prec->nsam)
         prec->nuse = prec->nsam;

=== modified file 'src/std/rec/compressRecord.dbd.pod'
--- src/std/rec/compressRecord.dbd.pod	2013-09-30 22:48:06 +0000
+++ src/std/rec/compressRecord.dbd.pod	2016-01-14 02:46:51 +0000
@@ -9,19 +9,37 @@
 
 =title Compress Record (compress)
 
-...
+The data compression record is used to collect and compress data from arrays.
+When the INP field references a data array field,
+it immediately compresses the entire array into an element of an array using one of several algorithms,
+overwriting the previous element. If the INP field obtains its value from a scalar-value field,
+the compression record will collect a new sample each time the record is processed
+and add it to the compressed data array as a circular buffer.
+
+The INP link can also specify a constant;
+however, if this is the case, the compression algorithms are ignored,
+and the record support routines merely return after checking the FLNK field.
 
 =head2 Record-specific Menus
 
 =head3 Menu compressALG
 
+=menu compressALG
+
 The ALG field which uses this menu controls the compression algorithm used.
 
-...
-
-=menu compressALG
-
-...
+There are six possible algorithms which can be specified as follows:
+
+* Circular Buffer
+* Average
+* N to 1 Low Value
+* N to 1 High Value
+* N to 1 Average
+* N to 1 Median
+
+=menu bufferingALG
+
+Selects FIFO (First in first out) or LIFO (Last in first out) insertion order.
 
 =head2 Parameter Fields
 
@@ -41,6 +59,10 @@
 	choice(compressALG_Circular_Buffer,"Circular Buffer")
 	choice(compressALG_N_to_1_Median,"N to 1 Median")
 }
+menu(bufferingALG) {
+	choice(bufferingALG_FIFO, "FIFO Buffer")
+	choice(bufferingALG_LIFO, "LIFO Buffer")
+}
 recordtype(compress) {
 
 =fields VAL
@@ -76,6 +98,13 @@
 		interest(1)
 		menu(compressALG)
 	}
+ 	field(BALG,DBF_MENU) {
+		prompt("Buffering Algorithm")
+		promptgroup(GUI_ALARMS)
+		special(SPC_RESET)
+		interest(1)
+		menu(bufferingALG)
+	}
 	field(NSAM,DBF_ULONG) {
 		prompt("Number of Values")
 		promptgroup(GUI_COMPRESS)

=== modified file 'src/std/rec/test/Makefile'
--- src/std/rec/test/Makefile	2016-01-07 19:22:43 +0000
+++ src/std/rec/test/Makefile	2016-01-14 02:46:51 +0000
@@ -38,6 +38,13 @@
 TESTFILES += ../linkRetargetLink.db
 TESTS += linkRetargetLinkTest
 
+TESTPROD_HOST += compressTest
+compressTest_SRCS += compressTest.c
+compressTest_SRCS += recTestIoc_registerRecordDeviceDriver.cpp
+testHarness_SRCS += compressTest.c
+TESTFILES += ../compressTest.db
+TESTS += compressTest
+
 TARGETS += $(COMMON_DIR)/asTestIoc.dbd
 asTestIoc_DBD += base.dbd
 asTestIoc_DBD += asTest.dbd

=== added file 'src/std/rec/test/compressTest.c'
--- src/std/rec/test/compressTest.c	1970-01-01 00:00:00 +0000
+++ src/std/rec/test/compressTest.c	2016-01-14 02:46:51 +0000
@@ -0,0 +1,351 @@
+/*************************************************************************\
+* Copyright (c) 2016 Michael Davidsaver
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+#include "dbUnitTest.h"
+#include "testMain.h"
+#include "dbLock.h"
+#include "errlog.h"
+#include "dbAccess.h"
+#include "epicsMath.h"
+
+#include "aiRecord.h"
+#include "compressRecord.h"
+
+#define testDEq(A,B,D) testOk(fabs((A)-(B))<(D), #A " (%f) ~= " #B " (%f)", A, B)
+
+void recTestIoc_registerRecordDeviceDriver(struct dbBase *);
+
+static
+void checkArrD(const char *pv, long elen, double a, double b, double c, double d)
+{
+    double buf[4];
+    double expect[4];
+    long nReq = NELEMENTS(buf), i;
+    unsigned match;
+    DBADDR addr;
+
+    expect[0] = a;
+    expect[1] = b;
+    expect[2] = c;
+    expect[3] = d;
+
+    if(dbNameToAddr(pv, &addr))
+        testAbort("Unknown PV '%s'", pv);
+
+    if(dbGet(&addr, DBR_DOUBLE, buf, NULL, &nReq, NULL))
+        testAbort("Failed to get '%s'", pv);
+
+    match = elen==nReq;
+    for(i=0; i<nReq && i<elen; i++) {
+        match &= fabs(buf[i]-expect[i])<0.01;
+    }
+    testOk(match, "dbGet(\"%s\") matches", pv);
+    if(elen!=nReq)
+        testDiag("lengths don't match %ld != %ld", elen, nReq);
+    for(i=0; i<nReq && i<elen; i++) {
+        if(fabs(buf[i]-expect[i])>=0.01)
+            testDiag("[%ld] -> %f != %f", i, expect[i], buf[i]);
+    }
+}
+
+static
+void checkArrI(const char *pv, long elen, epicsInt32 a, epicsInt32 b, epicsInt32 c, epicsInt32 d)
+{
+    epicsInt32 buf[4];
+    epicsInt32 expect[4];
+    long nReq = NELEMENTS(buf), i;
+    unsigned match;
+    DBADDR addr;
+
+    expect[0] = a;
+    expect[1] = b;
+    expect[2] = c;
+    expect[3] = d;
+
+    if(dbNameToAddr(pv, &addr))
+        testAbort("Unknown PV '%s'", pv);
+
+    if(dbGet(&addr, DBR_LONG, buf, NULL, &nReq, NULL))
+        testAbort("Failed to get '%s'", pv);
+
+    match = elen==nReq;
+    for(i=0; i<nReq && i<elen; i++) {
+        match &= buf[i]==expect[i];
+    }
+    testOk(match, "dbGet(\"%s\") matches", pv);
+    if(elen!=nReq)
+        testDiag("lengths don't match %ld != %ld", elen, nReq);
+    for(i=0; i<nReq && i<elen; i++) {
+        if(buf[i]!=expect[i])
+            testDiag("[%ld] -> %d != %d", i, (int)expect[i], (int)buf[i]);
+    }
+}
+
+static
+void testFIFOCirc(void)
+{
+    aiRecord *vrec;
+    compressRecord *crec;
+    double *cbuf;
+
+    testDiag("Test FIFO");
+
+    testdbPrepare();
+
+    testdbReadDatabase("recTestIoc.dbd", NULL, NULL);
+
+    recTestIoc_registerRecordDeviceDriver(pdbbase);
+
+    testdbReadDatabase("compressTest.db", NULL, "ALG=Circular Buffer,BALG=FIFO Buffer,NSAM=4");
+
+    vrec = (aiRecord*)testdbRecordPtr("val");
+    crec = (compressRecord*)testdbRecordPtr("comp");
+
+    eltc(0);
+    testIocInitOk();
+    eltc(1);
+
+    dbScanLock((dbCommon*)crec);
+    cbuf = crec->bptr;
+
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==0);
+
+    testDiag("Push 1.1");
+    vrec->val = 1.1;
+    dbProcess((dbCommon*)crec);
+
+    /* In FIFO mode the valid elements a cbuf[(off-nuse-1)%size] through cbuf[(off-1)%size] */
+    testOk1(crec->off==1);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==1);
+    testDEq(cbuf[0], 1.1, 0.1);
+    testDEq(cbuf[1], 0.0, 0.1);
+    testDEq(cbuf[2], 0.0, 0.1);
+    testDEq(cbuf[3], 0.0, 0.1);
+    checkArrD("comp", 1, 1.1, 0, 0, 0);
+
+    testDiag("Push 2.1");
+    vrec->val = 2.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==2);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==2);
+    testDEq(cbuf[0], 1.1, 0.1);
+    testDEq(cbuf[1], 2.1, 0.1);
+    testDEq(cbuf[2], 0.0, 0.1);
+    testDEq(cbuf[3], 0.0, 0.1);
+    checkArrD("comp", 2, 1.1, 2.1, 0, 0);
+
+    testDiag("Push 3.1");
+    vrec->val = 3.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==3);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==3);
+    testDEq(cbuf[0], 1.1, 0.1);
+    testDEq(cbuf[1], 2.1, 0.1);
+    testDEq(cbuf[2], 3.1, 0.1);
+    testDEq(cbuf[3], 0.0, 0.1);
+    checkArrD("comp", 3, 1.1, 2.1, 3.1, 0);
+
+    testDiag("Push 4.1");
+    vrec->val = 4.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 1.1, 0.1);
+    testDEq(cbuf[1], 2.1, 0.1);
+    testDEq(cbuf[2], 3.1, 0.1);
+    testDEq(cbuf[3], 4.1, 0.1);
+    checkArrD("comp", 4, 1.1, 2.1, 3.1, 4.1);
+
+    testDiag("Push 5.1");
+    vrec->val = 5.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==1);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 5.1, 0.1);
+    testDEq(cbuf[1], 2.1, 0.1);
+    testDEq(cbuf[2], 3.1, 0.1);
+    testDEq(cbuf[3], 4.1, 0.1);
+    checkArrD("comp", 4, 2.1, 3.1, 4.1, 5.1);
+
+    testDiag("Push 6.1");
+    vrec->val = 6.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==2);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 5.1, 0.1);
+    testDEq(cbuf[1], 6.1, 0.1);
+    testDEq(cbuf[2], 3.1, 0.1);
+    testDEq(cbuf[3], 4.1, 0.1);
+    checkArrD("comp", 4, 3.1, 4.1, 5.1, 6.1);
+
+    dbScanUnlock((dbCommon*)crec);
+
+    testDiag("Reset");
+    testdbPutFieldOk("comp.RES", DBF_LONG, 0);
+
+    dbScanLock((dbCommon*)crec);
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==0);
+    checkArrD("comp", 0, 0, 0, 0, 0);
+    dbScanUnlock((dbCommon*)crec);
+
+    testIocShutdownOk();
+
+    testdbCleanup();
+}
+
+static
+void testLIFOCirc(void)
+{
+    aiRecord *vrec;
+    compressRecord *crec;
+    double *cbuf;
+
+    testDiag("Test LIFO");
+
+    testdbPrepare();
+
+    testdbReadDatabase("recTestIoc.dbd", NULL, NULL);
+
+    recTestIoc_registerRecordDeviceDriver(pdbbase);
+
+    testdbReadDatabase("compressTest.db", NULL, "ALG=Circular Buffer,BALG=LIFO Buffer,NSAM=4");
+
+    vrec = (aiRecord*)testdbRecordPtr("val");
+    crec = (compressRecord*)testdbRecordPtr("comp");
+
+    eltc(0);
+    testIocInitOk();
+    eltc(1);
+
+    dbScanLock((dbCommon*)crec);
+    cbuf = crec->bptr;
+
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==0);
+
+    testDiag("Push 1.1");
+    vrec->val = 1.1;
+    dbProcess((dbCommon*)crec);
+
+    testDiag("off %u", crec->off);
+    testOk1(crec->off==3);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==1);
+    testDEq(cbuf[0], 0.0, 0.1);
+    testDEq(cbuf[1], 0.0, 0.1);
+    testDEq(cbuf[2], 0.0, 0.1);
+    testDEq(cbuf[3], 1.1, 0.1);
+    checkArrD("comp", 1, 1.1, 0, 0, 0);
+
+    testDiag("Push 2.1");
+    vrec->val = 2.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==2);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==2);
+    testDEq(cbuf[0], 0.0, 0.1);
+    testDEq(cbuf[1], 0.0, 0.1);
+    testDEq(cbuf[2], 2.1, 0.1);
+    testDEq(cbuf[3], 1.1, 0.1);
+    checkArrD("comp", 2, 2.1, 1.1, 0, 0);
+    checkArrI("comp", 2, 2, 1, 0, 0);
+
+    testDiag("Push 3.1");
+    vrec->val = 3.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==1);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==3);
+    testDEq(cbuf[0], 0.0, 0.1);
+    testDEq(cbuf[1], 3.1, 0.1);
+    testDEq(cbuf[2], 2.1, 0.1);
+    testDEq(cbuf[3], 1.1, 0.1);
+    checkArrD("comp", 3, 3.1, 2.1, 1.1, 0);
+    checkArrI("comp", 3, 3, 2, 1, 0);
+
+    testDiag("Push 4.1");
+    vrec->val = 4.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 4.1, 0.1);
+    testDEq(cbuf[1], 3.1, 0.1);
+    testDEq(cbuf[2], 2.1, 0.1);
+    testDEq(cbuf[3], 1.1, 0.1);
+    checkArrD("comp", 4, 4.1, 3.1, 2.1, 1.1);
+    checkArrI("comp", 4, 4, 3, 2, 1);
+
+    testDiag("Push 5.1");
+    vrec->val = 5.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==3);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 4.1, 0.1);
+    testDEq(cbuf[1], 3.1, 0.1);
+    testDEq(cbuf[2], 2.1, 0.1);
+    testDEq(cbuf[3], 5.1, 0.1);
+    checkArrD("comp", 4, 5.1, 4.1, 3.1, 2.1);
+    checkArrI("comp", 4, 5, 4, 3, 2);
+
+    testDiag("Push 6.1");
+    vrec->val = 6.1;
+    dbProcess((dbCommon*)crec);
+
+    testOk1(crec->off==2);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==4);
+    testDEq(cbuf[0], 4.1, 0.1);
+    testDEq(cbuf[1], 3.1, 0.1);
+    testDEq(cbuf[2], 6.1, 0.1);
+    testDEq(cbuf[3], 5.1, 0.1);
+    checkArrD("comp", 4, 6.1, 5.1, 4.1, 3.1);
+
+    dbScanUnlock((dbCommon*)crec);
+
+    testDiag("Reset");
+    testdbPutFieldOk("comp.RES", DBF_LONG, 0);
+
+    dbScanLock((dbCommon*)crec);
+    testOk1(crec->off==0);
+    testOk1(crec->inx==0);
+    testOk1(crec->nuse==0);
+    checkArrD("comp", 0, 0, 0, 0, 0);
+    dbScanUnlock((dbCommon*)crec);
+
+    testIocShutdownOk();
+
+    testdbCleanup();
+}
+
+MAIN(compressTest)
+{
+    testPlan(116);
+    testFIFOCirc();
+    testLIFOCirc();
+    return testDone();
+}

=== added file 'src/std/rec/test/compressTest.db'
--- src/std/rec/test/compressTest.db	1970-01-01 00:00:00 +0000
+++ src/std/rec/test/compressTest.db	2016-01-14 02:46:51 +0000
@@ -0,0 +1,7 @@
+record(ai, "val") {}
+record(compress, "comp") {
+  field(INP, "val NPP")
+  field(ALG, "$(ALG)")
+  field(BALG,"$(BALG)")
+  field(NSAM,"$(NSAM)")
+}

=== modified file 'src/std/rec/test/epicsRunRecordTests.c'
--- src/std/rec/test/epicsRunRecordTests.c	2015-08-27 16:13:49 +0000
+++ src/std/rec/test/epicsRunRecordTests.c	2016-01-14 02:46:51 +0000
@@ -13,6 +13,7 @@
 #include "epicsExit.h"
 
 int analogMonitorTest(void);
+int compressTest(void);
 int arrayOpTest(void);
 int asTest(void);
 int linkRetargetLinkTest(void);
@@ -23,6 +24,8 @@
 
     runTest(analogMonitorTest);
 
+    runTest(compressTest);
+
     runTest(arrayOpTest);
 
     runTest(asTest);