Publish

code/fpga/.gitignore

@@ -0,0 +1,13 @@
+verify
+sw_emu
+hw_emu
+hw
+.Xil
+.run
+emconfig.json
+vitis_env.sh
+.ipcache
+example_output
+test.txt
+*.jou
+*.str

code/fpga/Makefile

@@ -0,0 +1,106 @@
+ifndef PLATFORM
+    $(error PLATFORM is not set.)
+endif
+
+ifndef TARGET
+    $(info TARGET is not set; using sw_emu.)
+endif
+
+TARGET ?= sw_emu
+
+TARGETS := sw_emu hw_emu hw
+
+ifeq ($(filter $(TARGET),$(TARGETS)),)
+    $(error TARGET can only be one of: "$(TARGETS)")
+endif
+
+VXXFLAGS := -t ${TARGET} --log_dir $(TARGET) --report_dir $(TARGET) --temp_dir $(TARGET) -I/usr/include/x86_64-linux-gnu -Wno-unused-label
+GXXFLAGS := -Wall -g -std=c++11 -I${XILINX_XRT}/include/ -L${XILINX_XRT}/lib/ -lOpenCL -lpthread -lrt -lstdc++ -I..
+PROJ_HEADERS := ../fmindex.h ../util.h
+PROJ_OBJS := ../fmindex.o ../util.o
+
+ifeq ($(TARGET), hw)
+	EMULATION_FLAG :=
+else
+	EMULATION_FLAG := XCL_EMULATION_MODE=$(TARGET)
+endif
+
+.PHONY: all run-verify clean cleanall unopt opt
+
+all: $(TARGET) verify benchmark unopt opt
+
+unopt: $(TARGET)/unopt.xclbin
+
+ndrange: $(TARGET)/ndrange.xclbin
+
+ndrange2: $(TARGET)/ndrange2.xclbin
+
+memory: $(TARGET)/memory.xclbin
+
+final: $(TARGET)/final.xclbin
+
+run-verify: verify $(TARGET)/$(KERNEL).xclbin
+	@test -n "$(FMFILE)" || (echo "FMFILE undefined" ; exit 1)
+	@test -n "$(TESTFILE)" || (echo "TESTFILE undefined" ; exit 1)
+	@test -n "$(KERNEL)" || (echo "KERNEL undefined" ; exit 1)
+	@test -n "$(NDRANGE)" || (echo "NDRANGE undefined" ; exit 1)
+	@test -n "$(LOCALSIZE)" || (echo "LOCALSIZE undefined" ; exit 1)
+	cd $(TARGET) && $(EMULATION_FLAG) ../verify ../$(FMFILE) ../$(TARGET)/$(KERNEL).xclbin ../$(TESTFILE) $(NDRANGE) $(LOCALSIZE)
+
+$(TARGET):
+	mkdir $(TARGET)
+
+%.o: %.cpp $(PROJ_HEADERS)
+	g++ -c -o $@ $< $(GXXFLAGS)
+
+verify: verify.o
+	g++ -o $@ $(PROJ_OBJS) $< $(GXXFLAGS)
+
+benchmark: benchmark.o
+	g++ -o $@ $(PROJ_OBJS) $< $(GXXFLAGS)
+
+$(TARGET)/unopt.xo: unopt.cl no_ndrange.cfg
+	v++ -c -k fmindex $< $(VXXFLAGS) --config no_ndrange.cfg -o $@
+
+$(TARGET)/unopt.xclbin: $(TARGET)/unopt.xo emconfig.json
+	v++ -l $< $(VXXFLAGS) --config no_ndrange.cfg -o $@
+	mv -t $(TARGET) xrc.log xcd.log
+
+$(TARGET)/memory.xo: memory.cl no_ndrange.cfg
+	v++ -c -k fmindex $< $(VXXFLAGS) --config no_ndrange.cfg -o $@
+
+$(TARGET)/memory.xclbin: $(TARGET)/memory.xo emconfig.json
+	v++ -l $< $(VXXFLAGS) --config no_ndrange.cfg -o $@
+	mv -t $(TARGET) xrc.log xcd.log
+
+$(TARGET)/ndrange.xo: ndrange.cl ndrange.cfg
+	v++ -c -k fmindex $< $(VXXFLAGS) --config ndrange.cfg -o $@
+
+$(TARGET)/ndrange.xclbin: $(TARGET)/ndrange.xo emconfig.json
+	v++ -l $< $(VXXFLAGS) --config ndrange.cfg -o $@
+	mv -t $(TARGET) xrc.log xcd.log
+
+$(TARGET)/ndrange2.xo: ndrange2.cl ndrange2.cfg
+	v++ -c -k fmindex $< $(VXXFLAGS) --config ndrange2.cfg -o $@
+
+$(TARGET)/ndrange2.xclbin: $(TARGET)/ndrange2.xo emconfig.json
+	v++ -l $< $(VXXFLAGS) --config ndrange2.cfg -o $@
+	mv -t $(TARGET) xrc.log xcd.log
+
+$(TARGET)/final.xo: final.cl ndrange.cfg
+	v++ -c -k fmindex $< $(VXXFLAGS) --config ndrange.cfg -o $@
+
+$(TARGET)/final.xclbin: $(TARGET)/final.xo emconfig.json
+	v++ -l $< $(VXXFLAGS) --config ndrange.cfg -o $@
+	mv -t $(TARGET) xrc.log xcd.log
+
+emconfig.json:
+	emconfigutil --platform $(PLATFORM) --nd 1
+
+clean:
+	rm -rf emconfig.json *.info *.link_summary *.compile_summary \
+	    *.xclbin *.xo *.log _x $(TARGET) verify TempConfig *.csv *.run_summary \
+	    *.o .Xil .run .ipcache
+
+cleanall: clean
+	rm -rf $(TARGETS)

