tboudreaux/GridFire
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(GridFire): updated outputs

Browse Source
This commit is contained in:
Emily Boudreaux
2026-04-13 07:19:18 -04:00
parent d1872cb65a
commit 5a1a904e71
10 changed files with 704 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
benchmarks/SingleZoneSolver/gf_wall_vs_temp.cpp Normal file
View File

@@ -0,0 +1,134 @@
// ReSharper disable CppUnusedIncludeDirective
#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
#include <format>
#include "gridfire/gridfire.h"
#include <cppad/utility/thread_alloc.hpp> // Required for parallel_setup
#include "fourdst/composition/composition.h"
#include "fourdst/logging/logging.h"
#include "fourdst/atomic/species.h"
#include "fourdst/composition/utils.h"
#include "quill/Logger.h"
#include "quill/Backend.h"
#include <clocale>
#include "gridfire/reaction/reaclib.h"
#include "gridfire/utils/gf_omp.h"
template <std::floating_point T>
[[nodiscard]] constexpr auto linspace(T start, T end, std::size_t num_points) -> std::vector<T> {
if (num_points == 0) {
return {};
}
if (num_points == 1) {
return {start};
}
return std::views::iota(0uz, num_points)
| std::views::transform([=](std::size_t i) -> T {
const T t = static_cast<T>(i) / static_cast<T>(num_points - 1);
return std::lerp(start, end, t);
})
| std::ranges::to<std::vector<T>>();
}
gridfire::NetIn init(const double temp, const double rho, const double tMax) {
std::setlocale(LC_ALL, "");
quill::Logger* logger = fourdst::logging::LogManager::getInstance().getLogger("log");
logger->set_log_level(quill::LogLevel::TraceL2);
using namespace gridfire;
const std::vector<double> X = {0.7081145999999999, 2.94e-5, 0.276, 0.003, 0.0011, 9.62e-3, 1.62e-3, 5.16e-4};
const std::vector<std::string> symbols = {"H-1", "He-3", "He-4", "C-12", "N-14", "O-16", "Ne-20", "Mg-24"};
const fourdst::composition::Composition composition = fourdst::composition::buildCompositionFromMassFractions(symbols, X);
NetIn netIn;
netIn.composition = composition;
netIn.temperature = temp;
netIn.density = rho;
netIn.energy = 0;
netIn.tMax = tMax;
netIn.dt0 = 1e-12;
return netIn;
}
int main() {
GF_PAR_INIT()
using namespace gridfire;
constexpr double temp_init = 1.5e7;
constexpr double rho_init = 1.5e2;
constexpr double tMax = 3.1536e+12;
NetIn netIn = init(temp_init, rho_init, tMax);
policy::MainSequencePolicy stellarPolicy(netIn.composition);
const policy::ConstructionResults construct = stellarPolicy.construct();
std::println("Sandbox Engine Stack: {}", stellarPolicy);
std::println("Scratch Blob State: {}", *construct.scratch_blob);
// arrays to store timings
// Total number of interpolated data points
constexpr size_t N = 20;
std::array<double, N*N> eval_times{};
auto density = linspace(10.0, 5.0e2, N);
auto temperature = linspace(4e6,3e7, N);
solver::PointSolverContext solverCtx(*construct.scratch_blob);
solverCtx.set_stdout_logging(false);
solver::PointSolver solver(construct.engine);
auto startTime = std::chrono::high_resolution_clock::now();
size_t i = 0;
for (const auto temp : temperature) {
for (const auto dens : density) {
std::println("Evaluation {:3}/{:5} ({:3.0f}%): ρ = {:10.4E}, T = {:10.4E}", i + 1, N*N, 100.0*((static_cast<double>(i)+1.0)/(N*N)), dens, temp);
netIn.temperature = temp;
netIn.density = dens;
try {
auto start_eval_time = std::chrono::high_resolution_clock::now();
const NetOut netOut = solver.evaluate(solverCtx, netIn);
auto end_eval_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> eval_elapsed = end_eval_time - start_eval_time;
eval_times[i] = eval_elapsed.count();
} catch (const gridfire::exceptions::GridFireError& e) {
std::cerr << "Error during evaluation " << (i + 1) << ": " << e.what() << std::endl;
eval_times[i] = std::numeric_limits<double>::quiet_NaN();
}
i++;
}
}
auto endTime = std::chrono::high_resolution_clock::now();
std::println("Total time for {} evaluations: {} seconds", N, (endTime - startTime).count());
for (size_t j = 0; j < static_cast<size_t>(N*N); ++j) {
std::println("Evaluation {}: {} seconds", j + 1, eval_times[j]);
}
std::ofstream outfile("gf_wall_vs_temp_results.csv");
outfile << "Evaluation,Density,Temperature,TimeSeconds\n";
size_t j = 0;
for (const auto temp: temperature) {
for (const auto dens: density ) {
outfile << (j + 1) << "," << dens << ","<< temp << "," << eval_times[j] << "\n";
j++;
}
}
}

