// Copyright 2023 The IREE Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include <stdio.h>

#include "iree/base/api.h"
#include "iree/io/file_contents.h"
#include "iree/schemas/instruments/dispatch.h"

// NOTE: include order matters:
#include "iree/base/internal/flatcc/parsing.h"
#include "iree/schemas/instruments/dispatch_def_reader.h"

typedef struct {
  iree_instruments_DispatchFunctionDef_vec_t functions_def;
  iree_instruments_DispatchSiteDef_vec_t dispatch_sites_def;
} iree_dispatch_metadata_t;

static iree_status_t iree_tooling_dump_dispatch_metadata(
    const uint8_t* flatbuffer_ptr, iree_host_size_t flatbuffer_size,
    iree_dispatch_metadata_t* out_metadata, FILE* stream) {
  memset(out_metadata, 0, sizeof(*out_metadata));

  iree_instruments_DispatchInstrumentDef_table_t instr_def =
      iree_instruments_DispatchInstrumentDef_as_root(flatbuffer_ptr);

  iree_instruments_DispatchFunctionDef_vec_t functions_def =
      iree_instruments_DispatchInstrumentDef_functions(instr_def);
  out_metadata->functions_def = functions_def;
  for (iree_host_size_t i = 0;
       i < iree_instruments_DispatchFunctionDef_vec_len(functions_def); ++i) {
    fprintf(stream, "\n");
    iree_instruments_DispatchFunctionDef_table_t function_def =
        iree_instruments_DispatchFunctionDef_vec_at(functions_def, i);
    flatbuffers_string_t name =
        iree_instruments_DispatchFunctionDef_name(function_def);
    fprintf(stream,
            "//"
            "===---------------------------------------------------------------"
            "-------===//\n");
    fprintf(stream, "// export[%" PRIhsz "]: %s\n", i, name);
    fprintf(stream,
            "//"
            "===---------------------------------------------------------------"
            "-------===//\n");
    flatbuffers_string_t target =
        iree_instruments_DispatchFunctionDef_target(function_def);
    if (target) fprintf(stream, "//  target: %s\n", target);
    flatbuffers_string_t layout =
        iree_instruments_DispatchFunctionDef_layout(function_def);
    if (layout) fprintf(stream, "//  layout: %s\n", layout);
    flatbuffers_string_t source =
        iree_instruments_DispatchFunctionDef_source(function_def);
    if (source) fprintf(stream, "%s\n", source);
    fprintf(stream, "\n");
  }

  fprintf(stream,
          "//"
          "===---------------------------------------------------------------"
          "-------===//\n");
  iree_instruments_DispatchSiteDef_vec_t dispatch_sites_def =
      iree_instruments_DispatchInstrumentDef_sites(instr_def);
  out_metadata->dispatch_sites_def = dispatch_sites_def;
  for (iree_host_size_t i = 0;
       i < iree_instruments_DispatchSiteDef_vec_len(dispatch_sites_def); ++i) {
    iree_instruments_DispatchSiteDef_table_t dispatch_site_def =
        iree_instruments_DispatchSiteDef_vec_at(dispatch_sites_def, i);
    iree_instruments_DispatchFunctionDef_table_t function_def =
        iree_instruments_DispatchFunctionDef_vec_at(
            functions_def,
            iree_instruments_DispatchSiteDef_function(dispatch_site_def));
    flatbuffers_string_t name =
        iree_instruments_DispatchFunctionDef_name(function_def);
    fprintf(stream, "// dispatch site %" PRIhsz ": %s\n", i, name);
  }
  fprintf(stream,
          "//"
          "===---------------------------------------------------------------"
          "-------===//\n\n");

  return iree_ok_status();
}

