Changeset 619 for trunk/user

Timestamp:

Feb 12, 2019, 1:15:47 PM (6 years ago)

Author:

alain

Message:

1) Fix a bug in KSH : after the "load" command,

the [ksh] prompt is now printed after completion
of the loaded application.

2) Fix a bug in vmm_handle_cow() : the copy-on-write

use now a hal_remote_memcpy() to replicate the page content.

Location:

trunk/user

Files:

• ksh/ksh.c (modified) (46 diffs)
• sort/sort.c (modified) (10 diffs)

trunk/user/ksh/ksh.c

@@ -21 +21 @@
 //   the TXT terminal ownership.
 //
-// We use a semaphore to synchronize the two KSH threads. At each iteration, 
-// the interactive thread check the semaphore (with a sem_wait). It blocks 
-// and deschedules, if the KSH process loosed the TXT ownership (after a load,
-// or for any other cause. It unblocks with the following policy:
+// We use a semaphore to synchronize the two KSH threads. After each command
+// completion, the interactive thread check the TXT ownership (with a sem_wait),
+// and blocks, if the KSH process loosed the TXT ownership (after a load,
+// or for any other cause). It is unblocked with the following policy:
 // . if the command is "not a load", the semaphore is incremented by the 
-//   cmd_***() function when the command is completed, to allow the KSH interactive()
-//   function to get the next command in the while loop.    
+//   cmd_***() function when the command is completed, to get the next command 
+//   in the while loop.    
 // . if the command is a "load without &", the TXT is given to the NEW process by the
 //   execve() syscall, and is released to the KSH process when NEW process terminates.
@@ -56 +56 @@
 
 #define DEBUG_MAIN          0
-
+#define DEBUG_INTER         0
+#define DEBUG_PARSE         0
 #define DEBUG_CMD_CAT       0
 #define DEBUG_CMD_CP        0
 #define DEBUG_CMD_LOAD      0
 #define DEBUG_CMD_LS        0
+#define DEBUG_CMD_PS        0
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -88 +90 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-ksh_cmd_t       cmd[];                    // array of supported commands
+ksh_cmd_t       command[];                // array of supported commands
 
 log_entry_t     log_entries[LOG_DEPTH];   // array of registered commands
@@ -99 +101 @@
 sem_t           semaphore;                // block interactive thread when zero
 
+pthread_t       trdid;                    // interactive thread identifier
+ 
 //////////////////////////////////////////////////////////////////////////////////////////
 //         Shell  Commands
@@ -112 +116 @@
     char         * buf;
 
+#if DEBUG_CMD_CAT
+char string[64];
+#endif
+
         if (argc != 2) 
     {
@@ -134 +142 @@
 
 #if DEBUG_CMD_CAT
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[%s] file %s open / cycle %d\n",
-__FUNCTION__ , path , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, path );
+display_string( string );
 #endif
 
@@ -161 +167 @@
 
 #if DEBUG_CMD_CAT
-get_cycle( &cycle );
-printf("\n[%s] get size %d / cycle %d\n",
-__FUNCTION__ , size , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : get size = %d", __FUNCTION__, size );
+display_string( string );
 #endif
 
@@ -176 +181 @@
 
 #if DEBUG_CMD_CAT
-get_cycle( &cycle );
-printf("\n[%s] map file %d to buffer %x / cycle %d\n",
-__FUNCTION__ , fd , buf , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : map file %d to buffer %x", __FUNCTION__, fd , buf );
+display_string( string );
 display_vmm( 0 , getpid() );
 #endif
@@ -237 +241 @@
         struct stat  st;
 
+#if DEBUG_CMD_CP
+char string[64];
+#endif
+
         if (argc != 3) 
     {
@@ -259 +267 @@
 
 #if DEBUG_CMD_CP
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[%s] open file <%s> done / cycle %d\n",
-__FUNCTION__ , srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, srcpath );
+display_string( string );
 #endif
 
@@ -274 +280 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] stats file <%s> done / cycle %d\n",
-__FUNCTION__ , srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, srcpath );
+display_string( string );
 #endif
 
