Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator;
 
 
 import java.util.List;
 
 import static com.facebook.presto.spi.type.BigintType.BIGINT;
 
 @Fork(3)
 @Warmup(iterations = 10, time = 500, timeUnit = .)
 @Measurement(iterations = 10, time = 500, timeUnit = .)
 public class BenchmarkGroupByHash
 {
     @Benchmark
     public int runBenchmark(BenchmarkData data)
     {
         GroupByHash groupByHash = new GroupByHash(data.getTypes(), data.getChannels(), data.getHashChannel(), 100);
         int groupCount = 0;
         for (Page page : data.getPages()) {
             GroupByIdBlock groupIds = groupByHash.getGroupIds(page);
             groupCount += (intgroupIds.getGroupCount();
         }
         return groupCount;
     }
 
     private static List<PagecreatePages(int pageCountint channelCountint groupCountList<Typetypes)
     {
         int positionCount = . / (channelCount * 8);
         List<Pagepages = new ArrayList<>(pageCount);
         PageBuilder pageBuilder = new PageBuilder(types);
         for (int numPage = 0; numPage < pageCountnumPage++) {
             pageBuilder.reset();
             for (int i = 0; i < positionCounti++) {
                 int rand = ThreadLocalRandom.current().nextInt() % groupCount;
                 for (int numChannel = 0; numChannel < channelCountnumChannel++) {
                     .writeLong(pageBuilder.getBlockBuilder(numChannel), rand);
                 }
             }
             pages.add(pageBuilder.build());
         }
         return pages;
     }
 
     @State(.)
     public static class BenchmarkData
     {
         @Param({ "2""5""10""15""20" })
         private int channelCount;
 
         @Param({ "2""10""100""1000""10000" })
         private int groupCount;
 
         @Param({ "true""false" })
         private boolean hashEnabled;
 
         private final int maxPages = 20;
         private List<Pagepages;
         public Optional<IntegerhashChannel;
         public List<Typetypes;
         public int[] channels;
 
         @Setup
        public void setup()
        {
             = createPages(, Collections.<Type>nCopies());
             =  ? Optional.of( - 1) : Optional.empty();
             = Collections.<Type>nCopies( - 1, );
             = new int[ - 1];
            for (int i = 0; i <  - 1; i++) {
                [i] = i;
            }
        }
        public List<PagegetPages()
        {
            return ;
        }
        public Optional<IntegergetHashChannel()
        {
            return ;
        }
        public List<TypegetTypes()
        {
            return ;
        }
        public int[] getChannels()
        {
            return ;
        }
    }
    public static void main(String[] args)
            throws RunnerException
    {
        Options options = new OptionsBuilder()
                .verbosity(.)
                .include(".*" + BenchmarkGroupByHash.class.getSimpleName() + ".*")
                .build();
        new Runner(options).run();
    }
New to GrepCode? Check out our FAQ X