Merge lp:~dirk.zimoch/epics-base/named-soft-events into lp:~epics-core/epics-base/3.14

[Dirk Zimoch]

Soft events can be strings now.

Example:
record (event, "$(EVENTREC)") {
  field (VAL, "Injection Trigger")
}

record (ai, "$(OTHERREC)") {
  field (EVNT, "Injection Trigger")
}

record (calcout, "$(CALCREC)") {
  field (OEVT, "Injection Trigger")
}

Discussion:
Do we need hashing of the strings to speed up event triggering? Probably not when we can assume a small number of events and event names that differ early.

[lp:~dirk.zimoch/epics-base/named-soft-events]

12073. By Dirk Zimoch <dirk@ubuntu> on 2010-05-28

release notes updated

12074. By Dirk Zimoch <dirk@ubuntu> on 2010-05-28

Merged with 3.14

[Andrew Johnson (anj)]

What effect would merging this code have on sites that use an event timing system?

All distributed event networks pass events around as 8-bit numbers, and I believe the event receiver code announces such an event by calling post_event() with the relevant number.

I do not like the linear search for the posted event name, calling strcmp() against every item on the event_scan_list until the right name is found. This would have a fairly significant effect on performance, which matters on systems where the events happen quickly.

I want this code to be reviewed by someone with more knowledge of how those event systems work, but I don't currently think that this is the right solution.

[Dirk Zimoch (dirk.zimoch)]

Backward compatibility:

There are two fundamentally different types of "events". Hardware events from an timing/event system and software event. They share only the name. Typically a hardware event is bound to a software event using the event record. The VAL field contains the software event and the INP field contains the hardware event. So far the event record binds a numerical hardware event to a numerical software event (the numbers may be different).

Example:
record (event, "$(NAME)") {
    field (DTYP, "APS event receiver")
    field (INP, "#C$(CARD) S$(HARDEVENT) @")
    field (SCAN, "I/O Intr")
    field (VAL, "$(SOFTEVENT)")
    field (PRIO, "HIGH")
}

With this modification the records binds a numerical hardware event to a string software event (which may still consist of digits only if you like). Thus the change should be fully backward compatible.

However I will ask Timo and Babak to comment on this issue.

Performance:

I assumed a relatively small number of software event on a single IOC. Thus the O(n) behavior of a linear search (compared to the previous O(1) behaviour) would not be significant. Maybe that assumption is too optimistic.

Nevertheless I will try to re-work that piece of code. I have to see if I can reach O(1), e.g. using a hash value. At least O(log(n)) should be possible using a tree structure instead of a list.

[Timo Korhonen (timo-korhonen)]

I have not yet had the time to look at the code, but to not hold up the process, I make here some comments:
Dirk's description of what happens is correct. The 'hardware' event numbers are totally separated from the software event numbers. This can be very confusing to people who are using the system without knowing the deep details.
The event record support implementation, as Dirk explained, does essentially only the linking from a hard to a soft event. For this to work, the event receiver is programmed to create an interrupt upon receiving a particular event number. The interrupt routine calls (via a hook) scanIOrequest for event records with EVR device support (if any).
This applies to event systems from the APS version up to now (Micro-Research 230 and older.)

However, there is the new set of drivers that (mainly) Michael Davidsaver at BNL is developing. He probably should also take a look to see if and how this would affect his implementation (although I think it will be more or less the same story - linking hard and soft events.)

In all cases that I have seen the number of soft events fired from hard events has been really small (3-4) and I cannot think of a use case where one would like to dispatch a large number of different events within one IOC.
In the worst case, if the possibility to refer directly by numbers is kept and thus one can have the O(1) behaviour, I do not see any dangers in this. If O(1) can be achieved with this solution, all the better.

[Babak Kalantari (babak-kalantari)]

In general I like the idea of named events. I have faced situations where I was lost about the used soft events in an IOC and it was tedious to track down what HW event fired what SW event to avoild clashes.

My comments:
1) As far as I understood the ordring of adding/removing scan lists is not affected. I think it is important that the position of the event nodes in the lists remains the same in both cases (event / named_event).

2) The new method has introduced an additional lock for each priority list (event_list_lock) and for accessing a node in the event list first the lock of the corresponding priority has be acquired, the priority list be found, and the lock is then released. This will also introduce some performance penalty (in addition to strcmp). In the current method this is achieved by means of 2-dimentional array of [priority][event].

I know that normally number of soft events in an IOC is not big, nevertheless I think one has to study the performance effects of the new appraoch more deeply.