@@ -299 +304 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] open file <%s> done / cycle %d\n",
-__FUNCTION__ , dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : file %s open", __FUNCTION__, dstpath );
+display_string( string );
 #endif
 
@@ -311 +315 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] stats file <%s> done / cycle %d\n",
-__FUNCTION__ , dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : got stats for %s", __FUNCTION__, dstpath );
+display_string( string );
 #endif
 
@@ -336 +339 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] %d bytes read from <%s> / cycle %d\n",
-__FUNCTION__ , len, srcpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : read %d bytes from %s", __FUNCTION__, len, srcpath );
+display_string( string );
 #endif
 
@@ -349 +351 @@
 
 #if DEBUG_CMD_CP
-get_cycle( &cycle );
-printf("\n[%s] %d bytes writen to <%s> / cycle %d\n",
-__FUNCTION__ , len, dstpath , (int)cycle );
+snprintf( string , 64 , "[KSH] %s : write %d bytes to %s", __FUNCTION__, len, dstpath );
+display_string( string );
 #endif
 
@@ -573 +574 @@
     else
     {
-            printf("available commands:\n");
-            for (i = 0 ; cmd[i].name ; i++) 
-        {
-                    printf("\t%s\t : %s\n", cmd[i].name , cmd[i].desc);
+        printf("available commands:\n");
+            for (i = 0 ; command[i].name ; i++) 
+        {
+                    printf("\t%s\t : %s\n", command[i].name , command[i].desc);
             }
     }
@@ -624 +625 @@
     unsigned int         placement;          // placement specified if non zero
     unsigned int         cxy;                // target cluster if placement specified
+
+#if DEBUG_CMD_LOAD
+char string[64];
+#endif
 
         if( (argc < 2) || (argc > 4) )  
@@ -661 +666 @@
         }
 
+/*
+        // take semaphore to block the interactive thread
+        if ( sem_wait( &semaphore ) )
+        {
+            printf("\n[ksh error] cannot found semafore\n" );
+            exit( 1 );
+        }
+*/
         // get KSH process PID
         ksh_pid = getpid();
 
 #if DEBUG_CMD_LOAD
-long long unsigned cycle;
-get_cycle( &cycle );
-printf("\n[ksh] %s : ksh_pid %x / path %s / bg %d / place %d (%x) / cycle %d\n",
-__FUNCTION__, ksh_pid, argv[1], background, placement, cxy, (int)cycle );
+snprintf( string , 64 , "[KSH] %s : ksh_pid %x / path %s / bg %d / place %d (%x)\n",
+__FUNCTION__, ksh_pid, argv[1], background, placement, cxy );
+display_string( string );
 #endif
 
@@ -685 +697 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : child_pid %x after fork, before exec / cycle %d\n",
-__FUNCTION__ , getpid(), (int)cycle );
+snprintf( string , 64 , "[KSH] %s : child_pid %x after fork, before exec\n",
+__FUNCTION__ , getpid() );
+display_string( string );
 #endif
 
@@ -694 +706 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : child_pid %x after exec / ret_exec %d / cycle %d\n",
-__FUNCTION__ , getpid(), ret_exec, (int)cycle );
+snprintf( string , 64 , "[KSH] %s : child_pid %x after exec / ret_exec %x\n",
+__FUNCTION__ , getpid(), ret_exec );
+display_string( string );
 #endif
 
@@ -710 +722 @@
 
 #if DEBUG_CMD_LOAD
-get_cycle( &cycle );
-printf("\n[ksh] %s : ksh_pid %x after fork / ret_fork %x / cycle %d\n",
-__FUNCTION__, getpid(), ret_fork, (int)cycle );
-#endif
-
-            if( background )    // child in background =>  KSH must keep TXT ownership
+snprintf( string , 64 , "[KSH] %s : ksh_pid %x after fork / ret_fork %x\n",
+__FUNCTION__, getpid(), ret_fork );
+display_string( string );
+#endif
+
+            if( background )    //  KSH must keep TXT ownership
             {
+                // get back the TXT ownership
                 fg( ksh_pid );
+
+                // release semaphore to get next command
+                sem_post( &semaphore );
             }
