SYMBOL INDEX (425 symbols across 25 files)

FILE: src/config.rs
  function parse_key_val (line 16) | fn parse_key_val<T, U>(s: &str) -> Result<(T, U), anyhow::Error>
  type Interval (line 33) | pub enum Interval {
    method is_not_zero (line 40) | pub fn is_not_zero(&self) -> bool {
    method is_bounded (line 48) | pub fn is_bounded(&self) -> bool {
    method count (line 52) | pub fn count(&self) -> Option<u64> {
    method period (line 60) | pub fn period(&self) -> Option<tokio::time::Duration> {
    method period_secs (line 68) | pub fn period_secs(&self) -> Option<f32> {
  type Err (line 81) | type Err = String;
  method from_str (line 83) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type RetryDelay (line 96) | pub struct RetryDelay {
    method new (line 102) | pub fn new(time: &str) -> Option<Self> {
  type Err (line 118) | type Err = String;
  method from_str (line 120) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type ConnectionConf (line 134) | pub struct ConnectionConf {
  type RetryStrategy (line 188) | pub struct RetryStrategy {
  type Consistency (line 211) | pub enum Consistency {
    method scylla_consistency (line 225) | pub fn scylla_consistency(&self) -> scylla::frame::types::Consistency {
  method value_variants (line 241) | fn value_variants<'a>() -> &'a [Self] {
  method from_str (line 255) | fn from_str(s: &str, _ignore_case: bool) -> Result<Self, String> {
  method to_possible_value (line 270) | fn to_possible_value(&self) -> Option<PossibleValue> {
  type WeightedFunction (line 286) | pub struct WeightedFunction {
  type Err (line 292) | type Err = String;
  method from_str (line 294) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 318) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type EditCommand (line 325) | pub struct EditCommand {
  type SchemaCommand (line 333) | pub struct SchemaCommand {
  type LoadCommand (line 349) | pub struct LoadCommand {
  type RunCommand (line 382) | pub struct RunCommand {
    method set_timestamp_if_empty (line 514) | pub fn set_timestamp_if_empty(mut self) -> Self {
    method get_param (line 523) | pub fn get_param(&self, key: &str) -> Option<f64> {
  type ListCommand (line 532) | pub struct ListCommand {
  type ShowCommand (line 555) | pub struct ShowCommand {
  type HdrCommand (line 566) | pub struct HdrCommand {
  type PlotCommand (line 581) | pub struct PlotCommand {
  type Command (line 601) | pub enum Command {
  type AppConfig (line 660) | pub struct AppConfig {
  type SchemaConfig (line 679) | pub struct SchemaConfig {
  type LoadConfig (line 688) | pub struct LoadConfig {
  function ratio (line 697) | pub fn ratio() -> f64 {
  type RunConfig (line 704) | pub struct RunConfig {
  type WorkloadConfig (line 715) | pub struct WorkloadConfig {

FILE: src/error.rs
  type LatteError (line 9) | pub enum LatteError {
  type Result (line 53) | pub type Result<T> = std::result::Result<T, Box<LatteError>>;
  function from (line 56) | fn from(value: CassError) -> Self {

FILE: src/exec/chunks.rs
  type ChunksExt (line 12) | pub trait ChunksExt: Stream {
    method chunks_aggregated (line 26) | fn chunks_aggregated<Chunk, NewChunkFn, AccumulateFn>(
  type ChunksAggregated (line 45) | pub struct ChunksAggregated<Src, Chunk, NewChunkFn, AddFn> {
  type Clock (line 58) | enum Clock {
  function new (line 70) | pub fn new(
  function next_chunk (line 98) | fn next_chunk(self: Pin<&mut Self>) -> Option<Chunk> {
  function final_chunk (line 104) | fn final_chunk(self: Pin<&mut Self>) -> Option<Chunk> {
  type Item (line 118) | type Item = Chunk;
  method poll_next (line 120) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function test_empty (line 181) | async fn test_empty() {
  function test_count (line 189) | async fn test_count() {
  function test_period (line 197) | async fn test_period() {

FILE: src/exec/cycle.rs
  constant BATCH_SIZE (line 7) | const BATCH_SIZE: u64 = 64;
  type CycleCounter (line 11) | pub struct CycleCounter {
    method new (line 21) | pub fn new(start: u64) -> Self {
    method next (line 30) | pub fn next(&mut self) -> u64 {
    method next_batch (line 40) | fn next_batch(&mut self) {
    method share (line 47) | pub fn share(&self) -> CycleCounter {
  type BoundedCycleCounter (line 58) | pub struct BoundedCycleCounter {
    method new (line 69) | pub fn new(duration: config::Interval, cycle_range: (i64, i64)) -> Self {
    method next (line 80) | pub fn next(&mut self) -> Option<i64> {
    method cycle_number (line 105) | fn cycle_number(&mut self, result: u64) -> i64 {
    method share (line 110) | pub fn share(&self) -> Self {
  function cycle_counter_must_return_all_numbers (line 125) | pub fn cycle_counter_must_return_all_numbers() {
  function shared_cycle_counter_must_return_distinct_numbers (line 134) | pub fn shared_cycle_counter_must_return_distinct_numbers() {

FILE: src/exec/mod.rs
  function interval_stream (line 31) | fn interval_stream(rate: f64) -> IntervalStream {
  function run_stream (line 50) | async fn run_stream<T>(
  function spawn_stream (line 100) | fn spawn_stream(
  function receive_one_of_each (line 145) | async fn receive_one_of_each<T, S>(streams: &mut [S]) -> Vec<T>
  type ExecutionOptions (line 159) | pub struct ExecutionOptions {
  function par_execute (line 181) | pub async fn par_execute(
  type TerminateAfterErrorExt (line 241) | trait TerminateAfterErrorExt: Stream + Sized {
    method terminate_after_error (line 243) | fn terminate_after_error(self) -> TerminateAfterError<Self>;
    method terminate_after_error (line 250) | fn terminate_after_error(self) -> TerminateAfterError<Self> {
  type TerminateAfterError (line 259) | struct TerminateAfterError<S: Stream> {
  type Item (line 269) | type Item = S::Item;
  method poll_next (line 271) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function test_terminate (line 293) | async fn test_terminate() {

FILE: src/exec/progress.rs
  type ProgressBound (line 8) | enum ProgressBound {
  type Progress (line 13) | pub struct Progress {
    method with_duration (line 21) | pub fn with_duration(msg: String, max_time: Duration) -> Progress {
    method with_count (line 30) | pub fn with_count(msg: String, count: u64) -> Progress {
    method tick (line 39) | pub fn tick(&self) {
    method bar (line 44) | fn bar(fill_len: usize, total_len: usize) -> String {
  method fmt (line 56) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

FILE: src/exec/workload.rs
  type SessionRef (line 29) | struct SessionRef<'a> {
  function new (line 34) | pub fn new(context: &Context) -> SessionRef<'_> {
  method to_value (line 48) | fn to_value(self) -> VmResult<Value> {
  type ContextRefMut (line 56) | struct ContextRefMut<'a> {
  function new (line 61) | pub fn new(context: &mut Context) -> ContextRefMut<'_> {
  method to_value (line 68) | fn to_value(self) -> VmResult<Value> {
  type FnRef (line 77) | pub struct FnRef {
    method new (line 89) | pub fn new(name: &str) -> FnRef {
  method hash (line 83) | fn hash<H: Hasher>(&self, state: &mut H) {
  constant SCHEMA_FN (line 97) | pub const SCHEMA_FN: &str = "schema";
  constant PREPARE_FN (line 98) | pub const PREPARE_FN: &str = "prepare";
  constant ERASE_FN (line 99) | pub const ERASE_FN: &str = "erase";
  constant LOAD_FN (line 100) | pub const LOAD_FN: &str = "load";
  type Program (line 104) | pub struct Program {
    method new (line 118) | pub fn new(source: Source, params: HashMap<String, String>) -> Result<...
    method load_sources (line 148) | fn load_sources(source: Source) -> Result<Sources, LatteError> {
    method try_insert_lib_source (line 160) | fn try_insert_lib_source(parent: &Path, sources: &mut Sources) -> Resu...
    method unshare (line 175) | fn unshare(&self) -> Program {
    method vm (line 186) | fn vm(&self) -> Vm {
    method convert_error (line 198) | fn convert_error(&self, function_name: &str, result: Value) -> Result<...
    method async_call (line 228) | pub async fn async_call(
    method has_prepare (line 247) | pub fn has_prepare(&self) -> bool {
    method has_schema (line 251) | pub fn has_schema(&self) -> bool {
    method has_erase (line 255) | pub fn has_erase(&self) -> bool {
    method has_load (line 259) | pub fn has_load(&self) -> bool {
    method has_function (line 263) | pub fn has_function(&self, function: &FnRef) -> bool {
    method prepare (line 270) | pub async fn prepare(&mut self, context: &mut Context) -> Result<(), B...
    method schema (line 278) | pub async fn schema(&mut self, context: &mut Context) -> Result<(), Bo...
    method erase (line 286) | pub async fn erase(&mut self, context: &mut Context) -> Result<(), Box...
  type ProgramMetadata (line 294) | struct ProgramMetadata {
    method new (line 299) | pub fn new() -> Self {
  method register_meta (line 307) | fn register_meta(&mut self, meta: MetaRef<'_>) -> Result<(), MetaError> {
  type FnStats (line 318) | pub struct FnStats {
    method new (line 326) | pub fn new(function: FnRef) -> FnStats {
    method reset (line 335) | pub fn reset(&mut self) {
    method operation_completed (line 341) | pub fn operation_completed(&mut self, duration: Duration) {
    method operation_failed (line 346) | pub fn operation_failed(&mut self, duration: Duration) {
  type WorkloadStats (line 354) | pub struct WorkloadStats {
  type FnStatsCollector (line 362) | pub struct FnStatsCollector {
    method new (line 368) | pub fn new(functions: impl IntoIterator<Item = FnRef>) -> FnStatsColle...
    method functions (line 379) | pub fn functions(&self) -> impl Iterator<Item = FnRef> + '_ {
    method operation_completed (line 384) | pub fn operation_completed(&mut self, function: &FnRef, duration: Dura...
    method operation_failed (line 389) | pub fn operation_failed(&mut self, function: &FnRef, duration: Duratio...
    method fn_stats_mut (line 395) | fn fn_stats_mut(&mut self, function: &FnRef) -> &mut FnStats {
    method reset (line 403) | pub fn reset(&mut self, start_time: Instant) {
    method take (line 409) | pub fn take(&mut self, end_time: Instant) -> FnStatsCollector {
  type Workload (line 417) | pub struct Workload {
    method new (line 425) | pub fn new(context: Context, program: Program, functions: &[(FnRef, f6...
    method clone (line 435) | pub fn clone(&self) -> Result<Self, Box<LatteError>> {
    method run (line 451) | pub async fn run(&self, cycle: i64) -> Result<(i64, Instant), Box<Latt...
    method context (line 486) | pub fn context(&self) -> &Context {
    method reset (line 493) | pub fn reset(&self, start_time: Instant) {
    method take_stats (line 500) | pub fn take_stats(&self, end_time: Instant) -> WorkloadStats {
  type FunctionRouter (line 513) | struct FunctionRouter {
    method new (line 519) | pub fn new(functions: &[(FnRef, f64)]) -> Self {
    method select (line 528) | pub fn select(&self, rng: &mut impl Rng) -> &FnRef {

FILE: src/main.rs
  constant VERSION (line 49) | const VERSION: &str = env!("CARGO_PKG_VERSION");
  function load_report_or_abort (line 54) | fn load_report_or_abort(path: &Path) -> Report {
  function load_workload_script (line 69) | fn load_workload_script(workload: &Path, params: &[(String, String)]) ->...
  function find_workload (line 87) | fn find_workload(workload: &Path) -> PathBuf {
  function connect (line 112) | async fn connect(conf: &ConnectionConf) -> Result<(Context, Option<Clust...
  function schema (line 132) | async fn schema(conf: SchemaCommand) -> Result<()> {
  function load (line 150) | async fn load(conf: LoadCommand) -> Result<()> {
  function run (line 209) | async fn run(conf: RunCommand) -> Result<()> {
  function list (line 323) | async fn list(conf: ListCommand) -> Result<()> {
  function should_list (line 376) | fn should_list(report: &Report, conf: &ListCommand) -> bool {
  function show (line 404) | async fn show(conf: ShowCommand) -> Result<()> {
  function export_hdr_log (line 423) | async fn export_hdr_log(conf: HdrCommand) -> Result<()> {
  function async_main (line 477) | async fn async_main(run_id: String, command: Command) -> Result<()> {
  function edit (line 494) | fn edit(config: EditCommand) -> Result<()> {
  function edit_workload (line 502) | fn edit_workload(workload: PathBuf) -> Result<()> {
  function init_runtime (line 514) | fn init_runtime(thread_count: usize) -> std::io::Result<Runtime> {
  function setup_logging (line 525) | fn setup_logging(run_id: &str, config: &AppConfig) -> Result<WorkerGuard> {
  function run_id (line 551) | fn run_id() -> String {
  function main (line 555) | fn main() {

FILE: src/report/mod.rs
  constant ERR_MARGIN (line 25) | const ERR_MARGIN: f64 = 3.29;
  type ReportLoadError (line 28) | pub enum ReportLoadError {
  type Report (line 38) | pub struct Report {
    method new (line 46) | pub fn new(conf: RunCommand, result: BenchmarkStats) -> Report {
    method load (line 55) | pub fn load(path: &Path) -> Result<Report, ReportLoadError> {
    method save (line 63) | pub fn save(&self, path: &Path) -> io::Result<()> {
    method summary (line 70) | pub fn summary(&self) -> Summary {
  type Quantity (line 104) | pub struct Quantity<T> {
  function new (line 111) | pub fn new(value: Option<T>) -> Quantity<T> {
  function with_precision (line 119) | pub fn with_precision(mut self, precision: usize) -> Self {
  function with_error (line 124) | pub fn with_error(mut self, e: Option<T>) -> Self {
  function format_error (line 131) | fn format_error(&self) -> String {
  function from (line 141) | fn from(value: T) -> Self {
  function from (line 147) | fn from(value: Option<T>) -> Self {
  function from (line 153) | fn from(m: Mean) -> Self {
  function from (line 159) | fn from(m: Option<Mean>) -> Self {
  method fmt (line 166) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type OptionDisplay (line 189) | struct OptionDisplay<T>(Option<T>);
  method fmt (line 192) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type Rational (line 200) | trait Rational {
    method ratio (line 201) | fn ratio(a: Self, b: Self) -> Option<f32>;
    method ratio (line 205) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 211) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 217) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 223) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 229) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 235) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 241) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 247) | fn ratio(a: Self, b: Self) -> Option<f32> {
    method ratio (line 254) | fn ratio(_a: Self, _b: Self) -> Option<f32> {
    method ratio (line 260) | fn ratio(_a: Self, _b: Self) -> Option<f32> {
  method fmt (line 266) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type Line (line 278) | struct Line<M, V, F>
  function new (line 305) | fn new(label: String, unit: String, orientation: i8, v1: V, v2: Option<V...
  function into_box (line 317) | fn into_box(self) -> Box<Self> {
  function with_orientation (line 321) | fn with_orientation(mut self, orientation: i8) -> Self {
  function with_significance (line 326) | fn with_significance(mut self, s: Option<Significance>) -> Self {
  function fmt_measurement (line 333) | fn fmt_measurement(&self, v: Option<V>) -> String {
  function fmt_relative_change (line 341) | fn fmt_relative_change(&self, direction: i8, significant: bool) -> String {
  function fmt_unit (line 367) | fn fmt_unit(&self) -> String {
  method fmt (line 381) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  constant REPORT_WIDTH (line 405) | const REPORT_WIDTH: usize = 124;
  function fmt_section_header (line 407) | fn fmt_section_header(name: &str) -> String {
  function fmt_horizontal_line (line 419) | fn fmt_horizontal_line() -> String {
  function fmt_cmp_header (line 423) | fn fmt_cmp_header(display_significance: bool) -> String {
  type RunConfigCmp (line 437) | pub struct RunConfigCmp<'a> {
  function line (line 443) | fn line<S, M, F>(&self, label: S, unit: &str, f: F) -> Box<Line<M, &RunC...
  function format_time (line 459) | fn format_time(&self, conf: &RunCommand, format: &str) -> String {
  function param_names (line 464) | fn param_names(&self) -> BTreeSet<&String> {
  method fmt (line 475) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function print_log_header (line 592) | pub fn print_log_header() {
  method fmt (line 599) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function line (line 620) | fn line<S, M, F>(&self, label: S, unit: &str, f: F) -> Box<Line<M, &Benc...
  method fmt (line 639) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  type PathAndSummary (line 767) | pub struct PathAndSummary(pub PathBuf, pub Summary);
    constant COLUMNS (line 783) | pub const COLUMNS: &'static [&'static str] = &[
  type Summary (line 770) | pub struct Summary {
  method cell_value (line 798) | fn cell_value(&self, column: &str) -> Option<String> {
  function format_time (line 831) | fn format_time(timestamp: Option<i64>, format: &str) -> String {

FILE: src/report/plot.rs
  type SeriesKind (line 17) | enum SeriesKind {
    method y_axis_label (line 23) | pub fn y_axis_label(&self) -> &str {
  type Series (line 31) | struct Series {
    method full_label (line 41) | fn full_label(&self) -> String {
    method max_value (line 78) | pub fn max_value(&self, default: f32) -> f32 {
    method min_value (line 86) | pub fn min_value(&self, default: f32) -> f32 {
    method max_time (line 94) | pub fn max_time(&self) -> f32 {
  type YSpec (line 46) | enum YSpec {
  type FormatOption (line 52) | type FormatOption = DefaultFormatting;
  type ValueType (line 53) | type ValueType = f32;
  method map (line 55) | fn map(&self, value: &Self::ValueType, limit: (i32, i32)) -> i32 {
  method key_points (line 62) | fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueT...
  method range (line 69) | fn range(&self) -> Range<Self::ValueType> {
  function plot_graph (line 100) | pub async fn plot_graph(conf: PlotCommand) -> Result<()> {
  function data (line 224) | fn data(reports: &[Report], conf: &PlotCommand) -> Vec<Series> {
  function report_series (line 233) | fn report_series(report: &Report, color_index: usize, conf: &PlotCommand...
  function resp_time_series (line 245) | fn resp_time_series(report: &Report, color_index: usize, percentiles: &[...
  function throughput_series (line 270) | fn throughput_series(report: &Report, color_index: usize) -> Series {

FILE: src/report/table.rs
  type Row (line 4) | pub trait Row {
    method cell_value (line 5) | fn cell_value(&self, column: &str) -> Option<String>;
  type Table (line 8) | pub struct Table<R> {
  type Column (line 13) | struct Column {
  type Alignment (line 19) | pub enum Alignment {
  function new (line 25) | pub fn new<C: AsRef<str>>(columns: &[C]) -> Table<R> {
  function align (line 41) | pub fn align(&mut self, column_index: usize, alignment: Alignment) {
  function push (line 45) | pub fn push(&mut self, row: R) {
  function header (line 56) | fn header(&self, column: &Column) -> String {
  function value (line 66) | fn value(&self, row: &R, column: &Column) -> String {
  function left_padding (line 80) | fn left_padding(n: usize) -> String {
  function right_padding (line 88) | fn right_padding(n: usize) -> String {
  method fmt (line 98) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function render_table (line 127) | fn render_table() {

FILE: src/scripting/bind.rs
  function to_scylla_value (line 16) | fn to_scylla_value(v: &Value, typ: &ColumnType) -> Result<CqlValue, Cass...
  function convert_int (line 234) | fn convert_int<T: TryFrom<i64>, R>(
  function to_scylla_query_params (line 250) | pub fn to_scylla_query_params(
  function read_params (line 291) | fn read_params<'a, 'b>(
  function read_fields (line 306) | fn read_fields<'a, 'b>(

FILE: src/scripting/cass_error.rs
  type CassError (line 15) | pub struct CassError(pub Box<CassErrorKind>);
    method new (line 18) | pub fn new(kind: CassErrorKind) -> Self {
    method prepare_error (line 22) | pub fn prepare_error(cql: &str, err: PrepareError) -> CassError {
    method query_execution_error (line 26) | pub fn query_execution_error(cql: &str, params: &[CqlValue], err: Exec...
    method result_set_conversion_error (line 42) | pub fn result_set_conversion_error(
    method string_display (line 79) | pub fn string_display(&self, f: &mut rune::runtime::Formatter) -> VmRe...
    method display (line 84) | pub fn display(&self, buf: &mut String) -> std::fmt::Result {
    method from (line 140) | fn from(e: ErrorStack) -> CassError {
  type CassErrorKind (line 56) | pub enum CassErrorKind {
  type QueryInfo (line 72) | pub struct QueryInfo {
  method fmt (line 132) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function cql_value_obj_to_string (line 148) | pub fn cql_value_obj_to_string(v: &CqlValue) -> String {
  method fmt (line 227) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

FILE: src/scripting/connect.rs
  function tls_context (line 10) | fn tls_context(conf: &&ConnectionConf) -> Result<Option<SslContext>, Cas...
  function connect (line 29) | pub async fn connect(conf: &ConnectionConf) -> Result<Context, CassError> {
  type ClusterInfo (line 54) | pub struct ClusterInfo {

FILE: src/scripting/context.rs
  type Context (line 26) | pub struct Context {
    method new (line 49) | pub fn new(session: Session, retry_strategy: RetryStrategy) -> Context {
    method clone (line 67) | pub fn clone(&self) -> Result<Self, LatteError> {
    method cluster_info (line 82) | pub async fn cluster_info(&self) -> Result<Option<ClusterInfo>, CassEr...
    method prepare (line 104) | pub async fn prepare(&mut self, key: &str, cql: &str) -> Result<(), Ca...
    method execute (line 115) | pub async fn execute(&self, cql: &str) -> Result<(), CassError> {
    method execute_prepared (line 128) | pub async fn execute_prepared(&self, key: &str, params: Value) -> Resu...
    method execute_inner (line 148) | async fn execute_inner<R>(&self, f: impl Fn() -> R) -> Result<(), Exec...
    method elapsed_secs (line 183) | pub fn elapsed_secs(&self) -> f64 {
    method take_session_stats (line 188) | pub fn take_session_stats(&self) -> SessionStats {
    method reset (line 196) | pub fn reset(&self) {
  function get_exponential_retry_interval (line 202) | pub fn get_exponential_retry_interval(
  function should_retry (line 218) | fn should_retry<R>(result: &Result<R, ExecutionError>, retry_strategy: &...

FILE: src/scripting/cql_types.rs
  type Int8 (line 9) | pub struct Int8(pub i8);
  type Int16 (line 12) | pub struct Int16(pub i16);
  type Int32 (line 15) | pub struct Int32(pub i32);
  type Float32 (line 18) | pub struct Float32(pub f32);
  type Uuid (line 21) | pub struct Uuid(pub uuid::Uuid);
    method new (line 24) | pub fn new(i: i64) -> Uuid {
    method string_display (line 36) | pub fn string_display(&self, f: &mut rune::runtime::Formatter) -> VmRe...
  function to_i8 (line 47) | pub fn to_i8(value: i64) -> Option<Int8> {
  function to_i16 (line 53) | pub fn to_i16(value: i64) -> Option<Int16> {
  function to_i32 (line 59) | pub fn to_i32(value: i64) -> Option<Int32> {
  function to_f32 (line 65) | pub fn to_f32(value: i64) -> Float32 {
  function to_string (line 71) | pub fn to_string(value: i64) -> String {
  function clamp (line 77) | pub fn clamp(value: i64, min: i64, max: i64) -> i64 {
  function to_i8 (line 86) | pub fn to_i8(value: f64) -> Int8 {
  function to_i16 (line 91) | pub fn to_i16(value: f64) -> Int16 {
  function to_i32 (line 96) | pub fn to_i32(value: f64) -> Int32 {
  function to_f32 (line 101) | pub fn to_f32(value: f64) -> Float32 {
  function to_string (line 106) | pub fn to_string(value: f64) -> String {
  function clamp (line 112) | pub fn clamp(value: f64, min: f64, max: f64) -> f64 {

FILE: src/scripting/functions.rs
  function param (line 24) | pub fn param(
  function uuid (line 47) | pub fn uuid(i: i64) -> Uuid {
  function float_to_i8 (line 52) | pub fn float_to_i8(value: f64) -> Option<Int8> {
  function hash_inner (line 58) | fn hash_inner(i: i64) -> i64 {
  function hash (line 67) | pub fn hash(i: i64) -> i64 {
  function hash2 (line 73) | pub fn hash2(a: i64, b: i64) -> i64 {
  function hash2_inner (line 77) | fn hash2_inner(a: i64, b: i64) -> i64 {
  function hash_range (line 87) | pub fn hash_range(i: i64, max: i64) -> i64 {
  function normal (line 93) | pub fn normal(i: i64, mean: f64, std_dev: f64) -> VmResult<f64> {
  function uniform (line 101) | pub fn uniform(i: i64, min: f64, max: f64) -> VmResult<f64> {
  function uniform_vec (line 108) | pub fn uniform_vec(i: i64, len: usize, min: f64, max: f64) -> VmResult<V...
  function normal_vec (line 118) | pub fn normal_vec(i: i64, len: usize, mean: f64, std_dev: f64) -> VmResu...
  function blob (line 132) | pub fn blob(seed: i64, len: usize) -> Vec<u8> {
  function text (line 141) | pub fn text(seed: i64, len: usize) -> String {
  function vector (line 156) | pub fn vector(len: usize, generator: Function) -> VmResult<Vec<Value>> {
  function now_timestamp (line 167) | pub fn now_timestamp() -> i64 {
  function hash_select (line 173) | pub fn hash_select(i: i64, collection: &[Value]) -> Value {
  function join (line 179) | pub fn join(collection: &[Value], separator: &str) -> VmResult<String> {
  function read_to_string (line 195) | pub fn read_to_string(filename: &str) -> io::Result<String> {
  function read_lines (line 206) | pub fn read_lines(filename: &str) -> io::Result<Vec<String>> {
  function read_words (line 218) | pub fn read_words(filename: &str) -> io::Result<Vec<String>> {
  function read_resource_to_string_inner (line 235) | fn read_resource_to_string_inner(path: &str) -> io::Result<String> {
  function read_resource_to_string (line 245) | pub fn read_resource_to_string(path: &str) -> io::Result<String> {
  function read_resource_lines (line 250) | pub fn read_resource_lines(path: &str) -> io::Result<Vec<String>> {
  function read_resource_words (line 258) | pub fn read_resource_words(path: &str) -> io::Result<Vec<String>> {
  function prepare (line 266) | pub async fn prepare(mut ctx: Mut<Context>, key: Ref<str>, cql: Ref<str>...
  function execute (line 271) | pub async fn execute(ctx: Ref<Context>, cql: Ref<str>) -> Result<(), Cas...
  function execute_prepared (line 276) | pub async fn execute_prepared(
  function elapsed_secs (line 285) | pub fn elapsed_secs(ctx: &Context) -> f64 {

FILE: src/scripting/mod.rs
  type Resources (line 16) | struct Resources;
  function install (line 18) | pub fn install(rune_ctx: &mut rune::Context, params: HashMap<String, Str...
  function try_install (line 22) | fn try_install(

FILE: src/stats/histogram.rs
  type SerializableHistogram (line 13) | pub struct SerializableHistogram(pub Histogram<u64>);
    method deserialize (line 56) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 16) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type HistogramVisitor (line 29) | struct HistogramVisitor;
    type Value (line 32) | type Value = SerializableHistogram;
    method expecting (line 34) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_str (line 38) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>

FILE: src/stats/latency.rs
  type LatencyDistribution (line 11) | pub struct LatencyDistribution {
  type LatencyDistributionRecorder (line 19) | pub struct LatencyDistributionRecorder {
    method record (line 25) | pub fn record(&mut self, time: Duration) {
    method add (line 32) | pub fn add(&mut self, other: &LatencyDistributionRecorder) {
    method clear (line 37) | pub fn clear(&mut self) {
    method distribution (line 42) | pub fn distribution(&self) -> LatencyDistribution {
    method distribution_with_errors (line 50) | pub fn distribution_with_errors(&self) -> LatencyDistribution {
    method mean (line 59) | fn mean(&self, effective_n: u64) -> Mean {
  method default (line 74) | fn default() -> Self {

FILE: src/stats/mod.rs
  type Mean (line 27) | pub struct Mean {
    type Output (line 34) | type Output = Mean;
    method mul (line 36) | fn mul(self, rhs: f64) -> Self::Output {
  function t_test (line 56) | pub fn t_test(mean1: &Mean, mean2: &Mean) -> f64 {
  function not_nan (line 80) | fn not_nan(x: f64) -> Option<f64> {
  function not_nan_f32 (line 89) | fn not_nan_f32(x: f32) -> Option<f32> {
  constant MAX_KEPT_ERRORS (line 97) | const MAX_KEPT_ERRORS: usize = 10;
  type Sample (line 101) | pub struct Sample {
    method new (line 122) | pub fn new(base_start_time: Instant, stats: &[WorkloadStats]) -> Sample {
  type BenchmarkStats (line 192) | pub struct BenchmarkStats {
  type BenchmarkCmp (line 222) | pub struct BenchmarkCmp<'a> {
  type Significance (line 231) | pub struct Significance(pub f64);
  function cmp (line 236) | fn cmp<F>(&self, f: F) -> Option<Significance>
  function cmp_cycle_throughput (line 249) | pub fn cmp_cycle_throughput(&self) -> Option<Significance> {
  function cmp_req_throughput (line 255) | pub fn cmp_req_throughput(&self) -> Option<Significance> {
  function cmp_row_throughput (line 261) | pub fn cmp_row_throughput(&self) -> Option<Significance> {
  function cmp_mean_resp_time (line 267) | pub fn cmp_mean_resp_time(&self) -> Option<Significance> {
  function cmp_resp_time_percentile (line 273) | pub fn cmp_resp_time_percentile(&self, p: Percentile) -> Option<Signific...
  type Recorder (line 282) | pub struct Recorder {
    method start (line 311) | pub fn start(
    method record (line 346) | pub fn record(&mut self, samples: &[WorkloadStats]) -> &Sample {
    method finish (line 380) | pub fn finish(mut self) -> BenchmarkStats {
  function t_test_same (line 449) | fn t_test_same() {
  function t_test_different (line 464) | fn t_test_different() {

FILE: src/stats/percentiles.rs
  type Percentile (line 11) | pub enum Percentile {
    method value (line 30) | pub fn value(&self) -> f64 {
    method name (line 50) | pub fn name(&self) -> &'static str {
  type Percentiles (line 72) | pub struct Percentiles([Mean; Percentile::COUNT]);
    constant POPULATION_SIZE (line 75) | const POPULATION_SIZE: usize = 100;
    method compute (line 79) | pub fn compute(histogram: &Histogram<u64>, scale: f64) -> Percentiles {
    method compute_with_errors (line 96) | pub fn compute_with_errors(
    method get (line 125) | pub fn get(&self, percentile: Percentile) -> Mean {
  function bootstrap (line 131) | fn bootstrap(rng: &mut impl Rng, histogram: &Histogram<u64>, effective_n...
  function percentiles (line 149) | fn percentiles(hist: &Histogram<u64>, scale: f64) -> [f64; Percentile::C...
  function test_zero_error (line 166) | fn test_zero_error() {
  function test_min_max_error (line 179) | fn test_min_max_error() {

FILE: src/stats/session.rs
  type SessionStats (line 9) | pub struct SessionStats {
    method new (line 21) | pub fn new() -> SessionStats {
    method start_request (line 25) | pub fn start_request(&mut self) -> Instant {
    method complete_request (line 34) | pub fn complete_request(
    method reset (line 58) | pub fn reset(&mut self) {
  method default (line 73) | fn default() -> Self {

FILE: src/stats/throughput.rs
  type ThroughputMeter (line 5) | pub struct ThroughputMeter {
    method record (line 23) | pub fn record(&mut self, count: u64) {
    method throughput (line 33) | pub fn throughput(&self) -> Mean {
  method default (line 12) | fn default() -> Self {

FILE: src/stats/timeseries.rs
  type TimeSeriesStats (line 18) | pub struct TimeSeriesStats {
    method record (line 33) | pub fn record(&mut self, x: f64, weight: f64) {
    method add (line 39) | pub fn add(&mut self, other: &TimeSeriesStats) {
    method clear (line 46) | pub fn clear(&mut self) {
    method insert (line 51) | fn insert(&mut self, x: f64, weight: f64, level: usize) {
    method add_level (line 60) | fn add_level(&mut self, level: &Level) {
    method mean (line 68) | pub fn mean(&self) -> Mean {
    method effective_sample_size (line 85) | pub fn effective_sample_size(&self) -> u64 {
  type Level (line 24) | struct Level {
    method new (line 120) | fn new(level: usize) -> Self {
    method batch_len (line 128) | fn batch_len(&self) -> usize {
    method record (line 132) | fn record(&mut self, value: f64, weight: f64) -> Option<(f64, f64)> {
    method add (line 138) | fn add(&mut self, other: &Level) -> Option<(f64, f64)> {
    method merge (line 151) | fn merge(&mut self) -> Option<(f64, f64)> {
  type Stats (line 166) | struct Stats {
    method record (line 176) | pub fn record(&mut self, x: f64, weight: f64) {
    method add (line 186) | pub fn add(&mut self, other: &Stats) {
    method mean (line 199) | pub fn mean(&self) -> f64 {
    method variance (line 207) | pub fn variance(&self) -> f64 {
  function test_random (line 227) | fn test_random() {
  function test_correlated (line 248) | fn test_correlated(#[case] n: u64, #[case] cluster_size: usize) {
  function test_merge_variances (line 262) | fn test_merge_variances() {
  function test_merge_ess (line 285) | fn test_merge_ess() {