[Ralph Lange (ralph-lange)]

I don't like all these string comparisons at run time.

Couldn't the implementation register an event string at first use (using a simple register utility) and then use integer event numbers, so there are no changes in run time behaviour?

[mdavidsaver (mdavidsaver)]

> However, there is the new set of drivers that (mainly) Michael Davidsaver at
> BNL is developing. He probably should also take a look to see if and how this
> would affect his implementation (although I think it will be more or less the
> same story - linking hard and soft events.)

Named DB events will cause a small disruption, but the benefit is enough to justify it.

This will only effect me since I am using a longoutRecord instead of an eventRecord. I can't put an eventRecord in an autosave monitor set because it posts the VAL field whenever the event occurs instead of just when the VAL field changes. I could switch to using a stringoutRecord, and restrict 3.14 to strings which can be converted into integers.

[mdavidsaver (mdavidsaver)]

> I don't like all these string comparisons at run time.
>
> Couldn't the implementation register an event string at first use (using a
> simple register utility) and then use integer event numbers, so there are no
> changes in run time behaviour?

A simple thing might be to hash the string into an integer. To avoid collisions keep a list of previously hashed values. If a collision is detected then add spaces to the string until it produces a unique hash. Since the table is thus one-to-one it can be used for reverse lookups (ie scanpel()).

An objection to this is that computed hash list grows without bound if someone were to enter lots of different strings (typos?). A way to avoid this would be to separate event registration from use as Ralph suggests. Having for example, "int create_event_key(char*)" which takes a string and returns a unique integer key, and "post_event_key(int)" which takes the key.

This would be a significant change to how post_event() is used since the caller would be required to remember the integer key. So I imagine a shortcut "post_event(char*)" which does the hash every time would be needed.

[Dirk Zimoch (dirk.zimoch)]

I thought about ways to convert strings to numbers (or pointers) beforehand. The problem is that the event a record posts may change each time the record processes. This is unlikely but nevertheless possible. It would require a special treatment of event.VAL and calcout.OEVT. Whenever the field is changed, the special support could convert the string into a pointer to the scan list which is then stored in another field.

While this is possible with special support, I have no hope for event records reading the event from INP or SIOL. Is there any way to find out if a link target has changed it value without actually comparing the values? In the worst case, the string has to be converted to pointer each time the event record processes when in simulation mode or using soft device support.

This approach means that the code to convert string to pointer has to go into the soft device support and any other device support that modifies event.VAL. My previous approach was backward compatible to existing device supports.

[Andrew Johnson (anj)]

Minor issue: We already have a macro EPICS_DEPRECATED in compilerDependencies.h which expands out to __attribute__((deprecated)) on GNUC. Please use this in dbScan.h instead of your __attribute__() macro, we have worked hard to keep architecture-specific code in certain areas of the code-base only, preferably within libCom.

[Dirk Zimoch (dirk.zimoch)]

> Minor issue: We already have a macro EPICS_DEPRECATED in
> compilerDependencies.h which expands out to __attribute__((deprecated)) on
> GNUC. Please use this in dbScan.h instead of your __attribute__() macro, we
> have worked hard to keep architecture-specific code in certain areas of the
> code-base only, preferably within libCom.

OK. I missed that macro. And I have a typo in my macro. I forgot the trailing __ for the non-gnu compilers. (has nobody tried to compile this on Windows so far?)

[Dirk Zimoch (dirk.zimoch)]

I modified the code to run with O(1) in most cases. Only if the event name actually changed, the event list is searched. Checking for change costs only one strcmp when the value did not change. The check is only done if event.VAL or calcout.VAL is read though event.INP or event.SIOL.

I also replaced the semaphore lock with something quicker.

I will commit the modifications as soon as I have checked everything and have run some tests.

[Dirk Zimoch (dirk.zimoch)]

Performance test

I wrote a test that creates 255 events (named 1 ... 255) and processes one of them 1 million times. Here are the results:
mirror-3.14
  2.389 seconds
named-soft-events
  3.150 seconds
named-soft-events2
  2.223 seconds

(running on Ubuntu Linux in a vmWare box on Windows7 on my 1.3 GHz dual core laptop using 1 CPU core for vmWare)

[Ben Franksen (bfrk)]

On Dienstag, 26. Oktober 2010, Dirk Zimoch wrote:
> Performance test
>
> I wrote a test that creates 255 events (named 1 ... 255) and
> processes one of them 1 million times. Here are the results:
> mirror-3.14
> 2.389 seconds
> named-soft-events
> 3.150 seconds
> named-soft-events2
> 2.223 seconds
>
> (running on Ubuntu Linux in a vmWare box on Windows7 on my 1.3 GHz
> dual core laptop using 1 CPU core for vmWare)

