Changeset 3100

Timestamp:

04/19/12 06:22:02 (13 months ago)

Author:

mhauer

Message:

Added deferred initialization. Rank-based initialization remains unimplemented.
Added a simple test for deferred initialization.

Location:

trunk/core

Files:

• exec.c (modified) (2 diffs)
• globals.c (modified) (1 diff)
• globals.h (modified) (1 diff)
• object.h (modified) (1 diff)
• rt/gridlabd.h (modified) (1 diff)
• test/deferral (added)
• test/deferral/test_deferral.glm (added)

trunk/core/exec.c

@@ -492 +492 @@
 }
 
+static int init_by_deferral_retry(OBJECT **def_array, int def_ct){
+        OBJECT *obj;
+        int ct = 0, i = 0, obj_rv = 0;
+        OBJECT **next_arr = (OBJECT **)malloc(def_ct * sizeof(OBJECT *)), **tarray = 0;
+        int rv = SUCCESS;
+        char b[64];
+        int retry = 1, tries = 0;
+
+        if(global_init_max_defer < 1){
+                output_warning("init_max_defer is less than 1, disabling deferred initialization");
+        }
+        while(retry){
+                if(global_init_max_defer <= tries){
+                        output_error("init_by_deferral_retry(): exhausted initialization attempts");
+                        rv = FAILED;
+                        break;
+                }
+                memset(next_arr, 0, def_ct * sizeof(OBJECT *));
+                // initialize each object in def_array
+                for(i = 0; i < def_ct; ++i){
+                        obj = def_array[i];
+                        LOCK_OBJECT(obj);
+                        obj_rv = object_init(obj);
+                        switch(obj_rv){
+                                case 0:
+                                        rv = FAILED;
+                                        memset(b, 0, 64);
+                                        output_error("init_by_deferral_retry(): object %s initialization failed", object_name(obj, b, 63));
+                                        break;
+                                case 1:
+                                        obj->flags |= OF_INIT;
+                                        obj->flags -= OF_DEFERRED;
+                                        break;
+                                case 2:
+                                        next_arr[ct] = obj;
+                                        ++ct;
+                                        break;
+                                // no default
+                        }
+                        UNLOCK_OBJECT(obj);
+                        if(rv == FAILED){
+                                free(next_arr);
+                                return rv;
+                        }
+                }
+
+                if(ct == def_ct){
+                        output_error("init_by_deferral_retry(): all uninitialized objects deferred, model is unable to initialize");
+                        rv = FAILED;
+                        retry = 0;
+                } else if (0 == ct){
+                        rv = SUCCESS;
+                        retry = 0;
+                } else {
+                        ++tries;
+                        retry = 1;
+                        tarray = next_arr;
+                        next_arr = def_array;
+                        def_array = tarray;
+                        def_ct = ct;
+                        // three-point turn to swap the 'next' and the 'old' arrays, memset 0'ing at the top.
+                }
+        }
+
+        free(next_arr);
+        return rv;
+}
+
+static int init_by_deferral(){
+        OBJECT **def_array = 0;
+        int i = 0, obj_rv = 0, def_ct = 0;
+        OBJECT *obj = 0;
+        STATUS rv = SUCCESS;
+        char b[64];
+        def_array = (OBJECT **)malloc(sizeof(OBJECT *) * object_get_count());
+        obj = object_get_first();
+        while(obj != 0){
+                LOCK_OBJECT(obj);
+                obj_rv = object_init(obj);
+                switch (obj_rv){
+                        case 0:
+                                rv = FAILED;
+                                memset(b, 0, 64);
+                                output_error("init_by_deferral(): object %s initialization failed", object_name(obj, b, 63));
+                                break;
+                        case 1:
+                                obj->flags |= OF_INIT;
+                                break;
+                        case 2:
+                                def_array[def_ct] = obj;
+                                ++def_ct;
+                                obj->flags |= OF_DEFERRED;
+                                break;
+                        // no default
+                }
+                UNLOCK_OBJECT(obj);
+
+                if(rv == FAILED){
+                        free(def_array);
+                        return rv;
+                }
+
+                obj = obj->next;
+        }
+
+        // recursecursecursive
+        if(def_ct > 0){
+                rv = init_by_deferral_retry(def_array, def_ct);
+                if(rv == FAILED){ // got hung up retrying
+                                free(def_array);
+                                return FAILED;
+                }
+        }
+        free(def_array);
+
+        obj = object_get_first();
+        while (obj != 0){
+                if((obj->oclass->passconfig & PC_FORCE_NAME) == PC_FORCE_NAME){
+                        if(0 == strcmp(obj->name, "")){
+                                output_warning("init: object %s:%d should have a name, but doesn't", obj->oclass->name, obj->id);
+                                /* TROUBLESHOOT
+                                   The object indicated has been flagged by the module which implements its class as one which must be named
+                                   to work properly.  Please provide the object with a name and try again.
+                                 */
+                        }
+                }
+                obj = obj->next;
+        }
+        return SUCCESS;
+}
+
 static STATUS init_all(void)
 {
@@ -511 +642 @@
                         break;
                 case IS_DEFERRED:
-                        output_fatal("Deferred initialization mode not yet supported");
-                        rv = FAILED;
+                        rv = init_by_deferral();
                         break;
                 case IS_BOTTOMUP:

trunk/core/globals.c

@@ -182 +182 @@
         {"return_code", PT_int32, &global_return_code, PA_REFERENCE},
         {"module_compiler_flags", PT_enumeration, &global_module_compiler_flags, PA_PUBLIC, mcf_keys},
+        {"init_max_defer", PT_int32, &global_init_max_defer, PA_REFERENCE},
         /* add new global variables here */
 };

