Home | History | Annotate | Download | only in internal 
      1 /*
      2  * Copyright 2018 The gRPC Authors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package io.grpc.internal;
     18 
     19 import com.google.common.util.concurrent.ListenableFuture;
     20 import io.grpc.InternalChannelz;
     21 import io.grpc.InternalChannelz.ServerStats;
     22 import io.grpc.InternalChannelz.SocketStats;
     23 import io.grpc.InternalInstrumented;
     24 import io.grpc.InternalLogId;
     25 import java.util.concurrent.TimeUnit;
     26 import org.openjdk.jmh.annotations.Benchmark;
     27 import org.openjdk.jmh.annotations.BenchmarkMode;
     28 import org.openjdk.jmh.annotations.Mode;
     29 import org.openjdk.jmh.annotations.OutputTimeUnit;
     30 import org.openjdk.jmh.annotations.Param;
     31 import org.openjdk.jmh.annotations.Scope;
     32 import org.openjdk.jmh.annotations.Setup;
     33 import org.openjdk.jmh.annotations.State;
     34 
     35 /**
     36  * Javadoc.
     37  */
     38 @State(Scope.Benchmark)
     39 public class ChannelzBenchmark {
     40   // Number of items already present
     41   @Param({"10", "100", "1000", "10000"})
     42   public int preexisting;
     43 
     44   public InternalChannelz channelz = new InternalChannelz();
     45 
     46   public InternalInstrumented<ServerStats> serverToRemove;
     47 
     48   public InternalInstrumented<ServerStats> serverToAdd;
     49 
     50   public InternalInstrumented<ServerStats> serverForServerSocket;
     51   public InternalInstrumented<SocketStats> serverSocketToAdd;
     52   public InternalInstrumented<SocketStats> serverSocketToRemove;
     53 
     54   /**
     55    * Javadoc.
     56    */
     57   @Setup
     58   @SuppressWarnings({"unchecked", "rawtypes"})
     59   public void setUp() {
     60     serverToRemove = create();
     61     channelz.addServer(serverToRemove);
     62 
     63     serverForServerSocket = create();
     64     channelz.addServer(serverForServerSocket);
     65 
     66     serverSocketToRemove = create();
     67     channelz.addClientSocket(serverSocketToRemove);
     68     channelz.addServerSocket(serverForServerSocket, serverSocketToRemove);
     69 
     70     populate(preexisting);
     71 
     72     serverToAdd = create();
     73     serverSocketToAdd = create();
     74   }
     75 
     76   private void populate(int count) {
     77     for (int i = 0; i < count; i++) {
     78       // for addNavigable / removeNavigable
     79       InternalInstrumented<ServerStats> srv = create();
     80       channelz.addServer(srv);
     81 
     82       // for add / remove
     83       InternalInstrumented<SocketStats> sock = create();
     84       channelz.addClientSocket(sock);
     85 
     86       // for addServerSocket / removeServerSocket
     87       channelz.addServerSocket(serverForServerSocket, sock);
     88     }
     89   }
     90 
     91   @Benchmark
     92   @BenchmarkMode(Mode.SampleTime)
     93   @OutputTimeUnit(TimeUnit.NANOSECONDS)
     94   public void addNavigable() {
     95     channelz.addServer(serverToAdd);
     96   }
     97 
     98   @Benchmark
     99   @BenchmarkMode(Mode.SampleTime)
    100   @OutputTimeUnit(TimeUnit.NANOSECONDS)
    101   public void add() {
    102     channelz.addClientSocket(serverSocketToAdd);
    103   }
    104 
    105   @Benchmark
    106   @BenchmarkMode(Mode.SampleTime)
    107   @OutputTimeUnit(TimeUnit.NANOSECONDS)
    108   public void addServerSocket() {
    109     channelz.addServerSocket(serverForServerSocket, serverSocketToAdd);
    110   }
    111 
    112   @Benchmark
    113   @BenchmarkMode(Mode.SampleTime)
    114   @OutputTimeUnit(TimeUnit.NANOSECONDS)
    115   public void removeNavigable() {
    116     channelz.removeServer(serverToRemove);
    117   }
    118 
    119   @Benchmark
    120   @BenchmarkMode(Mode.SampleTime)
    121   @OutputTimeUnit(TimeUnit.NANOSECONDS)
    122   public void remove() {
    123     channelz.removeClientSocket(serverSocketToRemove);
    124   }
    125 
    126   @Benchmark
    127   @BenchmarkMode(Mode.SampleTime)
    128   @OutputTimeUnit(TimeUnit.NANOSECONDS)
    129   public void removeServerSocket() {
    130     channelz.removeServerSocket(serverForServerSocket, serverSocketToRemove);
    131   }
    132 
    133   private static <T> InternalInstrumented<T> create() {
    134     return new InternalInstrumented<T>() {
    135       final InternalLogId id = InternalLogId.allocate("fake-tag");
    136 
    137       @Override
    138       public ListenableFuture<T> getStats() {
    139         throw new UnsupportedOperationException();
    140       }
    141 
    142       @Override
    143       public InternalLogId getLogId() {
    144         return id;
    145       }
    146     };
    147   }
    148 }
    149