Changeset 897

Timestamp:

Feb 19, 2008 2:48:42 PM (16 years ago)

Author:

mmc

Message:

Improved the Rappture optimization API to include Tcl bindings.
Added standard build/test stuff for Tcl libraries. Created a
plugin hook for optimization libraries like pgapack. The plugin
support still needs some work.

Location:

trunk/optimizer

Files:

• src/Makefile (deleted)
• src/Makefile.in (added)
• src/aclocal.m4 (added)
• src/configure.in (added)
• src/pkgIndex.tcl.in (added)
• src/plugin_pgapack.c (added)
• src/rp_optimizer.c (modified) (10 diffs)
• src/rp_optimizer.h (modified) (6 diffs)
• src/rp_optimizer_plugin.h (added)
• src/rp_optimizer_tcl.c (added)
• src/rp_tcloptions.c (added)
• src/rp_tcloptions.h (added)
• src/tclconfig (added)
• src/tclconfig/config.guess (added)
• src/tclconfig/config.sub (added)
• src/tclconfig/install-sh (added)
• src/tclconfig/mkindex.tcl (added)
• src/tclconfig/mkinstalldirs (added)
• src/tclconfig/patchlevel.tcl (added)
• src/tclconfig/tcl.m4 (added)
• tests/aaa.test (added)
• tests/all.tcl (added)

trunk/optimizer/src/rp_optimizer.c

@@ -9 +9 @@
  * ======================================================================
  *  AUTHOR:  Michael McLennan, Purdue University
- *  Copyright (c) 2004-2007  Purdue Research Foundation
+ *  Copyright (c) 2008  Purdue Research Foundation
  *
  *  See the file "license.terms" for information on usage and
@@ -20 +20 @@
 #include "rp_optimizer.h"
 
+static void RpOptimCleanupParam _ANSI_ARGS_((RpOptimParam *paramPtr));
+
 /*
  * ----------------------------------------------------------------------
@@ -31 +33 @@
  */
 RpOptimEnv*
