void perror(int level, int errnum, const char *args, ...)
{
va_list ap;
#ifdef _USE_VTCODES
printf("\e[1m");
#endif
if(errnum>0)
{
if(ERROR_IS_WARNING(errnum))
printf("Warning: ");
else
printf("Error: ");
}
va_start(ap, args);
vprintf(args, ap);
va_end(ap);
#ifdef _USE_VTCODES
printf("\e[0m");
#endif
printf("\n");
if(errnum > 0)
describe_error(errnum);
}
void
open_device (dspdev_t * dsp)
{
const char * devdsp;
if (dsp->fd >= 0)
close_device (dsp);
dsp->format = 0; dsp->channels = 0; dsp->speed = 0;
if ((devdsp = getenv("OSS_AUDIODEV")) == NULL)
devdsp = "/dev/dsp";
if (raw_mode)
dsp->flags |= O_EXCL; /* Disable redirection to the virtual mixer */
if (dsp->dname[0] == '\0') strcpy (dsp->dname, devdsp);
if ((dsp->fd = open (dsp->dname, dsp->flags, 0)) == -1)
{
perror_msg (dsp->dname);
describe_error ();
exit (E_SETUP_ERROR);
}
if (raw_mode)
{
/*
* Disable sample rate/format conversions.
*/
int tmp = 0;
ioctl (dsp->fd, SNDCTL_DSP_COOKEDMODE, &tmp);
}
}
intmax_t handle_error (uintmax_t eflag, intmax_t errnum){ // {{{
const char *errmsg;
// check global_settings
if( (errmsg = describe_error(errnum)) == NULL)
goto exit;
fprintf(stderr, "%s\n", errmsg);
exit:
return errnum;
} // }}}
int
test_device(char *dn, int flags, testcfg_t *tcfg)
{
oss_audioinfo ainfo;
int code;
int fd;
fd = open(dn, O_WRONLY, 0);
if (fd == -1) {
int err = errno;
perror(dn);
errno = err;
describe_error(errno);
return (0);
}
ainfo.dev = -1;
if (ioctl(fd, SNDCTL_AUDIOINFO, &ainfo) == -1) {
perror("SNDCTL_AUDIOINFO");
(void) close(fd);
return (1);
}
(void) printf(_("\n*** Scanning sound adapter #%d ***\n"),
ainfo.card_number);
(void) printf(_("%s (audio engine %d): %s\n"), ainfo.devnode, ainfo.dev,
ainfo.name);
if (!ainfo.enabled) {
(void) printf(_(" - Device not present - Skipping\n"));
(void) close(fd);
return (1);
}
if (!(ainfo.caps & PCM_CAP_OUTPUT)) {
(void) printf(_(" - Skipping input only device\n"));
(void) close(fd);
return (1);
}
(void) printf(_(" - Performing audio playback test... "));
(void) fflush(stdout);
code = testdsp(fd, flags, tcfg);
(void) close(fd);
return (code == 1);
}
/* main program */
int main(int argc, char* argv[])
{
cl_float a_data[LENGTH];
cl_float b_data[LENGTH];
cl_float c_res [LENGTH];
cl_int rval;
size_t domain_size[1]; /* global domain size */
size_t workgroup_size[1];
cl_device_id device_id;
cl_context context;
cl_command_queue commands;
cl_program program_obj;
cl_kernel kernel;
cl_mem a_in; /* device memory for input vector a */
cl_mem b_in; /* device memory for input vector b */
cl_mem c_out; /* device memory for output vector c */
cl_uint count = LENGTH;
double start_time, end_time;
/* fill input vectors with random values */
for(int i = 0; i < count; ++i){
a_data[i] = rand() / (cl_float)RAND_MAX;
b_data[i] = rand() / (cl_float)RAND_MAX;
}
start_time = get_time();
cl_platform_id platform;
rval = clGetPlatformIDs(1, &platform, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not get platform", rval);
rval = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not get device ID", rval);
printf("Compute device:\n");
output_device_info(stdout, device_id, CL_FALSE);
/* create compute context */
context = clCreateContext(0, 1, &device_id, NULL, NULL, &rval);
if ((rval != CL_SUCCESS) || (context == NULL))
error_exit("Could not create compute context", rval);
/* create command queue */
commands = clCreateCommandQueue(context, device_id, 0, &rval);
if ((rval != CL_SUCCESS) || (commands == NULL))
error_exit("Could not create command queue", rval);
/* create compute program object from source buffer */
program_obj = clCreateProgramWithSource(context,
1, (const char **) &kernel_source, NULL, &rval);
if ((rval != CL_SUCCESS) || (program_obj == NULL))
error_exit("Could not create program object from source", rval);
/* build program object */
rval = clBuildProgram(program_obj, 0, NULL, NULL, NULL, NULL);
if (rval != CL_SUCCESS) {
size_t len;
char buffer[2048];
describe_error("Could not build executable", rval, stderr);
clGetProgramBuildInfo(program_obj, device_id, CL_PROGRAM_BUILD_LOG,
sizeof(buffer), buffer, &len);
fprintf(stderr, "%s\n", buffer);
return EXIT_FAILURE;
}
/* create compute kernel from program object */
kernel = clCreateKernel(program_obj, "vadd", &rval);
if ((rval != CL_SUCCESS) || (kernel == NULL))
error_exit("Could not create compute kernel", rval);
end_time = get_time();
printf("\nInitialization time %f seconds\n", end_time - start_time);
start_time = get_time();
/* create input (a, b) and output (c) arrays in device memory */
a_in = clCreateBuffer(context, CL_MEM_READ_ONLY,
sizeof(cl_float) * count, NULL, NULL);
b_in = clCreateBuffer(context, CL_MEM_READ_ONLY,
sizeof(cl_float) * count, NULL, NULL);
c_out= clCreateBuffer(context, CL_MEM_WRITE_ONLY,
sizeof(cl_float) * count, NULL, NULL);
if ((a_in == NULL) || (b_in == NULL) || (c_out== NULL))
error_exit("Could not allocate device memory", rval);
/* write a and b vectors into compute device memory */
rval = clEnqueueWriteBuffer(commands, a_in, CL_TRUE, 0,
sizeof(cl_float) * count, a_data, 0, NULL, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not copy a_data to device memory", rval);
rval = clEnqueueWriteBuffer(commands, b_in, CL_TRUE, 0,
sizeof(cl_float) * count, b_data, 0, NULL, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not copy b_data to device memory", rval);
end_time = get_time();
printf("Time to copy data %f seconds\n", end_time - start_time);
/* set arguments to compute kernel */
rval = 0;
rval = clSetKernelArg(kernel, 0, sizeof(cl_mem), &a_in);
rval |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &b_in);
rval |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &c_out);
rval |= clSetKernelArg(kernel, 3, sizeof(count), &count);
if (rval != CL_SUCCESS)
error_exit("Could not set kernel arguments", rval);
/* get maximum work group size for executing kernel on device */
rval = clGetKernelWorkGroupInfo(kernel, device_id,
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(workgroup_size[0]), workgroup_size, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not retrieve kernel work group info", rval);
start_time = get_time();
/* execute kernel over entire range of 1d input data set
using maximum number of work group items for device */
domain_size[0] = count;
rval = clEnqueueNDRangeKernel(commands, kernel, 1, NULL,
domain_size, workgroup_size, 0, NULL, NULL);
if (rval != CL_SUCCESS)
error_exit("Failed to execute kernel", rval);
/* wait for commands to complete before reading back results */
clFinish(commands);
end_time = get_time();
printf("TIme for kernel computation %f seconds\n", end_time - start_time);
/* read back results from compute device */
rval = clEnqueueReadBuffer(commands, c_out, CL_TRUE, 0,
sizeof(cl_float) * count, c_res, 0, NULL, NULL);
if (rval != CL_SUCCESS)
error_exit("Could not read output array", rval);
/* check results */
int correct = 0;
cl_float diff;
for(cl_uint i = 0; i < count; ++i)
{
diff = a_data[i] + b_data[i];
diff -= c_res[i];
if(diff*diff < TOL*TOL)
++correct;
else {
printf("difference %f in element %d: a %f b %f c %f\n",
diff, i, a_data[i], b_data[i], c_res[i]);
}
}
/* summarize results */
printf("\nC = A+B: %d out of %d results were correct\n",
correct, count);
/* clean up */
clReleaseMemObject(a_in);
clReleaseMemObject(b_in);
clReleaseMemObject(c_out);
clReleaseProgram(program_obj);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);
return EXIT_SUCCESS;
}
static ERL_NIF_TERM make_error_tuple(ErlNifEnv* env, int err) {
return enif_make_tuple2(env, ATOM_ERROR, describe_error(env, err));
}
int
main(int argc, char *argv[])
{
int t, i;
int maxdev;
int flags = 0;
int status = 0;
int numdev;
extern int optind;
testcfg_t *tcfg;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
tcfg = &test_stereo;
/*
* Simple command line switch handling.
*/
while ((i = getopt(argc, argv, "l2457")) != EOF) {
switch (i) {
case 'l':
flags |= TF_LOOP;
break;
case '2':
tcfg = &test_stereo;
break;
case '4':
tcfg = &test_quad;
break;
case '5':
tcfg = &test_51;
break;
case '7':
tcfg = &test_71;
break;
default:
(void) printf(_("Usage: %s [options...] [device]\n"
" -2 Stereo test\n"
" -4 Quadraphonic 4.0 test\n"
" -5 Surround 5.1 test\n"
" -7 Surround 7.1 test\n"
" -l Loop test\n"), argv[0]);
exit(-1);
}
}
/*
* Open the mixer device used for calling SNDCTL_SYSINFO and
* SNDCTL_AUDIOINFO.
*/
if ((mixerfd = open("/dev/mixer", O_RDWR, 0)) == -1) {
int err = errno;
perror("/dev/mixer");
errno = err;
describe_error(errno);
exit(-1);
}
prepare(tcfg); /* Prepare the wave data */
/*
* Enumerate all devices and play the test sounds.
*/
maxdev = find_num_devices();
if (maxdev < 1) {
(void) printf(_("\n*** No audio hardware available ***\n"));
exit(-1);
}
numdev = (argc - optind);
do {
char *dn;
oss_audioinfo ainfo;
if (numdev > 0) {
for (t = 0; t < numdev; t++) {
dn = argv[optind + t];
if (!test_device(dn, flags, tcfg))
status++;
}
} else {
for (t = 0; t < maxdev; t++) {
ainfo.dev = t;
if (ioctl(mixerfd, SNDCTL_AUDIOINFO,
&ainfo) == -1) {
perror("SNDCTL_AUDIOINFO");
status++;
continue;
}
dn = ainfo.devnode;
if (!test_device(dn, flags, tcfg))
status++;
}
}
if (status == 0)
(void) printf(_("\n*** All tests completed OK ***\n"));
else
(void) printf(_("\n*** Errors were detected ***\n"));
} while (flags & TF_LOOP);
(void) close(mixerfd);
return (status);
}
int main(int argc, char** argv) {
if(argc != 2 && argc != 3) {
c_print_format("Usage: %s FILE [cartridge/folder]\n", argv[0]);
return 0;
}
Arena arena = arena_create(MB(512));
String cartridge_folder_path_name = (argc > 2)
? string_from_c_string(argv[2])
: L("SuperMarioWorld.sfc");
Path cartridge_folder_path;
path_init(&cartridge_folder_path, cartridge_folder_path_name);
Path manifest_path;
path_init_from_c(&manifest_path, &cartridge_folder_path, "manifest.bml");
Buffer manifest_buffer = path_read_file(&manifest_path, &arena);
Wdc65816MapperBuilder rom_builder = { };
char name[256];
Buffer name_buffer = buffer(name, 256);
Buffer rom_buffer;
for(Wdc65816RomLoader loader = wdc65816_rom_loader_begin(&rom_builder,
string_from_buffer(manifest_buffer));
wdc65816_rom_loader_end(&loader);
wdc65816_rom_loader_next(&loader)) {
Wdc65816MemoryBufferRequest request = wdc65816_rom_loader_get_buffer_request(&loader,
name_buffer);
Buffer file_buffer = buffer(arena_alloc_array(&arena, request.size, u8), request.size);
if(string_equal(request.name, L("program.rom")) &&
request.type == WDC65816_MEMORY_ROM) {
rom_buffer = file_buffer;
}
wdc65816_rom_loader_set_buffer(&loader, file_buffer);
}
uint mapper_buffer_size = wdc65816_mapper_get_buffer_size();
u8* work_buffer = arena_alloc_array(&arena, mapper_buffer_size, u8);
Wdc65816Mapper rom;
wdc65816_mapper_init(&rom, &rom_builder, (u8**)work_buffer);
nuts_global_init();
Path working_dir;
path_init_working_directory(&working_dir);
FreeList sentinel;
free_list_init(&sentinel);
ErrorList error_list;
error_list_init(&error_list, arena_subarena(&arena, MB(10)));
AST ast;
ast_init(&ast, &arena);
String file_name = string_from_c_string(argv[1]);
/* struct timespec lex_start, lex_end, lex_time = { 0 }; */
/* struct timespec parse_start, parse_end, parse_time = { 0 }; */
/* struct timespec assemble_start, assemble_end, assemble_time = { 0 }; */
/* struct timespec all_start, all_end, all_time; */
/* clock_gettime(CLOCK_REALTIME, &all_start); */
Parser parser;
parser_init(&parser, &arena, &sentinel, &error_list, &ast);
int error_num = 0;
while(1) {
Path file;
path_init(&file, file_name);
Buffer file_buffer = path_read_file(&file, &arena);
TokenList token_list;
//c_print_format("read %.*s\n", file_name.length, file_name.data);
Text file_text = {
.buffer = file_buffer,
.name = file_name
};
/* clock_gettime(CLOCK_REALTIME, &lex_start); */
Result result = lex(file_text, &token_list, &arena, &error_list, &ast.identifier_map);
if(result == RESULT_ERROR) {
for(;error_num < error_list.length; error_num++) {
describe_error(error_list.errors[error_num]);
}
}
/* clock_gettime(CLOCK_REALTIME, &lex_end); */
/* lex_time = timespec_add(lex_time, timespec_sub(lex_start, lex_end)); */
/* clock_gettime(CLOCK_REALTIME, &parse_start); */
/* result = parse(&parser, token_list); */
/* clock_gettime(CLOCK_REALTIME, &parse_end); */
/* parse_time = timespec_add(parse_time, timespec_sub(parse_start, parse_end)); */
if(result == RESULT_NEED_TOKEN_STREAM) {
file_name = parser.needed_token_stream_file_name;
continue;
} else if(result == RESULT_OK) {
break;
} else if(result == RESULT_ERROR) {
for(;error_num < error_list.length; error_num++) {
describe_error(error_list.errors[error_num]);
}
return 1;
} else {
invalid_code_path;
}
}
/* clock_gettime(CLOCK_REALTIME, &assemble_start); */
Assembler assembler;
assembler_init(&assembler, &error_list, &ast, &rom);
Result result = RESULT_ERROR;
while(result != RESULT_OK) {
result = assemble(&assembler);
if(result == RESULT_NEED_FILE) {
String file_name = assembler_get_file_name(&assembler);
Path file;
path_init(&file, file_name);
Buffer file_buffer = path_read_file(&file, &arena);
assembler_give_buffer(&assembler, file_buffer);
} else if(result == RESULT_ERROR) {
break;
}
}
/* clock_gettime(CLOCK_REALTIME, &assemble_end); */
/* assemble_time = timespec_add(assemble_time, timespec_sub(assemble_start, assemble_end)); */
for(int i = 0; i < error_list.length; i++) {
describe_error(error_list.errors[i]);
}
/* parser_deinit(&parser); */
/* clock_gettime(CLOCK_REALTIME, &all_end); */
/* all_time = timespec_sub(all_start, all_end); */
/* c_print_format("Lex: %li.%06lims\n", lex_time.tv_sec * 1000 + lex_time.tv_nsec / 1000000, lex_time.tv_nsec % 1000000); */
/* c_print_format("Parse: %li.%06lims\n", parse_time.tv_sec * 1000 + parse_time.tv_nsec / 1000000, parse_time.tv_nsec % 1000000); */
/* c_print_format("Assemble: %li.%06lims\n", assemble_time.tv_sec * 1000 + assemble_time.tv_nsec / 1000000, assemble_time.tv_nsec % 1000000); */
/* c_print_format("All: %li.%06lims\n", all_time.tv_sec * 1000 + all_time.tv_nsec / 1000000, all_time.tv_nsec % 1000000); */
Path rom_path;
path_create_from(&rom_path, &cartridge_folder_path, L("program.rom"));
path_write_file(&rom_path, rom_buffer);
return 0;
}