static void iree_tooling_dump_print_value(
    iree_instrument_dispatch_value_type_t type, uint64_t raw_value,
    FILE* stream) {
  union {
    int8_t i8;
    int16_t i16;
    int32_t i32;
    int64_t i64;
    float f32;
    double f64;
    uint8_t value_storage[sizeof(uint64_t)];
  } value = {.i64 = raw_value};
  switch (type) {
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_SINT_8:
      fprintf(stream, "%" PRId8, value.i8);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_UINT_8:
      fprintf(stream, "%" PRIu8, value.i8);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_SINT_16:
      fprintf(stream, "%" PRId16, value.i16);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_UINT_16:
      fprintf(stream, "%" PRIu16, value.i16);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_SINT_32:
      fprintf(stream, "%" PRId32, value.i32);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_UINT_32:
      fprintf(stream, "%" PRIu32, value.i32);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_SINT_64:
      fprintf(stream, "%" PRId64, value.i64);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_UINT_64:
      fprintf(stream, "%" PRIu64, value.i64);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_POINTER:
      fprintf(stream, "%16" PRIX64, value.i64);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_FLOAT_16:
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_BFLOAT_16:
      fprintf(stream, "%4" PRIX16, value.i16);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_FLOAT_32:
      fprintf(stream, "%e %f", value.f32, value.f32);
      break;
    case IREE_INSTRUMENT_DISPATCH_VALUE_TYPE_FLOAT_64:
      fprintf(stream, "%e %f", value.f64, value.f64);
      break;
    default:
      fprintf(stream, "<<unknown type: %02X>>", (uint32_t)type);
      break;
  }
}

static iree_status_t iree_tooling_dump_dispatch_ringbuffer(
    const uint8_t* data_ptr, iree_host_size_t data_size,
    const iree_dispatch_metadata_t* metadata, FILE* stream) {
  const uint64_t ring_size = data_size - IREE_INSTRUMENT_DISPATCH_PADDING;
  const uint8_t* ring_data = data_ptr;
  const uint64_t ring_head = *(const uint64_t*)(ring_data + data_size - 8);
  const uint64_t ring_range = iree_min(ring_head, ring_size);

  for (iree_host_size_t i = 0; i < ring_range;) {
    const iree_instrument_dispatch_header_t* header =
        (const iree_instrument_dispatch_header_t*)(ring_data + i);
    switch (header->tag) {
      case IREE_INSTRUMENT_DISPATCH_TYPE_WORKGROUP: {
        const iree_instrument_dispatch_workgroup_t* workgroup =
            (const iree_instrument_dispatch_workgroup_t*)header;
        iree_instruments_DispatchSiteDef_table_t dispatch_site_def =
            iree_instruments_DispatchSiteDef_vec_at(
                metadata->dispatch_sites_def, workgroup->dispatch_id);
        iree_instruments_DispatchFunctionDef_table_t function_def =
            iree_instruments_DispatchFunctionDef_vec_at(
                metadata->functions_def,
                iree_instruments_DispatchSiteDef_function(dispatch_site_def));
        flatbuffers_string_t name_def =
            iree_instruments_DispatchFunctionDef_name(function_def);
        fprintf(stream,
                "%016" PRIX64
                " | WORKGROUP dispatch(%u %s %ux%ux%u) %u,%u,%u pid:%u\n",
                (uint64_t)i, workgroup->dispatch_id, name_def,
                workgroup->workgroup_count_x, workgroup->workgroup_count_y,
                workgroup->workgroup_count_z, workgroup->workgroup_id_x,
                workgroup->workgroup_id_y, workgroup->workgroup_id_z,
                workgroup->processor_id);
        i += sizeof(*workgroup);
        break;
      }
      case IREE_INSTRUMENT_DISPATCH_TYPE_PRINT: {
        const iree_instrument_dispatch_print_t* print =
            (const iree_instrument_dispatch_print_t*)header;
        fprintf(stream, "%016" PRIX64 " | PRINT %.*s\n",
                (uint64_t)print->workgroup_offset, (int)print->length,
                print->data);
        i += iree_host_align(sizeof(*print) + print->length, 16);
        break;
      }
      case IREE_INSTRUMENT_DISPATCH_TYPE_VALUE: {
        const iree_instrument_dispatch_value_t* value =
            (const iree_instrument_dispatch_value_t*)header;
        fprintf(stream, "%016" PRIX64 " | VALUE %04u = ",
                (uint64_t)value->workgroup_offset, (uint32_t)value->ordinal);
        iree_tooling_dump_print_value(value->type, value->bits, stream);
        fputc('\n', stream);
        i += sizeof(*value);
        break;
      }
      case IREE_INSTRUMENT_DISPATCH_TYPE_MEMORY_LOAD: {
        const iree_instrument_dispatch_memory_op_t* op =
            (const iree_instrument_dispatch_memory_op_t*)header;
        fprintf(stream, "%016" PRIX64 " | LOAD  %016" PRIX64 " %u\n",
                (uint64_t)op->workgroup_offset, op->address, (int)op->length);
        i += sizeof(*op);
        break;
      }
      case IREE_INSTRUMENT_DISPATCH_TYPE_MEMORY_STORE: {
        const iree_instrument_dispatch_memory_op_t* op =
            (const iree_instrument_dispatch_memory_op_t*)header;
        fprintf(stream, "%016" PRIX64 " | STORE %016" PRIX64 " %u\n",
                (uint64_t)op->workgroup_offset, op->address, (int)op->length);
        i += sizeof(*op);
        break;
      }
      default:
        return iree_make_status(IREE_STATUS_UNIMPLEMENTED,
                                "unimplemented dispatch instr type: %u",
                                (uint32_t)header->tag);
    }
  }

  return iree_ok_status();
}