232
benchmarks/SingleZoneSolver/main.cpp
View File

@@ -15,11 +15,15 @@
#include "quill/Logger.h"
#include "quill/Backend.h"
#include "nlohmann/json.hpp"
#include <clocale>
#include <sys/utsname.h>
#include "gridfire/reaction/reaclib.h"
#include "gridfire/utils/gf_omp.h"
#include "gridfire/utils/config.h"
gridfire::NetIn init(const double temp, const double rho, const double tMax) {
std::setlocale(LC_ALL, "");
@@ -63,97 +67,157 @@ int main() {
std::println("Scratch Blob State: {}", *construct.scratch_blob);
constexpr size_t runs = 10;
auto startTime = std::chrono::high_resolution_clock::now();
constexpr size_t runs = 100;
nlohmann::json results;
nlohmann::json metadata;
// arrays to store timings
std::array<std::chrono::duration<double>, runs> setup_times;
std::array<std::chrono::duration<double>, runs> eval_times;
std::array<NetOut, runs> serial_results;
for (size_t i = 0; i < runs; ++i) {
auto start_setup_time = std::chrono::high_resolution_clock::now();
solver::PointSolverContext solverCtx(*construct.scratch_blob);
solverCtx.set_stdout_logging(false);
solver::PointSolver solver(construct.engine);
auto end_setup_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> setup_elapsed = end_setup_time - start_setup_time;
setup_times[i] = setup_elapsed;
const auto now = std::chrono::system_clock::now();
std::string now_str = std::format("{:%Y-%m-%d %H:%M:%S}", now);
auto start_eval_time = std::chrono::high_resolution_clock::now();
const NetOut netOut = solver.evaluate(solverCtx, netIn);
auto end_eval_time = std::chrono::high_resolution_clock::now();
serial_results[i] = netOut;
std::chrono::duration<double> eval_elapsed = end_eval_time - start_eval_time;
eval_times[i] = eval_elapsed;
}
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = endTime - startTime;
std::println("");
metadata["Datetime"] = now_str;
metadata["GF_Version"] = version::toString();
// Summarize serial timings
double total_setup_time = 0.0;
double total_eval_time = 0.0;
for (size_t i = 0; i < runs; ++i) {
total_setup_time += setup_times[i].count();
total_eval_time += eval_times[i].count();
}
std::println("Average Setup Time over {} runs: {:.6f} seconds", runs, total_setup_time / runs);
std::println("Average Evaluation Time over {} runs: {:.6f} seconds", runs, total_eval_time / runs);
std::println("Total Time for {} runs: {:.6f} seconds", runs, elapsed.count());
std::array<NetOut, runs> parallelResults;
std::array<std::chrono::duration<double>, runs> setupTimes;
std::array<std::chrono::duration<double>, runs> evalTimes;
std::array<std::unique_ptr<gridfire::engine::scratch::StateBlob>, runs> workspaces;
for (size_t i = 0; i < runs; ++i) {
workspaces[i] = construct.scratch_blob->clone_structure();
utsname buffer{};
if (uname(&buffer) == 0) {
std::string osName = buffer.sysname;
#ifdef __APPLE__
if (osName == "Darwin") osName = "macOS";
#endif
metadata["OS"] = osName;
metadata["OS Version"] = buffer.release;
metadata["Architecture"] = buffer.machine;
} else {
metadata["OS"] = "Unknown";
}
#if defined(__clang__)
metadata["Compiler"] = "Clang " __clang_version__;
#elif defined(__GNUC__)
metadata["Compiler"] = "GCC " __VERSION__;
#else
metadata["Compiler"] = "Unknown";
#endif
// Parallel runs
startTime = std::chrono::high_resolution_clock::now();
metadata["Threads"] = omp_get_max_threads();
metadata["Runs"] = runs;
metadata["Temperature"] = temp;
metadata["Density"] = rho;
metadata["tMax_per_run_s"] = tMax;
GF_OMP(parallel for, for (size_t i = 0; i < runs; ++i)) {
auto start_setup_time = std::chrono::high_resolution_clock::now();
solver::PointSolverContext solverCtx(*construct.scratch_blob);
solverCtx.set_stdout_logging(false);
solver::PointSolver solver(construct.engine);
auto end_setup_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> setup_elapsed = end_setup_time - start_setup_time;
setupTimes[i] = setup_elapsed;
auto start_eval_time = std::chrono::high_resolution_clock::now();
parallelResults[i] = solver.evaluate(solverCtx, netIn);
auto end_eval_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> eval_elapsed = end_eval_time - start_eval_time;
evalTimes[i] = eval_elapsed;
}
endTime = std::chrono::high_resolution_clock::now();
elapsed = endTime - startTime;
std::println("");
results["Metadata"] = metadata;
// Summarize parallel timings
total_setup_time = 0.0;
total_eval_time = 0.0;
for (size_t i = 0; i < runs; ++i) {
total_setup_time += setupTimes[i].count();
total_eval_time += evalTimes[i].count();
for (size_t rID = 0; rID < runs; rID++) {
nlohmann::json run_result;
nlohmann::json run_metadata;
run_metadata["num_zones"] = rID;
run_result["metadata"] = run_metadata;
auto startTime = std::chrono::high_resolution_clock::now();
// arrays to store timings
std::array<std::chrono::duration<double>, runs> setup_times{};
std::array<std::chrono::duration<double>, runs> eval_times{};
std::array<NetOut, runs> serial_results;
for (size_t i = 0; i < rID; ++i) {
auto start_setup_time = std::chrono::high_resolution_clock::now();
solver::PointSolverContext solverCtx(*construct.scratch_blob);
solverCtx.set_stdout_logging(false);
solver::PointSolver solver(construct.engine);
auto end_setup_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> setup_elapsed = end_setup_time - start_setup_time;
setup_times[i] = setup_elapsed;
auto start_eval_time = std::chrono::high_resolution_clock::now();
const NetOut netOut = solver.evaluate(solverCtx, netIn);
auto end_eval_time = std::chrono::high_resolution_clock::now();
serial_results[i] = netOut;
std::chrono::duration<double> eval_elapsed = end_eval_time - start_eval_time;
eval_times[i] = eval_elapsed;
}
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = endTime - startTime;
std::println("");
nlohmann::json point_solver_time_results;
point_solver_time_results["total_time_s"] = elapsed.count();
run_result["Serial"] = point_solver_time_results;
// Summarize serial timings
double total_setup_time = 0.0;
double total_eval_time = 0.0;
for (size_t i = 0; i < rID; ++i) {
total_setup_time += setup_times[i].count();
total_eval_time += eval_times[i].count();
}
std::println("Average Setup Time over {} runs: {:.6f} seconds", runs, total_setup_time / runs);
std::println("Average Evaluation Time over {} runs: {:.6f} seconds", runs, total_eval_time / runs);
std::println("Total Time for {} runs: {:.6f} seconds", runs, elapsed.count());
std::array<NetOut, runs> parallelResults;
std::array<std::chrono::duration<double>, runs> setupTimes;
std::array<std::chrono::duration<double>, runs> evalTimes;
std::array<std::unique_ptr<gridfire::engine::scratch::StateBlob>, runs> workspaces;
for (size_t i = 0; i < rID; ++i) {
workspaces[i] = construct.scratch_blob->clone_structure();
}
// Parallel runs
startTime = std::chrono::high_resolution_clock::now();
GF_OMP(parallel for, for (size_t i = 0; i < rID; ++i)) {
auto start_setup_time = std::chrono::high_resolution_clock::now();
solver::PointSolverContext solverCtx(*construct.scratch_blob);
solverCtx.set_stdout_logging(false);
solver::PointSolver solver(construct.engine);
auto end_setup_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> setup_elapsed = end_setup_time - start_setup_time;
setupTimes[i] = setup_elapsed;
auto start_eval_time = std::chrono::high_resolution_clock::now();
parallelResults[i] = solver.evaluate(solverCtx, netIn);
auto end_eval_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> eval_elapsed = end_eval_time - start_eval_time;
evalTimes[i] = eval_elapsed;
}
endTime = std::chrono::high_resolution_clock::now();
elapsed = endTime - startTime;
std::println("");
nlohmann::json grid_solver_results;
grid_solver_results["total_time_s"] = elapsed.count();
run_result["Parallel"] = grid_solver_results;
// Summarize parallel timings
total_setup_time = 0.0;
total_eval_time = 0.0;
for (size_t i = 0; i < runs; ++i) {
total_setup_time += setupTimes[i].count();
total_eval_time += evalTimes[i].count();
}
std::println("Average Parallel Setup Time over {} runs: {:.6f} seconds", runs, total_setup_time / runs);
std::println("Average Parallel Evaluation Time over {} runs: {:.6f} seconds", runs, total_eval_time / runs);
std::println("Total Parallel Time for {} runs: {:.6f} seconds", runs, elapsed.count());
std::println("========== Summary ==========");
std::println("Serial Runs:");
std::println(" Average Setup Time: {:.6f} seconds", total_setup_time / runs);
std::println(" Average Evaluation Time: {:.6f} seconds", total_eval_time / runs);
std::println("Parallel Runs:");
std::println(" Average Setup Time: {:.6f} seconds", total_setup_time / runs);
std::println(" Average Evaluation Time: {:.6f} seconds", total_eval_time / runs);
std::println("Difference:");
std::println(" Setup Time Difference: {:.6f} seconds", (total_setup_time / runs) - (total_setup_time / runs));
std::println(" Evaluation Time Difference: {:.6f} seconds", (total_eval_time / runs) - (total_eval_time / runs));
std::println(" Setup Time Fractional Difference: {:.2f}%", ((total_setup_time / runs) - (total_setup_time / runs)) / (total_setup_time / runs) * 100.0);
std::println(" Evaluation Time Fractional Difference: {:.2f}%", ((total_eval_time / runs) - (total_eval_time / runs)) / (total_eval_time / runs) * 100.0);
results[std::format("Run_{}", rID)] = run_result;
}
std::println("Average Parallel Setup Time over {} runs: {:.6f} seconds", runs, total_setup_time / runs);
std::println("Average Parallel Evaluation Time over {} runs: {:.6f} seconds", runs, total_eval_time / runs);
std::println("Total Parallel Time for {} runs: {:.6f} seconds", runs, elapsed.count());
std::println("========== Summary ==========");
std::println("Serial Runs:");
std::println(" Average Setup Time: {:.6f} seconds", total_setup_time / runs);
std::println(" Average Evaluation Time: {:.6f} seconds", total_eval_time / runs);
std::println("Parallel Runs:");
std::println(" Average Setup Time: {:.6f} seconds", total_setup_time / runs);
std::println(" Average Evaluation Time: {:.6f} seconds", total_eval_time / runs);
std::println("Difference:");
std::println(" Setup Time Difference: {:.6f} seconds", (total_setup_time / runs) - (total_setup_time / runs));
std::println(" Evaluation Time Difference: {:.6f} seconds", (total_eval_time / runs) - (total_eval_time / runs));
std::println(" Setup Time Fractional Difference: {:.2f}%", ((total_setup_time / runs) - (total_setup_time / runs)) / (total_setup_time / runs) * 100.0);
std::println(" Evaluation Time Fractional Difference: {:.2f}%", ((total_eval_time / runs) - (total_eval_time / runs)) / (total_eval_time / runs) * 100.0);
}
std::ofstream o("gf_single_zone_solver_benchmark_results.json");
o << std::setw(4) << results << std::endl;
o.close();
}

6
benchmarks/SingleZoneSolver/meson.build
View File

@@ -3,3 +3,9 @@ executable(
'main.cpp',
dependencies: [gridfire_dep],
)
executable(
'gf_wall_vs_temp',
'gf_wall_vs_temp.cpp',
dependencies: [gridfire_dep]
)