func main()

in main.go [27:88]
47 lines of code
3 McCabe index (conditional complexity)

func main() {
	var params = initParams()
	printParams(params)

	testDataGenerator := lib.Params(params)
	testData := testDataGenerator.MakeTestData()

	startTime := time.Now()
	fmt.Printf("Start concurrency execute %s\n", startTime)
	runtime.GOMAXPROCS(runtime.NumCPU())

	var allReq, successReq, errorReq uint32
	var putConsumedCapacity, getConsumedCapacity uint64
	ticker(&allReq, &successReq, &errorReq)
	threadCount := len(testData) / *params.ConcurrentNo

	fmt.Printf("All test request:%v,Concurrent:%v,1thread count:%v",
		len(testData), *params.ConcurrentNo, threadCount)

	wg := sync.WaitGroup{}
	for i := 0; i < *params.ConcurrentNo; i++ {
		threadStartIndex := 0
		wg.Add(1)
		go func(i int) {
			if i != 0 {
				threadStartIndex = threadCount * i
			}
			fmt.Printf("PUT benchmark test start\n")
			putResult := lib.PutData(&allReq, &successReq, &errorReq, *params.MaxRequest, *params.TestDataSize,
				*params.TableName, *params.AwsRegion, testData, threadStartIndex, threadCount)

			atomic.AddUint64(&putConsumedCapacity, uint64(putResult))

			fmt.Printf("GET benchmark test start\n")
			getResult := lib.GetData(&allReq, &successReq, &errorReq, *params.MaxRequest,
				*params.TableName, *params.AwsRegion, testData, threadStartIndex, threadCount)

			atomic.AddUint64(&getConsumedCapacity, uint64(getResult))

			wg.Done()
		}(i)
	}
	wg.Wait()
	endTime := time.Now()
	benchmarkTime := endTime.Sub(startTime)
	throughput := float64(allReq) / benchmarkTime.Seconds()

	fmt.Printf("End all execute.\nBenchmark start time:%s\nBenchmark end time:%s\n"+
		"All request count:%d,success:%d,error%d\n",
		startTime, endTime, allReq, successReq, errorReq)

	fmt.Printf("Benchmark total time:%vsec\nAvg throughput:%vreq/sec\n",
		benchmarkTime.Seconds(), throughput)

	fmt.Printf("Benchmark total consumend capacity\nPUT:%v\nGET:%v (RoundDown)\n",
		putConsumedCapacity, getConsumedCapacity)

	printParams(params)

	os.Exit(0)

}