To me these numbers suggest that your hashing O(1) solution may not be
worth the added complexity and that doing string comparisons on small
strings is not very expensive. Could you do a test with somewhat longer
event names, around 20 to 30 characters long? What is the costs for the
better performance of named-soft-events2 over named-soft-events in
lines of code?

Cheers
Ben
--
"Never confuse what is natural with what is habitual."
                                   -- attributed to Mahatma Gandhi

[J. Lewis Muir (jlmuir)]

On 10/26/10 3:41 PM, Ben F. wrote:
> On Dienstag, 26. Oktober 2010, Dirk Zimoch wrote:
>> Performance test
>>
>> I wrote a test that creates 255 events (named 1 ... 255) and
>> processes one of them 1 million times. Here are the results:
>> mirror-3.14
>> 2.389 seconds
>> named-soft-events
>> 3.150 seconds
>> named-soft-events2
>> 2.223 seconds
>>
>> (running on Ubuntu Linux in a vmWare box on Windows7 on my 1.3 GHz
>> dual core laptop using 1 CPU core for vmWare)
>
> To me these numbers suggest that your hashing O(1) solution may not be
> worth the added complexity and that doing string comparisons on small
> strings is not very expensive. Could you do a test with somewhat longer
> event names, around 20 to 30 characters long? What is the costs for the
> better performance of named-soft-events2 over named-soft-events in
> lines of code?

I'm not against looking at lines of code, but I would not say that fewer
lines of code is always better. To me, readability is the more
important metric. If the code is twice as long as some other code to do
the same thing, but easier to understand, I'd choose the code that's
twice as long and easier to understand.

Lewis

[Dirk Zimoch (dirk.zimoch)]

In version 2 I use two function calls, the first one translates the event string to a pointer to the scan list and the second one posts the event with this pointer, which I store in a new SPEC_NOMOD field of the record. This is probably the reason why this approach is even faster than the original implementation with a lookup table. It eliminates one indirection.

The added complexity is that one must make sure to call the translation function only when necessary. That means that the record and/or device support code must find out when the event name has changed. Doing that wrongly reduces the performance to the original approach of doing the string search every time.

Can anyone tell me how I can publish version 2 here in launchpad without overwriting version 1?
And how to publish the test setup?

[Dirk Zimoch (dirk.zimoch)]

I tested long event names like "Event with a very long name number 123" (up to 38 chars, the first 35 of them the same for all 255 events)
 named-soft-events
  3.145 seconds
named-soft-events2
  2.381 seconds

More or less the same as with short event names. (Numbers vary a bit from turn to turn)

[lp:~dirk.zimoch/epics-base/named-soft-events]

12075. By Dirk Zimoch <dirk@ubuntu> on 2010-10-15

use EPICS_DEPRECATED macro

12076. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

new approach to handle named events efficiently

12077. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

bugfix: devEventSoft read_event with constant input and tse = epicsTimeEventDeviceTime did not read timestamp

12078. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

merged and conflict in RELEASE_NOTES.html solved

12079. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

typo in comment

[Ben Franksen (bfrk)]

On Mittwoch, 27. Oktober 2010, Dirk Zimoch wrote:
> I tested long event names like "Event with a very long name number
> 123" (up to 38 chars, the first 35 of them the same for all 255
> events) named-soft-events
> 3.145 seconds
> named-soft-events2
> 2.381 seconds
>
> More or less the same as with short event names. (Numbers vary a bit
> from turn to turn)

Interesting. I'd have expected the ratio between the two versions to
increase for longer strings. I did some research and found that gcc
heavily optimises strcmp, resulting (on certain architectures) in
machine code that uses 16-byte instructions, see

http://stackoverflow.com/questions/1128096/c-string-comparison-in-one-clock-cycle

You learn a bit more every day...

Cheers
Ben
--
"Never confuse what is natural with what is habitual."
                                   -- attributed to Mahatma Gandhi

[Dirk Zimoch (dirk.zimoch)]

The new code is in https://code.launchpad.net/~dirk.zimoch/epics-base/named-soft-events/+merge/39472

Unmerged revisions

12079. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

typo in comment

12078. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

merged and conflict in RELEASE_NOTES.html solved

12077. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

bugfix: devEventSoft read_event with constant input and tse = epicsTimeEventDeviceTime did not read timestamp

