docs: public void execute()
          throws MojoExecutionException, MojoFailureException
      {
          if ( isSkip() )
          {
              getLog().info( "skipping execute as per configuraion" );
              return;
          }
          if ( killAfter != -1 )
          {
              getLog().warn( "Warning: killAfter is now deprecated. Do you need it ? Please comment on MEXEC-6." );
          }
  
          arguments = new String[] {outputParentDirectory.getAbsolutePath(), outputDirectory.getAbsolutePath(), filterClassPackage};
  
          if ( getLog().isDebugEnabled() )
          {
              StringBuffer msg = new StringBuffer( "Invoking : " );
              msg.append( mainClass );
              msg.append( ".main(" );
              for ( int i = 0; i < arguments.length; i++ )
              {
                  if ( i > 0 )
                  {
                      msg.append( ", " );
                  }
                  msg.append( arguments[i] );
              }
              msg.append( ")" );
              getLog().debug( msg );
          }
  
          final Log log = getLog();
          IsolatedThreadGroup threadGroup = new IsolatedThreadGroup( mainClass /* name */);
          Thread bootstrapThread = new Thread( threadGroup, new Runnable()
          {
              public void run()
              {
              	long current = System.currentTimeMillis();
                  try
                  {   
                  	
                      Method main =
                          Thread.currentThread().getContextClassLoader().loadClass( mainClass ).getMethod( "main",
                                                                                                           new Class[] { String[].class } );
                      if ( !main.isAccessible() )
                      {
                          getLog().debug( "Setting accessibility to true in order to invoke main()." );
                          main.setAccessible( true );
                      }
                      if ( !Modifier.isStatic( main.getModifiers() ) )
                      {
                          throw new MojoExecutionException( "Can't call main(String[])-method because it is not static." );
                      }
                      main.invoke( null, new Object[] { arguments } );
                  }
                  catch ( NoSuchMethodException e )
                  { // just pass it on
                      Thread.currentThread().getThreadGroup().uncaughtException( Thread.currentThread(),
                                                                                 new Exception(
                                                                                                "The specified mainClass doesn't contain a main method with appropriate signature.",
                                                                                                e ) );
                  }
                  catch ( Exception e )
                  { // just pass it on
                      Thread.currentThread().getThreadGroup().uncaughtException( Thread.currentThread(), e );
                  } finally {
                  	log.info("JProtobuf pre compile done time took: " + (System.currentTimeMillis() - current) + "ms");
                  }
              }
          }, mainClass + ".main()" );
          bootstrapThread.setContextClassLoader( getClassLoader() );
          setSystemProperties();
  
          bootstrapThread.start();
          joinNonDaemonThreads( threadGroup );
          // It's plausible that spontaneously a non-daemon thread might be created as we try and shut down,
          // but it's too late since the termination condition (only daemon threads) has been triggered.
          if ( keepAlive )
          {
              getLog().warn( "Warning: keepAlive is now deprecated and obsolete. Do you need it? Please comment on MEXEC-6." );
              waitFor( 0 );
          }
  
          if ( cleanupDaemonThreads )
          {
  
              terminateThreads( threadGroup );
  
              try
              {
                  threadGroup.destroy();
              }
              catch ( IllegalThreadStateException e )
              {
                  getLog().warn( "Couldn't destroy threadgroup " + threadGroup, e );
              }
          }
  
          if ( originalSystemProperties != null )
          {
              System.setProperties( originalSystemProperties );
          }
  
          synchronized ( threadGroup )
          {
              if ( threadGroup.uncaughtException != null )
              {
                  throw new MojoExecutionException( "An exception occured while executing the Java class. "
                      + threadGroup.uncaughtException.getMessage(), threadGroup.uncaughtException );
              }
          }
  
          registerSourceRoots();
      }