buf.append("[HOTTHREAD MONITOR] ");

        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        buf.append('{');

        final boolean ignoreIdleThreads = Constants.TRUE.equalsIgnoreCase(fessConfig.getCrawlerHotthreadIgnoreIdleThreads());
        final TimeValue interval = TimeValue.parseTimeValue(fessConfig.getCrawlerHotthreadInterval(), "crawler.hotthread.interval");

        public String expires;

        @Option(name = "-h", aliases = "--hotThread", metaVar = "hotThread", usage = "Interval for Hot Thread logging")
        public Integer hotThread;

        protected Options() {
            // nothing
        }

        protected List<String> getWebConfigIdList() {

crawler.ignore.content.exception=true
crawler.failure.url.status.codes=404
crawler.system.monitor.interval=60
crawler.hotthread.ignore_idle_threads=true
crawler.hotthread.interval=500ms
crawler.hotthread.snapshots=10
crawler.hotthread.threads=3
crawler.hotthread.timeout=30s
crawler.hotthread.type=cpu
crawler.metadata.content.excludes=resourceName,X-Parsed-By,Content-Encoding.*,Content-Type.*,X-TIKA.*

        return this;
    }

    public CrawlJob dataConfigIds(final String[] dataConfigIds) {
        this.dataConfigIds = dataConfigIds;
        return this;
    }

    public CrawlJob hotThread(final int hotThreadInterval) {
        this.hotThreadInterval = hotThreadInterval;
        return this;
    }

    @Override
    public String execute() {
        //   check # of crawler processes

    String CRAWLER_HOTTHREAD_ignore_idle_threads = "crawler.hotthread.ignore_idle_threads";

    /** The key of the configuration. e.g. 500ms */
    String CRAWLER_HOTTHREAD_INTERVAL = "crawler.hotthread.interval";

    /** The key of the configuration. e.g. 10 */
    String CRAWLER_HOTTHREAD_SNAPSHOTS = "crawler.hotthread.snapshots";

    /** The key of the configuration. e.g. 3 */

	return NULL;
}

static void DoThread(int sigstack) {
	pthread_t tid;
	if (sigstack) {
		pthread_create(&tid, NULL, WithSigStack, NULL);
	} else {
		pthread_create(&tid, NULL, WithoutSigStack, NULL);
	}
	pthread_join(tid, NULL);
}
*/
import "C"

func init() {
	register("SigStack", SigStack)
}

func SigStack() {
	C.DoThread(0)
	C.DoThread(1)
	C.DoThread(0)
	C.DoThread(1)

	return 0;
}

void bigStack(callback *cb) {
	bigStackCallback = cb;
	HANDLE hThread = CreateThread(NULL, STACK_SIZE, threadEntry, NULL, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL);
	if (hThread == NULL) {
		fprintf(stderr, "CreateThread failed\n");
		exit(1);
	}
	WaitForSingleObject(hThread, INFINITE);

	b0.Event("ProcSteal", trace.ProcID(0), testgen.Seq(1), trace.ThreadID(1))

	// Status event for a goroutine blocked in a syscall for the entire generation.
	bz := g.Batch(trace.NoThread, 0)
	bz.Event("GoStatus", trace.GoID(1), trace.ThreadID(1), go122.GoSyscall)

		gs := g.gStates[r.Scope.Goroutine()]
		gs.rangeEnd(ev.Time(), r.Name, ev.Stack(), ctx)
	}
}

func (g *threadGenerator) GoroutineTransition(ctx *traceContext, ev *trace.Event) {
	if ev.Thread() != trace.NoThread {
		if _, ok := g.threads[ev.Thread()]; !ok {
			g.threads[ev.Thread()] = struct{}{}
		}
	}

	st := ev.StateTransition()
	goID := st.Resource.Goroutine()

	b0.Event("GoSyscallEndBlocked")
	b0.Event("ProcStatus", trace.ProcID(0), go122.ProcIdle)
	b0.Event("ProcStart", trace.ProcID(0), testgen.Seq(1))
	b0.Event("GoStatus", trace.GoID(4), trace.NoThread, go122.GoRunnable)
	b0.Event("GoStart", trace.GoID(4), testgen.Seq(1))
	b0.Event("GoSyscallBegin", testgen.Seq(2), testgen.NoStack)
	b0.Event("GoDestroySyscall")

	// A new Go-created thread with the same ID appears and