12076. By Dirk Zimoch <dirk@ubuntu> on 2010-10-27

new approach to handle named events efficiently

12075. By Dirk Zimoch <dirk@ubuntu> on 2010-10-15

use EPICS_DEPRECATED macro

12074. By Dirk Zimoch <dirk@ubuntu> on 2010-05-28

Merged with 3.14

12073. By Dirk Zimoch <dirk@ubuntu> on 2010-05-28

release notes updated

12072. By Dirk Zimoch <dirk@ubuntu> on 2010-05-25

stringlength and mutex issues fixed

12071. By Dirk Zimoch <dirk@ubuntu> on 2010-05-25

string val field

12070. By Dirk Zimoch <dirk@ubuntu> on 2010-05-24

OEVT size was missing

=== modified file 'documentation/RELEASE_NOTES.html'
--- documentation/RELEASE_NOTES.html	2010-10-26 15:49:26 +0000
+++ documentation/RELEASE_NOTES.html	2010-10-27 19:58:47 +0000
@@ -13,6 +13,7 @@
 <h2 align="center">Changes between 3.14.11 and 3.14.12</h2>
 <!-- Insert new items immediately below here ... -->
 
+<<<<<<< TREE
 <h4>Added windows-x64 target</h4>
 
 <p>64-bit binaries for Microsoft Windows platforms can now be built using the
@@ -121,6 +122,12 @@
 
 <p>The fields DTYP and INP/OUT can now be specified in any order.</p>
 
+=======
+<h4>Named Soft Events</h4>
+
+<p>Soft events can now be meaningful strings instead of numbers 1-255. 
+
+>>>>>>> MERGE-SOURCE
 <h4>Rewrite epicsThreadOnce()</h4>
 
 <p>Michael Davidsaver suggested a better implementation of epicsThreadOnce()

=== modified file 'src/db/dbCommon.dbd'
--- src/db/dbCommon.dbd	2009-04-23 20:35:02 +0000
+++ src/db/dbCommon.dbd	2010-10-27 19:58:47 +0000
@@ -43,10 +43,11 @@
 		special(SPC_SCAN)
 		interest(1)
 	}