-RpOptimCreate()
+RpOptimCreate(pluginData, cleanupPtr)
+    ClientData pluginData;        /* special data created for this env */
+    RpOptimCleanup *cleanupPtr;   /* routine to clean up pluginData */
 {
     RpOptimEnv *envPtr;
     envPtr = (RpOptimEnv*)malloc(sizeof(RpOptimEnv));
+    envPtr->pluginData = pluginData;
+    envPtr->cleanupPtr = cleanupPtr;
+
     envPtr->numParams = 0;
-    envPtr->maxParams = 2;
+    envPtr->maxParams = 5;
     envPtr->paramList = (RpOptimParam**)malloc(
         (size_t)(envPtr->maxParams*sizeof(RpOptimParam*))
@@ -90 +97 @@
  * ----------------------------------------------------------------------
  */
-void
-RpOptimAddParamNumber(envPtr, name, min, max)
+RpOptimParam*
+RpOptimAddParamNumber(envPtr, name)
     RpOptimEnv *envPtr;   /* context for this optimization */
     char *name;           /* name of this parameter */
-    double min;           /* minimum value for this parameter */
-    double max;           /* minimum value for this parameter */
 {
     RpOptimParamNumber *numPtr;
@@ -102 +107 @@
     numPtr->base.type = RP_OPTIMPARAM_NUMBER;
     numPtr->base.value.num = 0.0;
-    numPtr->min = min;
-    numPtr->max = max;
+    numPtr->min = -DBL_MAX;
+    numPtr->max = DBL_MAX;
 
     RpOptimAddParam(envPtr, (RpOptimParam*)numPtr);
+
+    return (RpOptimParam*)numPtr;
 }
 
@@ -118 +125 @@
  * ----------------------------------------------------------------------
  */
-void
-RpOptimAddParamString(envPtr, name, allowedValues)
+RpOptimParam*
+RpOptimAddParamString(envPtr, name)
     RpOptimEnv *envPtr;   /* context for this optimization */
     char *name;           /* name of this parameter */
-    char **allowedValues; /* null-term list of allowed values */
-{
-    int n;
-    RpOptimParam **endPtrPtr;
+{
     RpOptimParamString *strPtr;
     strPtr = (RpOptimParamString*)malloc(sizeof(RpOptimParamString));
@@ -131 +135 @@
     strPtr->base.type = RP_OPTIMPARAM_STRING;
     strPtr->base.value.str = NULL;
-
-    /* count the number of allowed values */
-    if (allowedValues) {
-        for (n=0; allowedValues[n] != NULL; n++)
-            ;
-    } else {
-        n = 0;
-    }
-    strPtr->numValues = n;
-    strPtr->values = (char**)malloc(n*sizeof(char*));
-
-    /* build a null-terminated list of copies of allowed values */
-    for (n=0; n < strPtr->numValues; n++) {
-        strPtr->values[n] = strdup(allowedValues[n]);
-    }
+    strPtr->values = NULL;
 
     RpOptimAddParam(envPtr, (RpOptimParam*)strPtr);
+
+    return (RpOptimParam*)strPtr;
+}
+
+/*
+ * ----------------------------------------------------------------------
+ * RpOptimFindParam()
+ *
+ * Used to look for an existing parameter with the specified name.
+ * Returns a pointer to the parameter, or NULL if not found.
+ * ----------------------------------------------------------------------
+ */
+RpOptimParam*
+RpOptimFindParam(envPtr, name)
+    RpOptimEnv *envPtr;   /* context for this optimization */
+    char *name;           /* name of this parameter */
+{
+    int n;
+    for (n=0; envPtr->numParams; n++) {
+        if (strcmp(name, envPtr->paramList[n]->name) == 0) {
+            return envPtr->paramList[n];
+        }
+    }
+    return NULL;
+}
+
+/*
+ * ----------------------------------------------------------------------
+ * RpOptimDeleteParam()
+ *
+ * Used to delete a parameter from the environment.  This is especially
+ * useful when an error is found while configuring the parameter, just
+ * after it was created.  If the name is not recognized, this function
+ * does nothing.
+ * ----------------------------------------------------------------------
+ */
+void
+RpOptimDeleteParam(envPtr, name)
+    RpOptimEnv *envPtr;   /* context for this optimization */
+    char *name;           /* name of this parameter */
+{
+    int n, j;
+    for (n=0; envPtr->numParams; n++) {
+        if (strcmp(name, envPtr->paramList[n]->name) == 0) {
+            RpOptimCleanupParam(envPtr->paramList[n]);
+            for (j=n+1; j < envPtr->numParams; j++) {
+                envPtr->paramList[j-1] = envPtr->paramList[j];
+            }
+            envPtr->numParams--;
+            break;
+        }
+    }
 }
 
@@ -172 +214 @@
     RpOptimStatus status = RP_OPTIM_UNKNOWN;
 
-    int n, nruns, ival;
+    int n, nruns, ival, nvals;
     double dval, fitness;
     RpOptimParamNumber *numPtr;
@@ -201 +243 @@
                 case RP_OPTIMPARAM_STRING:
                     strPtr = (RpOptimParamString*)envPtr->paramList[n];
-                    ival = (int)floor(drand48() * strPtr->numValues);
+                    for (nvals=0; strPtr->values[nvals]; nvals++)
+                        ;  /* count values */
+                    ival = (int)floor(drand48() * nvals);
                     envPtr->paramList[n]->value.str = strPtr->values[ival];
                     break;
@@ -244 +288 @@
 {
     int n;
-    RpOptimParam *paramPtr;
+
+    for (n=0; n < envPtr->numParams; n++) {
+        RpOptimCleanupParam(envPtr->paramList[n]);
+    }
+    if (envPtr->cleanupPtr) {
+        (*envPtr->cleanupPtr)(envPtr->pluginData);
+    }
+    free(envPtr->paramList);
+    free(envPtr);
+}
+
+/*
+ * ----------------------------------------------------------------------
+ * RpOptimCleanupParam()
+ *
+ * Used internally to free up the data associated with an optimization
+ * parameter.  Looks at the parameter type and frees up the appropriate
+ * data.
+ * ----------------------------------------------------------------------
+ */
+static void
+RpOptimCleanupParam(paramPtr)
+    RpOptimParam *paramPtr;  /* data to be freed */
+{
+    int n;
     RpOptimParamNumber *numPtr;
     RpOptimParamString *strPtr;
 
-    for (n=0; n < envPtr->numParams; n++) {
-        paramPtr = envPtr->paramList[n];
-        free(paramPtr->name);
-        switch (paramPtr->type) {
-            case RP_OPTIMPARAM_NUMBER:
-                numPtr = (RpOptimParamNumber*)paramPtr;
-                /* nothing special to free here */
-                break;
-            case RP_OPTIMPARAM_STRING:
-                strPtr = (RpOptimParamString*)paramPtr;
-                for (n=0; n < strPtr->numValues; n++) {
+    free(paramPtr->name);
+    switch (paramPtr->type) {
+        case RP_OPTIMPARAM_NUMBER:
+            numPtr = (RpOptimParamNumber*)paramPtr;
+            /* nothing special to free here */
+            break;
+        case RP_OPTIMPARAM_STRING:
+            strPtr = (RpOptimParamString*)paramPtr;
+            if (strPtr->values) {
+                for (n=0; strPtr->values[n]; n++) {
                     free(strPtr->values[n]);
                 }
-                break;
-        }
-        free(paramPtr);
-    }
-    free(envPtr->paramList);
-    free(envPtr);
-}
+            }
+            break;
+    }
+    free(paramPtr);
+}

trunk/optimizer/src/rp_optimizer.h

@@ -9 +9 @@
  * ======================================================================
  *  AUTHOR:  Michael McLennan, Purdue University
- *  Copyright (c) 2004-2007  Purdue Research Foundation
+ *  Copyright (c) 2008  Purdue Research Foundation
  *
  *  See the file "license.terms" for information on usage and
@@ -15 +15 @@
  * ======================================================================
  */
-#undef _ANSI_ARGS_
-#undef CONST
+#ifndef RP_OPTIMIZER
+#define RP_OPTIMIZER
 
-#ifndef NO_CONST
-#  define CONST const
-#else
-#  define CONST
-#endif
+#include <tcl.h>
+#include <math.h>
+#include <float.h>
+#include <string.h>
+#include <malloc.h>
 
-#ifndef NO_PROTOTYPES
-#  define _ANSI_ARGS_(x)  x
-#else
-#  define _ANSI_ARGS_(x)  ()
-#endif
-
-#ifdef EXTERN
-#  undef EXTERN
-#endif
-#ifdef __cplusplus
-#  define EXTERN extern "C"
-#else
-#  define EXTERN extern
-#endif
+/*
+ * General-purpose allocation/cleanup routines:
+ * These are used, for example, for the plug-in architecture.
+ */
+typedef ClientData (RpOptimInit)_ANSI_ARGS_(());
+typedef void (RpOptimCleanup)_ANSI_ARGS_((ClientData cdata));
 
 /*
@@ -73 +65 @@
     RpOptimParam base;              /* basic parameter info */
     char **values;                  /* array of allowed values */
-    int numValues;                  /* number of allowed values */
 } RpOptimParamString;
 
@@ -81 +72 @@
  */
 typedef struct RpOptimEnv {
+    ClientData pluginData;          /* data created by plugin init routine */
+    RpOptimCleanup *cleanupPtr;     /* cleanup routine for pluginData */
     RpOptimParam **paramList;       /* list of input parameters to vary */
     int numParams;                  /* current number of parameters */
@@ -98 +91 @@
     int numValues, double *fitnessPtr));
 
-
 /*
  *  Here are the functions in the API:
  */
-EXTERN RpOptimEnv* RpOptimCreate _ANSI_ARGS_(());
+EXTERN RpOptimEnv* RpOptimCreate _ANSI_ARGS_((ClientData pluginData,
+    RpOptimCleanup *cleanupPtr));
 
-EXTERN void RpOptimAddParamNumber _ANSI_ARGS_((RpOptimEnv *envPtr,
-    char *name, double min, double max));
+EXTERN RpOptimParam* RpOptimAddParamNumber _ANSI_ARGS_((RpOptimEnv *envPtr,
+    char *name));
 
-EXTERN void RpOptimAddParamString _ANSI_ARGS_((RpOptimEnv *envPtr,
-    char *name, char **allowedValues));
+EXTERN RpOptimParam* RpOptimAddParamString _ANSI_ARGS_((RpOptimEnv *envPtr,
+    char *name));
+
+EXTERN RpOptimParam* RpOptimFindParam _ANSI_ARGS_((RpOptimEnv *envPtr,
+    char *name));
+
+EXTERN void RpOptimDeleteParam _ANSI_ARGS_((RpOptimEnv *envPtr, char *name));
 
 EXTERN RpOptimStatus RpOptimPerform _ANSI_ARGS_((RpOptimEnv *envPtr,
@@ -114 +112 @@
 
 EXTERN void RpOptimDelete _ANSI_ARGS_((RpOptimEnv *envPtr));
+
+#endif