code/fpga/benchmark.cpp

@@ -0,0 +1,171 @@
+#define CL_HPP_CL_1_2_DEFAULT_BUILD
+#define CL_HPP_TARGET_OPENCL_VERSION 120
+#define CL_HPP_MINIMUM_OPENCL_VERSION 120
+#define CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY 1
+#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
+
+#include <CL/cl2.hpp>
+#include <fstream>
+#include <iostream>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <vector>
+
+#include "../fmindex.h"
+#include "../util.h"
+
+std::vector<cl::Device> get_xilinx_devices();
+char *read_binary_file(const std::string &xclbin_file_name, unsigned &nb);
+
+int main(int argc, char **argv) {
+  if (argc < 6) {
+    fprintf(
+        stderr,
+        "Usage: %s <FMINDEXFILE> <XCLBIN> <TESTFILE> <NDRANGE> <LOCALSIZE>\n",
+        argv[0]);
+    return 1;
+  }
+
+  int use_ndrange = atoi(argv[4]);
+  int local_size = atoi(argv[5]);
+
+  // Load FM-index.
+  fm_index *index = FMIndexReadFromFile(argv[1], 1);
+  if (!index) {
+    fprintf(stderr, "Could not read FM-index from file.\n");
+    return 1;
+  }
+
+  // Load test file.
+  unsigned pattern_count, pattern_sz, max_match_count;
+  char *patterns;
+
+  if (!(LoadTestData(argv[3], &patterns, &pattern_count, &pattern_sz,
+                     &max_match_count, 1))) {
+    fprintf(stderr, "Could not read test data file.\n");
+    return 1;
+  }
+
+  // Initialize OpenCL.
+  cl_int err;
+  unsigned fileBufSize;
+  std::vector<cl::Device> devices = get_xilinx_devices();
+  devices.resize(1);
+  cl::Device device = devices[0];
+  cl::Context context(device, NULL, NULL, NULL, &err);
+  char *fileBuf = read_binary_file(argv[2], fileBufSize);
+  cl::Program::Binaries bins{{fileBuf, fileBufSize}};
+  cl::Program program(context, devices, bins, NULL, &err);
+  cl::CommandQueue q(context, device, CL_QUEUE_PROFILING_ENABLE, &err);
+  cl::Kernel kernel(program, "fmindex", &err);
+
+  // Create OpenCL buffers for host data.
+  cl::Buffer bwt_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                     sizeof(char) * index->bwt_sz, index->bwt, &err);
+  cl::Buffer alphabet_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                          sizeof(char) * index->alphabet_sz, index->alphabet,
+                          &err);
+  cl::Buffer ranks_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                       sizeof(ranks_t) * index->bwt_sz * index->alphabet_sz,
+                       index->ranks, &err);
+  cl::Buffer sa_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                    sizeof(sa_t) * index->bwt_sz, index->sa, &err);
+  cl::Buffer ranges_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                        sizeof(ranges_t) * 2 * index->alphabet_sz,
+                        index->ranges, &err);
+  cl::Buffer patterns_buf(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
+                          sizeof(char) * pattern_count * pattern_sz, patterns,
+                          &err);
+  cl::Buffer out_buf(context, CL_MEM_WRITE_ONLY,
+                     sizeof(unsigned long) *
+                         (pattern_count * (max_match_count + 1)),
+                     NULL, &err);
+
+  // Map OpenCL buffers to kernel arguments.
+  kernel.setArg(0, bwt_buf);
+  kernel.setArg(1, alphabet_buf);
+  kernel.setArg(2, ranks_buf);
+  kernel.setArg(3, sa_buf);
+  kernel.setArg(4, ranges_buf);
+  kernel.setArg(5, patterns_buf);
+  kernel.setArg(6, out_buf);
+
+  // Map OpenCL buffers to kernel arguments including scalars.
+  kernel.setArg(0, bwt_buf);
+  kernel.setArg(1, alphabet_buf);
+  kernel.setArg(2, ranks_buf);
+  kernel.setArg(3, sa_buf);
+  kernel.setArg(4, ranges_buf);
+  kernel.setArg(5, patterns_buf);
+  kernel.setArg(6, out_buf);
+  kernel.setArg(7, index->bwt_sz);
+  kernel.setArg(8, index->alphabet_sz);
+  kernel.setArg(9, pattern_count);
+  kernel.setArg(10, pattern_sz);
+  kernel.setArg(11, max_match_count + 1);
+
+  // Schedule transfer of inputs and output.
+  q.enqueueMigrateMemObjects(
+      {bwt_buf, alphabet_buf, ranks_buf, sa_buf, ranges_buf, patterns_buf}, 0);
+
+  if (use_ndrange)
+    q.enqueueNDRangeKernel(kernel, 0, pattern_count, local_size);
+  else
+    q.enqueueTask(kernel);
+
+  q.enqueueMigrateMemObjects({out_buf}, CL_MIGRATE_MEM_OBJECT_HOST);
+
+  q.finish();
+
+  // Release resources.
+  delete[] fileBuf;
+  FMIndexFree(index);
+  return EXIT_SUCCESS;
+}
+
+// ------------------------------------------------------------------------------------
+// Utility functions
+// ------------------------------------------------------------------------------------
+std::vector<cl::Device> get_xilinx_devices() {
+  size_t i;
+  cl_int err;
+  std::vector<cl::Platform> platforms;
+  err = cl::Platform::get(&platforms);
+  cl::Platform platform;
+  for (i = 0; i < platforms.size(); i++) {
+    platform = platforms[i];
+    std::string platformName = platform.getInfo<CL_PLATFORM_NAME>(&err);
+    if (platformName == "Xilinx") {
+      std::cerr << "INFO: Found Xilinx Platform" << std::endl;
+      break;
+    }
+  }
+  if (i == platforms.size()) {
+    std::cerr << "ERROR: Failed to find Xilinx platform" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  // Getting ACCELERATOR Devices and selecting 1st such device
+  std::vector<cl::Device> devices;
+  err = platform.getDevices(CL_DEVICE_TYPE_ACCELERATOR, &devices);
+  return devices;
+}
+
+char *read_binary_file(const std::string &xclbin_file_name, unsigned &nb) {
+  if (access(xclbin_file_name.c_str(), R_OK) != 0) {
+    printf("ERROR: %s xclbin not available please build\n",
+           xclbin_file_name.c_str());
+    exit(EXIT_FAILURE);
+  }
+  // Loading XCL Bin into char buffer
+  std::cerr << "INFO: Loading '" << xclbin_file_name << "'\n";
+  std::ifstream bin_file(xclbin_file_name.c_str(), std::ifstream::binary);
+  bin_file.seekg(0, bin_file.end);
+  nb = bin_file.tellg();
+  bin_file.seekg(0, bin_file.beg);
+  char *buf = new char[nb];
+  bin_file.read(buf, nb);
+  return buf;
+}

code/fpga/benchmark_fpga.py

@@ -0,0 +1,232 @@
+import argparse
+import subprocess
+import os
+import shutil
+import json
+from pathlib import Path
+
+
+# Thanks Tristan Laan for data extraction functions.
+
+
+def _calculate_wattage(data: list) -> float:
+    return (int(data[1]) / 1000) * (int(data[2]) / 1000) \
+        + (int(data[3]) / 1000) * (int(data[4]) / 1000)
+
+
+def _get_power_profile_data(directory: Path) -> list:
+    file = next(directory.glob('power_profile_*.csv'))
+    data = []
+
+    with file.open() as f:
+        for i, line in enumerate(f):
+            if i < 2:
+                continue
+            csv_data = line.split(',')
+            data.append({'timestamp': float(csv_data[0]),
+                         'power': _calculate_wattage(csv_data)})
+
+    return data
+
+
+def _get_timeline_data(directory: Path) -> dict:
+    file = next(directory.glob('timeline_trace.csv'))
+    data = {}
+
+    with file.open() as f:
+        for i, line in enumerate(f):
+            cells = line.split(',')
+            if i < 13:
+                continue
+            if cells[0] == 'Footer':
+                break
+
+            if cells[1].startswith("KERNEL") and cells[1].endswith("all") and cells[2] in ["START", "END"]:
+                data[cells[2]] = cells[0]
+
+    return data
+
+
+def _is_mode(line: str):
+    if line == 'OpenCL API Calls':
+        return True
+    if line == 'Kernel Execution':
+        return True
+    if line == 'Compute Unit Utilization':
+        return True
+    if line == 'Data Transfer: Host to Global Memory':
+        return True
+    if line == 'Data Transfer: Kernels to Global Memory':
+        return True
+
+
+def _get_profile_summary_data(file: Path) -> dict:
+    data = dict()
+    mode = None
+    skip_line = False
+    with file.open() as f:
+        for line in f:
+            line = line.strip()
+            if skip_line:
+                skip_line = False
+                continue
+
+            if _is_mode(line):
+                mode = line
+                data[mode] = []
+                skip_line = True
+                continue
+
+            if line == '':
+                mode = None
+
+            if not mode:
+                continue
+
+            csv_data = line.split(',')
+
+            if mode == 'OpenCL API Calls':
+                data[mode].append({
+                        'name': csv_data[0],
+                        'calls': int(csv_data[1]),
+                        'time': float(csv_data[2])
+                    })
+
+            if mode == 'Kernel Execution':
+                data[mode].append({
+                        'kernel': csv_data[0],
+                        'enqueues': int(csv_data[1]),
+                        'time': float(csv_data[2])
+                    })
+
+            if mode == 'Compute Unit Utilization':
+                data[mode].append({
+                        'cu': csv_data[1],
+                        'kernel': csv_data[2],
+                        'time': float(csv_data[9])
+                    })
+
+            if mode == 'Data Transfer: Host to Global Memory':
+                data[mode].append({
+                        'type': csv_data[1],
+                        'transfers': int(csv_data[2]),
+                        'speed': float(csv_data[3]),
+                        'utilization': float(csv_data[4]),
+                        'size': float(csv_data[5]),
+                        'time': float(csv_data[6])
+                    })
+
+
+            if mode == 'Data Transfer: Kernels to Global Memory':
+                data[mode].append({
+                        'interface': csv_data[3],
+                        'type': csv_data[4],
+                        'transfers': int(csv_data[5]),
+                        'speed': float(csv_data[6]),
+                        'utilization': float(csv_data[7]),
+                        'size': float(csv_data[8])
+                    })
+
+    return data
+
+
+def read_data(directory: Path) -> dict:
+    data = dict()
+    profile = directory / 'profile_summary.csv'
+    try:
+        data['power'] = _get_power_profile_data(directory)
+        data['timeline'] = _get_timeline_data(directory)
+    except StopIteration:
+        pass
+    if profile.exists():
+        data.update(_get_profile_summary_data(profile))
+    return data
+
+
+def write_data(data: dict, file: Path):
+    with file.open('w') as f:
+        json.dump(data, f)
+
+
+class cd:
+    """Context manager for changing the current working directory"""
+    def __init__(self, newPath):
+        self.newPath = os.path.expanduser(newPath)
+
+    def __enter__(self):
+        self.savedPath = os.getcwd()
+        os.chdir(self.newPath)
+
+    def __exit__(self, etype, value, traceback):
+        os.chdir(self.savedPath)
+
+
+def main(repeats, count, maxmatches, lengths, dir, filenames, kernel, target, localsize, ndrange):
+    for filename in filenames:
+        for length in lengths:
+            benchmark(repeats, count, maxmatches, length, dir, filename, kernel, target, localsize, ndrange)
+
+
+def benchmark(repeats, count, maxmatches, length, dir, filename, kernel, target, localsize, ndrange):
+    textfilename = f"../{dir}/{filename}"
+    fmfilename = f"{textfilename}.fm"
+    resultdir = f"../{kernel}_results/{filename}.len{length}"
+    testfilename = f"{resultdir}/test.txt"
+
+    if target != "hw":
+        env = dict(os.environ, XCL_EMULATION_MODE=target)
+    else:
+        env = os.environ
+
+    gentestargs = ["../../generate_test_data", textfilename, fmfilename, testfilename, str(count), str(length), str(maxmatches)]
+    benchmarkargs = ["../benchmark", fmfilename, f"{kernel}.xclbin", testfilename, str(ndrange), str(localsize)]
+    print(" ".join(gentestargs))
+    print(" ".join(benchmarkargs))
+
+    with cd(target):
+        shutil.rmtree(resultdir, ignore_errors=True)
+        Path(resultdir).mkdir(parents=True, exist_ok=True)
+
+        for n in range(repeats):
+            print(f"{n+1}/{repeats}")
+
+            # Create test file.
+            gentestproc = subprocess.Popen(gentestargs, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            stdout, stderr = gentestproc.communicate()
+            if stderr:
+                print(f">{stderr.strip()}")
+            ret = gentestproc.poll()
+            if ret != 0:
+                print(f"Error creating test data: {stdout.strip()}")
+                exit(1)
+
+            # Execute kernel
+            benchmarkproc = subprocess.Popen(benchmarkargs, stdout=subprocess.PIPE, universal_newlines=True, stderr=subprocess.PIPE, env=env)
+            _, stderr = benchmarkproc.communicate()
+            if stderr:
+                print(f">{stderr.strip()}")
+            ret = benchmarkproc.poll()
+            if ret != 0:
+                print("Error benchmarking test data")
+                exit(1)
+
+            # Move data to result directory.
+            data = read_data(Path("."))
+            write_data(data, Path(resultdir) / f"run{n}.json")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-n", "--repeats", help="number of times to repeat each experiment", type=int, required=True)
+    parser.add_argument("-c", "--count", help="number of patterns", type=int, required=True)
+    parser.add_argument("-m", "--maxmatches", help="maximum number of matches per pattern", type=int, required=True)
+    parser.add_argument("-l", "--lengths", help="length of the patterns", type=int, nargs="+", default=[], required=True)
+    parser.add_argument("-d", "--dir", help="directory containing FM-indices and original texts (with the same name)", required=True)
+    parser.add_argument("-f", "--files", help="FM-index files to benchmark", nargs="+", default=[], required=True)
+    parser.add_argument("-k", "--kernel", help="FPGA kernel", required=True)
+    parser.add_argument("-t", "--target", help="compilation target", default="sw_emu", required=False)
+    parser.add_argument("-s", "--localsize", help="NDRange local size", type=int, required=True)
+    parser.add_argument("-r", "--ndrange", help="use NDRange", type=int, required=True)
+    args = parser.parse_args()
+
+    main(args.repeats, args.count, args.maxmatches, args.lengths, args.dir, args.files, args.kernel, args.target, args.localsize, args.ndrange)

code/fpga/final.cl

@@ -0,0 +1,72 @@
+#define LOCAL_SIZE 300
+#define MAX_PATTERN_SZ 8
+#define MAX_ALPHABET_SZ 97
+#define MAX_RANGES_SZ (2 * MAX_ALPHABET_SZ)
+#define PATTERNS_SZ (MAX_PATTERN_SZ * LOCAL_SIZE)
+
+inline static int string_index(__private char *s, char c) {
+  int i = 0;
+  while (1) {
+    if (s[i] == c)
+      return i;
+    ++i;
+  }
+}
+
+kernel
+__attribute__((reqd_work_group_size(LOCAL_SIZE, 1, 1)))
+__attribute__((xcl_zero_global_work_offset))
+void fmindex(__global char *bwt,
+             __global char *alphabet,
+             __global unsigned *ranks,
+             __global unsigned *sa,
+             __global unsigned *ranges,
+             __global char *patterns,
+             __global unsigned long *out,
+             size_t bwt_sz, size_t alphabet_sz, unsigned pattern_count,
+             unsigned pattern_sz, unsigned out_sz) {
+  int group_id = get_group_id(0);
+
+  __local char _patterns[PATTERNS_SZ];
+  __attribute__((xcl_pipeline_loop(1)))
+  for (unsigned i = 0; i < PATTERNS_SZ; ++i)
+    _patterns[i] = patterns[group_id * LOCAL_SIZE * pattern_sz + i];
+
+  __attribute__((xcl_pipeline_workitems)) {
+    int work_id = get_global_id(0);
+    int local_id = get_local_id(0);
+
+    __private char _alphabet[MAX_ALPHABET_SZ];
+    __attribute__((xcl_pipeline_loop(1)))
+    for (unsigned i = 0; i < alphabet_sz; ++i)
+      _alphabet[i] = alphabet[i];
+
+    __private unsigned _ranges[MAX_RANGES_SZ];
+    __attribute__((xcl_pipeline_loop(1)))
+    for (unsigned i = 0; i < 2 * alphabet_sz; ++i)
+      _ranges[i] = ranges[i];
+
+    int p_idx = pattern_sz - 1;
+    char c = _patterns[local_id * pattern_sz + p_idx];
+    int alphabet_idx = string_index(_alphabet, c);
+    unsigned start = _ranges[2 * alphabet_idx];
+    unsigned end = _ranges[2 * alphabet_idx + 1];
+  
+    p_idx -= 1;
+    while (p_idx >= 0 && end > 1) {
+      c = _patterns[local_id * pattern_sz + p_idx];
+      alphabet_idx = string_index(_alphabet, c);
+      unsigned range_start = _ranges[2 * alphabet_idx];
+      start = range_start + ranks[alphabet_sz * (start - 1) + alphabet_idx];
+      end = range_start + ranks[alphabet_sz * (end - 1) + alphabet_idx];
+      p_idx -= 1;
+    }
+  
+    unsigned long match_count = end - start;
+    out[work_id * out_sz] = match_count;
+
+    __attribute__((xcl_pipeline_loop(1)))
+    for (unsigned i = 0; i < match_count; ++i)
+      out[work_id * out_sz + i + 1] = sa[start + i];
+  }
+}

code/fpga/final_results/dna.10MB.len8/run2.json

@@ -0,0 +1 @@
+{"power": [{"timestamp": 37.8581, "power": 35.3288}, {"timestamp": 58.5703, "power": 35.3288}, {"timestamp": 79.0738, "power": 35.3288}, {"timestamp": 99.609, "power": 35.3288}, {"timestamp": 120.151, "power": 35.3288}, {"timestamp": 140.789, "power": 35.3288}, {"timestamp": 161.382, "power": 35.3288}, {"timestamp": 181.94, "power": 35.3288}, {"timestamp": 202.498, "power": 35.3288}, {"timestamp": 223.0, "power": 35.3288}, {"timestamp": 243.546, "power": 35.3288}, {"timestamp": 264.094, "power": 35.3288}, {"timestamp": 284.638, "power": 35.3288}, {"timestamp": 305.188, "power": 35.3288}, {"timestamp": 325.74, "power": 35.3288}, {"timestamp": 346.294, "power": 35.3288}, {"timestamp": 366.809, "power": 35.3288}, {"timestamp": 387.352, "power": 35.3288}, {"timestamp": 407.899, "power": 35.3288}, {"timestamp": 428.445, "power": 35.3288}, {"timestamp": 449.024, "power": 35.3288}, {"timestamp": 469.623, "power": 35.3288}, {"timestamp": 490.116, "power": 35.3288}, {"timestamp": 510.633, "power": 35.3288}, {"timestamp": 531.131, "power": 35.3288}, {"timestamp": 551.647, "power": 35.3288}, {"timestamp": 572.344, "power": 35.3288}, {"timestamp": 592.961, "power": 35.3288}, {"timestamp": 613.414, "power": 35.3288}, {"timestamp": 633.856, "power": 35.3288}, {"timestamp": 654.298, "power": 35.3288}, {"timestamp": 674.764, "power": 35.3288}, {"timestamp": 695.258, "power": 35.3288}, {"timestamp": 715.801, "power": 35.3288}, {"timestamp": 736.339, "power": 35.3288}, {"timestamp": 756.873, "power": 35.3288}, {"timestamp": 777.787, "power": 35.3288}, {"timestamp": 798.354, "power": 35.3288}], "timeline": {"START": "470.05948", "END": "523.05116"}, "OpenCL API Calls": [{"name": "clSetKernelArg", "calls": 19, "time": 284.273}, {"name": "clFinish", "calls": 1, "time": 229.365}, {"name": "clReleaseKernel", "calls": 1, "time": 86.4594}, {"name": "clCreateProgramWithBinary", "calls": 1, "time": 63.9265}, {"name": "clReleaseContext", "calls": 1, "time": 51.3423}, {"name": "clCreateContext", "calls": 1, "time": 35.5788}, {"name": "clReleaseProgram", "calls": 1, "time": 11.7884}, {"name": "clEnqueueMigrateMemObjects", "calls": 2, "time": 0.367593}, {"name": "clCreateKernel", "calls": 1, "time": 0.34037}, {"name": "clEnqueueNDRangeKernel", "calls": 1, "time": 0.146976}, {"name": "clReleaseMemObject", "calls": 21, "time": 0.077769}, {"name": "clRetainMemObject", "calls": 14, "time": 0.037016}, {"name": "clGetExtensionFunctionAddress", "calls": 1, "time": 0.025618}, {"name": "clCreateBuffer", "calls": 7, "time": 0.024742}, {"name": "clReleaseDevice", "calls": 2, "time": 0.023307}, {"name": "clGetPlatformInfo", "calls": 4, "time": 0.010228}, {"name": "clGetExtensionFunctionAddressForPlatform", "calls": 1, "time": 0.009001}, {"name": "clReleaseCommandQueue", "calls": 1, "time": 0.0084}, {"name": "clCreateCommandQueue", "calls": 1, "time": 0.007222}, {"name": "clGetDeviceIDs", "calls": 2, "time": 0.006521}, {"name": "clRetainDevice", "calls": 2, "time": 0.004685}], "Kernel Execution": [{"kernel": "fmindex", "enqueues": 1, "time": 52.9917}], "Compute Unit Utilization": [{"cu": "fmindex_1", "kernel": "fmindex", "time": 47.4359}, {"cu": "fmindex_2", "kernel": "fmindex", "time": 49.6304}, {"cu": "fmindex_3", "kernel": "fmindex", "time": 48.7461}, {"cu": "fmindex_4", "kernel": "fmindex", "time": 52.5406}, {"cu": "fmindex_5", "kernel": "fmindex", "time": 52.4821}], "Data Transfer: Host to Global Memory": [{"type": "READ", "transfers": 1, "speed": 7632.600307, "utilization": 79.506253, "size": 969240.0, "time": 126.986867}, {"type": "WRITE", "transfers": 1, "speed": 7027.815445, "utilization": 73.206411, "size": 346090.0, "time": 49.245769}], "Data Transfer: Kernels to Global Memory": [{"interface": "DDR[1:3]", "type": "READ", "transfers": 564951, "speed": 102.623, "utilization": 0.890823, "size": 0.00812744}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 35684, "speed": 371.67, "utilization": 3.2263, "size": 0.118922}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 604431, "speed": 104.444, "utilization": 0.906631, "size": 0.00811912}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 38166, "speed": 372.547, "utilization": 3.23391, "size": 0.119464}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 587746, "speed": 103.73, "utilization": 0.900437, "size": 0.0081225}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 37061, "speed": 372.351, "utilization": 3.23221, "size": 0.119424}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 670506, "speed": 109.093, "utilization": 0.946991, "size": 0.00810738}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 42277, "speed": 376.434, "utilization": 3.26766, "size": 0.12035}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 669545, "speed": 108.988, "utilization": 0.946073, "size": 0.00810754}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 42234, "speed": 376.111, "utilization": 3.26485, "size": 0.120291}]}