-	field(EVNT,DBF_SHORT) {
-		prompt("Event Number")
+	field(EVNT,DBF_STRING) {
+		prompt("Event Name")
 		promptgroup(GUI_SCAN)
 		special(SPC_SCAN)
+		size(40)
 		interest(1)
 	}
 	field(TSE,DBF_SHORT) {

=== modified file 'src/db/dbIocRegister.c'
--- src/db/dbIocRegister.c	2009-01-16 20:50:40 +0000
+++ src/db/dbIocRegister.c	2010-10-27 19:58:47 +0000
@@ -266,11 +266,11 @@
 { scanppl(args[0].dval);}
 
 /* scanpel */
-static const iocshArg scanpelArg0 = { "event number",iocshArgInt};
+static const iocshArg scanpelArg0 = { "event name",iocshArgString};
 static const iocshArg * const scanpelArgs[1] = {&scanpelArg0};
 static const iocshFuncDef scanpelFuncDef = {"scanpel",1,scanpelArgs};
 static void scanpelCallFunc(const iocshArgBuf *args)
-{ scanpel(args[0].ival);}
+{ scanpel(args[0].sval);}
 
 /* scanpiol */
 static const iocshFuncDef scanpiolFuncDef = {"scanpiol",0};

=== modified file 'src/db/dbScan.c'
--- src/db/dbScan.c	2009-04-03 17:46:26 +0000
+++ src/db/dbScan.c	2010-10-27 19:58:47 +0000
@@ -101,12 +101,13 @@
 
 /* EVENT */
 
-#define MAX_EVENTS 256
-typedef struct event_scan_list {
-    CALLBACK            callback;
-    scan_list           scan_list;
-} event_scan_list;
-static event_scan_list *pevent_list[NUM_CALLBACK_PRIORITIES][MAX_EVENTS];
+typedef struct event_list {
+    CALLBACK            callback[NUM_CALLBACK_PRIORITIES];
+    scan_list           scan_list[NUM_CALLBACK_PRIORITIES];
+    struct event_list *next;
+    char                event_name[MAX_STRING_SIZE];
+} event_list;
+static event_list * volatile pevent_list[256];
 
 
 /* IO_EVENT*/
@@ -204,35 +205,24 @@
         recGblRecordError(-1, (void *)precord,
             "scanAdd detected illegal SCAN value");
     } else if (scan == menuScanEvent) {
-        int evnt;
+        char* eventname;
         int prio;
-        event_scan_list *pesl;
+        event_list *pel;
 
-        evnt = precord->evnt;
-        if (evnt < 0 || evnt >= MAX_EVENTS) {
+        eventname = precord->evnt;
+        if (strlen(eventname) >= MAX_STRING_SIZE) {
             recGblRecordError(S_db_badField, (void *)precord,
-                "scanAdd detected illegal EVNT value");
-            precord->scan = menuScanPassive;
+                "scanAdd: too long EVNT value");
             return;
         }
         prio = precord->prio;
         if (prio < 0 || prio >= NUM_CALLBACK_PRIORITIES) {
             recGblRecordError(-1, (void *)precord,
                 "scanAdd: illegal prio field");
-            precord->scan = menuScanPassive;
             return;
         }
-        pesl = pevent_list[prio][evnt];
-        if (pesl == NULL) {
-            pesl = dbCalloc(1, sizeof(event_scan_list));
-            pevent_list[prio][evnt] = pesl;
-            pesl->scan_list.lock = epicsMutexMustCreate();
-            callbackSetCallback(eventCallback, &pesl->callback);
-            callbackSetPriority(prio, &pesl->callback);
-            callbackSetUser(pesl, &pesl->callback);
-            ellInit(&pesl->scan_list.list);
-        }
-        addToList(precord, &pesl->scan_list);
+        pel = eventNameToHandle(eventname);
+        if (pel) addToList(precord, &pel->scan_list[prio]);
     } else if (scan == menuScanI_O_Intr) {
         io_scan_list *piosl = NULL;
         int prio;
@@ -287,31 +277,25 @@
         recGblRecordError(-1, (void *)precord,
             "scanDelete detected illegal SCAN value");
     } else if (scan == menuScanEvent) {
-        int evnt;
+        char* eventname;
         int prio;
-        event_scan_list *pesl;
+        event_list *pel;
         scan_list *psl = 0;
 
-        evnt = precord->evnt;
-        if (evnt < 0 || evnt >= MAX_EVENTS) {
-            recGblRecordError(S_db_badField, (void *)precord,
-                "scanAdd detected illegal EVNT value");
-            precord->scan = menuScanPassive;
-            return;
-        }
+        eventname = precord->evnt;
         prio = precord->prio;
         if (prio < 0 || prio >= NUM_CALLBACK_PRIORITIES) {
             recGblRecordError(-1, (void *)precord,
-                "scanAdd: illegal prio field");
-            precord->scan = menuScanPassive;
+                "scanDelete detected illegal PRIO field");
             return;
         }
-        pesl = pevent_list[prio][evnt];
-        if (pesl) psl = &pesl->scan_list;
-        if (!pesl || !psl) 
-            recGblRecordError(-1, (void *)precord,
-                "scanDelete for bad evnt");
-        else
+        do /* multitheading: make sure pel is consistent */
+            pel = pevent_list[0];
+        while (pel != pevent_list[0]);
+        for (; pel; pel=pel->next) {
+            if (strcmp(pel->event_name, eventname) == 0) break;
+        }
+        if (pel && (psl = &pel->scan_list[prio]))
             deleteFromList(precord, psl);
     } else if (scan == menuScanI_O_Intr) {
         io_scan_list *piosl=NULL;
@@ -372,21 +356,22 @@
     return 0;
 }
 
