// Copyright 2015 The Bazel Authors. All rights reserved.
//
// 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.google.devtools.build.lib.profiler.statistics;
import com.google.common.collect.Maps;
import com.google.common.collect.Maps.EntryTransformer;
import com.google.common.collect.Multimap;
import com.google.devtools.build.lib.profiler.ProfileInfo;
import com.google.devtools.build.lib.profiler.ProfileInfo.Task;
import com.google.devtools.build.lib.util.LongArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
* Extracts the execution times of user-defined and built-in Skylark functions and computes
* statistics.
*
* <p>The statistics are separated for the total duration taken for a function call and the
* "self duration" taken only within the function itself, but not within any subtask of the
* corresponding {@link Task}.
*/
public final class SkylarkStatistics {
private final Map<String, LongArrayList> userFunctionDurations;
private final Map<String, LongArrayList> userCompiledDurations;
private final Map<String, LongArrayList> builtinFunctionDurations;
/**
* Self duration is the time taken just within a function itself, but not other subtasks of it.
*/
private final Map<String, LongArrayList> userFunctionSelfDurations;
private final Map<String, LongArrayList> userCompiledSelfDurations;
private final Map<String, LongArrayList> builtinFunctionSelfDurations;
private long userTotalNanos;
private long userCompiledTotalNanos;
private long builtinTotalNanos;
public SkylarkStatistics() {
userFunctionDurations = new HashMap<>();
userCompiledDurations = new HashMap<>();
builtinFunctionDurations = new HashMap<>();
userFunctionSelfDurations = new HashMap<>();
userCompiledSelfDurations = new HashMap<>();
builtinFunctionSelfDurations = new HashMap<>();
}
public SkylarkStatistics(ProfileInfo info) {
this();
addProfileInfo(info);
}
/**
* Adds Skylark function task durations from a {@link ProfileInfo} file.
*/
public void addProfileInfo(ProfileInfo info) {
computeStatistics(
info.getSkylarkUserFunctionTasks(),
info.getCompiledSkylarkUserFunctionTasks(),
info.getSkylarkBuiltinFunctionTasks());
}
/**
* @return the total time taken by all calls to built-in Skylark functions
*/
public long getBuiltinTotalNanos() {
return builtinTotalNanos;
}
/**
* @return the total time taken by all calls to user-defined Skylark functions
*/
public long getCompiledUserTotalNanos() {
return userCompiledTotalNanos;
}
/**
* @return the total time taken by all calls to user-defined Skylark functions
*/
public long getUserTotalNanos() {
return userTotalNanos;
}
/**
* @return The execution durations of all calls to built-in Skylark functions.
*/
public Map<String, LongArrayList> getBuiltinFunctionDurations() {
return builtinFunctionDurations;
}
/**
* return The execution durations of all calls to built-in functions excluding the durations of
* all subtasks.
*/
public Map<String, LongArrayList> getBuiltinFunctionSelfDurations() {
return builtinFunctionSelfDurations;
}
/**
* Builds and returns the {@link TasksStatistics} for the durations of each built-in function.
* The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getBuiltinFunctionStatistics() {
return buildTasksStatistics(builtinFunctionDurations);
}
/**
* Builds and returns the {@link TasksStatistics} for the self-times of each built-in function.
* The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getBuiltinFunctionSelfStatistics() {
return buildTasksStatistics(builtinFunctionSelfDurations);
}
/**
* @return The execution durations of all calls to user-defined Skylark functions.
*/
public Map<String, LongArrayList> getCompiledUserFunctionDurations() {
return userCompiledDurations;
}
/**
* return The execution durations of all calls to user-defined functions excluding the durations
* of all subtasks.
*/
public Map<String, LongArrayList> getCompiledUserFunctionSelfDurations() {
return userCompiledSelfDurations;
}
/**
* Builds and returns the {@link TasksStatistics} for the durations of each user-defined
* function. The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getCompiledUserFunctionStatistics() {
return buildTasksStatistics(userCompiledDurations);
}
/**
* Builds and returns the {@link TasksStatistics} for the self-times of each user-defined
* function. The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getCompiledUserFunctionSelfStatistics() {
return buildTasksStatistics(userCompiledSelfDurations);
}
/**
* @return The execution durations of all calls to user-defined Skylark functions.
*/
public Map<String, LongArrayList> getUserFunctionDurations() {
return userFunctionDurations;
}
/**
* return The execution durations of all calls to user-defined functions excluding the durations
* of all subtasks.
*/
public Map<String, LongArrayList> getUserFunctionSelfDurations() {
return userFunctionSelfDurations;
}
/**
* Builds and returns the {@link TasksStatistics} for the durations of each user-defined
* function. The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getUserFunctionStatistics() {
return buildTasksStatistics(userFunctionDurations);
}
/**
* Builds and returns the {@link TasksStatistics} for the self-times of each user-defined
* function. The return value is not cached and will be recomputed on another call.
*/
public Map<String, TasksStatistics> getUserFunctionSelfStatistics() {
return buildTasksStatistics(userFunctionSelfDurations);
}
/**
* For each Skylark function get the list of durations and self durations from the task maps.
*/
private void computeStatistics(
Multimap<String, Task> userTasks,
Multimap<String, Task> userCompiledTasks,
Multimap<String, Task> builtinTasks) {
userTotalNanos += addDurations(userTasks, userFunctionDurations, userFunctionSelfDurations);
userCompiledTotalNanos +=
addDurations(userCompiledTasks, userCompiledDurations, userCompiledSelfDurations);
builtinTotalNanos +=
addDurations(builtinTasks, builtinFunctionDurations, builtinFunctionSelfDurations);
}
/**
* Add all new durations to previously collected durations for all functions mapped to tasks.
* @return The sum of the execution times of all {@link Task} values in the map.
*/
private static long addDurations(
Multimap<String, Task> functionTasks,
Map<String, LongArrayList> durationsMap,
Map<String, LongArrayList> selfDurationsMap) {
long totalTime = 0;
for (Entry<String, Collection<Task>> entry : functionTasks.asMap().entrySet()) {
String function = entry.getKey();
Collection<Task> tasks = entry.getValue();
LongArrayList durations;
LongArrayList selfDurations;
if (durationsMap.containsKey(function)) {
durations = durationsMap.get(function);
selfDurations = selfDurationsMap.get(function);
} else {
durations = new LongArrayList(tasks.size());
selfDurations = new LongArrayList(tasks.size());
durationsMap.put(function, durations);
selfDurationsMap.put(function, selfDurations);
}
totalTime += addDurations(tasks, durations, selfDurations);
}
return totalTime;
}
/**
* Add all durations and self-times of the given function to the maps.
* @return The sum of the execution times of all {@link Task} values in the collection.
*/
private static long addDurations(
Collection<Task> tasks, LongArrayList durations, LongArrayList selfDurations) {
long totalTime = 0;
durations.ensureCapacity(durations.size() + tasks.size());
selfDurations.ensureCapacity(selfDurations.size() + tasks.size());
for (Task task : tasks) {
durations.add(task.durationNanos);
selfDurations.add(task.durationNanos - task.getInheritedDuration());
totalTime += task.durationNanos;
}
return totalTime;
}
/**
* Build a Map of {@link TasksStatistics} from the given duration maps.
*/
private static Map<String, TasksStatistics> buildTasksStatistics(
final Map<String, LongArrayList> durationsMap) {
return Maps.transformEntries(
durationsMap,
new EntryTransformer<String, LongArrayList, TasksStatistics>() {
@Override
public TasksStatistics transformEntry(String function, LongArrayList durations) {
return TasksStatistics.create(function, durations);
}
});
}
}