Beispiel #1
0
int skel_main(int argc, char *argv[])
{

  main_program(argc, argv);
  main_exit();

 
  return(0);
}
Beispiel #2
0
//Program entry point
int main()
{
	setup();

	//If both buttons are pressed on startup enter test mode
	if(button_pressed(0) && button_pressed(1))
	{
		while(1)
			test_program();
	}
	else
	{
		while(1)
			main_program();
	}
	
	return 0;
}
int
main(int argc, char **argv)
{
    struct arg_int *channels  = arg_int0("c", "channels", "<n>", "define number of channels (default is 1)");
    struct arg_int *subscribers  = arg_int0("s", "subscribers", "<n>", "define number of subscribers (default is 1)");

    struct arg_str *server_name = arg_str0("S", "server", "<hostname>", "server hostname where messages will be published (default is \"127.0.0.1\")");
    struct arg_int *server_port = arg_int0("P", "port", "<n>", "server port where messages will be published (default is 9080)");

    struct arg_int *timeout = arg_int0(NULL, "timeout", "<n>", "timeout when waiting events on communication to the server (default is 1000)");
    struct arg_int *verbose = arg_int0("v", "verbose", "<n>", "increase output messages detail (0 (default) - no messages, 1 - info messages, 2 - debug messages, 3 - trace messages");

    struct arg_lit *help    = arg_lit0(NULL, "help", "print this help and exit");
    struct arg_lit *version = arg_lit0(NULL, "version", "print version information and exit");
    struct arg_end *end     = arg_end(20);

    void* argtable[] = { channels, subscribers, server_name, server_port, timeout, verbose, help, version, end };

    const char* progname = "subscriber";
    int nerrors;
    int exitcode = EXIT_SUCCESS;

    /* verify the argtable[] entries were allocated sucessfully */
    if (arg_nullcheck(argtable) != 0) {
        /* NULL entries were detected, some allocations must have failed */
        printf("%s: insufficient memory\n", progname);
        exitcode = EXIT_FAILURE;
        goto exit;
    }

    /* set any command line default values prior to parsing */
    subscribers->ival[0] = DEFAULT_CONCURRENT_CONN;
    channels->ival[0] = DEFAULT_NUM_CHANNELS;
    server_name->sval[0] = DEFAULT_SERVER_HOSTNAME;
    server_port->ival[0] = DEFAULT_SERVER_PORT;
    timeout->ival[0] = DEFAULT_TIMEOUT;
    verbose->ival[0] = 0;

    /* Parse the command line as defined by argtable[] */
    nerrors = arg_parse(argc, argv, argtable);

    /* special case: '--help' takes precedence over error reporting */
    if (help->count > 0) {
        printf(DESCRIPTION_SUBSCRIBER, progname, VERSION, COPYRIGHT);
        printf("Usage: %s", progname);
        arg_print_syntax(stdout, argtable, "\n");
        arg_print_glossary(stdout, argtable, "  %-25s %s\n");
        exitcode = EXIT_SUCCESS;
        goto exit;
    }

    /* special case: '--version' takes precedence error reporting */
    if (version->count > 0) {
        printf(DESCRIPTION_SUBSCRIBER, progname, VERSION, COPYRIGHT);
        exitcode = EXIT_SUCCESS;
        goto exit;
    }

    /* If the parser returned any errors then display them and exit */
    if (nerrors > 0) {
        /* Display the error details contained in the arg_end struct.*/
        arg_print_errors(stdout, end, progname);
        printf("Try '%s --help' for more information.\n", progname);
        exitcode = EXIT_FAILURE;
        goto exit;
    }

    verbose_messages = verbose->ival[0];

    /* normal case: take the command line options at face value */
    exitcode = main_program(channels->ival[0], subscribers->ival[0], server_name->sval[0], server_port->ival[0], timeout->ival[0]);

exit:
    /* deallocate each non-null entry in argtable[] */
    arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));

    return exitcode;
}
Beispiel #4
0
int
main()
try
{
	sge::opencl::system opencl_system;

	fcppt::io::cout()
		<< FCPPT_TEXT("Querying the number of available platforms...\n");

	sge::opencl::platform::object_sequence &platforms(
		opencl_system.platforms());

	if(platforms.empty())
	{
		fcppt::io::cerr()
			<< FCPPT_TEXT("Couldn't find any OpenCL platforms on your system.\n");
		return EXIT_FAILURE;
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Number of OpenCL platforms: ") << platforms.size() << FCPPT_TEXT("\n")
		<< FCPPT_TEXT("Platform listing begin:\n")
		<< FCPPT_TEXT("-----------------------\n");

	sge::opencl::platform::object_sequence::size_type platform_index = 0;
	for(
		sge::opencl::platform::object const &current_platform
		:
		platforms
	)
	{
		fcppt::io::cout()
			<< FCPPT_TEXT("\tPlatform ")
			<< platform_index++
			<< FCPPT_TEXT(":\n")
			<< FCPPT_TEXT("\tName: ")
			<< fcppt::from_std_string(
				current_platform.name()
			)
			<< FCPPT_TEXT("\n")
			<< FCPPT_TEXT("\tVendor: ")
			<< fcppt::from_std_string(
				current_platform.vendor()
			)
			<< FCPPT_TEXT("\n")
			<< FCPPT_TEXT("Profile type: ")
			<<
				(current_platform.profile() == sge::opencl::platform::profile_type::full
				?
					fcppt::string(FCPPT_TEXT("full"))
				:
					fcppt::string(FCPPT_TEXT("embedded")))
			<< FCPPT_TEXT("\n")
			<< FCPPT_TEXT("\tVersion: ")
			<< current_platform.version().major_part()
			<< FCPPT_TEXT(".")
			<< current_platform.version().minor_part()
			<< FCPPT_TEXT("\n");

		if(!current_platform.version().platform_specific().empty())
			fcppt::io::cout()
				<< FCPPT_TEXT("\tPlatform specific version info: ")
				<< fcppt::from_std_string(current_platform.version().platform_specific())
				<< FCPPT_TEXT("\n");

		fcppt::io::cout()
			<< FCPPT_TEXT("\tExtension list begin:\n")
			<< FCPPT_TEXT("\t*********************\n")
			<< FCPPT_TEXT("\t\t")
			<<
				fcppt::from_std_string(
					boost::algorithm::join(
						current_platform.extensions(),
						std::string("\n\t\t")))
			<< FCPPT_TEXT("\r\t*********************\n")
			<< FCPPT_TEXT("-----------------------\n");
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Platform listing end\n");

	sge::opencl::platform::object_sequence::size_type chosen_platform_index;
	if(platforms.size() == 1)
	{
		chosen_platform_index = 0;
	}
	else
	{
		fcppt::io::cout()
			<< FCPPT_TEXT("Your choice: ");
		do
			chosen_platform_index =
				query_value_from_user<sge::opencl::platform::object_sequence::size_type>(
					fcppt::io::cin());
		while(chosen_platform_index >= platforms.size());
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("List devices with properties? [y/n] ");

	fcppt::char_type list_devices;
	do
		list_devices =
			query_value_from_user<fcppt::char_type>(
				fcppt::io::cin());
	while(list_devices != FCPPT_TEXT('y') && list_devices != FCPPT_TEXT('n'));

	sge::opencl::platform::object &chosen_platform =
		platforms[chosen_platform_index];

	if(list_devices == FCPPT_TEXT('y'))
	{
		fcppt::io::cout()
			<< FCPPT_TEXT("Number of devices on this platform: ")
			<< chosen_platform.devices().size()
			<< FCPPT_TEXT('\n')
			<< FCPPT_TEXT("Device listing begin:\n")
			<< FCPPT_TEXT("-----------------------\n");

		for(
			sge::opencl::device::object const &current_device
			:
			chosen_platform.devices()
		)
		{
			current_device.output_info(
				std::cout);
			fcppt::io::cout()
				<< FCPPT_TEXT("-----------------------\n");
		}

		fcppt::io::cout()
			<< FCPPT_TEXT("-----------------------\n")
			<< FCPPT_TEXT("Device listing end\n");
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Creating sge::systems object...\n");

	sge::window::dim const window_dim{
		1024u,
		768u
	};

	sge::systems::instance<
		brigand::list<
			sge::systems::with_window,
			sge::systems::with_renderer<
				sge::systems::renderer_caps::core
			>
		>
	> const sys(
		sge::systems::make_list
		(
			// FIXME: Move this higher?
			sge::systems::config()
			.log_settings(
				sge::systems::log_settings{
					sge::log::option_container{
						sge::log::option{
							sge::opencl::log_location(),
							fcppt::log::level::verbose
						}
					}
				}
			)
		)
		(
			sge::systems::window(
				sge::systems::window_source(
					sge::systems::original_window(
						sge::window::title(
							FCPPT_TEXT("Simple OpenCL example")
						)
					)
				)
			)
			.dont_show()
		)
		(
			sge::systems::renderer(
				sge::renderer::pixel_format::object(
					sge::renderer::pixel_format::color::depth32,
					sge::renderer::pixel_format::depth_stencil::off,
					sge::renderer::pixel_format::optional_multi_samples(),
					sge::renderer::pixel_format::srgb::no
				),
				sge::renderer::display_mode::parameters(
					sge::renderer::display_mode::vsync::on,
					sge::renderer::display_mode::optional_object()
				),
				sge::viewport::optional_resize_callback{
					sge::viewport::center_on_resize(
						window_dim
					)
				}
			)
		)
	);

	fcppt::io::cout()
		<< FCPPT_TEXT("Done. Creating a context with all devices on this platform...\n");

	sge::opencl::device::object_ref_sequence const device_refs(
		fcppt::algorithm::map<
			sge::opencl::device::object_ref_sequence
		>(
			chosen_platform.devices(),
			[](
				sge::opencl::device::object &_device
			)
			{
				return
					fcppt::make_ref(
						_device
					);
			}
		)
	);

	sge::opencl::context::object main_context(
		sge::opencl::context::parameters(
			chosen_platform,
			device_refs
		)
		.share_with(
			sys.renderer_device_core())
		.error_callback(
			sge::opencl::context::error_callback{
				&opencl_error_callback
			}
		)
	);

	fcppt::io::cout()
		<< FCPPT_TEXT("Context created, listing available planar image formats (read/write)\n");

	sge::opencl::memory_object::image::format_sequence const planar_image_formats =
		main_context.supported_planar_image_formats(
			CL_MEM_READ_WRITE);

	for(
		auto const format
		:
		planar_image_formats
	)
	{
		sge::opencl::memory_object::image::format_output(
			std::cout,
			format
		);

		std::cout << '\n';
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Listing available volume image formats (read/write)...\n");

	sge::opencl::memory_object::image::format_sequence const volume_image_formats =
		main_context.supported_volume_image_formats(
			CL_MEM_READ_WRITE);

	for(
		auto const format
		:
		volume_image_formats
	)
	{
		sge::opencl::memory_object::image::format_output(
			std::cout,
			format
		);

		std::cout << '\n';
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Done, now creating a program...");

	sge::opencl::program::object main_program(
		sys.log_context(),
		main_context,
		sge::opencl::program::source_string_sequence{
			std::string(
				"__kernel void hello_kernel("
				"float const multiplier,"
				"__global float *input)"
				"{"
				"int gid = get_global_id(0);"
				"int lid = get_local_id(0);"
				"input[gid] = lid * multiplier;"
				"}"
			)
		},
		sge::opencl::program::optional_build_parameters());

	fcppt::io::cout()
		<< FCPPT_TEXT("Program created, building the program...\n");

	volatile bool build_finished =
		false;

	main_program.build(
		sge::opencl::program::build_parameters()
		.notification_callback(
			sge::opencl::program::notification_callback{
				std::bind(
					&program_build_finished,
					std::ref(
						build_finished
					)
				)
			}
		)
	);

	std::cout << "Waiting for build completion\n";
	while(!build_finished)
		std::cout << "Build not finished yet\n";

	fcppt::io::cout()
		<< FCPPT_TEXT("Program built, now creating a kernel...\n");

	sge::opencl::kernel::object main_kernel(
		main_program,
		sge::opencl::kernel::name(
			"hello_kernel"));

	fcppt::io::cout()
		<< FCPPT_TEXT("Kernel created, now creating a vertex buffer...\n");

	sge::renderer::vertex::declaration_unique_ptr const vertex_declaration(
		sys.renderer_device_core().create_vertex_declaration(
			sge::renderer::vertex::declaration_parameters(
				sge::renderer::vf::dynamic::make_format<vf::format>())));

	sge::renderer::vertex::buffer_unique_ptr const vb(
		sys.renderer_device_core().create_vertex_buffer(
			sge::renderer::vertex::buffer_parameters(
				*vertex_declaration,
				sge::renderer::vf::dynamic::make_part_index<
					vf::format,
					vf::part
				>(),
				sge::renderer::vertex::count(
					6u),
				sge::renderer::resource_flags_field{
					sge::renderer::resource_flags::readable})));

	fcppt::io::cout()
		<< FCPPT_TEXT("Done, now creating OpenCL buffer from it\n");

	sge::opencl::memory_object::buffer cl_vb(
		main_context,
		*vb,
		sge::opencl::memory_object::renderer_buffer_lock_mode::write_only);

	main_kernel.argument(
		sge::opencl::kernel::argument_index(
			1u),
		cl_vb);

	main_kernel.argument(
		sge::opencl::kernel::argument_index(
			0u),
		sge::opencl::kernel::numeric_type(
			static_cast<cl_float>(
				2.0
			)
		)
	);

	fcppt::io::cout()
		<< FCPPT_TEXT("Done, now creating a command queue\n");

	sge::opencl::command_queue::object main_queue(
		device_refs[0].get(),
		main_context,
		sge::opencl::command_queue::execution_mode::out_of_order,
		sge::opencl::command_queue::profiling_mode::disabled);

	fcppt::io::cout()
		<< FCPPT_TEXT("Done, now enqueueing kernel and running it\n");

	{
		sge::opencl::memory_object::scoped_objects scoped_vb(
			main_queue,
			sge::opencl::memory_object::base_ref_sequence{
				fcppt::reference_to_base<
					sge::opencl::memory_object::base
				>(
					fcppt::make_ref(
						cl_vb
					)
				)
			}
		);

		sge::opencl::command_queue::enqueue_kernel(
			main_queue,
			main_kernel,
			sge::opencl::command_queue::global_dim1(
				sge::opencl::dim1(
					vb->linear_size()
					* 2u
				)
			),
			sge::opencl::command_queue::local_dim1(
				sge::opencl::dim1(
					2u
				)
			),
			sge::opencl::event::sequence()
		);
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Now locking the vb for reading and printing the values\n");

	{
		sge::renderer::vertex::scoped_lock const scoped_vb(
			*vb,
			sge::renderer::lock_mode::readwrite);

		typedef
		sge::renderer::vf::view<vf::part>
		vertex_view;

		vertex_view const vertices(
			scoped_vb.value());

		for(
			auto const vertex
			:
			vertices
		)
		{
			fcppt::io::cout()
				<< vertex.get<vf::scalar_quantity>()
				<< FCPPT_TEXT('\n');
		}
	}

	fcppt::io::cout()
		<< FCPPT_TEXT("Done\n");
}
catch(
	fcppt::exception const &_error
)
{
	fcppt::io::cerr()
		<< _error.string()
		<< FCPPT_TEXT('\n');

	return EXIT_FAILURE;
}
catch(
	std::exception const &_error
)
{
	std::cerr
		<< _error.what()
		<< '\n';

	return EXIT_FAILURE;
}