-int scanpel(int event_number)   /* print event list */
+int scanpel(char* eventname)   /* print event list */
 {
     char message[80];
-    int prio, evnt;
-    event_scan_list *pesl;
-
-    for (evnt = 0; evnt < MAX_EVENTS; evnt++) {
-        if (event_number && evnt<event_number) continue;
-        if (event_number && evnt>event_number) break;
-        for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
-            pesl = pevent_list[prio][evnt];
-            if (!pesl) continue;
-            if (ellCount(&pesl->scan_list.list) == 0) continue;
-            sprintf(message, "Event %d Priority %s", evnt, priorityName[prio]);
-            printList(&pesl->scan_list, message);
+    int prio;
+    event_list *pel;
+    
+    do /* multitheading: make sure pel is consistent */
+        pel = pevent_list[0];
+    while (pel != pevent_list[0]);
+    for (; pel; pel = pel->next) {
+        if (!eventname || strcmp(pel->event_name, eventname) == 0) {
+            for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
+                if (ellCount(&pel->scan_list[prio].list) == 0) continue;
+                sprintf(message, "Event \"%s\" Priority %s", pel->event_name, priorityName[prio]);
+                printList(&pel->scan_list[prio], message);
+            }
         }
     }
     return 0;
@@ -412,39 +397,73 @@
 

 static void eventCallback(CALLBACK *pcallback)
 {
-    event_scan_list *pesl;
+    scan_list *psl;
 
-    callbackGetUser(pesl, pcallback);
-    scanList(&pesl->scan_list);
+    callbackGetUser(psl, pcallback);
+    scanList(psl);
 }
 
 static void initEvent(void)
 {
-    int evnt, prio;
-
+}
+
+event_list *eventNameToHandle(char *eventname)
+{
+    int prio;
+    event_list *pel;
+    static epicsMutexId lock = NULL;
+
+    if (!lock) lock = epicsMutexMustCreate();
+    if (!eventname || eventname[0] == 0) return NULL;
+    epicsMutexMustLock(lock);
+    for (pel = pevent_list[0]; pel; pel=pel->next) {
+        if (strcmp(pel->event_name, eventname) == 0) break;
+    }
+    if (pel == NULL) {
+        pel = dbCalloc(1, sizeof(event_list));
+        strcpy(pel->event_name, eventname);
+        for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
+            callbackSetUser(&pel->scan_list[prio], &pel->callback[prio]);
+            callbackSetPriority(prio, &pel->callback[prio]);
+            callbackSetCallback(eventCallback, &pel->callback[prio]);
+            pel->scan_list[prio].lock = epicsMutexMustCreate();
+            ellInit(&pel->scan_list[prio].list);
+        }
+        pel->next=pevent_list[0];
+        pevent_list[0]=pel;
+        { /* backward compatibility */
+            char* p;
+            long e = strtol(eventname, &p, 0);
+            if (*p == 0 && e > 0 && e <= 255)
+                pevent_list[e]=pel;
+        }
+    }
+    epicsMutexUnlock(lock);
+    return pel;
+}
+
+void postEvent(event_list *pel)
+{
+    int prio;
+
+    if (scanCtl != ctlRun) return;
+    if (!pel) return;
     for (prio = 0; prio < NUM_CALLBACK_PRIORITIES; prio++) {
-        for (evnt = 0; evnt < MAX_EVENTS; evnt++) {
-            pevent_list[prio][evnt] = NULL;
-        }
+        if (ellCount(&pel->scan_list[prio].list) >0)
+            callbackRequest(&pel->callback[prio]);
     }
 }
 
+/* backward compatibility */
 void post_event(int event)
 {
-    int prio;
-    event_scan_list *pesl;
-
-    if (scanCtl != ctlRun) return;
-    if (event < 0 || event >= MAX_EVENTS) {
-        errMessage(-1, "illegal event passed to post_event");
-        return;
-    }
-    for (prio=0; prio<NUM_CALLBACK_PRIORITIES; prio++) {
-        pesl = pevent_list[prio][event];
-        if (!pesl) continue;
-        if (ellCount(&pesl->scan_list.list) >0)
-            callbackRequest((void *)pesl);
-    }
+    event_list* pel;
+    
+    if (event <= 0 || event > 255) return;
+    do { /* multitheading: make sure pel is consistent */
+        pel = pevent_list[event];
+    } while (pel != pevent_list[event]);
+    postEvent(pel);
 }
 

 void scanIoInit(IOSCANPVT *ppioscanpvt)

=== modified file 'src/db/dbScan.h'
--- src/db/dbScan.h	2010-10-05 19:27:37 +0000
+++ src/db/dbScan.h	2010-10-27 19:58:47 +0000
@@ -19,6 +19,7 @@
 
 #include "menuScan.h"
 #include "shareLib.h"
+#include "compilerDependencies.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -36,6 +37,7 @@
 struct io_scan_list;
 
 typedef struct io_scan_list *IOSCANPVT;
+typedef struct event_list *EVENTPVT;
 
 struct dbCommon;
 
@@ -43,7 +45,9 @@
 epicsShareFunc void scanRun(void);
 epicsShareFunc void scanPause(void);
 
-epicsShareFunc void post_event(int event);
+epicsShareFunc EVENTPVT eventNameToHandle(char* event);
+epicsShareFunc void postEvent(EVENTPVT epvt);
+epicsShareFunc void post_event(int event) EPICS_DEPRECATED;
 epicsShareFunc void scanAdd(struct dbCommon *);
 epicsShareFunc void scanDelete(struct dbCommon *);
 epicsShareFunc double scanPeriod(int scan);
@@ -54,7 +58,7 @@
 epicsShareFunc int scanppl(double rate);
 
 /*print event lists*/