trunk/core/globals.h

@@ -230 +230 @@
 /* system call */
 GLOBAL int global_return_code INIT(0); /**< return code from last system call */
+GLOBAL int global_init_max_defer INIT(64); /**< maximum number of times objects will be deferred for initialization */
 
 /* remote data access */

trunk/core/object.h

@@ -28 +28 @@
 
 /* object flags */
-#define OF_NONE         0x0000 /**< Object flag; none set */
-#define OF_HASPLC       0x0001 /**< Object flag; external PLC is attached, disables local PLC */
-#define OF_LOCKED       0x0002 /**< Object flag; data write pending, reread recommended after lock clears */
-#define OF_RECALC       0x0008 /**< Object flag; recalculation of derived values is needed */
-#define OF_FOREIGN      0x0010 /**< Object flag; indicates that object was created in a DLL and memory cannot be freed by core */
-#define OF_SKIPSAFE     0x0020 /**< Object flag; indicates that skipping updates is safe */
-#define OF_FORECAST 0x0040 /**< Object flag; inidcates that the object has a valid forecast available */
-#define OF_DEFERRED 0x0080 /**< Object flag; indicates that the object started to be initialized, but requested deferral */
-#define OF_RERANK       0x4000 /**< Internal use only */
+#define OF_NONE         0x0000  /**< Object flag; none set */
+#define OF_HASPLC       0x0001  /**< Object flag; external PLC is attached, disables local PLC */
+#define OF_LOCKED       0x0002  /**< Object flag; data write pending, reread recommended after lock clears */
+#define OF_RECALC       0x0008  /**< Object flag; recalculation of derived values is needed */
+#define OF_FOREIGN      0x0010  /**< Object flag; indicates that object was created in a DLL and memory cannot be freed by core */
+#define OF_SKIPSAFE     0x0020  /**< Object flag; indicates that skipping updates is safe */
+#define OF_FORECAST     0x0040  /**< Object flag; inidcates that the object has a valid forecast available */
+#define OF_DEFERRED     0x0080  /**< Object flag; indicates that the object started to be initialized, but requested deferral */
+#define OF_INIT         0x0100  /**< Object flag; indicates that the object has been successfully initialized */
+#define OF_RERANK       0x4000  /**< Internal use only */
 
 typedef struct s_namespace {

trunk/core/rt/gridlabd.h

@@ -775 +775 @@
 #define OF_SKIPSAFE     0x0020 /**< Object flag; indicates that skipping updates is safe */
 #define OF_FORECAST 0x0040 /**< Object flag; inidcates that the object has a valid forecast available */
+#define OF_DEFERRED     0x0080  /**< Object flag; indicates that the object started to be initialized, but requested deferral */
+#define OF_INIT         0x0100  /**< Object flag; indicates that the object has been successfully initialized */
 #define OF_RERANK       0x4000 /**< Internal use only */