Merge branch 'cuda_fix' into 'main' (594c51a6) · Commits · Cianciosa, Mark / graph_framework

graph_framework/cuda_context.hpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -746,6 +746,7 @@ namespace gpu {
		graph::output_nodes<T, SAFE_MATH> &outputs,
		graph::map_nodes<T, SAFE_MATH> &setters,
		jit::register_map &registers,
		jit::register_map &indices,
		const jit::register_usage &usage) {
		for (auto &[out, in] : setters) {
		graph::shared_leaf<T, SAFE_MATH> a = out->compile(source_buffer,

graph_korc/xkorc.cpp

+96 −57

Original line number	Diff line number	Diff line
		@@ -2,21 +2,17 @@
		#include "../graph_framework/timing.hpp"

		//------------------------------------------------------------------------------
		/// @brief Main program of the driver.
		/// @brief Run Korc
		///
		/// @param[in] argc Number of commandline arguments.
		/// @param[in] argv Array of commandline arguments.
		/// @tparam T Base type.
		//------------------------------------------------------------------------------
		int main(int argc, const char * argv[]) {
		START_GPU
		(void)argc;
		(void)argv;

		template<jit::float_scalar T>
		void run_korc() {
		const timeing::measure_diagnostic t_total("Total Time");

		const size_t num_particles = 10000000;
		const size_t num_particles = 1;
		std::cout << "Num particles " << num_particles << std::endl;
		std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<double>::max_concurrency()),
		std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<T>::max_concurrency()),
		static_cast<unsigned int> (num_particles)),
		static_cast<unsigned int> (1)));

		@@ -29,12 +25,12 @@ int main(int argc, const char * argv[]) {

		const timeing::measure_diagnostic t_setup("Setup Time");

		auto eq = equilibrium::make_efit<double> (EFIT_FILE);
		//auto eq = equilibrium::make_slab_density<double> ();
		auto eq = equilibrium::make_efit<T> (EFIT_FILE);
		//auto eq = equilibrium::make_slab_density<T> ();
		auto b0 = eq->get_characteristic_field(thread_number);
		const double q = 1.602176634E-19;
		const double me = 9.1093837139E-31;
		const double c = 299792458.0;
		const T q = 1.602176634E-19;
		const T me = 9.1093837139E-31;
		const T c = 299792458.0;

		auto gryo_period = me/(q*b0);
		std::cout << "gryo_period " << gryo_period->evaluate().at(0) << std::endl;
		@@ -43,17 +39,17 @@ int main(int argc, const char * argv[]) {

		std::cout << "Local num particles " << local_num_particles << std::endl;

		auto ux = graph::variable<double> (local_num_particles, "u_{x}");
		auto uy = graph::variable<double> (local_num_particles, "u_{y}");
		auto uz = graph::variable<double> (local_num_particles, "u_{z}");
		auto ux = graph::variable<T> (local_num_particles, "u_{x}");
		auto uy = graph::variable<T> (local_num_particles, "u_{y}");
		auto uz = graph::variable<T> (local_num_particles, "u_{z}");

		ux->set(0.99);
		uy->set(0.0);
		uz->set(0.0);
		ux->set(0.0);
		uy->set(0.99);
		uz->set(0.1);

		auto x = graph::variable<double> (local_num_particles, "x");
		auto y = graph::variable<double> (local_num_particles, "y");
		auto z = graph::variable<double> (local_num_particles, "z");
		auto x = graph::variable<T> (local_num_particles, "x");
		auto y = graph::variable<T> (local_num_particles, "y");
		auto z = graph::variable<T> (local_num_particles, "z");
		auto pos = graph::vector(x, y, z);

		x->set(1.7);
		@@ -62,9 +58,9 @@ int main(int argc, const char * argv[]) {

		auto u_vec = graph::vector(ux, uy, uz);

		auto gamma = graph::variable<double> (local_num_particles, "\\gamma");
		auto gamma = graph::variable<T> (local_num_particles, "\\gamma");

		auto dt = graph::constant<double> (0.25);
		auto dt = graph::constant<T> (0.25);

		auto gamma_init = 1.0/graph::sqrt(1.0 - u_vec->dot(u_vec));

		@@ -74,7 +70,7 @@ int main(int argc, const char * argv[]) {
		pos->get_y(),
		pos->get_z())/b0;

		workflow::manager<double> work(thread_number);
		workflow::manager<T> work(thread_number);
		work.add_preitem({
		graph::variable_cast(ux),
		graph::variable_cast(uy),
		@@ -103,7 +99,7 @@ int main(int argc, const char * argv[]) {

		auto u_next = (u_prime + u_prime_dot_t*t + u_prime->cross(t))/s;

		auto pos_next = pos + larmor_radiusdtu_next/gamma;
		auto pos_next = pos + larmor_radiusdtu_next/gamma_next;

		work.add_item({
		graph::variable_cast(x),
		@@ -124,14 +120,43 @@ int main(int argc, const char * argv[]) {
		}, "step");

		work.compile();

		std::ostringstream stream;
		stream << "korc_" << thread_number << ".nc";

		output::result_file file(stream.str(), local_num_particles);
		output::data_set<T> dataset(file);

		dataset.create_variable(file, "x", x, work.get_context());
		dataset.create_variable(file, "y", y, work.get_context());
		dataset.create_variable(file, "z", z, work.get_context());
		dataset.create_variable(file, "ux", ux, work.get_context());
		dataset.create_variable(file, "uy", uy, work.get_context());
		dataset.create_variable(file, "uz", uz, work.get_context());
		dataset.create_variable(file, "gamma", gamma, work.get_context());

		file.end_define_mode();
		std::thread sync([]{});

		t_setup.print();

		const timeing::measure_diagnostic t_run("Run Time");
		work.pre_run();
		for (size_t i = 0; i < 1000000; i++) {
		/*sync.join();
		work.wait();
		sync = std::thread([&file, &dataset] () -> void {
		dataset.write(file);
		});*/

		work.run();
		}
		work.wait();

		sync.join();
		dataset.write(file);
		work.wait();

		t_run.print();
		}, i);
		}
		@@ -142,6 +167,20 @@ int main(int argc, const char * argv[]) {

		std::cout << std::endl << "Timing:" << std::endl;
		t_total.print();
		}

		//------------------------------------------------------------------------------
		/// @brief Main program of the driver.
		///
		/// @param[in] argc Number of commandline arguments.
		/// @param[in] argv Array of commandline arguments.
		//------------------------------------------------------------------------------
		int main(int argc, const char * argv[]) {
		START_GPU
		(void)argc;
		(void)argv;

		run_korc<double> ();

		END_GPU
		}

graph_playground/xplayground.cpp

+44 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,10 @@
		//------------------------------------------------------------------------------
		#include "../graph_framework/jit.hpp"

		#include <numbers>

		#include "../graph_framework/equilibrium.hpp"

		//------------------------------------------------------------------------------
		/// @brief Main program of the playground.
		///
		@@ -17,7 +21,47 @@ int main(int argc, const char * argv[]) {

		// Insert code here. No code should be commited to this file beyond this
		// template.
		auto r = graph::variable<double> (1000, "r");
		auto phi = graph::variable<double> (1000, "\\phi");
		auto z = graph::variable<double> (1000, "z");

		auto eq = equilibrium::make_efit<double> (EFIT_FILE);

		auto bvec = eq->get_magnetic_field(r*graph::cos(phi),
		r*graph::sin(phi),
		z);

		bvec->get_x()->to_latex();
		std::cout << "\\\\" << std::endl;
		bvec->get_y()->to_latex();
		std::cout << "\\\\" << std::endl;
		bvec->get_z()->to_latex();
		std::cout << "\\\\" << std::endl;
		std::cout << std::endl << std::endl << std::endl;

		r->set(static_cast<double> (1.7));
		z->set(static_cast<double> (0.0));
		std::vector<double> temp(1000);
		for (size_t i = 0; i < 1000; i++) {
		temp[i] = 2.0std::numbers::pi_v<double>i/999.0;
		}
		phi->set(temp);

		workflow::manager<double> work(0);
		work.add_item({
		graph::variable_cast(r),
		graph::variable_cast(phi),
		graph::variable_cast(z)
		}, {
		bvec->get_x(),
		bvec->get_y(),
		bvec->get_z()
		}, {}, "bvec_kernel");
		work.compile();
		work.run();
		for (size_t i = 0; i < 1000; i++) {
		work.print(i, {r, phi, z, bvec->get_x(), bvec->get_y(), bvec->get_z()});
		}

		END_GPU
		}