-epicsShareFunc int scanpel(int event_number);
+epicsShareFunc int scanpel(char *event_name);
 
 /*print io_event list*/
 epicsShareFunc int scanpiol(void);

=== modified file 'src/dev/softDev/devEventSoft.c'
--- src/dev/softDev/devEventSoft.c	2010-10-05 19:27:37 +0000
+++ src/dev/softDev/devEventSoft.c	2010-10-27 19:58:47 +0000
@@ -51,7 +51,7 @@
     /* INP must be CONSTANT, PV_LINK, DB_LINK or CA_LINK*/
     switch (prec->inp.type) {
     case CONSTANT:
-        if (recGblInitConstantLink(&prec->inp, DBF_USHORT, &prec->val))
+        if (recGblInitConstantLink(&prec->inp, DBF_STRING, &prec->val))
             prec->udf = FALSE;
         break;
     case PV_LINK:
@@ -69,9 +69,15 @@
 static long read_event(eventRecord *prec)
 {
     long status;
+    char newEvent[MAX_STRING_SIZE];
 
-    status = dbGetLink(&prec->inp, DBR_USHORT, &prec->val, 0, 0);
+    if (prec->inp.type == CONSTANT) return 0;
+    status = dbGetLinkValue(&prec->inp, DBR_STRING, newEvent, 0, 0);
     if (!status) {
+        if (strcmp(newEvent, prec->val) != 0) {
+            strcpy(prec->val, newEvent);
+            prec->epvt = eventNameToHandle(prec->val);
+        }
         prec->udf = FALSE;
         if (prec->tsel.type == CONSTANT &&
             prec->tse == epicsTimeEventDeviceTime)

=== modified file 'src/rec/calcoutRecord.c'
--- src/rec/calcoutRecord.c	2010-04-05 18:49:18 +0000
+++ src/rec/calcoutRecord.c	2010-10-27 19:58:47 +0000
@@ -197,6 +197,8 @@
     callbackSetUser(prec, &prpvt->checkLinkCb);
     prpvt->cbScheduled = 0;
 
+    prec->epvt = eventNameToHandle(prec->oevt);
+    
     if (pcalcoutDSET->init_record) pcalcoutDSET->init_record(prec);
     prec->pval = prec->val;
     prec->mlst = prec->val;
@@ -357,6 +359,9 @@
         }
         db_post_events(prec, plinkValid, DBE_VALUE);
         return 0;
+      case(calcoutRecordOEVT):
+        prec->epvt = eventNameToHandle(prec->oevt);
+        return 0;
       default:
         recGblDbaddrError(S_db_badChoice, paddr, "calc: special");
         return(S_db_badChoice);
@@ -539,27 +544,21 @@
     if (prec->nsev < INVALID_ALARM ) {
         /* Output the value */
         status = writeValue(prec);
-        /* post event if output event != 0 */
-        if (prec->oevt > 0) {
-            post_event((int)prec->oevt);
-        }
+        /* post output event if set */
+        if (prec->epvt) postEvent(prec->epvt);
     } else switch (prec->ivoa) {
         case menuIvoaContinue_normally:
             status = writeValue(prec);
-            /* post event if output event != 0 */
-            if (prec->oevt > 0) {
-                post_event((int)prec->oevt);
-            }
+            /* post output event if set */
+            if (prec->epvt) postEvent(prec->epvt);
             break;
         case menuIvoaDon_t_drive_outputs:
             break;
         case menuIvoaSet_output_to_IVOV:
             prec->oval = prec->ivov;
             status = writeValue(prec);
-            /* post event if output event != 0 */
-            if (prec->oevt > 0) {
-                post_event((int)prec->oevt);
-            }
+            /* post output event if set */
+            if (prec->epvt) postEvent(prec->epvt);
             break;
         default:
             status = -1;

=== modified file 'src/rec/calcoutRecord.dbd'
--- src/rec/calcoutRecord.dbd	2010-10-04 18:46:09 +0000
+++ src/rec/calcoutRecord.dbd	2010-10-27 19:58:47 +0000
@@ -255,10 +255,19 @@
 		prompt("OCAL Valid")
 		interest(1)
 	}
-	field(OEVT,DBF_USHORT) {
+	field(OEVT,DBF_STRING) {
 		prompt("Event To Issue")
 		promptgroup(GUI_CLOCK)
+		special(SPC_MOD)
 		asl(ASL0)
+		size(40)
+	}
+	%#include "dbScan.h"
+        field(EPVT, DBF_NOACCESS) {
+		prompt("Event private")
+		special(SPC_NOMOD)
+		interest(4)
+		extra("EVENTPVT epvt")
 	}
 	field(IVOA,DBF_MENU) {
 		prompt("INVALID output action")

=== modified file 'src/rec/eventRecord.c'
--- src/rec/eventRecord.c	2010-10-05 19:27:37 +0000
+++ src/rec/eventRecord.c	2010-10-27 19:58:47 +0000
@@ -32,6 +32,7 @@
 #include "errMdef.h"
 #include "recSup.h"
 #include "recGbl.h"
+#include "special.h"
 #include "menuYesNo.h"
 #define GEN_SIZE_OFFSET
 #include "eventRecord.h"
@@ -43,7 +44,7 @@
 #define initialize NULL
 static long init_record(eventRecord *, int);
 static long process(eventRecord *);
-#define special NULL
+static long special(DBADDR *, int);
 static long get_value(eventRecord *, struct valueDes *);
 #define cvt_dbaddr NULL
 #define get_array_info NULL
@@ -103,9 +104,11 @@
     }
 
     if (prec->siol.type == CONSTANT) {
-	recGblInitConstantLink(&prec->siol,DBF_USHORT,&prec->sval);
+	recGblInitConstantLink(&prec->siol,DBF_STRING,&prec->sval);
     }
 
+    prec->epvt = eventNameToHandle(prec->val);
+
     if( (pdset=(struct eventdset *)(prec->dset)) && (pdset->init_record) ) 
 		status=(*pdset->init_record)(prec);
     return(status);
@@ -123,7 +126,7 @@
 	if ( !pact && prec->pact ) return(0);
 	prec->pact = TRUE;
  
-	if(prec->val>0) post_event((int)prec->val);
+	postEvent(prec->epvt);
 
 	recGblGetTimeStamp(prec);
 
@@ -137,10 +140,21 @@
 	return(status);
 }
 
+

+static long special(DBADDR *paddr, int after)
+{
+    eventRecord *prec = (eventRecord *)paddr->precord;
+    
+    if (!after) return 0;
+    if (dbGetFieldIndex(paddr) == eventRecordVAL) {
+        prec->epvt = eventNameToHandle(prec->val);
+    }
+}
 
+

 static long get_value(eventRecord *prec, struct valueDes *pvdes)
 {
-    pvdes->field_type = DBF_USHORT;
+    pvdes->field_type = DBF_STRING;
     pvdes->no_elements=1;
     pvdes->pvalue = (void *)(&prec->val);
     return(0);
@@ -177,10 +191,13 @@
                 return(status);
         }
         if (prec->simm == menuYesNoYES){
-                status=dbGetLink(&(prec->siol),DBR_USHORT,
+                status=dbGetLink(&(prec->siol),DBR_STRING,
 			&(prec->sval),0,0);
                 if (status==0) {
-                        prec->val=prec->sval;
+                        if (strcmp(prec->sval, prec->val) != 0) {
+                                strcpy(prec->val, prec->sval);
+                                prec->epvt = eventNameToHandle(prec->val);
+                        }
                         prec->udf=FALSE;
                 }
         } else {

=== modified file 'src/rec/eventRecord.dbd'
--- src/rec/eventRecord.dbd	2002-07-12 21:35:43 +0000
+++ src/rec/eventRecord.dbd	2010-10-27 19:58:47 +0000
@@ -9,10 +9,19 @@
 #*************************************************************************
 recordtype(event) {
 	include "dbCommon.dbd" 
-	field(VAL,DBF_USHORT) {
-		prompt("Event Number To Post")
+	field(VAL,DBF_STRING) {
+		prompt("Event Name To Post")
 		promptgroup(GUI_INPUTS)
+		special(SPC_MOD)
 		asl(ASL0)
+		size(40)
+	}
+	%#include "dbScan.h"
+        field(EPVT, DBF_NOACCESS) {
+		prompt("Event private")
+		special(SPC_NOMOD)
+		interest(4)
+		extra("EVENTPVT epvt")
 	}
 	field(INP,DBF_INLINK) {
 		prompt("Input Specification")
@@ -24,8 +33,9 @@
 		promptgroup(GUI_INPUTS)
 		interest(1)
 	}
-	field(SVAL,DBF_USHORT) {
+	field(SVAL,DBF_STRING) {
 		prompt("Simulation Value")
+		size(40)
 	}
 	field(SIML,DBF_INLINK) {
 		prompt("Sim Mode Location")