static iree_status_t iree_tooling_dump_instrument_file(
    iree_const_byte_span_t file_contents, FILE* stream) {
  const uint8_t* file_ptr = file_contents.data;
  iree_host_size_t file_size = file_contents.data_length;

  iree_dispatch_metadata_t dispatch_metadata = {0};
  for (iree_host_size_t file_offset = 0; file_offset < file_size;) {
    const iree_idbts_chunk_header_t* header =
        (const iree_idbts_chunk_header_t*)(file_ptr + file_offset);
    const uint8_t* payload = file_ptr + file_offset + sizeof(*header);
    switch (header->type) {
      case IREE_IDBTS_CHUNK_TYPE_DISPATCH_METADATA: {
        IREE_RETURN_IF_ERROR(iree_tooling_dump_dispatch_metadata(
            payload, header->content_length, &dispatch_metadata, stream));
        break;
      }
      case IREE_IDBTS_CHUNK_TYPE_DISPATCH_RINGBUFFER: {
        IREE_RETURN_IF_ERROR(iree_tooling_dump_dispatch_ringbuffer(
            payload, header->content_length, &dispatch_metadata, stream));
        break;
      }
      default:
        return iree_make_status(IREE_STATUS_UNIMPLEMENTED,
                                "unimplemented chunk type: %u",
                                (uint32_t)header->type);
    }
    file_offset +=
        sizeof(*header) + iree_host_align(header->content_length, 16);
  }

  return iree_ok_status();
}

int main(int argc, char** argv) {
  IREE_TRACE_APP_ENTER();

  if (argc < 2) {
    fprintf(stderr,
            "Syntax: iree-dump-instruments instruments.bin > instruments.txt\n"
            "Example usage:\n"
            "  $ iree-compile \\n"
            "        --iree-hal-target-device=local \\n"
            "        --iree-hal-local-target-device-backends=llvm-cpu \\n"
            "        --iree-hal-instrument-dispatches=16mib \\n"
            "        --iree-llvmcpu-instrument-memory-accesses=false \\n"
            "        runtime/src/iree/runtime/demo/simple_mul.mlir \\n"
            "        -o=simple_mul_instr.vmfb\n"
            "  $ iree-run-module \\n"
            "        --device=local-sync \\n"
            "        --module=simple_mul_instr.vmfb \\n"
            "        --function=simple_mul \\n"
            "        --input=4xf32=2 \\n"
            "        --input=4xf32=4 \\n"
            "        --instrument_file=instrument.bin\n"
            "  $ iree-dump-instruments instrument.bin\n"
            "\n");
    IREE_TRACE_APP_EXIT(EXIT_FAILURE);
    return EXIT_FAILURE;
  }

  iree_io_file_contents_t* file_contents = NULL;
  iree_status_t status = iree_io_file_contents_map(
      iree_make_cstring_view(argv[1]), IREE_IO_FILE_ACCESS_READ,
      iree_allocator_system(), &file_contents);
  if (iree_status_is_ok(status)) {
    status =
        iree_tooling_dump_instrument_file(file_contents->const_buffer, stdout);
  }
  iree_io_file_contents_free(file_contents);

  if (!iree_status_is_ok(status)) {
    iree_status_fprint(stderr, status);
    iree_status_free(status);
    IREE_TRACE_APP_EXIT(EXIT_FAILURE);
    return EXIT_FAILURE;
  }
  IREE_TRACE_APP_EXIT(EXIT_SUCCESS);
  return EXIT_SUCCESS;
}