code/fpga/final_results/proteins.10MB.len4/run2.json

@@ -0,0 +1 @@
+{"power": [{"timestamp": 37.5244, "power": 35.55}, {"timestamp": 58.164, "power": 35.55}, {"timestamp": 78.7018, "power": 35.55}, {"timestamp": 99.2378, "power": 35.55}, {"timestamp": 120.151, "power": 35.55}, {"timestamp": 141.054, "power": 35.55}, {"timestamp": 161.599, "power": 35.55}, {"timestamp": 182.148, "power": 35.55}, {"timestamp": 202.687, "power": 35.55}, {"timestamp": 223.229, "power": 35.55}, {"timestamp": 243.771, "power": 35.55}, {"timestamp": 264.268, "power": 35.55}, {"timestamp": 284.803, "power": 35.55}, {"timestamp": 305.374, "power": 35.55}, {"timestamp": 325.921, "power": 35.55}, {"timestamp": 346.45, "power": 35.55}, {"timestamp": 366.976, "power": 35.55}, {"timestamp": 387.504, "power": 35.55}, {"timestamp": 408.004, "power": 35.55}, {"timestamp": 428.487, "power": 35.55}, {"timestamp": 449.009, "power": 35.55}, {"timestamp": 469.533, "power": 35.55}, {"timestamp": 490.064, "power": 35.55}, {"timestamp": 510.595, "power": 35.55}, {"timestamp": 531.126, "power": 35.55}, {"timestamp": 551.663, "power": 35.55}, {"timestamp": 572.167, "power": 35.55}, {"timestamp": 592.687, "power": 35.55}, {"timestamp": 613.209, "power": 35.55}, {"timestamp": 633.744, "power": 35.55}, {"timestamp": 654.266, "power": 35.55}, {"timestamp": 674.79, "power": 35.55}, {"timestamp": 695.316, "power": 35.55}, {"timestamp": 715.814, "power": 35.55}, {"timestamp": 736.307, "power": 35.55}, {"timestamp": 756.941, "power": 35.55}, {"timestamp": 777.496, "power": 35.55}], "timeline": {"START": "460.5235", "END": "544.193416"}, "OpenCL API Calls": [{"name": "clFinish", "calls": 1, "time": 319.984}, {"name": "clSetKernelArg", "calls": 19, "time": 141.285}, {"name": "clReleaseKernel", "calls": 1, "time": 103.68}, {"name": "clCreateProgramWithBinary", "calls": 1, "time": 63.4156}, {"name": "clReleaseContext", "calls": 1, "time": 45.2731}, {"name": "clCreateContext", "calls": 1, "time": 35.3638}, {"name": "clReleaseProgram", "calls": 1, "time": 11.3396}, {"name": "clCreateKernel", "calls": 1, "time": 0.339542}, {"name": "clEnqueueMigrateMemObjects", "calls": 2, "time": 0.32061}, {"name": "clEnqueueNDRangeKernel", "calls": 1, "time": 0.129708}, {"name": "clReleaseMemObject", "calls": 21, "time": 0.068368}, {"name": "clRetainMemObject", "calls": 14, "time": 0.037032}, {"name": "clGetExtensionFunctionAddress", "calls": 1, "time": 0.026461}, {"name": "clReleaseDevice", "calls": 2, "time": 0.024029}, {"name": "clCreateBuffer", "calls": 7, "time": 0.023938}, {"name": "clGetPlatformInfo", "calls": 4, "time": 0.01011}, {"name": "clReleaseCommandQueue", "calls": 1, "time": 0.009336}, {"name": "clGetExtensionFunctionAddressForPlatform", "calls": 1, "time": 0.009038}, {"name": "clGetDeviceIDs", "calls": 2, "time": 0.007053}, {"name": "clCreateCommandQueue", "calls": 1, "time": 0.006983}, {"name": "clRetainDevice", "calls": 2, "time": 0.004766}], "Kernel Execution": [{"kernel": "fmindex", "enqueues": 1, "time": 83.6699}], "Compute Unit Utilization": [{"cu": "fmindex_1", "kernel": "fmindex", "time": 80.4245}, {"cu": "fmindex_2", "kernel": "fmindex", "time": 79.8295}, {"cu": "fmindex_3", "kernel": "fmindex", "time": 83.2092}, {"cu": "fmindex_4", "kernel": "fmindex", "time": 80.0805}, {"cu": "fmindex_5", "kernel": "fmindex", "time": 77.5907}], "Data Transfer: Host to Global Memory": [{"type": "READ", "transfers": 1, "speed": 9028.270275, "utilization": 94.044482, "size": 430080.0, "time": 47.637032}, {"type": "WRITE", "transfers": 1, "speed": 6066.104762, "utilization": 63.188591, "size": 1142980.0, "time": 188.420449}], "Data Transfer: Kernels to Global Memory": [{"interface": "DDR[1:3]", "type": "READ", "transfers": 1007752, "speed": 107.617, "utilization": 0.934174, "size": 0.00828578}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 61843, "speed": 381.678, "utilization": 3.31318, "size": 0.123571}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 998939, "speed": 107.42, "utilization": 0.932467, "size": 0.00828831}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 61301, "speed": 380.614, "utilization": 3.30395, "size": 0.123514}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 1095151, "speed": 112.589, "utilization": 0.977336, "size": 0.00826298}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 67282, "speed": 384.546, "utilization": 3.33808, "size": 0.123974}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 999152, "speed": 107.218, "utilization": 0.930713, "size": 0.00828824}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 61282, "speed": 381.24, "utilization": 3.30938, "size": 0.12358}, {"interface": "DDR[1:3]", "type": "READ", "transfers": 961481, "speed": 106.662, "utilization": 0.925882, "size": 0.00829954}, {"interface": "DDR[1:3]", "type": "WRITE", "transfers": 58961, "speed": 381.281, "utilization": 3.30973, "size": 0.123333}]}