-        }
-    }
-
-    // release semaphore to get next command
-    sem_post( &semaphore );
-    
+            else                // KSH loosed TXT ownership
+            {
+                // semaphore will be released by the KSH main thread
+                // when the loaded process exit
+            }
+        }
+    }
 }   // end cmd_load
 
@@ -758 +775 @@
     DIR            * dir;
 
+#if DEBUG_CMD_LS
+char string[64];
+#endif
+
         if (argc > 2 )
     {
@@ -774 +795 @@
 
 #if DEBUG_CMD_LS
-printf("\n[ksh] %s : directory <%s> open / DIR %x\n",
+snprintf( string , 64 , "[KSH] %s : directory <%s> open / DIR %x\n",
 __FUNCTION__, pathname , dir );
+display_string( string );
 #endif
 
@@ -794 +816 @@
 
 #if DEBUG_CMD_LS
-printf("\n[ksh] %s : directory <%s> closed\n",
+snprintf( string , 64 , "[KSH] %s : directory <%s> closed\n",
 __FUNCTION__, pathname );
+display_string( string );
 #endif
 
@@ -865 +888 @@
     unsigned int y;
 
+#if DEBUG_CMD_PS
+char string[64];
+#endif
+
         if (argc != 1)
     {
@@ -879 +906 @@
             for( y = 0 ; y < y_size ; y++ )
             {
+
+#if DEBUG_CMD_PS
+snprintf( string , 64 , "\n[KSH] %s : call display_cluster_process()", __FUNCTION__ );
+display_string( string );
+#endif
+
                 // display only owned processes
                 display_cluster_processes( HAL_CXY_FROM_XY(x,y), 1 ); 
@@ -1003 +1036 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
-ksh_cmd_t cmd[] =
+ksh_cmd_t command[] =
 {
         { "cat",     "display file content",                            cmd_cat     },
@@ -1031 +1064 @@
 static void __attribute__ ((noinline)) parse( char * buf )
 {
-        int argc = 0;
-        char *argv[MAX_ARGS];
-        int i;
-        int len = strlen(buf);
+        int    argc = 0;
+        char * argv[MAX_ARGS];
+        int    i;
+        int    len = strlen(buf);
+
+#if DEBUG_PARSE
+char string[64];
+snprintf( string , 64 , "\n[KSH] %s : <%s>", __FUNCTION__ , buf );
+display_string( string );
+#endif
 
         // build argc/argv
         for (i = 0; i < len; i++) 
     {
+        // convert SPACE to NUL
                 if (buf[i] == ' ') 
         {
@@ -1053 +1093 @@
         }
 
+#if DEBUG_PARSE
+snprintf( string , 64 , "\n[KSH] %s : argc = %d for <%s>", __FUNCTION__ , argc , argv[0] );
+display_string( string );
+#endif
+
     // analyse command type
         if (argc > 0)
@@ -1058 +1103 @@
                 int found = 0;
 
-                argv[argc] = NULL;
-
                 // try to match typed command 
-                for (i = 0 ; cmd[i].name ; i++)
-        {
-                        if (strcmp(argv[0], cmd[i].name) == 0)
+                for ( i = 0 ; command[i].name ; i++ )
+        {
+                        if (strcmp(argv[0], command[i].name) == 0)
             {
-                                cmd[i].fn(argc, argv);
+                                command[i].fn(argc, argv);
                                 found = 1;
                                 break;
@@ -1085 +1128 @@
 {
         char           c;                                               // read character
-        char           buf[CMD_MAX_SIZE];               // buffer for one command
     unsigned int   end_command;             // last character found in a command
         unsigned int   count;                   // pointer in command buffer
@@ -1091 +1133 @@
         unsigned int   state;                   // escape sequence state
 
+        char           cmd[CMD_MAX_SIZE];               // buffer for one command
+
+#if DEBUG_INTER
+char string[64];
+#endif
 
 /* To lauch one command without interactive mode 
-   
 if( sem_wait( &semaphore ) )
 {
@@ -1101 +1147 @@
 else
 {
-    printf("\n[ksh] ls bin/user\n");
+    printf("\n[ksh] load bin/user/sort.elf\n");
 }
 
-strcpy( buf , "ls bin/user" );
-parse( buf );
-
+strcpy( cmd , "load bin/user/sort.elf" );
+parse( cmd );
 */
 
@@ -1127 +1172 @@
         // - BRAKET : the wo characters (ESC,[) have been found
 
-    // external loop on the commands
-    // the in teractive thread should not exit this loop
+    // take the semaphore for the first command
+    if ( sem_wait( &semaphore ) )
+    {
+        printf("\n[ksh error] cannot found semafore\n" );
+        exit( 1 );
+    }
+
+    // display prompt for the first command
+    printf("\n[ksh] ");
+
+    // external loop on the commands / the interactive thread do not exit this loop
         while (1)
         {
             // initialize command buffer
-            memset( buf, 0x20 , sizeof(buf) );   // TODO useful ?
-            count = 0;
-            state = NORMAL;
-
-        // decrement semaphore, and block if the KSH process is not the TXT owner
-        if ( sem_wait( &semaphore ) )
-        {
-            printf("\n[ksh error] cannot found semafore\n" );
-            exit( 1 );
-        }
-
-        // display prompt on a new line
-        printf("\n[ksh] ");
- 
+            memset( cmd, 0x20 , sizeof(cmd) );   // TODO useful ?
+            count       = 0;
+            state       = NORMAL;
         end_command = 0;
+
+#if DEBUG_INTER 
+unsigned int pid = getpid();
+snprintf( string , 64 , "\n[KSH] %s : request a new command", __FUNCTION__ );
+display_string( string );
+#endif
 
         // internal loop on characters in one command
@@ -1171 +1220 @@
                                     {
                                             // complete command with NUL character
-                                            buf[count] = 0;
+                                            cmd[count] = 0;
                         count++;
 
-                                        // register command in log arrays
-                                            strcpy(log_entries[ptw].buf, buf);
+                        // register command in log
+                                            strncpy( log_entries[ptw].buf , cmd , count );
                                             log_entries[ptw].count = count;
                                             ptw = (ptw + 1) % LOG_DEPTH;
                                             ptr = ptw;
 
+#if DEBUG_INTER
+snprintf( string , 64 , "[KSH] %s : parse and execute <%s>", __FUNCTION__, cmd );
+display_string( string );
+#endif
                         // echo character
                         putchar( c );
 
                                             // call parser to analyse and execute command
-                                            parse( buf );
+                                            parse( cmd );
                                     }
                     else                         // no command registered
@@ -1204 +1257 @@
                             else                                               // normal character
                                 {
-                                    if (count < sizeof(buf) - 1)
+                                    if (count < (sizeof(cmd) - 1) )
                                     {
                         // register character in command buffer
-                                            buf[count] = c;
+                                            cmd[count] = c;
                                             count++;
 
@@ -1213 +1266 @@
                         putchar( c );
                                         }
+                    else
+                    {
+                                printf("\none command cannot exceed %d characters\n", sizeof(cmd) );
+                    }
                                 }
                         }
@@ -1228 +1285 @@
                         else if( state == BRAKET )
                         {
-                                if (c == 'D')   // valid  LEFT sequence => move buf pointer left
+                                if (c == 'D')   // valid  LEFT sequence => move cmd pointer left
                                 {
                                         if (count > 0)
@@ -1239 +1296 @@
                                         state = NORMAL;
                                 }
-                                else if (c == 'C')   // valid  RIGHT sequence => move buf pointer right
+                                else if (c == 'C')   // valid  RIGHT sequence => move cmd pointer right
                                 {
-                                        if (count < sizeof(buf) - 1)
+                                        if (count < sizeof(cmd) - 1)
                                         {
-                                                printf("%c", buf[count]);
+                                                printf("%c", cmd[count]);
                                                 count++;
                                         }
@@ -1256 +1313 @@
                                         count = 0;
 
-                                        // copy log command into buf
+                                        // copy log command into cmd
                                         ptr = (ptr - 1) % LOG_DEPTH;
-                                        strcpy(buf, log_entries[ptr].buf);
+                                        strcpy(cmd, log_entries[ptr].buf);
                                         count = log_entries[ptr].count - 1;
 
                                         // display log command
-                                        printf("%s", buf);
+                                        printf("%s", cmd);
 
                                         // get next user char
@@ -1273 +1330 @@
                                         count = 0;
 
-                                        // copy log command into buf
+                                        // copy log command into cmd
                                         ptr = (ptr + 1) % LOG_DEPTH;
-                                        strcpy(buf, log_entries[ptr].buf);
+                                        strcpy(cmd, log_entries[ptr].buf);
                                         count = log_entries[ptr].count;
 
                                         // display log command
-                                        printf("%s", buf);
+                                        printf("%s", cmd);
 
                                         // get next user char
@@ -1291 +1348 @@
                         }
                 }  // end internal while loop on characters
+
+#if DEBUG_INTER 
+snprintf( string , 64 , "\n[KSH] %s : complete <%s> command", __FUNCTION__, cmd );
+display_string( string );
+#endif
+
+        // block interactive thread if KSH loose TXT ownership
+        if ( sem_wait( &semaphore ) )
+        {
+            printf("\n[ksh error] cannot found semafore\n" );
+            exit( 1 );
+        }
+
+        // display prompt for next command
+        printf("\n[ksh] ");
+
         }  // end external while loop on commands
+
 }  // end interactive()
 
@@ -1302 +1376 @@
     int          child_pid;       // child process identifier
     int          parent_pid;      // parent process identifier (i.e. this process)
-    pthread_t    trdid;           // interactive thread identifier (unused)
     unsigned int is_owner;        // non-zero if KSH process is TXT owner
 
@@ -1315 +1388 @@
 
 #if DEBUG_MAIN
-printf("\n[ksh] main started on core[%x,%d]\n", cxy , lid ); 
+printf("\n[ksh] main thread started on core[%x,%d]\n", cxy , lid ); 
 #endif
     
@@ -1339 +1412 @@
                     NULL ); 
 #if DEBUG_MAIN
-printf("\n[ksh] main launched interactive thread => wait children termination\n" ); 
+printf("\n[ksh] main thread launched interactive thread %x\n", trdid ); 
 #endif
 
@@ -1360 +1433 @@
         is_fg( parent_pid , &is_owner );
         if( is_owner ) sem_post( &semaphore );
-
     }
 }  // end main()

trunk/user/sort/sort.c

@@ -29 +29 @@
 #include <hal_macros.h>
 
-#define ARRAY_LENGTH        0x1000    // 4096 values
-
+#define ARRAY_LENGTH        256        // number of values
 #define MAX_THREADS         1024       // 16 * 16 * 4
-
+#define USE_DQT_BARRIER     1
 #define DISPLAY_ARRAY       0
 #define INTERACTIVE_MODE    0
@@ -42 +41 @@
 typedef struct
 {
-    unsigned int threads;      // total number of threads
+    unsigned int threads;       // total number of threads
     unsigned int thread_uid;    // thread user index (0 to threads -1)
     unsigned int main_uid;      // main thread user index
@@ -206 +205 @@
 void main( void )
 {
+    int                    error;
     unsigned int           x_size;             // number of rows
     unsigned int           y_size;             // number of columns
     unsigned int           ncores;             // number of cores per cluster
-    unsigned int           threads;            // total number of threads
+    unsigned int           total_threads;      // total number of threads
     unsigned int           thread_uid;         // user defined thread index
     unsigned int           main_cxy;           // cluster identifier for main
@@ -226 +226 @@
     // compute number of threads (one thread per core)
     get_config( &x_size , &y_size , &ncores );
-    threads = x_size * y_size * ncores;
+    total_threads = x_size * y_size * ncores;
 
     // get core coordinates and user index for the main thread
@@ -235 +235 @@
 
     // checks number of threads
-    if ( (threads != 1)   && (threads != 2)   && (threads != 4)   && 
-         (threads != 8)   && (threads != 16 ) && (threads != 32)  && 
-         (threads != 64)  && (threads != 128) && (threads != 256) && 
-         (threads != 512) && (threads != 1024) )
+    if ( (total_threads != 1)   && (total_threads != 2)   && (total_threads != 4)   && 
+         (total_threads != 8)   && (total_threads != 16 ) && (total_threads != 32)  && 
+         (total_threads != 64)  && (total_threads != 128) && (total_threads != 256) && 
+         (total_threads != 512) && (total_threads != 1024) )
     {
         printf("\n[SORT ERROR] number of cores must be power of 2\n");
@@ -245 +245 @@
 
     // check array size
-    if ( ARRAY_LENGTH % threads) 
+    if ( ARRAY_LENGTH % total_threads) 
     {
         printf("\n[SORT ERROR] array size must be multiple of number of threads\n");
@@ -251 +251 @@
     }
 
-    printf("\n[SORT] main starts on core[%x,%d] / %d thread(s) / %d values / PID %x\n",
-    main_cxy, main_lid, threads, ARRAY_LENGTH, getpid() );
-
-    // Barrier initialization
-    barrier_attr.x_size   = x_size; 
-    barrier_attr.y_size   = y_size;
-    barrier_attr.nthreads = ncores;
-    if( pthread_barrier_init( &barrier, &barrier_attr , threads ) )
+    printf("\n\n[SORT] main starts on core[%x,%d] / %d threads / %d values / PID %x\n",
+    main_cxy, main_lid, total_threads, ARRAY_LENGTH, getpid() );
+
+    // initialize barrier
+    if( USE_DQT_BARRIER )
+    {
+        barrier_attr.x_size   = x_size; 
+        barrier_attr.y_size   = y_size;
+        barrier_attr.nthreads = ncores;
+        error = pthread_barrier_init( &barrier, &barrier_attr , total_threads );
+    }
+    else // use SIMPLE_BARRIER
+    {
+        error = pthread_barrier_init( &barrier, NULL , total_threads );
+    }
+
+    if( error )
     {
         printf("\n[SORT ERROR] cannot initialise barrier\n" );
@@ -290 +299 @@
 
                 // set sort arguments for all threads
-                arg[thread_uid].threads      = threads;
+                arg[thread_uid].threads      = total_threads;
                 arg[thread_uid].thread_uid   = thread_uid;
                 arg[thread_uid].main_uid     = main_uid;
@@ -330 +339 @@
     sort( &arg[main_uid] );
 
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
+    // destroy barrier
+    pthread_barrier_destroy( &barrier );
+
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
     // Check result
     int    success = 1;
-    int*   res_array = ( (threads==  2) ||
-                         (threads==  8) || 
-                         (threads== 32) || 
-                         (threads==128) || 
-                         (threads==512) ) ? array1 : array0;
+    int*   res_array = ( (total_threads ==   2) ||
+                         (total_threads ==   8) || 
+                         (total_threads ==  32) || 
+                         (total_threads == 128) || 
+                         (total_threads == 512) ) ? array1 : array0;
     
     for( n=0 ; n<(ARRAY_LENGTH-2) ; n++ )
@@ -359 +379 @@
     {
         printf("\n[SORT] success at cycle %d\n", (unsigned int)cycle );
-        exit( 0 );
     }
     else
     {
         printf("\n[SORT] failure at cycle %d\n", (unsigned int)cycle );
-        exit( 1 );
-    }
+    }
+
+#if INTERACTIVE_MODE
+idbg();
+#endif
+
+    exit( 0 );
 
 }  // end main()