[
{
"path": ".gitignore",
"content": "*.S\n*.bin\n\nbin/\nbuild/\ncmake-build-debug/\nvalidation_log/\n__pycache__/\n.idea/\n.vscode/\n\n# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n*.dll\n\n# Compiled Static libraries\n*.lai\n*.la\n*.a\n*.lib\n\n# Executables\n*.exe\n*.out\n*.app\n"
},
{
"path": "LICENSE",
"content": "Copyright (c) 2024, VIA Research Group at KAIST\n\nPermission is hereby granted, free of charge, to any person obtaining a\ncopy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be included\nin all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\nOR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
},
{
"path": "README.md",
"content": "# 📖 Introduction\n![](\"./assets/uPIMulator_logo.png\")
\n\n**Welcome to the uPIMulator Framework Documentation!**\n\nThis documentation serves as your comprehensive guide to the uPIMulator framework, catering to both novice and experienced researchers.\nHere, you'll find the resources necessary to leverage uPIMulator effectively for your research projects.\n\nWe provide in-depth coverage of uPIMulator's features, from foundational concepts to advanced functionalities.\nExplore this documentation to unlock the full potential of uPIMulator and elevate your research endeavors.\n\n# 🤙 Contact Information\n## 📍 Address\n[KAIST](https://www.kaist.ac.kr/en/), School of Electrical Engineering\n\n[Vertically Integrated Architecture Research Group](https://sites.google.com/view/kaist-via/home)\n\nOffice: N1 818 @ [KAIST](https://www.kaist.ac.kr/en/)\n\n## 📧 Email\n- Bongjoon Hyun: [bongjoon.hyun@gmail.com](mailto:bongjoon.hyun@gmail.com)\n- Taehun Kim: [taehun.kim@kaist.ac.kr](mailto:taehun.kim@kaist.ac.kr)\n- Dongjae Lee: [dongjae.lee@kaist.ac.kr](mailto:dongjae.lee@kaist.ac.kr)\n- Minsoo Rhu: [minsoo.rhu@gmail.com](mailto:minsoo.rhu@gmail.com)\n\nPlease feel free to reach out to us if you have any questions or require further assistance.\n\n# 🧑💻 Released Versions\n> **uPIMulator: A Flexible and Scalable Simulation Framework for General-Purpose Processing-In-Memory (PIM) Architectures**\n\nuPIMulator is a cycle-level performance simulator tailored for general-purpose Processing-In-Memory (PIM) systems adhering to the UPMEM Instruction Set Architecture (ISA). This tool provides a detailed simulation environment, empowering computer architecture researchers and PIM program developers to investigate and harness the capabilities of PIM technology.\n\nFor comprehensive insights into uPIMulator and its applications, refer to our HPCA-2024 publication:\n\n\"[Pathfinding Future PIM Architectures by Demystifying a Commercial PIM Technology](https://www.computer.org/csdl/proceedings-article/hpca/2024/931300a263/1VOAAZSdy0w)\", HPCA, 2024\n\nThe currently available versions are:\n1. Python & C++ version\n2. Go version\n3. Go & virtual machine version\n\nAll source code and version history can be accessed in our GitHub repository.\n\n## The Python & C++ Version\nThis is our initial implementation of uPIMulator, used in our HPCA-2024 publication. \nYou'll find it in the `python_cpp` directory. Refer to the included [README](./python_cpp/README.md) for usage instructions.\n\n## The Go Version\nOur second implementation, optimized for speed and memory efficiency.\nLocated in the `golang` directory, it offers an 8.5x speed increase and 7.5x memory reduction due to multi-threading.\nWe generally recommend this version for most use cases. See the [README](./golang/README.md) for details.\n\n## The Go & Virtual Machine Version\nThis latest version extends the Go version with virtual machine capabilities, eliminating the need for manual data preparation code in many scenarios.\nIt's particularly suitable for complex or dynamic benchmarks where manual data preparation is challenging, though it may not offer the fastest simulation speed.\nRefer to the [README](./golang_vm/README.md) for further guidance.\n\n# 🔍 Summary of Correlation Ratio (R²) and Mean Absolute Error (MAE)\n## Single DPU\n![](\"./assets/validation_single_dpu.png\")
\n\n## Multiple DPUs\n![](\"./assets/validation_multi_dpus.png\")
\n\n- Each data point represents a single kernel from the PrIM benchmark suite.\n- Summary of Correlation Ratio (R²) and Mean Absolute Error (MAE) for single- and multi-DPU simulations:\n\n| Scenario | Total Data Points | Correlation (R²) | MAE |\n|---|---|---|---|\n| Single DPU (no inter-DPU communication) | 710 | 98.4% | 12.0% |\n| Multi-DPU (with inter-DPU communication) | 387 | 83.6% | 26.9% |\n\n- These validation results were obtained using the Python & C++ version of uPIMulator.\n\n# List of Supported Instructions\n- uPIMulator currently supports 599 out of the 970 instructions defined in the [UPMEM-PIM ISA](https://sdk.upmem.com/2023.2.0/201_IS.html#instruction-set-architecture).\nDue to limitations in the publicly available ISA documentation, support for the remaining 371 instructions is pending.\nHowever, the currently supported instructions have been sufficient to enable functionally correct simulations of the [PrIM benchmark suite](https://github.com/CMU-SAFARI/prim-benchmarks), producing results consistent with those obtained on real UPMEM-PIM hardware.\n\n- For a detailed list of the currently supported instructions, please refer to [this Google spreadsheet](https://docs.google.com/spreadsheets/d/1xq8t6aRvafmTlGmy4Am8i3QmoOzli1heNxLmCEIlCv4/edit?usp=sharing).\n\n# 🪨 Materials\n- Bongjoon Hyun, Taehun Kim, Dongjae Lee, and Minsoo Rhu, \"[Pathfinding Future PIM Architectures by Demystifying a Commercial PIM Technology](https://www.computer.org/csdl/proceedings-article/hpca/2024/931300a263/1VOAAZSdy0w)\", *The 30th IEEE International Symposium on High-Performance Computer Architecture ([HPCA-30](https://hpca-conf.org/2024/))*, Edinburgh, Scotland, Mar. 2024\n - ${\\textsf{\\color{red}Best Paper Award}}$\n - Acceptance rate: 18% (75 among 410)\n - [Slide](https://drive.google.com/file/d/1TRgFu6YdBu2gtdtDKIuJI85u8Be8w60M/view?usp=sharing)\n - [Presentation](https://youtu.be/e-RXYl568fw?si=LbTYbM7p7qod-L8w)\n\n# 🎁 Contributions\nWe welcome and encourage contributions to uPIMulator!\nIf you are interested in contributing or have questions, please feel free to open an issue or submit a pull request.\n\n## List of Maintainers\n- Bongjoon Hyun (bongjoon.hyun@gmail.com)\n- Taehun Kim (taehun.kim@kaist.ac.kr)\n- Dongjae Lee (dongjae.lee@kaist.ac.kr)\n- Minsoo Rhu (minsoo.rhu@gmail.com)\n\n## List of Contributors\n\n# 🙏 Acknowledgement\nWe would like to thank the developers of the [PrIM benchmark suite](https://github.com/CMU-SAFARI/prim-benchmarks), which was instrumental in developing this project.\n\nThis research is funded by the generous support from the following organizations:\n- Institute of Information & Communications Technology Planning & Evaluation (IITP) grant funded by the Korea government(MSIT) (No. 2022-0-01037, Development of High Performance Processing-in-Memory Technology based on DRAM) and the Korea government(MSIT) (No.RS-2024-00438851, (SW Starlab) High-performance Privacy-preserving Machine Learning System and System Software)\n- National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (NRF-2021R1A2C2091753)\n- Samsung Electronics\n\nWe appreciate their commitment to advancing research in this field.\n\n## 📔 Citation\nBongjoon Hyun, Taehun Kim, Dongjae Lee, and Minsoo Rhu, \"[Pathfinding Future PIM Architectures by Demystifying a Commercial PIM Technology](https://www.computer.org/csdl/proceedings-article/hpca/2024/931300a263/1VOAAZSdy0w)\", IEEE International Symposium on High-Performance Computer Architecture (HPCA), March 2024.\n"
},
{
"path": "golang/README.md",
"content": "# ⚙️ Usage\n## Currently Supported Mode\nuPIMulator operates in an execution-driven simulation mode, enabling cycle-level performance analysis of PIM-based applications.\n\n## Workflow\nThe typical usage workflow comprises two primary stages:\n\n1. **Binary Generation:** Compile, assemble, and link your application code to generate the required binary files for simulation.\n2. **Cycle-Level Simulation:** Utilize the generated binary files as input to the cycle-level simulator to obtain detailed performance metrics and insights.\n\nWe are actively working on expanding uPIMulator's capabilities and may introduce additional usage modes in future releases. \n\n## Installation & Build\n### Prerequisites\n\n- **Go Compiler and SDK:** uPIMulator requires Go 1.21.5 or later. \nYou can download and install Go from the [official website](https://go.dev/doc/install).\n\n- **Docker:** Please ensure that Docker is installed on your system.\n\n- **Docker Group Membership:** Your Ubuntu user account needs to be a member of the `docker` group.\n\n- **Tested Environment:** uPIMulator has been thoroughly tested on Ubuntu 18.04 with an Intel CPU.\nWhile we strive for compatibility across different environments, optimal performance and functionality are guaranteed within the tested setup.\n\n### Installation Steps\n\n1. **Install and Build**\n Navigate to the `uPIMulator` directory and execute the build script:\n\n ```bash\n cd /path/to/uPIMulator/golang/uPIMulator/script\n python build.py\n ```\n\n## Binary Files Generation & Cycle-Level Simulation\nWe will use the VA (vector addition) benchmark as an example to demonstrate the binary file generation and simulation process.\nPlease note that the initial simulation might take approximately 30 minutes.\n\n### Execution\nTo initiate a simulation, provide the following:\n\n- **Benchmark name:** Specify the desired benchmark (e.g., 'VA').\n- **Number of tasklets:** Define the number of tasklets to be utilized.\n- **Output directory path:** Indicate the absolute path to the directory where you want to store binary files, log files, and other simulation artifacts. \n\nYou can further customize the simulation by utilizing command-line options to adjust various parameters.\n\n### Simulation Output\nDetailed simulation results will be written to the standard output (`stdout`).\n\n> **Important Notes:**\n> - **Create Output Directory:** Prior to running the simulation, create an empty directory at the specified `bin_dirpath`. \n> **Absolute Paths:** Always provide absolute paths for both `root_dirpath` (the repository's root directory) and `bin_dirpath`.\n\n### Example Command\n\n```bash\ncd /path/to/uPIMulator/golang/uPIMulator\nrm -rf bin\nmkdir bin\n./build/uPIMulator --root_dirpath /path/to/uPIMulator/golang/uPIMulator --bin_dirpath /path/to/uPIMulator/golang/uPIMulator/bin --benchmark VA --num_channels 1 --num_ranks_per_channel 1 --num_dpus_per_rank 1 --num_tasklets 16 --data_prep_params 1024\n```\n\n# 📄 Reproducing Figures from the Paper\nTo replicate the figures presented in our paper, please adhere to the instructions provided below.\nWe offer replication manuals for Figures 5, 6, 7, 9 and 10 for brevity.\n\n## Configuration of PrIM Benchmarks\n\n- **Single DPU Focus:** For Figures 5, 6, 7, and 9 the parameters `num_channels`, `num_ranks_per_channel`, and `num_dpus_per_rank` must always be set to `1`, as these experiments specifically characterize the behavior of a single DPU.\n- **Data Preparation Parameter:** When generating the binary files for the PrIM benchmarks, please configure the `data_prep_param` parameter according to the following table:\n\n| Benchmark | `data_prep_param` (Figures 5, 6) | `data_prep_param` (Figure 10) |\n|---|---|---|\n| BS | 32768 | 131072 |\n| GEMV | 2048 | 4096 |\n| HST-L | 131072 | 524288 |\n| HST-S | 131072 | 524288 |\n| MLP | 256 | 1024 |\n| RED | 524288 | 2097152|\n| SCAN-RSS | 262144 | 1048576|\n| SCAN-SSA | 262144 | 1048576|\n| SEL | 524288 | 2097152|\n| TRNS | 1024 | 128 |\n| TS | 2048 | 65536 |\n| UNI | 524288 | 2097152|\n| VA | 524288 | 2097152|\n\n### Example Command\n\n```bash\n./uPIMulator --root_dirpath /path/to/uPIMulator/ --bin_dirpath /path/to/uPIMulator/bin --benchmark VA --num_channels 1 --num_ranks_per_channel 1 --num_dpus_per_rank 1 --num_tasklets 16 --data_prep_params 524288\n``` \n\nPlease ensure you adhere to these configurations to accurately replicate the figures presented in the paper. \n\n## Figure 5: PrIM Compute and Memory Utilization\n![](\"../assets/uPIMulator_figure5.png\")
\n\nThis figure illustrates the compute utilization (represented by red points) and memory read bandwidth utilization (represented by blue points) of the PrIM benchmarks when executed with varying numbers of threads (tasklets): 1, 4, and 16.\n\n### Metrics Calculation\n\n- **Compute Utilization (IPC):** `num_instructions` / `logic_cycle`\n- **Memory Read Bandwidth Utilization (GB/s):** Refer to the provided Excel sheet for the calculation: [link](../assets/figure5_mem_util_calculator.xlsx)\n\n> **Note:** The values for `num_instructions` and `logic_cycle` required in these calculations can be obtained from the simulation results generated by uPIMulator. \n\n## Figure 6: DPU Runtime Breakdown\n![](\"../assets/uPIMulator_fiture6.png\")
\n\nThis figure presents a breakdown of DPU runtime, categorizing cycles into:\n\n- **Active Cycles (Black):** Represent cycles when the DPU is actively executing instructions.\n- **Idle Cycles (Red, Yellow, Blue):** Represent cycles when the DPU is stalled due to various reasons.\n\n### Calculation of Cycle Ratios\nTo generate the breakdown depicted in the figure, you can utilize the following formulas:\n\n- **Issuable Ratio:** `breakdown_run` / `logic_cycle`\n- **Idle (Memory) Ratio:** `breakdown_dma` / `logic_cycle`\n- **Idle (Revolver) Ratio:** `breakdown_etc` / `logic_cycle`\n- **Idle (RF) Ratio:** `backpressure` / `logic_cycle`\n\n> **Note:** The values for the variables used in these formulas (`breakdown_run`, `logic_cycle`, etc.) are available in the simulation results produced by uPIMulator. \n\n## Figure 7: Issuable Tasklets\n![](\"../assets/uPIMulator_figure7.png\")
\n\nThis figure visualizes the number of tasklets (threads) that are ready for execution (issuable) by the DPU scheduler at each cycle.\n\n### Replication\nTo reproduce this figure, utilize the provided [Excel sheet](../assets/figure7_active_tasklet_breakdown.xlsx).\nThe spreadsheet includes instructions on how to populate it with the relevant simulation output data, and it will automatically generate the corresponding figure.\n\n> **Important Configuration Note**: Please ensure that the number of threads is configured to **16 tasklets** when running the simulations for this figure.\n> You can achieve this by using the following command-line argument: `--num_tasklets 16`.\n\n## Figure 9: Instruction Mix (Single DPU)\n![](\"../assets/uPIMulator_figure9.png\")
\n\nFigure 9 provides a breakdown of the instruction mix observed during single-DPU execution.\nTo generate this figure, follow the steps outlined below using the `upmem_profiler` tool and the accompanying Excel sheet.\n\n### Procedure\n\n1. **Build the Profiler**\n\n ```bash\n cd /path/to/uPIMulator/tools/upmem_profiler/script\n bash build.sh\n ```\n\n2. **Extract Instructions**\n Run the simulation with the `--verbose 1` flag to capture detailed instruction traces.\n\n ```bash\n cd /path/to/uPIMulator/golang/uPIMulator/\n ./build/uPIMulator --root_dirpath /path/to/uPIMulator/golang/uPIMulator --bin_dirpath /path/to/uPIMulator/golang/uPIMulator/bin --benchmark VA --num_channels 1 --num_ranks_per_channel 1 --num_dpus_per_rank 1 --num_tasklets 16 --data_prep_params 1024 --verbose 1 > trace.txt\n ```\n\n3. **Run the Profiler**\n Process the generated trace file using the `upmem_profiler` in `instruction_mix` mode.\n\n ```bash\n cd /path/to/uPIMulator/tools/upmem_profiler/\n ./build/src/upmem_profiler --logpath /path/to/uPIMulator/golang/uPIMulator/trace.txt --mode instruction_mix\n ```\n\n4. **Generate the Figure**\n Utilize the profiler's output to populate the provided [Excel sheet](../assets/figure9_instruction_mix.xlsx), which will automatically generate the instruction mix figure.\n\n> **Important Configuration Note:** Similar to Figure 7, the instruction mix analysis in Figure 9 is based on simulations with **16 tasklets**.\n> Ensure that you maintain this configuration (`--num_tasklets 16`) for accurate replication. \n\n## Figure 10: Multi-DPU Latency Breakdown and Speedup\n![](\"../assets/uPIMulator_figure10.png\")
\n\nFigure 10 presents the latency breakdown and speedup achieved in multi-DPU scenarios.\n\n### Configuring the Number of DPUs\nYou can adjust the number of DPUs by modifying the following parameters in `uPIMulator`:\n\n- `num_channels` \n- `num_ranks_per_channel`\n- `num_dpus_per_rank`\n\n### Generating the Latency Breakdown\nTo obtain the latency breakdown data for plotting, utilize the `upmem_reg_model` tool located in the `tools/upmem_reg_model/` directory.\nThis tool implements a communication model between the host and DPUs based on linear regression.\n\n### Procedure\n\n1. **Prepare Input Excel:**\n - We provide a sample input Excel file as a template.\n - Append a new row to this file, specifying the benchmark name, number of DPUs, and the `data_prep_param` used in your simulation.\n - Fill in the relevant time values (in milliseconds) obtained from your simulation results, such as kernel execution time.\n You can convert cycle counts to time in milliseconds by dividing the cycle count by the corresponding clock frequency (in MHz) and then multiplying by 1000.\n\n2. **Run the Regression Model:**\n\n ```bash\n cd /path/to/uPIMulator/tools/upmem_reg_model/src\n python main.py --input_excel_filepath /path/to/your/input_excel_file --output_excel_filepath /path/to/your/output_excel_file\n ```\n\n3. **Access the Output:** \n - The linear regression results will be available in the specified output Excel file.\n - Use this data to create the latency breakdown plots as shown in Figure 10.\n\nPlease ensure that you follow these steps carefully to accurately reproduce the multi-DPU latency breakdown and speedup analysis presented in the paper.\n\n# 🌋 Adding Custom Benchmarks\nuPIMulator empowers you to go beyond the provided PrIM benchmark suite by incorporating your own custom benchmarks.\nThis is particularly beneficial if you have access to UPMEM-PIM hardware and want to evaluate your code's performance in a simulated environment.\n\n## Requirements\nTo successfully integrate a new benchmark, ensure it adheres to the following:\n\n1. **UPMEM-C Language:** The benchmark must be implemented in UPMEM-C, a C-like language tailored for UPMEM-PIM programming.\nConsult the [UPMEM SDK documentation](https://sdk.upmem.com/2021.4.0/) for detailed programming guidelines.\n\n2. **File Structure and Naming:** \n - Maintain the same file hierarchy as the PrIM benchmarks, including a `dpu` subdirectory.\n - Include a `CMakeLists.txt` file within your benchmark's directory hierarchy, mirroring the structure used in the PrIM examples.\n This is essential as uPIMulator's interpreter and linker automatically detect and compile benchmarks using these `CMakeLists.txt` files.\n\n## Data Preparation\nSince UPMEM PIM-enabled memory directly utilizes physical addresses and uPIMulator currently doesn't support concurrent execution of host and PIM-enabled memory, exercise caution when feeding input/output data. \n\nYou'll need to provide Go source code to handle data preparation for your benchmark.\nThis script should reside in the `uPIMulator/src/assembler` directory and be recognized by `uPIMulator/src/assembler/assembler.go`.\n\n> **Key Considerations for Data Preparation Scripts**\n> - Data transferred from the host to DPUs using `dpu_push_xfer` must be organized within the `input_dpu_mram_heap_pointer_name` variable in your data preparation script.\n> - Similarly, data transferred from DPUs to the host using `dpu_push_xfer` should be placed within the `output_dpu_mram_heap_pointer_name` variable.\n\n## Reference Examples\nWe have included data preparation scripts for the 13 supported PrIM benchmarks.\nThese serve as excellent references for structuring your custom data preparation scripts.\n\nBy following these guidelines, you can seamlessly integrate your benchmarks into uPIMulator for comprehensive performance evaluation and analysis. \n\nIf you have any questions or encounter any difficulties during the integration process, don't hesitate to reach out to us for support. \n"
},
{
"path": "golang/uPIMulator/benchmark/BS/CMakeLists.txt",
"content": "#add_subdirectory(host)\r\nadd_subdirectory(dpu)"
},
{
"path": "golang/uPIMulator/benchmark/BS/Makefile",
"content": "DPU_DIR := dpu\nHOST_DIR := host\nBUILDDIR ?= bin\nNR_TASKLETS ?= 16\nNR_DPUS ?= 1\nPROBLEM_SIZE ?= 2\n\ndefine conf_filename\n\t${BUILDDIR}/.NR_DPUS_$(1)_NR_TASKLETS_$(2).conf\nendef\nCONF := $(call conf_filename,${NR_DPUS},${NR_TASKLETS})\n\nCOMMON_INCLUDES := support\nHOST_TARGET := ${BUILDDIR}/host_code\nDPU_TARGET := ${BUILDDIR}/dpu_code\n\nHOST_SOURCES := $(wildcard ${HOST_DIR}/*.c)\nDPU_SOURCES := $(wildcard ${DPU_DIR}/*.c)\n\n.PHONY: all clean test\n\n__dirs := $(shell mkdir -p ${BUILDDIR})\n\nCOMMON_FLAGS := -w -I${COMMON_INCLUDES}\nHOST_FLAGS := ${COMMON_FLAGS} -std=c11 -O3 `dpu-pkg-config --cflags --libs dpu` -DNR_TASKLETS=${NR_TASKLETS} -DNR_DPUS=${NR_DPUS} -DPROBLEM_SIZE=${PROBLEM_SIZE}\nDPU_FLAGS := ${COMMON_FLAGS} -O2 -DNR_TASKLETS=${NR_TASKLETS}\n\nall: ${HOST_TARGET} ${DPU_TARGET}\n\n${CONF}:\n\t$(RM) $(call conf_filename,*,*)\n\ttouch ${CONF}\n\n${HOST_TARGET}: ${HOST_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\t$(CC) -o $@ ${HOST_SOURCES} ${HOST_FLAGS}\n\t$(CC) -S -o ${HOST_TARGET}.S ${HOST_SOURCES} ${HOST_FLAGS}\n\n${DPU_TARGET}: ${DPU_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\tdpu-upmem-dpurte-clang ${DPU_FLAGS} -o $@ ${DPU_SOURCES}\n\tdpu-upmem-dpurte-clang -S ${DPU_FLAGS} -o ${DPU_TARGET}.S ${DPU_SOURCES}\n\nclean:\n\t$(RM) -r $(BUILDDIR)\n\ntest: all\n\t./${HOST_TARGET} -i 262144\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/cpu/Makefile",
"content": "all:\n\tgcc bs_omp.c -o bs_omp -fopenmp\nrun:\n\t./bs_omp 262144 16777216\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/cpu/README",
"content": "Binary Search (BS)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n ./bs_omp 2048576 16777216\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/cpu/bs_omp.c",
"content": "\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"timer.h\"\n\n#define DTYPE uint64_t\n/*\n* @brief creates a \"test file\" by filling a bufferwith values\n*/\nvoid create_test_file(DTYPE * input, uint64_t nr_elements, DTYPE * querys, uint64_t n_querys) {\n\n uint64_t max = UINT64_MAX;\n uint64_t min = 0;\n\n srand(time(NULL));\n\n input[0] = 1;\n for (uint64_t i = 1; i < nr_elements; i++) {\n input[i] = input[i - 1] + (rand() % 10) + 1;\n }\n\n for(uint64_t i = 0; i < n_querys; i++)\n {\n\tquerys[i] = input[rand() % (nr_elements - 2)];\n }\n}\n\n/**\n* @brief compute output in the host\n*/\nuint64_t binarySearch(DTYPE * input, uint64_t input_size, DTYPE* querys, unsigned n_querys)\n{\n\n\tuint64_t found = -1;\n\tuint64_t q, r, l, m;\n\t\n #pragma omp parallel for private(q,r,l,m)\n \tfor(q = 0; q < n_querys; q++)\n \t{\n\t\tl = 0;\n\t\tr = input_size;\n\t\twhile (l <= r) \n\t\t{\n\t \t\tm = l + (r - l) / 2;\n\n\t \t\t// Check if x is present at mid\n\t \t\tif (input[m] == querys[q])\n\t\t\t{\t\n\t\t \t\tfound += m;\n\t\t\t\tbreak;\n\t\t\t}\n\t \t\t// If x greater, ignore left half\n\t \t\tif (input[m] < querys[q])\n\t\t\t \tl = m + 1;\n\n\t \t\t// If x is smaller, ignore right half\n\t\t\telse\n\t\t \t\tr = m - 1;\n\t\t\n\t\t}\n \t}\n\n \treturn found;\n}\n\n /**\n * @brief Main of the Host Application.\n */\n int main(int argc, char **argv) {\n\n Timer timer;\n uint64_t input_size = atol(argv[1]);\n uint64_t n_querys = atol(argv[2]);\n\n printf(\"Vector size: %lu, num searches: %lu\\n\", input_size, n_querys);\n\t\n DTYPE * input = malloc((input_size) * sizeof(DTYPE));\n DTYPE * querys = malloc((n_querys) * sizeof(DTYPE));\n\n DTYPE result_host = -1;\n\n // Create an input file with arbitrary data.\n create_test_file(input, input_size, querys, n_querys);\n\t\n start(&timer, 0, 0);\n result_host = binarySearch(input, input_size - 1, querys, n_querys); \n stop(&timer, 0);\n\n\n int status = (result_host);\n if (status) {\n printf(\"[OK] Execution time: \");\n\tprint(&timer, 0, 1);\n\tprintf(\"ms.\\n\");\n } else {\n printf(\"[ERROR]\\n\");\n }\n free(input);\n\n\n return status ? 0 : 1;\n}\n\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/cpu/timer.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#include \r\n\r\ntypedef struct Timer{\r\n\r\n struct timeval startTime[4];\r\n struct timeval stopTime[4];\r\n double time[4];\r\n\r\n}Timer;\r\n\r\nvoid start(Timer *timer, int i, int rep) {\r\n if(rep == 0) {\r\n timer->time[i] = 0.0;\r\n }\r\n gettimeofday(&timer->startTime[i], NULL);\r\n}\r\n\r\nvoid stop(Timer *timer, int i) {\r\n gettimeofday(&timer->stopTime[i], NULL);\r\n timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +\r\n (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);\r\n}\r\n\r\nvoid print(Timer *timer, int i, int REP) { printf(\"%f\\t\", timer->time[i] / (1000 * REP)); }\r\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/Makefile",
"content": "all:\n\tnvcc -arch=sm_30 -m64 -Xcompiler -fPIC -shared -o cu_binary_search.so binary_search.cu -std=c++11\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/README",
"content": "Binary Search (BS)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n python3 run.py\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/binary_search.cu",
"content": "#include \r\n#include \r\n#include \"binary_search.h\"\r\n\r\n#include \r\n#include \r\n\r\n#define BLOCKDIM 512\r\n#define SEARCH_CHUNK 16\r\n#define BLOCK_CHUNK (BLOCKDIM*SEARCH_CHUNK)\r\n\r\n\r\n__global__ void search_kernel(const long int *arr,\r\n const long int len, const long int *querys, const long int num_querys, long int *res, bool *flag)\r\n{\r\n int search;\r\n if(*flag == false) {\r\n int tid = threadIdx.x;\r\n __shared__ int s_arr[BLOCK_CHUNK];\r\n\r\n /* Since each value is being copied to shared memory, the rest of the\r\n following uncommented code is unncessary, since a direct comparison\r\n can be done at the time of copy below. */\r\n // for(int i = 0; i < BLOCKDIM; ++i) {\r\n // int shared_loc = i*SEARCH_CHUNK + tid;\r\n // int global_loc = shared_loc + BLOCK_CHUNK * blockIdx.x;\r\n // if(arr[global_loc] == search) {\r\n // *flag = true;\r\n // *res = global_loc;\r\n // }\r\n // __syncthreads();\r\n // }\r\n\r\n /* Copy chunk of array that this entire block of threads will read\r\n from the slower global memory to the faster shared memory. */\r\n for(long int i = 0; i < SEARCH_CHUNK; ++i) {\r\n int shared_loc = tid*SEARCH_CHUNK + i;\r\n int global_loc = shared_loc + BLOCK_CHUNK * blockIdx.x;\r\n\r\n /* Make sure to stay within the bounds of the global array,\r\n else assign a dummy value. */\r\n if(global_loc < len) {\r\n s_arr[shared_loc] = arr[global_loc];\r\n }\r\n else {\r\n s_arr[shared_loc] = INT_MAX;\r\n }\r\n }\r\n __syncthreads();\r\n\r\n for(long int i = 0; i < num_querys; i++)\r\n {\r\n search = querys[i];\r\n /* For each runtime, set the initial search range. */\r\n int L = 0;\r\n int R = SEARCH_CHUNK - 1;\r\n int m = (L + R) / 2;\r\n\r\n /* Pointer to the part of the shared array for this runtime. */\r\n int *s_ptr = &s_arr[tid*SEARCH_CHUNK];\r\n\r\n /* Each runtime will search a chunk of the block array.\r\n Many blocks will not find a solution so the search must\r\n be allowed to fail on a per block basis. The loop will\r\n break (fail) when L >= R. */\r\n while(L <= R && *flag == false)\r\n {\r\n if(s_ptr[m] < search) {\r\n L = m + 1;\r\n }\r\n else if(s_ptr[m] > search) {\r\n R = m - 1;\r\n }\r\n else {\r\n *flag = true;\r\n *res = m += tid*SEARCH_CHUNK + BLOCK_CHUNK * blockIdx.x;\r\n }\r\n\r\n m = (L + R) / 2;\r\n }\r\n }\r\n }\r\n}\r\n\r\n\r\n\r\nint binary_search(const long int *arr, const long int len, const long int *querys, const long int num_querys)\r\n{\r\n long int *d_arr, *d_querys, *d_res;\r\n bool *d_flag;\r\n\r\n size_t arr_size = len * sizeof(long int);\r\n size_t querys_size = num_querys * sizeof(long int);\r\n size_t res_size = sizeof(long int);\r\n size_t flag_size = sizeof(bool);\r\n\r\n cudaMalloc(&d_arr, arr_size);\r\n cudaMalloc(&d_querys, querys_size);\r\n cudaMalloc(&d_res, res_size);\r\n cudaMalloc(&d_flag, flag_size);\r\n\r\n cudaMemcpy(d_arr, arr, arr_size, cudaMemcpyHostToDevice);\r\n cudaMemcpy(d_querys, querys, querys_size, cudaMemcpyHostToDevice);\r\n cudaMemset(d_flag, 0, flag_size);\r\n\r\n /* Set res value to -1, so that if the function returns -1, that\r\n indicates an algorithm failure. */\r\n cudaMemset(d_res, -0x1, res_size);\r\n\r\n int blockSize = BLOCKDIM;\r\n int gridSize = (len-1)/BLOCK_CHUNK + 1;\r\n\r\n auto start = std::chrono::high_resolution_clock::now();\r\n search_kernel<<>>(d_arr, len, d_querys, num_querys ,d_res, d_flag);\r\n cudaDeviceSynchronize();\r\n auto end = std::chrono::high_resolution_clock::now();\r\n std::cout << \"Kernel Time: \" <<\r\n std::chrono::duration_cast(end-start).count() <<\r\n \" ms\" << std::endl;\r\n\r\n long int res;\r\n cudaMemcpy(&res, d_res, res_size, cudaMemcpyDeviceToHost);\r\n\r\n return res;\r\n}\r\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/binary_search.h",
"content": "#ifndef BINARY_SEARCH_H\r\n#define BINARY_SEARCH_H\r\n\r\n#ifdef _WIN32\r\n #include \r\n #define DLL_EXPORT __declspec(dllexport)\r\n#else\r\n #define DLL_EXPORT\r\n#endif\r\n\r\n\r\nextern \"C\" {\r\n\r\n int DLL_EXPORT binary_search(const long int *arr, const long int len, const long int *querys, const long int num_querys);\r\n\r\n}\r\n\r\n#endif /* BINARY_SEARCH_H */\r\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/cpu_lib.py",
"content": "# -*- coding: utf-8 -*-\n\n\ndef binary_search(arr, search):\n\n L = 0\n R = len(arr)\n\n while L <= R:\n\n if L > R:\n return -1 # Error code 1\n\n m = (L + R) / 2\n if arr[m] < search:\n L = m + 1\n elif arr[m] > search:\n R = m - 1\n else:\n return m\n\n return -2 # Error code 2\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/cu_lib_import.py",
"content": "# -*- coding: utf-8 -*-\r\n\r\n__all__ = [\r\n \"binary_search\",\r\n]\r\n\r\n\r\nimport os.path as path\r\nimport platform\r\nfrom ctypes import *\r\n\r\nfrom numpy.ctypeslib import load_library, ndpointer\r\n\r\n## Load the DLL\r\nif platform.system() == \"Linux\":\r\n cuda_lib = load_library(\"cu_binary_search.so\", path.dirname(path.realpath(__file__)))\r\nelif platform.system() == \"Windows\":\r\n cuda_lib = load_library(\"cu_binary_search.dll\", path.dirname(path.realpath(__file__)))\r\n\r\n\r\n## Define argtypes for all functions to import\r\nargtype_defs = {\r\n \"binary_search\": [ndpointer(\"i8\"), c_int, ndpointer(\"i8\"), c_int],\r\n}\r\n\r\n\r\n## Import functions from DLL\r\nfor func, argtypes in argtype_defs.items():\r\n locals().update({func: cuda_lib[func]})\r\n locals()[func].argtypes = argtypes\r\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/baselines/gpu/run.py",
"content": "# -*- coding: utf-8 -*-\n\nimport time\n\nimport numpy as np\n\n# Local Imports\nfrom cu_lib_import import binary_search as gpu_search\n\n# Set an array label to create\narr_len = 2048576\nnum_querys = 16777216\n\n# Dummy array created\narr = np.arange(0, arr_len, 1).astype(\"i8\")\n\n# Random search querys created\nquerys = np.random.randint(1, arr_len, num_querys)\n\n# GPU search function call\nt0 = time.time()\nres_gpu = gpu_search(arr, len(arr), querys, len(querys))\nprint(\"Total GPU Time: %i ms\" % ((time.time() - t0) * 1e003))\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/dpu/CMakeLists.txt",
"content": "set(CMAKE_C_COMPILER \"/root/upmem-2023.2.0-Linux-x86_64/bin/dpu-upmem-dpurte-clang\")\r\nset(CMAKE_C_FLAGS \"-w -I/root/uPIMulator/benchmark/BS/support -O2 -S -DNR_TASKLETS=${NR_TASKLETS}\")\r\n\r\nfile(GLOB_RECURSE SRCS *.c)\r\n\r\nadd_executable(BS_device ${SRCS})\r\n\r\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/dpu/task.c",
"content": "/*\n* Binary Search with multiple tasklets\n*\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"common.h\"\n\n__host dpu_arguments_t DPU_INPUT_ARGUMENTS;\n__host dpu_results_t DPU_RESULTS[NR_TASKLETS];\n\n// Search\nDTYPE __attribute__ ((noinline)) search(DTYPE *bufferA, DTYPE searching_for) {\n DTYPE found = -2;\n if(bufferA[0] <= searching_for)\n {\n found = -1;\n for (uint32_t i = 0; i < BLOCK_SIZE / sizeof(DTYPE); i++){\n if(bufferA[i] == searching_for)\n {\n found = i;\n break;\n }\n }\n }\n return found;\n}\n\nBARRIER_INIT(my_barrier, NR_TASKLETS);\n\nextern int main_kernel1(void);\n\nint(*kernels[nr_kernels])(void) = {main_kernel1};\n\nint main(void){\n // Kernel\n return kernels[DPU_INPUT_ARGUMENTS.kernel]();\n}\n\n// main_kernel1\nint main_kernel1() {\n unsigned int tasklet_id = me();\n #if PRINT\n printf(\"tasklet_id = %u\\n\", tasklet_id);\n #endif\n if(tasklet_id == 0){\n mem_reset(); // Reset the heap\n }\n // Barrier\n barrier_wait(&my_barrier);\n\n DTYPE searching_for, found;\n uint64_t input_size = DPU_INPUT_ARGUMENTS.input_size;\n\n // Address of the current processing block in MRAM\n uint32_t start_mram_block_addr_A = (uint32_t) DPU_MRAM_HEAP_POINTER;\n uint32_t start_mram_block_addr_aux = start_mram_block_addr_A;\n uint32_t end_mram_block_addr_A = start_mram_block_addr_A + sizeof(DTYPE) * input_size;\n uint32_t current_mram_block_addr_query = end_mram_block_addr_A + tasklet_id * (DPU_INPUT_ARGUMENTS.slice_per_dpu / NR_TASKLETS) * sizeof(DTYPE);\n\n // Initialize a local cache to store the MRAM block\n DTYPE *cache_A = (DTYPE *) mem_alloc(BLOCK_SIZE);\n DTYPE *cache_aux_A = (DTYPE *) mem_alloc(BLOCK_SIZE);\n DTYPE *cache_aux_B = (DTYPE *) mem_alloc(BLOCK_SIZE);\n\n dpu_results_t *result = &DPU_RESULTS[tasklet_id];\n\n // TODO(bongjoon.hyun@gmail.com): original PrIM benchmark uses uint64_t for targets' type\n for(uint32_t targets = 0; targets < (DPU_INPUT_ARGUMENTS.slice_per_dpu / NR_TASKLETS); targets++)\n {\n found = -1;\n\n mram_read((__mram_ptr void const *) current_mram_block_addr_query, &searching_for, 8);\n current_mram_block_addr_query += 8;\n\n bool end = false;\n\n // Initialize input vector boundaries\n start_mram_block_addr_A = (uint32_t) DPU_MRAM_HEAP_POINTER;\n start_mram_block_addr_aux = start_mram_block_addr_A;\n end_mram_block_addr_A = start_mram_block_addr_A + sizeof(DTYPE) * input_size;\n\n uint32_t current_mram_block_addr_A = start_mram_block_addr_A;\n\n // Bring first and last values to WRAM\n mram_read((__mram_ptr void const *) current_mram_block_addr_A, cache_aux_A, BLOCK_SIZE);\n mram_read((__mram_ptr void const *) (end_mram_block_addr_A - BLOCK_SIZE * sizeof(DTYPE)), cache_aux_B, BLOCK_SIZE);\n\n current_mram_block_addr_A = (start_mram_block_addr_A + end_mram_block_addr_A) / 2;\n while(!end)\n {\n // Load cache with current MRAM block\n mram_read((__mram_ptr void const *) current_mram_block_addr_A, cache_A, BLOCK_SIZE);\n\n // Search inside block\n found = search(cache_A, searching_for);\n\n // If found > -1, we found the searching_for query\n if(found > -1)\n {\n result->found = found + (current_mram_block_addr_A - start_mram_block_addr_aux) / sizeof(DTYPE);\n break;\n }\n\n // If found == -2, we need to discard right part of the input vector\n if(found == -2)\n {\n end_mram_block_addr_A = current_mram_block_addr_A;\n current_mram_block_addr_A = (current_mram_block_addr_A + start_mram_block_addr_A) / 2;\n }\n\n // If found == -1, we need to discard left part of the input vector\n else if (found == -1)\n {\n start_mram_block_addr_A = current_mram_block_addr_A;\n current_mram_block_addr_A = (current_mram_block_addr_A + end_mram_block_addr_A) / 2;\n }\n\n // Start boundary check\n if(current_mram_block_addr_A < (start_mram_block_addr_aux + BLOCK_SIZE))\n {\n end = true;\n mram_read((__mram_ptr void const *) current_mram_block_addr_A, cache_A, BLOCK_SIZE);\n found = search(cache_A, searching_for);\n\n if(found > -1)\n {\n end = true;\n result->found = found + (current_mram_block_addr_A - start_mram_block_addr_aux) / sizeof(DTYPE);\n }\n }\n\n // End boundary check\n if(current_mram_block_addr_A > (end_mram_block_addr_A - BLOCK_SIZE))\n {\n end = true;\n mram_read((__mram_ptr void const *) end_mram_block_addr_A - BLOCK_SIZE, cache_A, BLOCK_SIZE);\n found = search(cache_A, searching_for);\n\n if(found > -1)\n {\n result->found = found + (current_mram_block_addr_A - start_mram_block_addr_aux) / sizeof(DTYPE);\n }\n }\n }\n }\n return 0;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/host/app.c",
"content": "/**\n* app.c\n* BS Host Application Source File\n*\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if ENERGY\n#include \n#endif\n\n#include \"params.h\"\n#include \"timer.h\"\n\n// Define the DPU Binary path as DPU_BINARY here\n#define DPU_BINARY \"./bin/bs_dpu\"\n\n// Create input arrays\nvoid create_test_file(DTYPE * input, DTYPE * querys, uint64_t nr_elements, uint64_t nr_querys) {\n\n\tinput[0] = 1;\n\tfor (uint64_t i = 1; i < nr_elements; i++) {\n\t\tinput[i] = input[i - 1] + 1;\n\t}\n\tfor (uint64_t i = 0; i < nr_querys; i++) {\n\t\tquerys[i] = i;\n\t}\n}\n\n// Compute output in the host\nint64_t binarySearch(DTYPE * input, DTYPE * querys, DTYPE input_size, uint64_t num_querys)\n{\n\tuint64_t result = -1;\n\tDTYPE r;\n\tfor(uint64_t q = 0; q < num_querys; q++)\n\t{\n\t\tDTYPE l = 0;\n\t\tr = input_size;\n\t\twhile (l <= r) {\n\t\t\tDTYPE m = l + (r - l) / 2;\n\n\t\t\t// Check if x is present at mid\n\t\t\tif (input[m] == querys[q])\n\t\t\tresult = m;\n\n\t\t\t// If x greater, ignore left half\n\t\t\tif (input[m] < querys[q])\n\t\t\tl = m + 1;\n\n\t\t\t// If x is smaller, ignore right half\n\t\t\telse\n\t\t\tr = m - 1;\n\t\t}\n\t}\n\treturn result;\n}\n\n\n// Main of the Host Application\nint main(int argc, char **argv) {\n\n\tstruct Params p = input_params(argc, argv);\n\tstruct dpu_set_t dpu_set, dpu;\n\tuint32_t nr_of_dpus;\n\tuint64_t input_size = INPUT_SIZE;\n\tuint64_t num_querys = p.num_querys;\n\tDTYPE result_host = -1;\n\tDTYPE result_dpu = -1;\n\n\t// Create the timer\n\tTimer timer;\n\n\t// Allocate DPUs and load binary\n\tDPU_ASSERT(dpu_alloc(NR_DPUS, NULL, &dpu_set));\n\tDPU_ASSERT(dpu_load(dpu_set, DPU_BINARY, NULL));\n\tDPU_ASSERT(dpu_get_nr_dpus(dpu_set, &nr_of_dpus));\n\n\t#if ENERGY\n\tstruct dpu_probe_t probe;\n\tDPU_ASSERT(dpu_probe_init(\"energy_probe\", &probe));\n\t#endif\n\n\t// Query number adjustement for proper partitioning\n\tif(num_querys % (nr_of_dpus * NR_TASKLETS))\n\tnum_querys = num_querys + (nr_of_dpus * NR_TASKLETS - num_querys % (nr_of_dpus * NR_TASKLETS));\n\n\tassert(num_querys % (nr_of_dpus * NR_TASKLETS) == 0 && \"Input dimension\"); // Allocate input and querys vectors\n\n\tDTYPE * input = malloc((input_size) * sizeof(DTYPE));\n\tDTYPE * querys = malloc((num_querys) * sizeof(DTYPE));\n\n\t// Create an input file with arbitrary data\n\tcreate_test_file(input, querys, input_size, num_querys);\n\n\t// Compute host solution\n\tstart(&timer, 0, 0);\n\tresult_host = binarySearch(input, querys, input_size - 1, num_querys);\n\tstop(&timer, 0);\n\n\t// Create kernel arguments\n\tuint64_t slice_per_dpu = num_querys / nr_of_dpus;\n\tdpu_arguments_t input_arguments = {input_size, slice_per_dpu, 0};\n\n\tfor (unsigned int rep = 0; rep < p.n_warmup + p.n_reps; rep++) {\n\t\t// Perform input transfers\n\t\tuint64_t i = 0;\n\n\t\tif (rep >= p.n_warmup)\n\t\tstart(&timer, 1, rep - p.n_warmup);\n\n\t\tDPU_FOREACH(dpu_set, dpu, i)\n\t\t{\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, &input_arguments));\n\t\t}\n\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, \"DPU_INPUT_ARGUMENTS\", 0, sizeof(input_arguments), DPU_XFER_DEFAULT));\n\n\t\ti = 0;\n\n\t\tDPU_FOREACH(dpu_set, dpu, i)\n\t\t{\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, input));\n\t\t}\n\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, input_size * sizeof(DTYPE), DPU_XFER_DEFAULT));\n\n\t\ti = 0;\n\n\t\tDPU_FOREACH(dpu_set, dpu, i)\n\t\t{\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, querys + slice_per_dpu * i));\n\t\t}\n\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, input_size * sizeof(DTYPE), slice_per_dpu * sizeof(DTYPE), DPU_XFER_DEFAULT));\n\n\t\tif (rep >= p.n_warmup)\n\t\tstop(&timer, 1);\n\n\t\t// Run kernel on DPUs\n\t\tif (rep >= p.n_warmup)\n\t\t{\n\t\t\tstart(&timer, 2, rep - p.n_warmup);\n\t\t\t#if ENERGY\n\t\t\tDPU_ASSERT(dpu_probe_start(&probe));\n\t\t\t#endif\n\t\t}\n\n\t\tDPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS));\n\n\t\tif (rep >= p.n_warmup)\n\t\t{\n\t\t\tstop(&timer, 2);\n\t\t\t#if ENERGY\n\t\t\tDPU_ASSERT(dpu_probe_stop(&probe));\n\t\t\t#endif\n\t\t}\n\t\t// Print logs if required\n\t\t#if PRINT\n\t\tunsigned int each_dpu = 0;\n\t\tprintf(\"Display DPU Logs\\n\");\n\t\tDPU_FOREACH(dpu_set, dpu)\n\t\t{\n\t\t\tprintf(\"DPU#%d:\\n\", each_dpu);\n\t\t\tDPU_ASSERT(dpulog_read_for_dpu(dpu.dpu, stdout));\n\t\t\teach_dpu++;\n\t\t}\n\t\t#endif\n\n\t\t// Retrieve results\n\t\tif (rep >= p.n_warmup)\n\t\tstart(&timer, 3, rep - p.n_warmup);\n\t\tdpu_results_t* results_retrieve[nr_of_dpus];\n\t\ti = 0;\n\t\tDPU_FOREACH(dpu_set, dpu, i)\n\t\t{\n\t\t\tresults_retrieve[i] = (dpu_results_t*)malloc(NR_TASKLETS * sizeof(dpu_results_t));\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, results_retrieve[i]));\n\t\t}\n\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, \"DPU_RESULTS\", 0, NR_TASKLETS * sizeof(dpu_results_t), DPU_XFER_DEFAULT));\n\n\t\tDPU_FOREACH(dpu_set, dpu, i)\n\t\t{\n\t\t\tfor(unsigned int each_tasklet = 0; each_tasklet < NR_TASKLETS; each_tasklet++)\n\t\t\t{\n\t\t\t\tif(results_retrieve[i][each_tasklet].found > result_dpu)\n\t\t\t\t{\n\t\t\t\t\tresult_dpu = results_retrieve[i][each_tasklet].found;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfree(results_retrieve[i]);\n\t\t}\n\t\tif(rep >= p.n_warmup)\n\t\tstop(&timer, 3);\n\t}\n\t// Print timing results\n\tprintf(\"CPU Version Time (ms): \");\n\tprint(&timer, 0, p.n_reps);\n\tprintf(\"CPU-DPU Time (ms): \");\n\tprint(&timer, 1, p.n_reps);\n\tprintf(\"DPU Kernel Time (ms): \");\n\tprint(&timer, 2, p.n_reps);\n\tprintf(\"DPU-CPU Time (ms): \");\n\tprint(&timer, 3, p.n_reps);\n\n\t#if ENERGY\n\tdouble energy;\n\tDPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_AVERAGE, &energy));\n\tprintf(\"DPU Energy (J): %f\\t\", energy * num_iterations);\n\t#endif\n\n\tint status = (result_dpu == result_host);\n\tif (status) {\n\t\tprintf(\"[\" ANSI_COLOR_GREEN \"OK\" ANSI_COLOR_RESET \"] results are equal\\n\");\n\t} else {\n\t\tprintf(\"[\" ANSI_COLOR_RED \"ERROR\" ANSI_COLOR_RESET \"] results differ!\\n\");\n\t}\n\n\tfree(input);\n\tDPU_ASSERT(dpu_free(dpu_set));\n\n\treturn status ? 0 : 1;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/support/common.h",
"content": "#ifndef _COMMON_H_\n#define _COMMON_H_\n\n#ifdef TL\n#define TASKLETS_INITIALIZER TASKLETS(TL, main, 2048, 2)\n#define NB_OF_TASKLETS_PER_DPU TL\n#else\n#define TASKLETS_INITIALIZER TASKLETS(16, main, 2048, 2)\n#define NB_OF_TASKLETS_PER_DPU 16\n#endif\n\n// Transfer size between MRAM and WRAM\n#ifdef BL\n#define BLOCK_SIZE_LOG2 BL\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#else\n#define BLOCK_SIZE_LOG2 8\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#endif\n\n// Data type\n#define DTYPE int64_t\n\n// Vector size\n#define INPUT_SIZE 2048576\n\ntypedef struct {\n\tuint64_t input_size;\n\tuint64_t slice_per_dpu;\n\tenum kernels {\n\t\tkernel1 = 0,\n\t\tnr_kernels = 1,\n\t} kernel;\n} dpu_arguments_t;\n\n// Structures used by both the host and the dpu to communicate information\ntypedef struct {\n DTYPE found;\n} dpu_results_t;\n\n#ifndef ENERGY\n#define ENERGY 0\n#endif\n#define PRINT 0\n\n#define ANSI_COLOR_RED \"\\x1b[31m\"\n#define ANSI_COLOR_GREEN \"\\x1b[32m\"\n#define ANSI_COLOR_RESET \"\\x1b[0m\"\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/support/params.h",
"content": "#ifndef _PARAMS_H_\n#define _PARAMS_H_\n\n#include \"common.h\"\n\ntypedef struct Params {\n long num_querys;\n unsigned n_warmup;\n unsigned n_reps;\n}Params;\n\nvoid usage() {\n fprintf(stderr,\n \"\\nUsage: ./program [options]\"\n \"\\n\"\n \"\\nGeneral options:\"\n \"\\n -h help\"\n \"\\n -w # of untimed warmup iterations (default=1)\"\n \"\\n -e # of timed repetition iterations (default=3)\"\n \"\\n\"\n \"\\nBenchmark-specific options:\"\n \"\\n -i problem size (default=2 queries)\"\n \"\\n\");\n }\n\n struct Params input_params(int argc, char **argv) {\n struct Params p;\n p.num_querys = PROBLEM_SIZE;\n p.n_warmup = 1;\n p.n_reps = 3;\n\n int opt;\n while((opt = getopt(argc, argv, \"h:i:w:e:\")) >= 0) {\n switch(opt) {\n case 'h':\n usage();\n exit(0);\n break;\n case 'i': p.num_querys = atol(optarg); break;\n case 'w': p.n_warmup = atoi(optarg); break;\n case 'e': p.n_reps = atoi(optarg); break; \n\tdefault:\n \tfprintf(stderr, \"\\nUnrecognized option!\\n\");\n \tusage();\n \texit(0);\n }\n }\n assert(NR_DPUS > 0 && \"Invalid # of dpus!\");\n\n return p;\n }\n #endif\n"
},
{
"path": "golang/uPIMulator/benchmark/BS/support/timer.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#include \r\n\r\ntypedef struct Timer{\r\n\r\n struct timeval startTime[4];\r\n struct timeval stopTime[4];\r\n double time[4];\r\n\r\n}Timer;\r\n\r\nvoid start(Timer *timer, int i, int rep) {\r\n if(rep == 0) {\r\n timer->time[i] = 0.0;\r\n }\r\n gettimeofday(&timer->startTime[i], NULL);\r\n}\r\n\r\nvoid stop(Timer *timer, int i) {\r\n gettimeofday(&timer->stopTime[i], NULL);\r\n timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +\r\n (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);\r\n}\r\n\r\nvoid print(Timer *timer, int i, int REP) { printf(\"%f\\t\", timer->time[i] / (1000 * REP)); }\r\n"
},
{
"path": "golang/uPIMulator/benchmark/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 3.16)\n\nproject(benchmark)\n\nadd_subdirectory(BS)\nadd_subdirectory(GEMV)\nadd_subdirectory(HST-L)\nadd_subdirectory(HST-S)\nadd_subdirectory(MLP)\nadd_subdirectory(RED)\nadd_subdirectory(SCAN-RSS)\nadd_subdirectory(SCAN-SSA)\nadd_subdirectory(SEL)\nadd_subdirectory(TRNS)\nadd_subdirectory(TS)\nadd_subdirectory(UNI)\nadd_subdirectory(VA)\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/CMakeLists.txt",
"content": "#add_subdirectory(host)\r\nadd_subdirectory(dpu)"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/Makefile",
"content": "DPU_DIR := dpu\nHOST_DIR := host\nBUILDDIR ?= bin\nNR_TASKLETS ?= 16 \nBL ?= 10\nNR_DPUS ?= 1 \n\ndefine conf_filename\n\t${BUILDDIR}/.NR_DPUS_$(1)_NR_TASKLETS_$(2)_BL_$(3).conf\nendef\nCONF := $(call conf_filename,${NR_DPUS},${NR_TASKLETS},${BL})\n\nHOST_TARGET := ${BUILDDIR}/host_code\nDPU_TARGET := ${BUILDDIR}/dpu_code\n\nCOMMON_INCLUDES := support\nHOST_SOURCES := $(wildcard ${HOST_DIR}/*.c)\nDPU_SOURCES := $(wildcard ${DPU_DIR}/*.c)\n\n.PHONY: all clean test\n\n__dirs := $(shell mkdir -p ${BUILDDIR})\n\nCOMMON_FLAGS := -w -I${COMMON_INCLUDES}\nHOST_FLAGS := ${COMMON_FLAGS} -std=c11 -O3 `dpu-pkg-config --cflags --libs dpu` -DNR_TASKLETS=${NR_TASKLETS} -DNR_DPUS=${NR_DPUS} -DBL=${BL}\nDPU_FLAGS := ${COMMON_FLAGS} -O2 -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL}\n\nall: ${HOST_TARGET} ${DPU_TARGET}\n\n${CONF}:\n\t$(RM) $(call conf_filename,*,*)\n\ttouch ${CONF}\n\n${HOST_TARGET}: ${HOST_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\t$(CC) -o $@ ${HOST_SOURCES} ${HOST_FLAGS}\n\t$(CC) -S -o ${HOST_TARGET}.S ${HOST_SOURCES} ${HOST_FLAGS}\n\n${DPU_TARGET}: ${DPU_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\tdpu-upmem-dpurte-clang ${DPU_FLAGS} -o $@ ${DPU_SOURCES}\n\tdpu-upmem-dpurte-clang -S ${DPU_FLAGS} -o ${DPU_TARGET}.S ${DPU_SOURCES}\n\nclean:\n\t$(RM) -r $(BUILDDIR)\n\ntest: all\n\t./${HOST_TARGET} -m 1024 -n 1024\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_10_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_11_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_12_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_13_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_14_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_15_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_16",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_16_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_17_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_18_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_19_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_1_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_20_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_21_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_22_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_23_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_24_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_2_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_3_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_4_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_5_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_6_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_7_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_8_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/_NR_TASKLETS_9_BL_10.conf",
"content": ""
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/cpu/Makefile",
"content": "all:\n\t\tgcc -o gemv -fopenmp gemv_openmp.c \n\nclean:\n\t\trm gemv\n\n\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/cpu/README",
"content": "Matrix-Vector Multiplication (GEMV)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n ./gemv\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/cpu/gemv_openmp.c",
"content": "#include \n#include \n#include \"../../support/timer.h\"\n#include \"gemv_utils.h\"\n\nint main(int argc, char *argv[])\n{\n const size_t rows = 20480;\n const size_t cols = 8192;\n\n double **A, *b, *x;\n\n b = (double*) malloc(sizeof(double)*rows);\n x = (double*) malloc(sizeof(double)*cols);\n\n allocate_dense(rows, cols, &A);\n\n make_hilbert_mat(rows,cols, &A);\n\n#pragma omp parallel\n {\n#pragma omp for\n for (size_t i = 0; i < cols; i++) {\n x[i] = (double) i+1 ;\n }\n\n#pragma omp for\n for (size_t i = 0; i < rows; i++) {\n b[i] = (double) 0.0;\n }\n }\n\n Timer timer;\n start(&timer, 0, 0);\n\n\n gemv(A, x, rows, cols, &b);\n \n stop(&timer, 0);\n\n\n printf(\"Kernel \");\n print(&timer, 0, 1);\n printf(\"\\n\");\n\n#if 0\n print_vec(x, rows);\n print_mat(A, rows, cols);\n print_vec(b, rows);\n#endif\n\n printf(\"sum(x) = %f, sum(Ax) = %f\\n\", sum_vec(x,cols), sum_vec(b,rows));\n return 0;\n}\n\nvoid gemv(double** A, double* x, size_t rows, size_t cols, double** b) {\n#pragma omp parallel for\n for (size_t i = 0; i < rows; i ++ )\n for (size_t j = 0; j < cols; j ++ ) {\n (*b)[i] = (*b)[i] + A[i][j]*x[j];\n }\n}\n\nvoid make_hilbert_mat(size_t rows, size_t cols, double*** A) {\n#pragma omp parallel for\n for (size_t i = 0; i < rows; i++) {\n for (size_t j = 0; j < cols; j++) {\n (*A)[i][j] = 1.0/( (double) i + (double) j + 1.0);\n }\n }\n}\n\ndouble sum_vec(double* vec, size_t rows) {\n double sum = 0.0;\n#pragma omp parallel for reduction(+:sum)\n for (int i = 0; i < rows; i++) sum = sum + vec[i];\n return sum;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/cpu/gemv_utils.h",
"content": "void allocate_dense(size_t rows,size_t cols, double*** dense) {\n\n *dense = malloc(sizeof(double)*rows);\n **dense = malloc(sizeof(double)*rows*cols);\n\n for (size_t i=0; i < rows; i++ ) {\n (*dense)[i] = (*dense)[0] + i*cols;\n }\n\n}\n\nvoid print_mat(double** A, size_t rows, size_t cols) {\n for (size_t i = 0; i < rows; i++) {\n for (size_t j = 0; j < cols; j++) {\n printf(\"%f \", A[i][j]);\n }\n printf(\"\\n\");\n }\n}\n\nvoid print_vec(double* b, size_t rows) {\n for (size_t i = 0; i < rows; i++) {\n printf(\"%f\\n\", b[i]);\n }\n}\n\nvoid gemv(double** A, double* x, size_t rows, size_t cols, double** b);\nvoid make_hilbert_mat(size_t rows, size_t cols, double*** A);\ndouble sum_vec(double* vec, size_t rows);\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/gpu/Makefile",
"content": "all:\n\t/usr/local/cuda/bin/nvcc gemv.cu -I/usr/local/cuda/include -lm -o gemv\n\nclean:\n\trm gemv\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/gpu/README",
"content": "Matrix-Vector Multiplication (GEMV)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n ./gemv\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/baselines/gpu/gemv.cu",
"content": "#include \n#include \n#include \n#include \n\n#define THREAD 128\n\n#define T int\n\n__global__ void gemv(int m, int n, T *adim, T *b, T *d_ans);\n\nvoid cgemv(int m, int n, T *adim, T *b, T *d_ans);\n\ndouble gettime()\n{\nstruct timeval tv;\ngettimeofday(&tv, NULL);\nreturn tv.tv_sec + (double)tv.tv_usec*1.0e-6;\n}\n\nint main(int argc, char **argv)\n{\n/* for CPU */\nint i, j;\nint *bdim, *c, *ans, *h_ans;\n//double start, stop;\n//double cpu_time, gpu_time;\nint n = 8192;\nint m = 20480;\n\nbdim = (T*)malloc(sizeof(T) *m*n);\nc = (T*)malloc(sizeof(T) *n);\nans = (T*)malloc(sizeof(T) *m);\nh_ans = (T*)malloc(sizeof(T) *m);\n\n/* for GPU */\nT *d_bdim, *d_c, *d_ans;\ncudaMalloc((void **)&d_bdim, sizeof(T)*m*n);\ncudaMalloc((void **)&d_c, sizeof(T)*n);\ncudaMalloc((void **)&d_ans, sizeof(T)*m);\n\nfor(i = 0; i < n; i++)\n{\nc[i] = 1;\nfor(j = 0; j < m; j++)\nbdim[i*m+j] = 1;\n}\n\n//start = gettime();\ncgemv(m, n, bdim, c, ans);\n//stop = gettime();\n//cpu_time=stop - start;\n\n// Event creation\ncudaEvent_t start, stop;\ncudaEventCreate(&start);\ncudaEventCreate(&stop);\nfloat time1 = 0;\n\n\ncudaMemcpy(d_bdim, bdim, sizeof(T)*m*n, cudaMemcpyHostToDevice);\ncudaMemcpy(d_c, c, sizeof(T)*n, cudaMemcpyHostToDevice);\n\n// Start timer\ncudaEventRecord( start, 0 );\n//start = gettime();\ngemv<<>>(m, n, d_bdim, d_c, d_ans);\n//stop = gettime();\n// End timer\ncudaEventRecord( stop, 0 );\ncudaEventSynchronize( stop );\ncudaEventElapsedTime( &time1, start, stop );\n\n//gpu_time=stop - start;\n\ncudaMemcpy(h_ans, d_ans, sizeof(T)*m, cudaMemcpyDeviceToHost);\n\n//printf(\"cpu_time : %.6f[sec]\\n\",cpu_time);\n//printf(\"gpu_time : %.6f[sec]\\n\",gpu_time);\n//printf(\"%f x\\n\", cpu_time / gpu_time);\n\n\nfor(i = 0; i < m; i++)\nprintf(\"%d -- %d\\n\", ans[i], h_ans[i]);\n\nprintf(\"Execution time = %f ms\\n\", time1);\n\n\nfree(bdim);\nfree(c);\nfree(ans);\nfree(h_ans);\ncudaFree(d_bdim);\ncudaFree(d_c);\ncudaFree(d_ans);\n\nreturn 0;\n} \n\n__global__ void gemv(int m, int n, T* adim, T* b, T* d_ans)\n{\nint i;\nint div = n/THREAD;\n__shared__ T tmp[THREAD];\n\ntmp[threadIdx.x] = 0.0;\n\nfor(i = 0; i < div; i++)\n{\ntmp[threadIdx.x] += adim[blockIdx.x*n+i*THREAD+threadIdx.x] * b[i * THREAD + threadIdx.x];\n}\nif(threadIdx.x < m%THREAD)\ntmp[threadIdx.x] += adim[blockIdx.x*n+THREAD*div+threadIdx.x] * b[THREAD * div + threadIdx.x];\n\n__syncthreads();\n\nfor(i = THREAD / 2; i > 31; i = i / 2)\n{\nif(threadIdx.x < i)\ntmp[threadIdx.x] += tmp[threadIdx.x + i];\n__syncthreads();\n}\n\nif(threadIdx.x < 16)\n{\ntmp[threadIdx.x] += tmp[threadIdx.x + 16];\n__syncthreads();\ntmp[threadIdx.x] += tmp[threadIdx.x + 8];\n__syncthreads();\ntmp[threadIdx.x] += tmp[threadIdx.x + 4];\n__syncthreads();\ntmp[threadIdx.x] += tmp[threadIdx.x + 2];\n__syncthreads();\ntmp[threadIdx.x] += tmp[threadIdx.x + 1];\n__syncthreads();\n}\n\n\nif(threadIdx.x == 0)\nd_ans[blockIdx.x] = tmp[0];\n\n}\n\nvoid cgemv(int m, int n, T *adim, T *b, T *d_ans)\n{\nint i, j;\n\nfor(i = 0; i < m; i++)\nfor(j = 0; j < n; j++)\nd_ans[i] += adim[i*n+j] * b[j];\n\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/dpu/CMakeLists.txt",
"content": "SET(BL 10)\r\n\r\nset(CMAKE_C_COMPILER \"/root/upmem-2023.2.0-Linux-x86_64/bin/dpu-upmem-dpurte-clang\")\r\nset(CMAKE_C_FLAGS \"-w -I/root/uPIMulator/benchmark/GEMV/support -O2 -S -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL}\")\r\n\r\nfile(GLOB_RECURSE SRCS *.c)\r\n\r\nadd_executable(GEMV_device ${SRCS})\r\n\r\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/dpu/task.c",
"content": "/*\n * Matrix vector multiplication with multiple tasklet\n *\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../support/common.h\"\n\n__host dpu_arguments_t DPU_INPUT_ARGUMENTS;\n\n// GEMV\nvoid __attribute__ ((noinline)) gemv(T *bufferC, T *bufferA, T *bufferB, int pos) {\n\tfor (unsigned int i = 0; i < BLOCK_SIZE / sizeof(T); i++) {\n\t\tbufferC[pos] += bufferA[i] * bufferB[i];\n\t}\n\treturn;\n}\n\n// Barrier\nBARRIER_INIT(my_barrier, NR_TASKLETS);\n\n// main\nint main() {\n\tunsigned int tasklet_id = me();\n#if PRINT\n\tprintf(\"tasklet_id = %u\\n\", tasklet_id);\n#endif\n\tif (tasklet_id == 0){ // Initialize once the cycle counter\n\t\tmem_reset(); // Reset the heap\n\t}\n\t// Barrier\n\tbarrier_wait(&my_barrier);\n\n\tint32_t n_size = DPU_INPUT_ARGUMENTS.n_size;\n\tint32_t n_size_pad = DPU_INPUT_ARGUMENTS.n_size_pad;\n\tuint32_t nr_rows = DPU_INPUT_ARGUMENTS.nr_rows;\n\tuint32_t max_rows = DPU_INPUT_ARGUMENTS.max_rows;\n\n\n\tunsigned int nrows = nr_rows;\n\tunsigned int rows_per_tasklet; \n\tunsigned int start_row;\n\tunsigned int chunks = nrows / (NR_TASKLETS + NR_TASKLETS);\n\tunsigned int dbl_chunks = chunks + chunks; \n\trows_per_tasklet = dbl_chunks;\n\tunsigned int rest_rows = nrows % (NR_TASKLETS + NR_TASKLETS);\n\n\tif ((tasklet_id + tasklet_id) < rest_rows)\n\t\trows_per_tasklet += 2;\n\tif (rest_rows > 0) {\n\t\tif ((tasklet_id + tasklet_id) >= rest_rows) {\n\t\t\tunsigned int hlf_rest_rows = rest_rows >> 1;\n\t\t\tif ((rest_rows & 1) == 1)\n\t\t\t\tstart_row = (hlf_rest_rows + 1) * (dbl_chunks + 2) + (tasklet_id - 1 - hlf_rest_rows) * dbl_chunks;\n\t\t\telse\n\t\t\t\tstart_row = (hlf_rest_rows) * (dbl_chunks + 2) + (tasklet_id - hlf_rest_rows) * dbl_chunks;\n\t\t} else \n\t\t\tstart_row = tasklet_id * (dbl_chunks + 2);\n\t} else {\n\t\tstart_row = tasklet_id * (dbl_chunks);\n\t}\n\n\t// Address of the current row in MRAM\n\tuint32_t mram_base_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + start_row * n_size * sizeof(T));\n\tuint32_t mram_base_addr_B = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T));\n\tuint32_t mram_base_addr_C = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T) + n_size_pad * sizeof(T) + start_row * sizeof(T));\n\tuint32_t mram_temp_addr_A = mram_base_addr_A;\n\tuint32_t mram_temp_addr_B = mram_base_addr_B;\n\n\t// Inititalize a local cache to store the MRAM block\n\tT *cache_A = (T *) mem_alloc(BLOCK_SIZE + 8);\n\tT *cache_A_aux = (T *) mem_alloc(8);\n\tT *cache_B = (T *) mem_alloc(BLOCK_SIZE);\n\tT *cache_C = (T *) mem_alloc(8);\n\n\tint offset = 0;\n\n\t// Iterate over nr_rows\n\tfor (unsigned int i = start_row; i < start_row + rows_per_tasklet; i += 2) {\n\n\t\tmram_temp_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + i * n_size * sizeof(T));\n\t\tmram_temp_addr_B = mram_base_addr_B;\n\n\t\tcache_C[0] = 0;\n\t\tcache_C[1] = 0;\n\t\tfor(unsigned int pos = 0; pos < 2 && i + pos < nr_rows; pos++){\n\t\t\tint n = 0, j;\n\t\t\tfor (n = 0; n < (int32_t) (n_size - (BLOCK_SIZE/sizeof(T))); n += (BLOCK_SIZE / sizeof(T)))\n\t\t\t{\n\n\t\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE);\n\t\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE);\n\n\t\t\t\tif(offset)\n\t\t\t\t{\n\n\t\t\t\t\tfor(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) - 1; off++)\n\t\t\t\t\t{\n\t\t\t\t\t\tcache_A[off] = cache_A[off + 1];\n\t\t\t\t\t}\n\n\t\t\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE), cache_A_aux, 8);\n\n\t\t\t\t\tcache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0];\n\t\t\t\t}\n\n\t\t\t\t// Compute GEMV\n\t\t\t\tgemv(cache_C, cache_A, cache_B, pos);\n\n\t\t\t\t// Update memory addresses\n\t\t\t\tmram_temp_addr_A += BLOCK_SIZE;\n\t\t\t\tmram_temp_addr_B += BLOCK_SIZE;\n\t\t\t}\n\n\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE);\n\n\n\t\t\tif(offset)\n\t\t\t{\n\t\t\t\tfor(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) -1; off++)\n\t\t\t\t{\n\n\t\t\t\t\tcache_A[off] = cache_A[off + 1];\n\t\t\t\t}\n\n\t\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE ), cache_A_aux, 8);\n\n \t\t\t cache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0];\n\t\t\t}\n\n\n\t\t\tmram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE);\n\n\t\t\tfor (j = 0; j < (int) (n_size - n); j++) {\n\t\t\t\t// Compute GEMV\n\t\t\t\tif(j >= (int)(BLOCK_SIZE / sizeof(T))){ \n\t\t\t\t\tprintf(\"error\\n\");\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tcache_C[pos] += cache_A[j] * cache_B[j];\n\t\t\t}\n\n\n\t\t\tmram_temp_addr_A += (BLOCK_SIZE - ((BLOCK_SIZE / sizeof(T)) - (n_size - n)) * sizeof(T));\n\t\t\tmram_temp_addr_B = mram_base_addr_B;\n\n\t\t\tif(mram_temp_addr_A % 8 != 0)\n\t\t\t{\n\t\t\t\toffset = 1;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\toffset = 0;\n\t\t\t}\n\t\t}\n\t\t// Write cache to current MRAM block\n\t\tmram_write(cache_C, (__mram_ptr void *) (mram_base_addr_C), 8);\n\n\t\t// Update memory address\n\t\tmram_base_addr_C += 2 * sizeof(T);\n\n\t}\n\n\treturn 0;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/host/app.c",
"content": "/**\n * app.c\n * GEMV Host Application Source File\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if ENERGY\n#include \n#endif\n\n#include \"../support/common.h\"\n#include \"../support/timer.h\"\n#include \"../support/params.h\"\n\n// Define the DPU Binary path as DPU_BINARY here\n#ifndef DPU_BINARY\n#define DPU_BINARY \"./bin/gemv_dpu\"\n#endif\n\nstatic T* A;\nstatic T* B;\nstatic T* C;\nstatic T* C_dpu;\n\n// Create input arrays\nstatic void init_data(T* A, T* B, unsigned int m_size, unsigned int n_size) {\n\tsrand(0);\n\n\tfor (unsigned int i = 0; i < m_size * n_size; i++)\n\t{\n\t\tA[i] = (unsigned int) (rand()%50);\n\t}\n\n\tfor (unsigned int i = 0; i < n_size; i++)\n\t{\n\t\tB[i] = (unsigned int) (rand()%50);\n\t}\n}\n\n// Compute output in the host\nstatic void gemv_host(T* C, T* A, T* B, unsigned int m_size, unsigned int n_size) {\n\tfor (unsigned int i = 0; i < m_size; i++)\n\t{\n\t\tC[i] = 0;\n\t}\n\n\tfor (unsigned int m = 0; m < m_size; m++) {\n\t\tfor (unsigned int n = 0; n < n_size; n++)\n\t\t{\n\t\t\tC[m] += A[m * n_size + n] * B[n];\n\t\t}\n\t}\n}\n\n// Main of the Host Application\nint main(int argc, char **argv) {\n\n\tstruct Params p = input_params(argc, argv);\n\n\tstruct dpu_set_t dpu_set, dpu;\n\tuint32_t nr_of_dpus;\n\n\t// Allocate DPUs and load binary\n\tDPU_ASSERT(dpu_alloc(NR_DPUS, NULL, &dpu_set));\n\tDPU_ASSERT(dpu_load(dpu_set, DPU_BINARY, NULL));\n\tDPU_ASSERT(dpu_get_nr_dpus(dpu_set, &nr_of_dpus));\n\n#if ENERGY\n\tstruct dpu_probe_t probe;\n\tDPU_ASSERT(dpu_probe_init(\"energy_probe\", &probe));\n#endif\n\n\tunsigned int i;\n\tunsigned int m_size = p.m_size;\n\tunsigned int n_size = p.n_size;\n\n\t// Initialize help data\n\tdpu_info = (struct dpu_info_t *) malloc(nr_of_dpus * sizeof(struct dpu_info_t));\n\tdpu_arguments_t *input_args = (dpu_arguments_t *) malloc(nr_of_dpus * sizeof(dpu_arguments_t));\n\tuint32_t max_rows_per_dpu = 0;\n\tuint32_t n_size_pad = n_size;\n\tif(n_size % 2 == 1)\n\t{\n\t\tn_size_pad++;\n\t}\n\n\ti = 0;\n\tDPU_FOREACH(dpu_set, dpu, i) {\n\t\tuint32_t rows_per_dpu;\n\t\tuint32_t prev_rows_dpu = 0;\n\t\tuint32_t chunks = m_size / nr_of_dpus;\n\t\trows_per_dpu = chunks;\n\t\tuint32_t rest_rows = m_size % nr_of_dpus;\n\t\tif (i < rest_rows)\n\t\t\trows_per_dpu++;\n\t\tif (rest_rows > 0) {\n\t\t\tif (i >= rest_rows)\n\t\t\t\tprev_rows_dpu = rest_rows * (chunks + 1) + (i - rest_rows) * chunks;\n\t\t\telse\n\t\t\t\tprev_rows_dpu = i * (chunks + 1);\n\t\t} else {\n\t\t\tprev_rows_dpu = i * chunks;\n\t\t}\n\n\t\t// Keep max rows for parallel transfers\n\t\tuint32_t rows_per_dpu_pad = rows_per_dpu;\n\t\tif (rows_per_dpu_pad % 2 == 1) // 4-byte elements\n\t\t\trows_per_dpu_pad++;\n\t\tif (rows_per_dpu_pad > max_rows_per_dpu)\n\t\t\tmax_rows_per_dpu = rows_per_dpu_pad;\n\n\t\tdpu_info[i].rows_per_dpu = rows_per_dpu;\n\t\tdpu_info[i].rows_per_dpu_pad = rows_per_dpu_pad;\n\t\tdpu_info[i].prev_rows_dpu = prev_rows_dpu;\n\n\t\t// Copy input arguments to DPU\n\t\tinput_args[i].n_size = n_size;\n\t\tinput_args[i].n_size_pad = n_size_pad;\n\t\tinput_args[i].nr_rows = rows_per_dpu;\n\t}\n\n\tA = malloc(max_rows_per_dpu * nr_of_dpus * n_size_pad * sizeof(T));\n\tB = malloc(n_size_pad * sizeof(T));\n\tC = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T));\n\n\t// Initialize data with arbitrary data\n\tinit_data(A, B, m_size, n_size);\n\n\t// Timer\n\tTimer timer;\n\n\t// Compute output on CPU (performance comparison and verification purposes)\n\tstart(&timer, 0, 0);\n\tgemv_host(C, A, B, m_size, n_size);\n\tstop(&timer, 0);\n\tfor (unsigned int rep = 0; rep < p.n_warmup + p.n_reps; rep++) {\n\n\n\n\t\tif (rep >= p.n_warmup)\n\t\t\tstart(&timer, 1, rep - p.n_warmup);\n\t\t// Input arguments\n\t\ti = 0;\n\t\tDPU_FOREACH(dpu_set, dpu, i) {\n\t\t\t// Copy input arguments to DPU\n\t\t\tinput_args[i].max_rows = max_rows_per_dpu;\n\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, input_args + i));\n\t\t}\n\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, \"DPU_INPUT_ARGUMENTS\", 0, sizeof(dpu_arguments_t), DPU_XFER_DEFAULT));\n\n\t\t// Copy input array and vector\n\t\ti = 0;\n\t\tDPU_FOREACH(dpu_set, dpu, i) {\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, A + dpu_info[i].prev_rows_dpu * n_size));\n\t\t}\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, max_rows_per_dpu * n_size_pad * sizeof(T), DPU_XFER_DEFAULT));\n\t\tDPU_FOREACH(dpu_set, dpu, i) {\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, B));\n\t\t}\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) , n_size_pad * sizeof(T), DPU_XFER_DEFAULT));\n\n\t\tif (rep >= p.n_warmup)\n\t\t\tstop(&timer, 1);\n\n\t\t// Run kernel on DPUs\n\t\tif (rep >= p.n_warmup)\n\t\t{\n\t\t\tstart(&timer, 2, rep - p.n_warmup);\n#if ENERGY\n\t\t\tDPU_ASSERT(dpu_probe_start(&probe));\n#endif\n\t\t}\n\n\t\tDPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS));\n\n\t\tif (rep >= p.n_warmup)\n\t\t{\n\t\t\tstop(&timer, 2);\n#if ENERGY\n\t\t\tDPU_ASSERT(dpu_probe_stop(&probe));\n#endif\n\t\t}\n#if PRINT\n\t\t// Display DPU Logs\n\t\tDPU_FOREACH(dpu_set, dpu) {\n\t\t\tDPU_ASSERT(dpulog_read_for_dpu(dpu.dpu, stdout));\n\t\t}\n#endif\n\n\t\t// Retrieve results\n\t\tC_dpu = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T));\n\t\tif (rep >= p.n_warmup)\n\t\t\tstart(&timer, 3, rep - p.n_warmup);\n\t\ti = 0;\n\t\tDPU_FOREACH(dpu_set, dpu, i) {\n\t\t\tDPU_ASSERT(dpu_prepare_xfer(dpu, C_dpu + i * max_rows_per_dpu));\n\t\t}\n\t\tDPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) + n_size_pad * sizeof(T), max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT));\n\t\tif(rep >= p.n_warmup)\n\t\t\tstop(&timer, 3);\n\t}\n#if ENERGY\n\tdouble acc_energy, avg_energy, acc_time, avg_time;\n\tDPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_ACCUMULATE, &acc_energy));\n\tDPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_AVERAGE, &avg_energy));\n\tDPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_ACCUMULATE, &acc_time));\n\tDPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_AVERAGE, &avg_time));\n#endif\n\n\t// Print timing results\n\tprintf(\"CPU Version Time (ms): \");\n\tprint(&timer, 0, 1);\n\tprintf(\"CPU-DPU Time (ms): \");\n\tprint(&timer, 1, p.n_reps);\n\tprintf(\"DPU Kernel Time (ms): \");\n\tprint(&timer, 2, p.n_reps);\n\tprintf(\"DPU-CPU Time (ms): \");\n\tprint(&timer, 3, p.n_reps);\n\n#if ENERGY\n\tprintf(\"Energy (J): %f J\\t\", avg_energy);\n#endif\n\n\t// Check output\n\tbool status = true;\n\tunsigned int n,j;\n\ti = 0;\n\tfor (n = 0; n < nr_of_dpus; n++) {\n\t\tfor (j = 0; j < dpu_info[n].rows_per_dpu; j++) {\n\t\t\tif(C[i] != C_dpu[n * max_rows_per_dpu + j]) {\n\t\t\t\tstatus = false;\n#if PRINT\n\t//\t\t\tprintf(\"%d: %d -- %d\\n\", i, C[i], C_dpu[n * max_rows_per_dpu + j]);\n#endif\n\t\t\t}\n\t\t\ti++;\n\t\t}\n\t}\n\tif (status) {\n\t\tprintf(\"[\" ANSI_COLOR_GREEN \"OK\" ANSI_COLOR_RESET \"] Outputs are equal\\n\");\n\t} else {\n\t\tprintf(\"[\" ANSI_COLOR_RED \"ERROR\" ANSI_COLOR_RESET \"] Outputs differ!\\n\");\n\t}\n\n\t// Deallocation\n\tfree(A);\n\tfree(B);\n\tfree(C);\n\tfree(C_dpu);\n\tDPU_ASSERT(dpu_free(dpu_set));\n\n#if ENERGY\n\tDPU_ASSERT(dpu_probe_deinit(&probe));\n#endif\n\n\treturn status ? 0 : -1;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/support/common.h",
"content": "#ifndef _COMMON_H_\n#define _COMMON_H_\n\n// Structures used by both the host and the dpu to communicate information \ntypedef struct {\n uint32_t n_size;\n uint32_t n_size_pad;\n uint32_t nr_rows;\n uint32_t max_rows;\n} dpu_arguments_t;\n\n// Specific information for each DPU\nstruct dpu_info_t {\n uint32_t rows_per_dpu;\n uint32_t rows_per_dpu_pad;\n uint32_t prev_rows_dpu;\n};\nstruct dpu_info_t *dpu_info;\n\n// Transfer size between MRAM and WRAM\n#ifdef BL\n#define BLOCK_SIZE_LOG2 BL\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#else\n#define BLOCK_SIZE_LOG2 8\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#define BL BLOCK_SIZE_LOG2\n#endif\n\n// Data type\n#define T uint32_t\n\n#ifndef ENERGY\n#define ENERGY 0\n#endif\n#define PRINT 0\n\n#define ANSI_COLOR_RED \"\\x1b[31m\"\n#define ANSI_COLOR_GREEN \"\\x1b[32m\"\n#define ANSI_COLOR_RESET \"\\x1b[0m\"\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/support/params.h",
"content": "#ifndef _PARAMS_H_\n#define _PARAMS_H_\n\n#include \"common.h\"\n\ntypedef struct Params {\n unsigned int m_size;\n unsigned int n_size;\n unsigned int n_warmup;\n unsigned int n_reps;\n}Params;\n\nstatic void usage() {\n fprintf(stderr,\n \"\\nUsage: ./program [options]\"\n \"\\n\"\n \"\\nGeneral options:\"\n \"\\n -h help\"\n \"\\n -w # of untimed warmup iterations (default=1)\"\n \"\\n -e # of timed repetition iterations (default=3)\"\n \"\\n\"\n \"\\nBenchmark-specific options:\"\n \"\\n -m m_size (default=8192 elements)\"\n \"\\n -n n_size (default=8192 elements)\"\n \"\\n\");\n}\n\nstruct Params input_params(int argc, char **argv) {\n struct Params p;\n p.m_size = 8192;\n p.n_size = 8192;\n p.n_warmup = 1;\n p.n_reps = 3;\n\n int opt;\n while((opt = getopt(argc, argv, \"hm:n:w:e:\")) >= 0) {\n switch(opt) {\n case 'h':\n usage();\n exit(0);\n break;\n case 'm': p.m_size = atoi(optarg); break;\n case 'n': p.n_size = atoi(optarg); break;\n case 'w': p.n_warmup = atoi(optarg); break;\n case 'e': p.n_reps = atoi(optarg); break;\n default:\n fprintf(stderr, \"\\nUnrecognized option!\\n\");\n usage();\n exit(0);\n }\n }\n assert(NR_DPUS > 0 && \"Invalid # of dpus!\");\n\n return p;\n}\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/GEMV/support/timer.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#include \r\n\r\ntypedef struct Timer{\r\n\r\n struct timeval startTime[4];\r\n struct timeval stopTime[4];\r\n double time[4];\r\n\r\n}Timer;\r\n\r\nvoid start(Timer *timer, int i, int rep) {\r\n if(rep == 0) {\r\n timer->time[i] = 0.0;\r\n }\r\n gettimeofday(&timer->startTime[i], NULL);\r\n}\r\n\r\nvoid stop(Timer *timer, int i) {\r\n gettimeofday(&timer->stopTime[i], NULL);\r\n timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +\r\n (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);\r\n //printf(\"Time (ms): %f\\t\",((timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +\r\n // (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec)) / 1000);\r\n \r\n}\r\n\r\nvoid print(Timer *timer, int i, int REP) { printf(\"%f\\t\", timer->time[i] / (1000 * REP)); }\r\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/CMakeLists.txt",
"content": "#add_subdirectory(host)\r\nadd_subdirectory(dpu)"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/Makefile",
"content": "DPU_DIR := dpu\nHOST_DIR := host\nBUILDDIR ?= bin\nNR_TASKLETS ?= 16\nBL ?= 8\nNR_DPUS ?= 1\nNR_HISTO ?= 1\nENERGY ?= 0\n\ndefine conf_filename\n\t${BUILDDIR}/.NR_DPUS_$(1)_NR_TASKLETS_$(2)_BL_$(3)_NR_DPUS_$(4).conf\nendef\nCONF := $(call conf_filename,${NR_DPUS},${NR_TASKLETS},${BL},${NR_DPUS})\n\nHOST_TARGET := ${BUILDDIR}/host_code\nDPU_TARGET := ${BUILDDIR}/dpu_code\n\nCOMMON_INCLUDES := support\nHOST_SOURCES := $(wildcard ${HOST_DIR}/*.c)\nDPU_SOURCES := $(wildcard ${DPU_DIR}/*.c)\n\n.PHONY: all clean test\n\n__dirs := $(shell mkdir -p ${BUILDDIR})\n\nCOMMON_FLAGS := -w -I${COMMON_INCLUDES}\nHOST_FLAGS := ${COMMON_FLAGS} -std=c11 -O3 `dpu-pkg-config --cflags --libs dpu` -DNR_TASKLETS=${NR_TASKLETS} -DNR_DPUS=${NR_DPUS} -DBL=${BL} -DENERGY=${ENERGY}\nDPU_FLAGS := ${COMMON_FLAGS} -O2 -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL} -DNR_HISTO=${NR_HISTO} \n\nall: ${HOST_TARGET} ${DPU_TARGET}\n\n${CONF}:\n\t$(RM) $(call conf_filename,*,*)\n\ttouch ${CONF}\n\n${HOST_TARGET}: ${HOST_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\t$(CC) -o $@ ${HOST_SOURCES} ${HOST_FLAGS}\n\t$(CC) -S -o ${HOST_TARGET}.S ${HOST_SOURCES} ${HOST_FLAGS}\n\n${DPU_TARGET}: ${DPU_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\tdpu-upmem-dpurte-clang ${DPU_FLAGS} -o $@ ${DPU_SOURCES}\n\tdpu-upmem-dpurte-clang -S ${DPU_FLAGS} -o ${DPU_TARGET}.S ${DPU_SOURCES}\n\nclean:\n\t$(RM) -r $(BUILDDIR)\n\ntest: all\n\t./${HOST_TARGET}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/dpu/CMakeLists.txt",
"content": "SET(BL 10)\r\nSET(NR_HISTO 1)\r\n\r\nset(CMAKE_C_COMPILER \"/root/upmem-2023.2.0-Linux-x86_64/bin/dpu-upmem-dpurte-clang\")\r\nset(CMAKE_C_FLAGS \"-w -I/root/uPIMulator/benchmark/HST-L/support -O2 -S -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL} -DNR_HISTO=${NR_HISTO}\")\r\n\r\nfile(GLOB_RECURSE SRCS *.c)\r\n\r\nadd_executable(HST-L_device ${SRCS})\r\n\r\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/dpu/task.c",
"content": "/*\n* Histogram (HST-L) with multiple tasklets\n*\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../support/common.h\"\n\n__host dpu_arguments_t DPU_INPUT_ARGUMENTS;\n\n// Array for communication between adjacent tasklets\nuint32_t* message[NR_TASKLETS];\n// DPU histogram\nuint32_t* histo_dpu;\n\n// Barrier\nBARRIER_INIT(my_barrier, NR_TASKLETS);\nATOMIC_BIT_INIT(barriers_mutexes)[NR_HISTO];\nbarrier_t barriers[NR_HISTO];\n\n// Mutex\nmutex_id_t my_mutex[NR_HISTO];\n\n// Histogram in each tasklet\nvoid __attribute__ ((noinline)) histogram(uint32_t* histo, uint32_t bins, T *input, uint32_t histo_id, unsigned int l_size){\n for(unsigned int j = 0; j < l_size; j++) {\n T d = (input[j] * bins) >> DEPTH;\n mutex_lock(my_mutex[histo_id]);\n histo[d] += 1;\n mutex_unlock(my_mutex[histo_id]);\n }\n}\n\nextern int main_kernel1(void);\n\nint (*kernels[nr_kernels])(void) = {main_kernel1};\n\nint main(void) { \n // Kernel\n return kernels[DPU_INPUT_ARGUMENTS.kernel](); \n}\n\n// main_kernel1\nint main_kernel1() {\n unsigned int tasklet_id = me();\n#if PRINT\n printf(\"tasklet_id = %u\\n\", tasklet_id);\n#endif\n unsigned int l_tasklet_id = tasklet_id / NR_HISTO;\n unsigned int nr_l_tasklet = NR_TASKLETS / NR_HISTO;\n unsigned int my_histo_id = tasklet_id & (NR_HISTO - 1);\n\n if (tasklet_id == 0){ // Initialize once the cycle counter\n mem_reset(); // Reset the heap\n // Initialize barriers\n for (unsigned int each_barrier = 0; each_barrier < NR_HISTO; each_barrier++) {\n barriers[each_barrier].wait_queue = 0xff;\n barriers[each_barrier].count = nr_l_tasklet;\n barriers[each_barrier].initial_count = nr_l_tasklet;\n barriers[each_barrier].lock = (uint8_t) &ATOMIC_BIT_GET(barriers_mutexes)[each_barrier];\n }\n }\n // Barrier\n barrier_wait(&my_barrier);\n\n uint32_t input_size_dpu_bytes = DPU_INPUT_ARGUMENTS.size;\n uint32_t input_size_dpu_bytes_transfer = DPU_INPUT_ARGUMENTS.transfer_size; // Transfer input size per DPU in bytes\n uint32_t bins = DPU_INPUT_ARGUMENTS.bins;\n\n // Address of the current processing block in MRAM\n uint32_t base_tasklet = tasklet_id << BLOCK_SIZE_LOG2;\n uint32_t mram_base_addr_A = (uint32_t)DPU_MRAM_HEAP_POINTER;\n uint32_t mram_base_addr_histo = (uint32_t)(DPU_MRAM_HEAP_POINTER + input_size_dpu_bytes_transfer);\n\n // Initialize a local cache to store the MRAM block\n T *cache_A = (T *) mem_alloc(BLOCK_SIZE);\n\t\n // Local histogram\n if (tasklet_id < NR_HISTO){ // Allocate DPU histogram\n uint32_t *histo = (uint32_t *) mem_alloc(bins * sizeof(uint32_t));\n message[tasklet_id] = histo;\n }\n // Barrier\n barrier_wait(&barriers[my_histo_id]);\n\n uint32_t *my_histo = message[my_histo_id];\n\n // Initialize local histogram\n for(unsigned int i = l_tasklet_id; i < bins; i += nr_l_tasklet){\n my_histo[i] = 0;\n }\n // Barrier\n barrier_wait(&barriers[my_histo_id]);\n\n // Compute histogram\n for(unsigned int byte_index = base_tasklet; byte_index < input_size_dpu_bytes; byte_index += BLOCK_SIZE * NR_TASKLETS){\n\n // Bound checking\n uint32_t l_size_bytes = (byte_index + BLOCK_SIZE >= input_size_dpu_bytes) ? (input_size_dpu_bytes - byte_index) : BLOCK_SIZE;\n\n // Load cache with current MRAM block\n mram_read((const __mram_ptr void*)(mram_base_addr_A + byte_index), cache_A, l_size_bytes);\n\n // Histogram in each tasklet\n histogram(my_histo, bins, cache_A, my_histo_id, l_size_bytes >> DIV);\n }\n\n // Barrier\n barrier_wait(&my_barrier);\n\n uint32_t *histo_dpu = message[0];\n for (unsigned int i = tasklet_id; i < bins; i += NR_TASKLETS){\n uint32_t b = 0;\n for (unsigned int j = 0; j < NR_HISTO; j++){\t\t\t\n b += *(message[j] + i);\n }\n histo_dpu[i] = b;\n }\n\n // Barrier\n barrier_wait(&my_barrier);\n\n // Write dpu histogram to current MRAM block\n if(tasklet_id == 0){\n if(bins * sizeof(uint32_t) <= 2048)\n mram_write(histo_dpu, (__mram_ptr void*)(mram_base_addr_histo), bins * sizeof(uint32_t));\n else \n for(unsigned int offset = 0; offset < ((bins * sizeof(uint32_t)) >> 11); offset++){\n \t mram_write(histo_dpu + (offset << 9), (__mram_ptr void*)(mram_base_addr_histo + (offset << 11)), 2048);\n }\n }\n\n return 0;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/host/app.c",
"content": "/**\n* app.c\n* HST-L Host Application Source File\n*\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../support/common.h\"\n#include \"../support/timer.h\"\n#include \"../support/params.h\"\n\n// Define the DPU Binary path as DPU_BINARY here\n#ifndef DPU_BINARY\n#define DPU_BINARY \"./bin/dpu_code\"\n#endif\n\n#if ENERGY\n#include \n#endif\n\n// Pointer declaration\nstatic T* A;\nstatic unsigned int* histo_host;\nstatic unsigned int* histo;\n\n// Create input arrays\nstatic void read_input(T* A, const Params p) {\n\n char dctFileName[100];\n FILE *File = NULL;\n\n // Open input file\n unsigned short temp;\n sprintf(dctFileName, p.file_name);\n if((File = fopen(dctFileName, \"rb\")) != NULL) {\n for(unsigned int y = 0; y < p.input_size; y++) {\n fread(&temp, sizeof(unsigned short), 1, File);\n A[y] = (unsigned int)ByteSwap16(temp);\n if(A[y] >= 4096)\n A[y] = 4095;\n }\n fclose(File);\n } else {\n printf(\"%s does not exist\\n\", dctFileName);\n exit(1);\n }\n}\n\n// Compute output in the host\nstatic void histogram_host(unsigned int* histo, T* A, unsigned int bins, unsigned int nr_elements, int exp, unsigned int nr_of_dpus) {\n if(!exp){\n for (unsigned int i = 0; i < nr_of_dpus; i++) {\n for (unsigned int j = 0; j < nr_elements; j++) {\n T d = A[j];\n histo[i * bins + ((d * bins) >> DEPTH)] += 1;\n }\n }\n }\n else{\n for (unsigned int j = 0; j < nr_elements; j++) {\n T d = A[j];\n histo[(d * bins) >> DEPTH] += 1;\n }\n }\n}\n\n// Main of the Host Application\nint main(int argc, char **argv) {\n\n struct Params p = input_params(argc, argv);\n\n struct dpu_set_t dpu_set, dpu;\n uint32_t nr_of_dpus;\n \n#if ENERGY\n struct dpu_probe_t probe;\n DPU_ASSERT(dpu_probe_init(\"energy_probe\", &probe));\n#endif\n\n // Allocate DPUs and load binary\n DPU_ASSERT(dpu_alloc(NR_DPUS, NULL, &dpu_set));\n DPU_ASSERT(dpu_load(dpu_set, DPU_BINARY, NULL));\n DPU_ASSERT(dpu_get_nr_dpus(dpu_set, &nr_of_dpus));\n printf(\"Allocated %d DPU(s)\\n\", nr_of_dpus);\n\n unsigned int i = 0;\n unsigned int input_size; // Size of input image\n unsigned int dpu_s = p.dpu_s;\n if(p.exp == 0)\n input_size = p.input_size * nr_of_dpus; // Size of input image\n else if(p.exp == 1)\n input_size = p.input_size; // Size of input image\n\telse\n input_size = p.input_size * dpu_s; // Size of input image\n\n const unsigned int input_size_8bytes = \n ((input_size * sizeof(T)) % 8) != 0 ? roundup(input_size, 8) : input_size; // Input size per DPU (max.), 8-byte aligned\n const unsigned int input_size_dpu = divceil(input_size, nr_of_dpus); // Input size per DPU (max.)\n const unsigned int input_size_dpu_8bytes = \n ((input_size_dpu * sizeof(T)) % 8) != 0 ? roundup(input_size_dpu, 8) : input_size_dpu; // Input size per DPU (max.), 8-byte aligned\n\n // Input/output allocation\n A = malloc(input_size_dpu_8bytes * nr_of_dpus * sizeof(T));\n T *bufferA = A;\n histo_host = malloc(p.bins * sizeof(unsigned int));\n histo = malloc(nr_of_dpus * p.bins * sizeof(unsigned int));\n\n // Create an input file with arbitrary data\n read_input(A, p);\n if(p.exp == 0){\n for(unsigned int j = 1; j < nr_of_dpus; j++){\n memcpy(&A[j * input_size_dpu_8bytes], &A[0], input_size_dpu_8bytes * sizeof(T));\n }\n }\n else if(p.exp == 2){\n for(unsigned int j = 1; j < dpu_s; j++)\n memcpy(&A[j * p.input_size], &A[0], p.input_size * sizeof(T));\n }\n\n // Timer declaration\n Timer timer;\n\n printf(\"NR_TASKLETS\\t%d\\tBL\\t%d\\tinput_size\\t%u\\n\", NR_TASKLETS, BL, input_size);\n\n // Loop over main kernel\n for(int rep = 0; rep < p.n_warmup + p.n_reps; rep++) {\n memset(histo_host, 0, p.bins * sizeof(unsigned int));\n memset(histo, 0, nr_of_dpus * p.bins * sizeof(unsigned int));\n\n // Compute output on CPU (performance comparison and verification purposes)\n if(rep >= p.n_warmup)\n start(&timer, 0, rep - p.n_warmup);\n histogram_host(histo_host, A, p.bins, p.input_size, 1, nr_of_dpus);\n if(rep >= p.n_warmup)\n stop(&timer, 0);\n\n printf(\"Load input data\\n\");\n if(rep >= p.n_warmup)\n start(&timer, 1, rep - p.n_warmup);\n // Input arguments\n unsigned int kernel = 0;\n i = 0;\n\t dpu_arguments_t input_arguments[NR_DPUS];\n\t for(i=0; i= p.n_warmup)\n stop(&timer, 1);\n\n printf(\"Run program on DPU(s) \\n\");\n // Run DPU kernel\n if(rep >= p.n_warmup) {\n start(&timer, 2, rep - p.n_warmup);\n #if ENERGY\n DPU_ASSERT(dpu_probe_start(&probe));\n #endif\n }\n DPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS));\n if(rep >= p.n_warmup) {\n stop(&timer, 2);\n #if ENERGY\n DPU_ASSERT(dpu_probe_stop(&probe));\n #endif\n }\n\n#if PRINT\n {\n unsigned int each_dpu = 0;\n printf(\"Display DPU Logs\\n\");\n DPU_FOREACH (dpu_set, dpu) {\n printf(\"DPU#%d:\\n\", each_dpu);\n DPU_ASSERT(dpulog_read_for_dpu(dpu.dpu, stdout));\n each_dpu++;\n }\n }\n#endif\n\n printf(\"Retrieve results\\n\");\n i = 0;\n if(rep >= p.n_warmup)\n start(&timer, 3, rep - p.n_warmup);\n // PARALLEL RETRIEVE TRANSFER\n DPU_FOREACH(dpu_set, dpu, i) {\n DPU_ASSERT(dpu_prepare_xfer(dpu, histo + p.bins * i));\n }\n DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, input_size_dpu_8bytes * sizeof(T), p.bins * sizeof(unsigned int), DPU_XFER_DEFAULT));\n\t\t\n // Final histogram merging\n for(i = 1; i < nr_of_dpus; i++){\n for(unsigned int j = 0; j < p.bins; j++){\n histo[j] += histo[j + i * p.bins];\n }\t\t\t\n }\t\t\n if(rep >= p.n_warmup)\n stop(&timer, 3);\n\n }\n\n // Print timing results\n printf(\"CPU \");\n print(&timer, 0, p.n_reps);\n printf(\"CPU-DPU \");\n print(&timer, 1, p.n_reps);\n printf(\"DPU Kernel \");\n print(&timer, 2, p.n_reps);\n printf(\"DPU-CPU \");\n print(&timer, 3, p.n_reps);\n\n #if ENERGY\n double energy;\n DPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_AVERAGE, &energy));\n printf(\"DPU Energy (J): %f\\t\", energy);\n #endif\t\n\n\n // Check output\n bool status = true;\n if(p.exp == 1) \n for (unsigned int j = 0; j < p.bins; j++) {\n if(histo_host[j] != histo[j]){ \n status = false;\n#if PRINT\n printf(\"%u - %u: %u -- %u\\n\", j, j, histo_host[j], histo[j]);\n#endif\n }\n }\n else if(p.exp == 2) \n for (unsigned int j = 0; j < p.bins; j++) {\n if(dpu_s * histo_host[j] != histo[j]){ \n status = false;\n#if PRINT\n printf(\"%u - %u: %u -- %u\\n\", j, j, dpu_s * histo_host[j], histo[j]);\n#endif\n }\n }\n else\n for (unsigned int j = 0; j < p.bins; j++) {\n if(nr_of_dpus * histo_host[j] != histo[j]){ \n status = false;\n#if PRINT\n printf(\"%u - %u: %u -- %u\\n\", j, j, nr_of_dpus * histo_host[j], histo[j]);\n#endif\n }\n }\n if (status) {\n printf(\"[\" ANSI_COLOR_GREEN \"OK\" ANSI_COLOR_RESET \"] Outputs are equal\\n\");\n } else {\n printf(\"[\" ANSI_COLOR_RED \"ERROR\" ANSI_COLOR_RESET \"] Outputs differ!\\n\");\n }\n\n // Deallocation\n free(A);\n free(histo_host);\n free(histo);\n DPU_ASSERT(dpu_free(dpu_set));\n\t\n return status ? 0 : -1;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/run.sh",
"content": "#!/bin/bash\n\nfor i in 1 \ndo\n\tfor b in 64 128 256 512 1024 2048 4096\n\tdo\n \tfor k in 1 2 4 8 16\n\t do\n\t NR_DPUS=$i NR_TASKLETS=$k BL=10 make all\n\t\t wait\n ./bin/host_code -w 2 -e 5 -b ${b} > profile/HSTL_${b}_tl${k}_dpu${i}.txt\n\t\t wait\n\t\t make clean\n\t\t wait\n\t\tdone\n\tdone\ndone\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/support/common.h",
"content": "#ifndef _COMMON_H_\n#define _COMMON_H_\n\n// Transfer size between MRAM and WRAM\n#ifdef BL\n#define BLOCK_SIZE_LOG2 BL\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#else\n#define BLOCK_SIZE_LOG2 8\n#define BLOCK_SIZE (1 << BLOCK_SIZE_LOG2)\n#define BL BLOCK_SIZE_LOG2\n#endif\n\n// Data type\n#define T uint32_t\n#define DIV 2 // Shift right to divide by sizeof(T)\n#define REGS (BLOCK_SIZE >> 2) // 32 bits\n\n// Pixel depth\n#define DEPTH 12\n#define ByteSwap16(n) (((((unsigned int)n) << 8) & 0xFF00) | ((((unsigned int)n) >> 8) & 0x00FF))\n\n// Structures used by both the host and the dpu to communicate information \ntypedef struct {\n uint32_t size;\n uint32_t transfer_size;\n uint32_t bins;\n\tenum kernels {\n\t kernel1 = 0,\n\t nr_kernels = 1,\n\t} kernel;\n} dpu_arguments_t;\n\n#ifndef ENERGY\n#define ENERGY 0\n#endif\n#define PRINT 0 \n\n#define ANSI_COLOR_RED \"\\x1b[31m\"\n#define ANSI_COLOR_GREEN \"\\x1b[32m\"\n#define ANSI_COLOR_RESET \"\\x1b[0m\"\n\n#define divceil(n, m) (((n)-1) / (m) + 1)\n#define roundup(n, m) ((n / m) * m + m)\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/support/params.h",
"content": "#ifndef _PARAMS_H_\n#define _PARAMS_H_\n\n#include \"common.h\"\n\ntypedef struct Params {\n unsigned int input_size;\n unsigned int bins;\n int n_warmup;\n int n_reps;\n const char *file_name;\n int exp;\n int dpu_s;\n}Params;\n\nstatic void usage() {\n fprintf(stderr,\n \"\\nUsage: ./program [options]\"\n \"\\n\"\n \"\\nGeneral options:\"\n \"\\n -h help\"\n \"\\n -w # of untimed warmup iterations (default=1)\"\n \"\\n -e # of timed repetition iterations (default=3)\"\n \"\\n -x Weak (0) or strong (1, 2) scaling (default=0)\"\n \"\\n\"\n \"\\nBenchmark-specific options:\"\n \"\\n -i input size (default=1536*1024 elements)\"\n \"\\n -b histogram size (default=256 bins)\"\n \"\\n -f input image file (default=../input/image_VanHateren.iml)\"\n \"\\n\");\n}\n\nstruct Params input_params(int argc, char **argv) {\n struct Params p;\n p.input_size = 1536 * 1024;\n p.bins = 256;\n p.n_warmup = 1;\n p.n_reps = 3;\n p.exp = 0;\n p.file_name = \"./input/image_VanHateren.iml\";\n p.dpu_s = 64;\n\n int opt;\n while((opt = getopt(argc, argv, \"hi:b:w:e:f:x:z:\")) >= 0) {\n switch(opt) {\n case 'h':\n usage();\n exit(0);\n break;\n case 'i': p.input_size = atoi(optarg); break;\n case 'b': p.bins = atoi(optarg); break;\n case 'w': p.n_warmup = atoi(optarg); break;\n case 'e': p.n_reps = atoi(optarg); break;\n case 'f': p.file_name = optarg; break;\n case 'x': p.exp = atoi(optarg); break;\n case 'z': p.dpu_s = atoi(optarg); break;\n default:\n fprintf(stderr, \"\\nUnrecognized option!\\n\");\n usage();\n exit(0);\n }\n }\n assert(NR_DPUS > 0 && \"Invalid # of dpus!\");\n\n return p;\n}\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-L/support/timer.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#include \r\n\r\ntypedef struct Timer{\r\n\r\n struct timeval startTime[4];\r\n struct timeval stopTime[4];\r\n double time[4];\r\n\r\n}Timer;\r\n\r\nvoid start(Timer *timer, int i, int rep) {\r\n if(rep == 0) {\r\n timer->time[i] = 0.0;\r\n }\r\n gettimeofday(&timer->startTime[i], NULL);\r\n}\r\n\r\nvoid stop(Timer *timer, int i) {\r\n gettimeofday(&timer->stopTime[i], NULL);\r\n timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +\r\n (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);\r\n}\r\n\r\nvoid print(Timer *timer, int i, int REP) { printf(\"Time (ms): %f\\t\", timer->time[i] / (1000 * REP)); }\r\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/CMakeLists.txt",
"content": "#add_subdirectory(host)\r\nadd_subdirectory(dpu)"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/Makefile",
"content": "DPU_DIR := dpu\nHOST_DIR := host\nBUILDDIR ?= bin\nNR_TASKLETS ?= 16\nBL ?= 10\nNR_DPUS ?= 1\nENERGY ?= 0\n\ndefine conf_filename\n\t${BUILDDIR}/.NR_DPUS_$(1)_NR_TASKLETS_$(2)_BL_$(3).conf\nendef\nCONF := $(call conf_filename,${NR_DPUS},${NR_TASKLETS},${BL})\n\nHOST_TARGET := ${BUILDDIR}/host_code\nDPU_TARGET := ${BUILDDIR}/dpu_code\n\nCOMMON_INCLUDES := support\nHOST_SOURCES := $(wildcard ${HOST_DIR}/*.c)\nDPU_SOURCES := $(wildcard ${DPU_DIR}/*.c)\n\n.PHONY: all clean test\n\n__dirs := $(shell mkdir -p ${BUILDDIR})\n\nCOMMON_FLAGS := -w -I${COMMON_INCLUDES}\nHOST_FLAGS := ${COMMON_FLAGS} -std=c11 -O3 `dpu-pkg-config --cflags --libs dpu` -DNR_TASKLETS=${NR_TASKLETS} -DNR_DPUS=${NR_DPUS} -DBL=${BL} -DENERGY=${ENERGY}\nDPU_FLAGS := ${COMMON_FLAGS} -O2 -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL}\n\nall: ${HOST_TARGET} ${DPU_TARGET}\n\n${CONF}:\n\t$(RM) $(call conf_filename,*,*)\n\ttouch ${CONF}\n\n${HOST_TARGET}: ${HOST_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\t$(CC) -o $@ ${HOST_SOURCES} ${HOST_FLAGS}\n\t$(CC) -S -o ${HOST_TARGET}.S ${HOST_SOURCES} ${HOST_FLAGS}\n\n${DPU_TARGET}: ${DPU_SOURCES} ${COMMON_INCLUDES} ${CONF}\n\tdpu-upmem-dpurte-clang ${DPU_FLAGS} -o $@ ${DPU_SOURCES}\n\tdpu-upmem-dpurte-clang -S ${DPU_FLAGS} -o ${DPU_TARGET}.S ${DPU_SOURCES}\n\nclean:\n\t$(RM) -r $(BUILDDIR)\n\ntest: all\n\t./${HOST_TARGET}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/cpu/Makefile",
"content": "all:\n\tgcc -o hist -fopenmp app_baseline.c \n\nclean:\n\trm hist\n\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/cpu/README",
"content": "Histogram - input partition (HST)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n ./hist -y 1006632960 -t 4\n\nFor more options:\n\n ./hsti -h\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/cpu/app_baseline.c",
"content": "/*\n* JGL@SAFARI\n*/\n\n/**\n* @file app.c\n* @brief Template for a Host Application Source File.\n*\n* The macros DPU_BINARY and NR_TASKLETS are directly\n* used in the static functions, and are not passed as arguments of these functions.\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"../../support/common.h\"\n#include \"../../support/timer.h\"\n\n// Pointer declaration\nstatic T* A;\nstatic unsigned int* histo_host;\n\ntypedef struct Params {\n unsigned int input_size;\n unsigned int bins;\n int n_warmup;\n int n_reps;\n const char *file_name;\n int exp;\n int n_threads;\n}Params;\n\n/**\n* @brief creates input arrays\n* @param nr_elements how many elements in input arrays\n*/\nstatic void read_input(T* A, const Params p) {\n\n char dctFileName[100];\n FILE *File = NULL;\n\n // Open input file\n unsigned short temp;\n sprintf(dctFileName, p.file_name);\n if((File = fopen(dctFileName, \"rb\")) != NULL) {\n for(unsigned int y = 0; y < p.input_size; y++) {\n fread(&temp, sizeof(unsigned short), 1, File);\n A[y] = (unsigned int)ByteSwap16(temp);\n if(A[y] >= 4096)\n A[y] = 4095;\n }\n fclose(File);\n } else {\n printf(\"%s does not exist\\n\", dctFileName);\n exit(1);\n }\n}\n\n/**\n* @brief compute output in the host\n*/\nstatic void histogram_host(unsigned int* histo, T* A, unsigned int bins, unsigned int nr_elements, int exp, unsigned int nr_of_dpus, int t) {\n\n omp_set_num_threads(t);\n\n if(!exp){\n #pragma omp parallel for\n for (unsigned int i = 0; i < nr_of_dpus; i++) {\n for (unsigned int j = 0; j < nr_elements; j++) {\n T d = A[j];\n histo[i * bins + ((d * bins) >> DEPTH)] += 1;\n }\n }\n }\n else{\n #pragma omp parallel for\n for (unsigned int j = 0; j < nr_elements; j++) {\n T d = A[j];\n #pragma omp atomic update\n histo[(d * bins) >> DEPTH] += 1;\n }\n }\n}\n\n// Params ---------------------------------------------------------------------\nvoid usage() {\n fprintf(stderr,\n \"\\nUsage: ./program [options]\"\n \"\\n\"\n \"\\nGeneral options:\"\n \"\\n -h help\"\n \"\\n -w # of untimed warmup iterations (default=1)\"\n \"\\n -e # of timed repetition iterations (default=3)\"\n \"\\n -t # of threads (default=8)\"\n \"\\n -x Weak (0) or strong (1) scaling (default=0)\"\n \"\\n\"\n \"\\nBenchmark-specific options:\"\n \"\\n -i input size (default=1536*1024 elements)\"\n \"\\n -b histogram size (default=256 bins)\"\n \"\\n -f input image file (default=../input/image_VanHateren.iml)\"\n \"\\n\");\n}\n\nstruct Params input_params(int argc, char **argv) {\n struct Params p;\n p.input_size = 1536 * 1024;\n p.bins = 256;\n p.n_warmup = 1;\n p.n_reps = 3;\n p.n_threads = 8;\n p.exp = 1;\n p.file_name = \"../../input/image_VanHateren.iml\";\n\n int opt;\n while((opt = getopt(argc, argv, \"hi:b:w:e:f:x:t:\")) >= 0) {\n switch(opt) {\n case 'h':\n usage();\n exit(0);\n break;\n case 'i': p.input_size = atoi(optarg); break;\n case 'b': p.bins = atoi(optarg); break;\n case 'w': p.n_warmup = atoi(optarg); break;\n case 'e': p.n_reps = atoi(optarg); break;\n case 'f': p.file_name = optarg; break;\n case 'x': p.exp = atoi(optarg); break;\n case 't': p.n_threads = atoi(optarg); break;\n default:\n fprintf(stderr, \"\\nUnrecognized option!\\n\");\n usage();\n exit(0);\n }\n }\n assert(p.n_threads > 0 && \"Invalid # of ranks!\");\n\n return p;\n}\n\n/**\n* @brief Main of the Host Application.\n*/\nint main(int argc, char **argv) {\n\n struct Params p = input_params(argc, argv);\n\n uint32_t nr_of_dpus;\n \n const unsigned int input_size = p.input_size; // Size of input image\n if(!p.exp)\n assert(input_size % p.n_threads == 0 && \"Input size!\");\n else\n assert(input_size % p.n_threads == 0 && \"Input size!\");\n\n // Input/output allocation\n A = malloc(input_size * sizeof(T));\n T *bufferA = A;\n if(!p.exp)\n histo_host = malloc(nr_of_dpus * p.bins * sizeof(unsigned int));\n else\n histo_host = malloc(p.bins * sizeof(unsigned int));\n\n // Create an input file with arbitrary data.\n read_input(A, p);\n\n Timer timer;\n start(&timer, 0, 0);\n\n\tif(!p.exp)\n memset(histo_host, 0, nr_of_dpus * p.bins * sizeof(unsigned int));\n else\n memset(histo_host, 0, p.bins * sizeof(unsigned int));\n\n histogram_host(histo_host, A, p.bins, input_size, p.exp, nr_of_dpus, p.n_threads);\n\n stop(&timer, 0);\n printf(\"Kernel \");\n print(&timer, 0, 1);\n printf(\"\\n\");\n\t\n return 0;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/Makefile",
"content": "# \n# Copyright (c) 2016 University of Cordoba and University of Illinois\n# All rights reserved.\n# \n# Developed by: IMPACT Research Group\n# University of Cordoba and University of Illinois\n# http://impact.crhc.illinois.edu/\n# \n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# with the Software without restriction, including without limitation the \n# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n# sell copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# \n# > Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimers.\n# > Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimers in the\n# documentation and/or other materials provided with the distribution.\n# > Neither the names of IMPACT Research Group, University of Cordoba, \n# University of Illinois nor the names of its contributors may be used \n# to endorse or promote products derived from this Software without \n# specific prior written permission.\n# \n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n# CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n# THE SOFTWARE.\n# \n\nCXX=/usr/local/cuda/bin/nvcc\nCXX_FLAGS=-std=c++11\n\nLIB=-L/usr/lib/ -L/usr/local/cuda/lib64 -lm\n\nINC=-I/usr/local/cuda/include\n\nDEP=kernel.cpp kernel.h main.cpp kernel.cu support/common.h support/cuda-setup.h support/partitioner.h support/timer.h support/verify.h\nSRC=main.cpp kernel.cpp kernel.cu\nEXE=hsti\n\nall:\n\t$(CXX) $(CXX_FLAGS) $(SRC) $(LIB) $(INC) -o $(EXE)\n\nclean:\n\trm -f $(EXE)\n\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/README",
"content": "Histogram - input partition (HST)\n\nCompilation instructions:\n\n make\n\nExecution instructions\n\n ./hsti -n 1006632960 -g 512\n\nFor more options:\n\n ./hsti -h\n\n\nNote:\nThe input folder contains one image from Van Hateren's natural image database \n(http://www.kyb.tuebingen.mpg.de/?id=227). Image pixels are 12-bit depth. Thus, \nfor calculation of the B-bin histogram of an image, the corresponding histogram \nbin is computed as ((pixel * B) >> 12).\nMonochrome images from other databases or synthetic images can also be used. The \nread input function (in main.cpp) might need to be changed accordingly. If image \npixels are b-bit depth and the histogram contains B bins, the histogram bin will \nbe computed as ((pixel * B) >> b).\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/kernel.cpp",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#include \"kernel.h\"\n#include \"support/partitioner.h\"\n#include \n#include \n#include \n#include \n\n// CPU threads--------------------------------------------------------------------------------------\nvoid run_cpu_threads(std::atomic_uint *histo, unsigned int *data, int size, int bins, int n_threads, int chunk, int n_tasks, float alpha\n#ifdef CUDA_8_0\n , std::atomic_int *worklist\n#endif\n ) {\n std::vector cpu_threads;\n for(int k = 0; k < n_threads; k++) {\n cpu_threads.push_back(std::thread([=]() {\n\n#ifdef CUDA_8_0\n Partitioner p = partitioner_create(n_tasks, alpha, k, n_threads, worklist);\n#else\n Partitioner p = partitioner_create(n_tasks, alpha, k, n_threads);\n#endif\n\n unsigned int Hs[bins];\n // Local histogram initialization\n for(int i = 0; i < bins; i++) {\n Hs[i] = 0;\n }\n\n for(int i = cpu_first(&p); cpu_more(&p); i = cpu_next(&p)) {\n for(int j = 0; j < chunk; j++) {\n // Read pixel\n unsigned int d = ((data[i * chunk + j] * bins) >> 12);\n\n // Vote in histogram\n Hs[d]++;\n }\n }\n\n // Merge to global histogram\n for(int i = 0; i < bins; i++) {\n (&histo[i])->fetch_add(Hs[i]);\n }\n\n }));\n }\n std::for_each(cpu_threads.begin(), cpu_threads.end(), [](std::thread &t) { t.join(); });\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/kernel.cu",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#define _CUDA_COMPILER_\n\n#include \"support/common.h\"\n#include \"support/partitioner.h\"\n\n// CUDA kernel ------------------------------------------------------------------------------------------\n__global__ void Histogram_kernel(int size, int bins, int n_tasks, float alpha, unsigned int *data,\n unsigned int *histo\n#ifdef CUDA_8_0\n , int *worklist\n#endif\n ) {\n\n extern __shared__ unsigned int l_mem[];\n unsigned int* l_histo = l_mem;\n#ifdef CUDA_8_0\n int* l_tmp = (int*)&l_histo[bins];\n#endif\n \n#ifdef CUDA_8_0\n Partitioner p = partitioner_create(n_tasks, alpha, worklist, l_tmp);\n#else\n Partitioner p = partitioner_create(n_tasks, alpha);\n#endif\n \n // Block and runtime index\n const int bx = blockIdx.x;\n const int tx = threadIdx.x;\n const int bD = blockDim.x;\n const int gD = gridDim.x;\n\n // Sub-histograms initialization\n for(int pos = tx; pos < bins; pos += bD) {\n l_histo[pos] = 0;\n }\n\n __syncthreads(); // Intra-block synchronization\n\n // Main loop\n for(int i = gpu_first(&p); gpu_more(&p); i = gpu_next(&p)) {\n \n // Global memory read\n unsigned int d = data[i * bD + tx];\n\n // Atomic vote in shared memory\n atomicAdd(&l_histo[((d * bins) >> 12)], 1);\n }\n\n __syncthreads(); // Intra-block synchronization\n\n // Merge per-block histograms and write to global memory\n for(int pos = tx; pos < bins; pos += bD) {\n// Atomic addition in global memory\n#ifdef CUDA_8_0\n atomicAdd_system(histo + pos, l_histo[pos]);\n#else\n atomicAdd(histo + pos, l_histo[pos]);\n#endif\n }\n}\n\ncudaError_t call_Histogram_kernel(int blocks, int threads, int size, int bins, int n_tasks, float alpha, \n unsigned int *data, unsigned int *histo, int l_mem_size\n#ifdef CUDA_8_0\n , int* worklist\n#endif\n ){\n dim3 dimGrid(blocks);\n dim3 dimBlock(threads);\n Histogram_kernel<<>>(size, bins, n_tasks, alpha, \n data, histo\n#ifdef CUDA_8_0\n , worklist\n#endif\n );\n cudaError_t err = cudaGetLastError();\n return err;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/kernel.h",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#include \n#include \n#include \"support/common.h\"\n\nvoid run_cpu_threads(std::atomic_uint *histo, unsigned int *data, int size, int bins, int num_threads, int chunk, int n_tasks, float alpha\n#ifdef CUDA_8_0\n , std::atomic_int *wl\n#endif\n );\n\ncudaError_t call_Histogram_kernel(int blocks, int threads, int size, int bins, int n_tasks, float alpha, \n unsigned int *data, unsigned int *histo, int l_mem_size\n#ifdef CUDA_8_0\n , int* worklist\n#endif\n\t\t);\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/main.cpp",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#include \"support/cuda-setup.h\"\n#include \"kernel.h\"\n#include \"support/common.h\"\n#include \"support/timer.h\"\n#include \"support/verify.h\"\n\n#include \n#include \n#include \n\n// Params ---------------------------------------------------------------------\nstruct Params {\n\n int device;\n int n_gpu_threads;\n int n_gpu_blocks;\n int n_threads;\n int n_warmup;\n int n_reps;\n float alpha;\n int in_size;\n int n_bins;\n\n Params(int argc, char **argv) {\n device = 0;\n n_gpu_threads = 256;\n n_gpu_blocks = 16;\n n_threads = 4;\n n_warmup = 5;\n n_reps = 50;\n alpha = 0.2;\n in_size = 1536 * 1024 * 640;\n n_bins = 256;\n int opt;\n while((opt = getopt(argc, argv, \"hd:i:g:t:w:r:a:n:b:\")) >= 0) {\n switch(opt) {\n case 'h':\n usage();\n exit(0);\n break;\n case 'd': device = atoi(optarg); break;\n case 'i': n_gpu_threads = atoi(optarg); break;\n case 'g': n_gpu_blocks = atoi(optarg); break;\n case 't': n_threads = atoi(optarg); break;\n case 'w': n_warmup = atoi(optarg); break;\n case 'r': n_reps = atoi(optarg); break;\n case 'a': alpha = atof(optarg); break;\n case 'n': in_size = atoi(optarg); break;\n case 'b': n_bins = atoi(optarg); break;\n default:\n fprintf(stderr, \"\\nUnrecognized option!\\n\");\n usage();\n exit(0);\n }\n }\n if(alpha == 0.0) {\n assert(n_gpu_threads > 0 && \"Invalid # of device threads!\");\n assert(n_gpu_blocks > 0 && \"Invalid # of device blocks!\");\n } else if(alpha == 1.0) {\n assert(n_threads > 0 && \"Invalid # of host threads!\");\n } else if(alpha > 0.0 && alpha < 1.0) {\n assert(n_gpu_threads > 0 && \"Invalid # of device threads!\");\n assert(n_gpu_blocks > 0 && \"Invalid # of device blocks!\");\n assert(n_threads > 0 && \"Invalid # of host threads!\");\n } else {\n#ifdef CUDA_8_0\n assert((n_gpu_threads > 0 && n_gpu_blocks > 0 || n_threads > 0) && \"Invalid # of host + device workers!\");\n#else\n assert(0 && \"Illegal value for -a\");\n#endif\n }\n }\n\n void usage() {\n fprintf(stderr,\n \"\\nUsage: ./hsti [options]\"\n \"\\n\"\n \"\\nGeneral options:\"\n \"\\n -h help\"\n \"\\n -d CUDA device ID (default=0)\"\n \"\\n -i # of device threads per block (default=256)\"\n \"\\n -g # of device blocks (default=16)\"\n \"\\n -t # of host threads (default=4)\"\n \"\\n -w # of untimed warmup iterations (default=5)\"\n \"\\n -r # of timed repetition iterations (default=50)\"\n \"\\n\"\n \"\\nData-partitioning-specific options:\"\n \"\\n -a fraction of input elements to process on host (default=0.2)\"\n#ifdef CUDA_8_0\n \"\\n NOTE: Dynamic partitioning used when is not between 0.0 and 1.0\"\n#else\n \"\\n NOTE: must be between 0.0 and 1.0\"\n#endif\n \"\\n\"\n \"\\nBenchmark-specific options:\"\n \"\\n -n input size (default=1572864, i.e., 1536x1024)\"\n \"\\n -b # of bins in histogram (default=256)\"\n \"\\n\");\n }\n};\n\n// Input Data -----------------------------------------------------------------\nvoid read_input(unsigned int *input, const Params &p) {\n\n char dctFileName[100];\n FILE *File = NULL;\n\n // Open input file\n unsigned short temp;\n sprintf(dctFileName, \"./input/image_VanHateren.iml\");\n if((File = fopen(dctFileName, \"rb\")) != NULL) {\n for(int y = 0; y < p.in_size; y++) {\n int fr = fread(&temp, sizeof(unsigned short), 1, File);\n input[y] = (unsigned int)ByteSwap16(temp);\n if(input[y] >= 4096)\n input[y] = 4095;\n }\n fclose(File);\n } else {\n printf(\"%s does not exist\\n\", dctFileName);\n exit(1);\n }\n}\n\n// Main ------------------------------------------------------------------------------------------\nint main(int argc, char **argv) {\n\n Params p(argc, argv);\n CUDASetup setcuda(p.device);\n Timer timer;\n cudaError_t cudaStatus;\n\n // Allocate buffers\n timer.start(\"Allocation\");\n int n_tasks = divceil(p.in_size, p.n_gpu_threads);\n#ifdef CUDA_8_0\n unsigned int *h_in;\n cudaStatus = cudaMallocManaged(&h_in, p.in_size * sizeof(unsigned int));\n std::atomic_uint *h_histo;\n cudaStatus = cudaMallocManaged(&h_histo, p.n_bins * sizeof(std::atomic_uint));\n unsigned int * d_in = h_in;\n std::atomic_uint *d_histo = h_histo;\n std::atomic_int * worklist;\n cudaStatus = cudaMallocManaged(&worklist, sizeof(std::atomic_int));\n#else\n unsigned int * h_in = (unsigned int *)malloc(p.in_size * sizeof(unsigned int));\n std::atomic_uint *h_histo = (std::atomic_uint *)malloc(p.n_bins * sizeof(std::atomic_uint));\n unsigned int * h_histo_merge = (unsigned int *)malloc(p.n_bins * sizeof(unsigned int));\n unsigned int * d_in;\n cudaStatus = cudaMalloc((void**)&d_in, p.in_size * sizeof(unsigned int));\n unsigned int * d_histo;\n cudaStatus = cudaMalloc((void**)&d_histo, p.n_bins * sizeof(unsigned int));\n ALLOC_ERR(h_in, h_histo, h_histo_merge);\n#endif\n CUDA_ERR();\n cudaDeviceSynchronize();\n timer.stop(\"Allocation\");\n timer.print(\"Allocation\", 1);\n\n // Initialize\n timer.start(\"Initialization\");\n const int max_gpu_threads = setcuda.max_gpu_threads();\n read_input(h_in, p);\n#ifdef CUDA_8_0\n for(int i = 0; i < p.n_bins; i++) {\n h_histo[i].store(0);\n }\n#else\n memset(h_histo, 0, p.n_bins * sizeof(unsigned int));\n#endif\n cudaDeviceSynchronize();\n timer.stop(\"Initialization\");\n timer.print(\"Initialization\", 1);\n\n#ifndef CUDA_8_0\n // Copy to device\n timer.start(\"Copy To Device\");\n cudaStatus = cudaMemcpy(d_in, h_in, p.in_size * sizeof(unsigned int), cudaMemcpyHostToDevice);\n cudaStatus = cudaMemcpy(d_histo, h_histo, p.n_bins * sizeof(unsigned int), cudaMemcpyHostToDevice);\n cudaDeviceSynchronize();\n CUDA_ERR();\n timer.stop(\"Copy To Device\");\n timer.print(\"Copy To Device\", 1);\n#endif\n\n // Loop over main kernel\n for(int rep = 0; rep < p.n_warmup + p.n_reps; rep++) {\n\n // Reset\n#ifdef CUDA_8_0\n if(p.alpha < 0.0 || p.alpha > 1.0) { // Dynamic partitioning\n worklist[0].store(0);\n }\n for(int i = 0; i < p.n_bins; i++) {\n h_histo[i].store(0);\n }\n#else\n memset(h_histo, 0, p.n_bins * sizeof(unsigned int));\n cudaStatus = cudaMemcpy(d_histo, h_histo, p.n_bins * sizeof(unsigned int), cudaMemcpyHostToDevice);\n cudaDeviceSynchronize();\n CUDA_ERR();\n#endif\n\n if(rep >= p.n_warmup)\n timer.start(\"Kernel\");\n\n p.n_gpu_blocks = p.in_size / p.n_gpu_threads;\n\n // Launch GPU threads\n // Kernel launch\n if(p.n_gpu_blocks > 0) {\n assert(p.n_gpu_threads <= max_gpu_threads && \n \"The runtime block size is greater than the maximum runtime block size that can be used on this device\");\n cudaStatus = call_Histogram_kernel(p.n_gpu_blocks, p.n_gpu_threads, p.in_size, p.n_bins, n_tasks, \n p.alpha, d_in, (unsigned int*)d_histo, p.n_bins * sizeof(unsigned int)\n#ifdef CUDA_8_0\n + sizeof(int), (int*)worklist\n#endif\n );\n CUDA_ERR();\n }\n\n // Launch CPU threads\n std::thread main_thread(run_cpu_threads, h_histo, h_in, p.in_size, p.n_bins, p.n_threads, p.n_gpu_threads,\n n_tasks, p.alpha\n#ifdef CUDA_8_0\n , worklist\n#endif\n );\n\n cudaDeviceSynchronize();\n main_thread.join();\n\n if(rep >= p.n_warmup)\n timer.stop(\"Kernel\");\n }\n timer.print(\"Kernel\", p.n_reps);\n\n#ifndef CUDA_8_0\n // Copy back\n timer.start(\"Copy Back and Merge\");\n cudaStatus = cudaMemcpy(h_histo_merge, d_histo, p.n_bins * sizeof(unsigned int), cudaMemcpyDeviceToHost);\n CUDA_ERR();\n cudaDeviceSynchronize();\n for(unsigned int i = 0; i < p.n_bins; ++i) {\n h_histo_merge[i] += (unsigned int)h_histo[i];\n }\n timer.stop(\"Copy Back and Merge\");\n timer.print(\"Copy Back and Merge\", 1);\n#endif\n\n // Verify answer\n#ifdef CUDA_8_0\n verify((unsigned int *)h_histo, h_in, p.in_size, p.n_bins);\n#else\n verify((unsigned int *)h_histo_merge, h_in, p.in_size, p.n_bins);\n#endif\n\n // Free memory\n timer.start(\"Deallocation\");\n#ifdef CUDA_8_0\n cudaStatus = cudaFree(h_in);\n cudaStatus = cudaFree(h_histo);\n cudaStatus = cudaFree(worklist);\n#else\n free(h_in);\n free(h_histo);\n free(h_histo_merge);\n cudaStatus = cudaFree(d_in);\n cudaStatus = cudaFree(d_histo);\n#endif\n CUDA_ERR();\n cudaDeviceSynchronize();\n timer.stop(\"Deallocation\");\n timer.print(\"Deallocation\", 1);\n\n // Release timers\n timer.release(\"Allocation\");\n timer.release(\"Initialization\");\n timer.release(\"Copy To Device\");\n timer.release(\"Kernel\");\n timer.release(\"Copy Back and Merge\");\n timer.release(\"Deallocation\");\n\n printf(\"Test Passed\\n\");\n return 0;\n}\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/support/common.h",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#ifndef _COMMON_H_\n#define _COMMON_H_\n\n#define ByteSwap16(n) (((((unsigned int)n) << 8) & 0xFF00) | ((((unsigned int)n) >> 8) & 0x00FF))\n\n#define PRINT 0\n\n#define divceil(n, m) (((n)-1) / (m) + 1)\n\n#endif\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/support/cuda-setup.h",
"content": "/*\n * Copyright (c) 2016 University of Cordoba and University of Illinois\n * All rights reserved.\n *\n * Developed by: IMPACT Research Group\n * University of Cordoba and University of Illinois\n * http://impact.crhc.illinois.edu/\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * with the Software without restriction, including without limitation the \n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * > Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimers.\n * > Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimers in the\n * documentation and/or other materials provided with the distribution.\n * > Neither the names of IMPACT Research Group, University of Cordoba, \n * University of Illinois nor the names of its contributors may be used \n * to endorse or promote products derived from this Software without \n * specific prior written permission.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\n * THE SOFTWARE.\n *\n */\n\n#include \n#include \n#include \n\n// Allocation error checking\n#define ERR_1(v1) \\\n if(v1 == NULL) { \\\n fprintf(stderr, \"Allocation error at %s, %d\\n\", __FILE__, __LINE__); \\\n exit(-1); \\\n }\n#define ERR_2(v1,v2) ERR_1(v1) ERR_1(v2)\n#define ERR_3(v1,v2,v3) ERR_2(v1,v2) ERR_1(v3)\n#define ERR_4(v1,v2,v3,v4) ERR_3(v1,v2,v3) ERR_1(v4)\n#define ERR_5(v1,v2,v3,v4,v5) ERR_4(v1,v2,v3,v4) ERR_1(v5)\n#define ERR_6(v1,v2,v3,v4,v5,v6) ERR_5(v1,v2,v3,v4,v5) ERR_1(v6)\n#define GET_ERR_MACRO(_1,_2,_3,_4,_5,_6,NAME,...) NAME\n#define ALLOC_ERR(...) GET_ERR_MACRO(__VA_ARGS__,ERR_6,ERR_5,ERR_4,ERR_3,ERR_2,ERR_1)(__VA_ARGS__)\n\n#define CUDA_ERR() \\\n if(cudaStatus != cudaSuccess) { \\\n fprintf(stderr, \"CUDA error: %s\\n at %s, %d\\n\", cudaGetErrorString(cudaStatus), __FILE__, __LINE__); \\\n exit(-1); \\\n }\n\nstruct CUDASetup {\n\n cudaDeviceProp device_prop;\n\n CUDASetup(int device) {\n cudaError_t cudaStatus;\n cudaStatus = cudaSetDevice(device);\n CUDA_ERR();\n\n cudaStatus = cudaGetDeviceProperties(&device_prop, device);\n CUDA_ERR();\n fprintf(stderr, \"%s\\t\", device_prop.name);\n\n }\n\n int max_gpu_threads() {\n return device_prop.maxThreadsPerBlock;\n }\n};\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/support/partitioner.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#ifndef _PARTITIONER_H_\r\n#define _PARTITIONER_H_\r\n\r\n#ifndef _CUDA_COMPILER_\r\n#include \r\n#endif\r\n\r\n#if !defined(_CUDA_COMPILER_) && defined(CUDA_8_0)\r\n#include \r\n#endif\r\n\r\n// Partitioner definition -----------------------------------------------------\r\n\r\ntypedef struct Partitioner {\r\n\r\n int n_tasks;\r\n int cut;\r\n int current;\r\n#ifndef _CUDA_COMPILER_\r\n int thread_id;\r\n int n_threads;\r\n#endif\r\n\r\n\r\n#ifdef CUDA_8_0\r\n // CUDA 8.0 support for dynamic partitioning\r\n int strategy;\r\n#ifdef _CUDA_COMPILER_\r\n int *worklist;\r\n int *tmp;\r\n#else\r\n std::atomic_int *worklist;\r\n#endif\r\n#endif\r\n\r\n} Partitioner;\r\n\r\n// Partitioning strategies\r\n#define STATIC_PARTITIONING 0\r\n#define DYNAMIC_PARTITIONING 1\r\n\r\n// Create a partitioner -------------------------------------------------------\r\n\r\n#ifdef _CUDA_COMPILER_\r\n__device__\r\n#endif\r\ninline Partitioner partitioner_create(int n_tasks, float alpha\r\n#ifndef _CUDA_COMPILER_\r\n , int thread_id, int n_threads\r\n#endif\r\n#ifdef CUDA_8_0\r\n#ifdef _CUDA_COMPILER_\r\n , int *worklist\r\n , int *tmp\r\n#else\r\n , std::atomic_int *worklist\r\n#endif\r\n#endif\r\n ) {\r\n Partitioner p;\r\n p.n_tasks = n_tasks;\r\n#ifndef _CUDA_COMPILER_\r\n p.thread_id = thread_id;\r\n p.n_threads = n_threads;\r\n#endif\r\n if(alpha >= 0.0 && alpha <= 1.0) {\r\n p.cut = p.n_tasks * alpha;\r\n#ifdef CUDA_8_0\r\n p.strategy = STATIC_PARTITIONING;\r\n#endif\r\n } else {\r\n#ifdef CUDA_8_0\r\n p.strategy = DYNAMIC_PARTITIONING;\r\n p.worklist = worklist;\r\n#ifdef _CUDA_COMPILER_\r\n p.tmp = tmp;\r\n#endif\r\n#endif\r\n }\r\n return p;\r\n}\r\n\r\n// Partitioner iterators: first() ---------------------------------------------\r\n\r\n#ifndef _CUDA_COMPILER_\r\n\r\ninline int cpu_first(Partitioner *p) {\r\n#ifdef CUDA_8_0\r\n if(p->strategy == DYNAMIC_PARTITIONING) {\r\n p->current = p->worklist->fetch_add(1);\r\n } else\r\n#endif\r\n {\r\n p->current = p->thread_id;\r\n }\r\n return p->current;\r\n}\r\n\r\n#else\r\n\r\n__device__ inline int gpu_first(Partitioner *p) {\r\n#ifdef CUDA_8_0\r\n if(p->strategy == DYNAMIC_PARTITIONING) {\r\n if(threadIdx.y == 0 && threadIdx.x == 0) {\r\n p->tmp[0] = atomicAdd_system(p->worklist, 1);\r\n }\r\n __syncthreads();\r\n p->current = p->tmp[0];\r\n } else\r\n#endif\r\n {\r\n p->current = p->cut + blockIdx.x;\r\n }\r\n return p->current;\r\n}\r\n\r\n#endif\r\n\r\n// Partitioner iterators: more() ----------------------------------------------\r\n\r\n#ifndef _CUDA_COMPILER_\r\n\r\ninline bool cpu_more(const Partitioner *p) {\r\n#ifdef CUDA_8_0\r\n if(p->strategy == DYNAMIC_PARTITIONING) {\r\n return (p->current < p->n_tasks);\r\n } else\r\n#endif\r\n {\r\n return (p->current < p->cut);\r\n }\r\n}\r\n\r\n#else\r\n\r\n__device__ inline bool gpu_more(const Partitioner *p) {\r\n return (p->current < p->n_tasks);\r\n}\r\n\r\n#endif\r\n\r\n// Partitioner iterators: next() ----------------------------------------------\r\n\r\n#ifndef _CUDA_COMPILER_\r\n\r\ninline int cpu_next(Partitioner *p) {\r\n#ifdef CUDA_8_0\r\n if(p->strategy == DYNAMIC_PARTITIONING) {\r\n p->current = p->worklist->fetch_add(1);\r\n } else\r\n#endif\r\n {\r\n p->current = p->current + p->n_threads;\r\n }\r\n return p->current;\r\n}\r\n\r\n#else\r\n\r\n__device__ inline int gpu_next(Partitioner *p) {\r\n#ifdef CUDA_8_0\r\n if(p->strategy == DYNAMIC_PARTITIONING) {\r\n if(threadIdx.y == 0 && threadIdx.x == 0) {\r\n p->tmp[0] = atomicAdd_system(p->worklist, 1);\r\n }\r\n __syncthreads();\r\n p->current = p->tmp[0];\r\n } else\r\n#endif\r\n {\r\n p->current = p->current + gridDim.x;\r\n }\r\n return p->current;\r\n}\r\n\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "golang/uPIMulator/benchmark/HST-S/baselines/gpu/support/timer.h",
"content": "/*\r\n * Copyright (c) 2016 University of Cordoba and University of Illinois\r\n * All rights reserved.\r\n *\r\n * Developed by: IMPACT Research Group\r\n * University of Cordoba and University of Illinois\r\n * http://impact.crhc.illinois.edu/\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * with the Software without restriction, including without limitation the \r\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\r\n * sell copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * > Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimers.\r\n * > Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimers in the\r\n * documentation and/or other materials provided with the distribution.\r\n * > Neither the names of IMPACT Research Group, University of Cordoba, \r\n * University of Illinois nor the names of its contributors may be used \r\n * to endorse or promote products derived from this Software without \r\n * specific prior written permission.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE \r\n * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH\r\n * THE SOFTWARE.\r\n *\r\n */\r\n\r\n#include \r\n#include \r\n#include \r\n#include