/* performs properties change with support of undoing */
static void
file_attrib(char *path, DWORD add, DWORD sub, int recurse_dirs)
{
/* FIXME: set attributes recursively. */
DWORD attrs = GetFileAttributes(path);
if(attrs == INVALID_FILE_ATTRIBUTES)
{
LOG_WERROR(GetLastError());
return;
}
if(add != 0)
{
const size_t wadd = add;
if(perform_operation(OP_ADDATTR, NULL, (void *)wadd, path, NULL) == 0)
{
add_operation(OP_ADDATTR, (void *)wadd, (void *)(~attrs & wadd), path,
"");
}
}
if(sub != 0)
{
const size_t wsub = sub;
if(perform_operation(OP_SUBATTR, NULL, (void *)wsub, path, NULL) == 0)
{
add_operation(OP_SUBATTR, (void *)wsub, (void *)(~attrs & wsub), path,
"");
}
}
}
static int instream_start_pa(SoundIoPrivate *si, SoundIoInStreamPrivate *is) {
SoundIoInStream *instream = &is->pub;
SoundIoInStreamPulseAudio *ispa = &is->backend_data.pulseaudio;
SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
pa_threaded_mainloop_lock(sipa->main_loop);
pa_stream_flags_t flags = PA_STREAM_AUTO_TIMING_UPDATE;
if (instream->software_latency > 0.0)
flags = (pa_stream_flags_t) (flags|PA_STREAM_ADJUST_LATENCY);
int err = pa_stream_connect_record(ispa->stream,
instream->device->id,
&ispa->buffer_attr, flags);
if (err) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return SoundIoErrorOpeningDevice;
}
while (!ispa->stream_ready)
pa_threaded_mainloop_wait(sipa->main_loop);
pa_operation *update_timing_info_op = pa_stream_update_timing_info(ispa->stream, timing_update_callback, si);
if ((err = perform_operation(si, update_timing_info_op))) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return err;
}
pa_threaded_mainloop_unlock(sipa->main_loop);
return 0;
}
// Ensure perform_operation() succeeds given valid input parameters.
void test_perform_operation(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
{"*", binary_operator},
};
char *args[] = {
"1", "+", "3", "*", "10",
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
// Setup return values of mock operator functions.
// Addition.
expect_value(binary_operator, a, 1);
expect_value(binary_operator, b, 3);
will_return(binary_operator, 4);
// Multiplication.
expect_value(binary_operator, a, 4);
expect_value(binary_operator, b, 10);
will_return(binary_operator, 40);
assert_int_equal(perform_operation(
array_length(args), args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values,
&intermediate_values, &error_occurred), 40);
assert_int_equal(error_occurred, 0);
assert_true(intermediate_values);
assert_int_equal(intermediate_values[0], 4);
assert_int_equal(intermediate_values[1], 40);
test_free(intermediate_values);
}
char* solve(char *input, float *answer) {
int read_count;
float new_number;
char operator = '+';
while (operator != ')' && operator != '=') {
new_number = 0;
if (input[0] == '(') {
printf("found new sub-expression!\n");
input = solve(input+1, &new_number);
} else {
printf("input starts with %c\n", input[0]);
sscanf(input, "%f%n", &new_number, &read_count);
input += read_count;
}
printf("%.1f %c %.1f\n", *answer, operator, new_number);
perform_operation(answer, operator, new_number);
operator = input[0];
input++;
}
printf("exiting sub-expression or end\n");
return input;
}
int
example_syscall(struct credential *cred, int index, int op)
{
/*
* CHECK: new [[INST0:[0-9]+]]: [[INIT:1:0x0]]
*/
struct object *o;
int error = get_object(index, &o);
if (error != 0)
return (error);
/*
* perform_operation() contains the NOW event:
* CHECK: clone [[INST0]]:[[INIT]] -> [[INST1:[0-9]+]]:[[NOW:[0-9]+:0x1]]
*/
perform_operation(op, o);
// Error: missing release(o)!
//release(o);
/*
* ERR: Instance {{[0-9]+}} is in state {{[0-9]+}}
* ERR: but received event '{{.*}}example_syscall{{.*}}cleanup
* ERR: causes transition in: [
* ERR: ({{[0-9]+}}:0x0 -> {{[0-9]+}}:0x0 <clean>)
* ERR: ({{[0-9]+}}:0x1 -> {{[0-9]+}}:0x{{[01]}} <clean>)
* ERR: ]
*/
return 0;
}
int main(int argc, char *argv[]) {
int return_value;
int number_of_intermediate_values;
int *intermediate_values;
// Peform the operation.
const int result = perform_operation(
argc - 1, &argv[1],
sizeof(operator_function_map) / sizeof(operator_function_map[0]),
operator_function_map, &number_of_intermediate_values,
&intermediate_values, &return_value);
// If no errors occurred display the result.
if (!return_value && argc > 1) {
unsigned int i;
unsigned int intermediate_value_index = 0;
printf("%s\n", argv[1]);
for (i = 2; i < argc; i += 2) {
assert(intermediate_value_index < number_of_intermediate_values);
printf(" %s %s = %d\n", argv[i], argv[i + 1],
intermediate_values[intermediate_value_index++]);
}
printf("= %d\n", result);
}
if (intermediate_values) {
free(intermediate_values);
}
return return_value;
}
int
example_syscall(struct credential *cred, int index, int op)
{
struct object *o;
int error = get_object(index, &o);
if (error != 0)
return (error);
des_cblock des_key;
des_key_schedule key_schedule;
crypto_setup(&des_key, &key_schedule);
if ((error = security_check(cred, o, op))) return error;
some_helper(op);
void_helper(o);
perform_operation(op, o);
crypto_encrypt(&des_key, &key_schedule);
log_audit_record(o, op);
release(o);
return 0;
}
static int instream_start_pa(struct SoundIoPrivate *si, struct SoundIoInStreamPrivate *is) {
struct SoundIoInStream *instream = &is->pub;
struct SoundIoInStreamPulseAudio *ispa = &is->backend_data.pulseaudio;
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
pa_threaded_mainloop_lock(sipa->main_loop);
pa_stream_flags_t flags = (pa_stream_flags_t)(PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING);
int err = pa_stream_connect_record(ispa->stream,
instream->device->id,
&ispa->buffer_attr, flags);
if (err) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return SoundIoErrorOpeningDevice;
}
while (!SOUNDIO_ATOMIC_LOAD(ispa->stream_ready))
pa_threaded_mainloop_wait(sipa->main_loop);
pa_operation *update_timing_info_op = pa_stream_update_timing_info(ispa->stream, timing_update_callback, si);
if ((err = perform_operation(si, update_timing_info_op))) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return err;
}
pa_threaded_mainloop_unlock(sipa->main_loop);
return 0;
}
static void
file_chmod(char *path, const char *mode, const char *inv_mode, int recurse_dirs)
{
int op = recurse_dirs ? OP_CHMODR : OP_CHMOD;
if(perform_operation(op, (void *)mode, path, NULL) == 0)
add_operation(op, strdup(mode), strdup(inv_mode), path, "");
}
// Ensure perform_operation() returns 0 when no arguments are specified.
void test_perform_operation_no_arguments(void **state) {
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
assert_int_equal(perform_operation(
0, NULL, 0, NULL, &number_of_intermediate_values, &intermediate_values,
&error_occurred), 0);
assert_int_equal(error_occurred, 0);
}
void main(void)
{ long tests;
fscanf(in,"%ld\n",&tests);
for(long test=0;test<tests;test++){
n=0, val=0, read=0, op='+';
fscanf(in,"%ld",&n);
while((ch=fgetc(in))!=13)
{ if(ch==EOF) break;
if(ch=='+' || ch=='^') perform_operation();
if(ch>='0' && ch<='9')
if(op=='+') read=(read*10+ch-'0')%n;
else read=(read*10+ch-'0')%(n-1);
}
perform_operation();
fprintf(out,"%ld\n",val);
};
fclose(in);
fclose(out);
}
int
example_syscall(struct credential *cred)
{
struct object *o;
int error = get_object(&o);
if (error != 0)
return (error);
return perform_operation(o);
}
/* Ensure perform_operation() asserts when a NULL operator_functions array is
* specified. */
void test_perform_operation_null_operator_functions(void **state) {
char *args[] = {
"1", "+", "2", "*", "4"
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
expect_assert_failure(perform_operation(
array_length(args), args, 1, NULL, &number_of_intermediate_values,
&intermediate_values, &error_occurred));
}
// Ensure perform_operation() asserts when a NULL arguments array is specified.
void test_perform_operation_null_args(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
expect_assert_failure(perform_operation(
1, NULL, array_length(operator_functions), operator_functions,
&number_of_intermediate_values, &intermediate_values,
&error_occurred));
}
/* Ensure perform_operation() asserts when a NULL pointer is specified for
* intermediate_values. */
void test_perform_operation_null_intermediate_values(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
char *args[] = {
"1", "+", "2", "*", "4"
};
int number_of_intermediate_values;
int error_occurred;
expect_assert_failure(perform_operation(
array_length(args), args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values, NULL,
&error_occurred));
}
/* Ensure perform_operation() asserts when a NULL pointer is specified for
* number_of_intermediate_values. */
static void test_perform_operation_null_number_of_intermediate_values(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
const char *args[] = {
"1", "+", "2", "*", "4"
};
int *intermediate_values;
int error_occurred;
(void) state; /* unused */
expect_assert_failure(perform_operation(
array_length(args), (char **) args, 1, operator_functions, NULL,
&intermediate_values, &error_occurred));
}
int do_stuff(const Params * parameters)
{
if (parameters->Flags & FLAG_HELP || ((parameters->Flags | FLAG_LOAD | FLAG_SAVE) != parameters->Flags) )
{/* We wanted HELP or we did not get SAVE or LOAD */
print_help(); /* tell the loser what to do, then :-) */
return 0;
}
int verbose = parameters->Flags & FLAG_VERBOSE;
int image_handle;
int w, h;
ILboolean result;
/* Quite obvious stuff, just load an image */
ilGenImages(1, & image_handle);
ilBindImage(image_handle);
result = ilLoadImage(parameters->Load_filename);
if (result == IL_FALSE)
{
int error = ilGetError();
fprintf(stderr, "Error: Something went wrong when loading file '%s' (%s)\n", parameters->Load_filename, iluErrorString(error));
return error;
}
/* If we get image's dimensions, people will believe that we have actually loaded something :-) */
w = ilGetInteger(IL_IMAGE_WIDTH);
h = ilGetInteger(IL_IMAGE_HEIGHT);
if (verbose)
printf("Loaded '%s', size %dx%d\n", parameters->Load_filename, w, h);
/* Now let's do our stuff!!! */
int i;
for (i = 0; i < parameters->Calls_count; i++)
perform_operation(parameters->Calls_strings[i], verbose);
/* our stuff has been done... */
result = ilSaveImage(parameters->Save_filename);
if (result == IL_FALSE)
{
int error = ilGetError();
fprintf(stderr, "Error: Something went wrong when saving file '%s' (%s)\n", parameters->Save_filename, iluErrorString(error));
ilDeleteImages(1, & image_handle);
return error;
}
ilDeleteImages(1, & image_handle);
return 0;
}
/* Ensure perform_operation() returns an error when an integer doesn't follow
* an operator. */
void test_perform_operation_no_integer_after_operator(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
char *args[] = {
"1", "+", "test",
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
expect_string(example_test_fprintf, temporary_buffer,
"Unable to parse integer test of argument 2\n");
assert_int_equal(perform_operation(
array_length(args), args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values,
&intermediate_values, &error_occurred), 0);
assert_int_equal(error_occurred, 1);
}
/* Ensure perform_operation() returns an error when nothing follows an
* operator. */
static void test_perform_operation_missing_argument(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
const char *args[] = {
"1", "+",
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
(void) state; /* unused */
expect_string(example_test_fprintf, temporary_buffer,
"Binary operator + missing argument\n");
assert_int_equal(perform_operation(
array_length(args), (char **) args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values,
&intermediate_values, &error_occurred), 0);
assert_int_equal(error_occurred, 1);
}
/* Ensure perform_operation() returns an error if the first argument isn't
* an integer string. */
static void test_perform_operation_first_arg_not_integer(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
};
const char *args[] = {
"test", "+", "2", "*", "4"
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
(void) state; /* unused */
expect_string(example_test_fprintf, temporary_buffer,
"Unable to parse integer from argument test\n");
assert_int_equal(perform_operation(
array_length(args), (char **) args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values,
&intermediate_values, &error_occurred), 0);
assert_int_equal(error_occurred, 1);
}
void
caller_with_literals()
{
perform_operation(3, 0);
}
// call this while holding the main loop lock
static int refresh_devices(struct SoundIoPrivate *si) {
struct SoundIo *soundio = &si->pub;
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
assert(!sipa->current_devices_info);
sipa->current_devices_info = ALLOCATE(struct SoundIoDevicesInfo, 1);
if (!sipa->current_devices_info)
return SoundIoErrorNoMem;
pa_operation *list_sink_op = pa_context_get_sink_info_list(sipa->pulse_context, sink_info_callback, si);
pa_operation *list_source_op = pa_context_get_source_info_list(sipa->pulse_context, source_info_callback, si);
pa_operation *server_info_op = pa_context_get_server_info(sipa->pulse_context, server_info_callback, si);
int err;
if ((err = perform_operation(si, list_sink_op))) {
return err;
}
if ((err = perform_operation(si, list_source_op))) {
return err;
}
if ((err = perform_operation(si, server_info_op))) {
return err;
}
if (sipa->device_query_err) {
return sipa->device_query_err;
}
// based on the default sink name, figure out the default output index
// if the name doesn't match just pick the first one. if there are no
// devices then we need to set it to -1.
sipa->current_devices_info->default_output_index = -1;
sipa->current_devices_info->default_input_index = -1;
if (sipa->current_devices_info->input_devices.length > 0) {
sipa->current_devices_info->default_input_index = 0;
for (int i = 0; i < sipa->current_devices_info->input_devices.length; i += 1) {
struct SoundIoDevice *device = SoundIoListDevicePtr_val_at(
&sipa->current_devices_info->input_devices, i);
assert(device->aim == SoundIoDeviceAimInput);
if (strcmp(device->id, sipa->default_source_name) == 0) {
sipa->current_devices_info->default_input_index = i;
}
}
}
if (sipa->current_devices_info->output_devices.length > 0) {
sipa->current_devices_info->default_output_index = 0;
for (int i = 0; i < sipa->current_devices_info->output_devices.length; i += 1) {
struct SoundIoDevice *device = SoundIoListDevicePtr_val_at(
&sipa->current_devices_info->output_devices, i);
assert(device->aim == SoundIoDeviceAimOutput);
if (strcmp(device->id, sipa->default_sink_name) == 0) {
sipa->current_devices_info->default_output_index = i;
}
}
}
soundio_destroy_devices_info(sipa->ready_devices_info);
sipa->ready_devices_info = sipa->current_devices_info;
sipa->current_devices_info = NULL;
pa_threaded_mainloop_signal(sipa->main_loop, 0);
soundio->on_events_signal(soundio);
return 0;
}
static int outstream_open_pa(struct SoundIoPrivate *si, struct SoundIoOutStreamPrivate *os) {
struct SoundIoOutStreamPulseAudio *ospa = &os->backend_data.pulseaudio;
struct SoundIoOutStream *outstream = &os->pub;
if ((unsigned)outstream->layout.channel_count > PA_CHANNELS_MAX)
return SoundIoErrorIncompatibleBackend;
if (!outstream->name)
outstream->name = "SoundIoOutStream";
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
SOUNDIO_ATOMIC_STORE(ospa->stream_ready, false);
SOUNDIO_ATOMIC_FLAG_TEST_AND_SET(ospa->clear_buffer_flag);
assert(sipa->pulse_context);
pa_threaded_mainloop_lock(sipa->main_loop);
pa_sample_spec sample_spec;
sample_spec.format = to_pulseaudio_format(outstream->format);
sample_spec.rate = outstream->sample_rate;
sample_spec.channels = outstream->layout.channel_count;
pa_channel_map channel_map = to_pulseaudio_channel_map(&outstream->layout);
ospa->stream = pa_stream_new(sipa->pulse_context, outstream->name, &sample_spec, &channel_map);
if (!ospa->stream) {
pa_threaded_mainloop_unlock(sipa->main_loop);
outstream_destroy_pa(si, os);
return SoundIoErrorNoMem;
}
pa_stream_set_state_callback(ospa->stream, playback_stream_state_callback, os);
ospa->buffer_attr.maxlength = UINT32_MAX;
ospa->buffer_attr.tlength = UINT32_MAX;
ospa->buffer_attr.prebuf = 0;
ospa->buffer_attr.minreq = UINT32_MAX;
ospa->buffer_attr.fragsize = UINT32_MAX;
int bytes_per_second = outstream->bytes_per_frame * outstream->sample_rate;
if (outstream->software_latency > 0.0) {
int buffer_length = outstream->bytes_per_frame *
ceil_dbl_to_int(outstream->software_latency * bytes_per_second / (double)outstream->bytes_per_frame);
ospa->buffer_attr.maxlength = buffer_length;
ospa->buffer_attr.tlength = buffer_length;
}
pa_stream_flags_t flags = (pa_stream_flags_t)(PA_STREAM_START_CORKED | PA_STREAM_AUTO_TIMING_UPDATE |
PA_STREAM_INTERPOLATE_TIMING);
int err = pa_stream_connect_playback(ospa->stream,
outstream->device->id, &ospa->buffer_attr,
flags, NULL, NULL);
if (err) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return SoundIoErrorOpeningDevice;
}
while (!SOUNDIO_ATOMIC_LOAD(ospa->stream_ready))
pa_threaded_mainloop_wait(sipa->main_loop);
pa_operation *update_timing_info_op = pa_stream_update_timing_info(ospa->stream, timing_update_callback, si);
if ((err = perform_operation(si, update_timing_info_op))) {
pa_threaded_mainloop_unlock(sipa->main_loop);
return err;
}
size_t writable_size = pa_stream_writable_size(ospa->stream);
outstream->software_latency = ((double)writable_size) / (double)bytes_per_second;
pa_threaded_mainloop_unlock(sipa->main_loop);
return 0;
}
static void
perform_merge(int op)
{
#ifndef _WIN32
struct stat src, dst;
#endif
ops_t *ops;
create_empty_dir("first");
create_empty_dir("first/nested1");
create_empty_dir("first/nested1/nested2");
create_empty_file("first/nested1/nested2/file");
create_empty_dir("second");
create_empty_dir("second/nested1");
#ifndef _WIN32
/* Something about GNU Hurd and OS X differs, so skip this workaround there.
* Really need to figure out what's wrong with this thing... */
#if !defined(__gnu_hurd__) && !defined(__APPLE__)
{
struct timeval tv[2];
gettimeofday(&tv[0], NULL);
tv[1] = tv[0];
/* This might be Linux-specific, but for the test to work properly access
* time should be newer than modification time, in which case it's not
* changed on listing directory. */
tv[0].tv_sec += 3;
tv[0].tv_usec += 4;
tv[1].tv_sec += 1;
tv[1].tv_usec += 2;
utimes("first/nested1", tv);
}
#endif
assert_success(chmod("first/nested1", 0700));
assert_success(os_stat("first/nested1", &src));
#endif
cmd_group_begin("undo msg");
assert_non_null(ops = ops_alloc(op, 0, "merge", ".", "."));
ops->crp = CRP_OVERWRITE_ALL;
if(op == OP_MOVEF)
{
assert_success(merge_dirs("first", "second", ops));
}
else
{
#ifndef _WIN32
if(!cfg.use_system_calls)
{
assert_success(
perform_operation(op, ops, NULL, "first/nested1", "second/"));
}
else
#endif
{
assert_success(perform_operation(op, ops, NULL, "first", "second"));
}
}
ops_free(ops);
cmd_group_end();
#ifndef _WIN32
{
assert_success(os_stat("second/nested1", &dst));
#ifndef HAVE_STRUCT_STAT_ST_MTIM
#define st_atim st_atime
#define st_mtim st_mtime
#endif
assert_success(memcmp(&src.st_atim, &dst.st_atim, sizeof(src.st_atim)));
assert_success(memcmp(&src.st_mtim, &dst.st_mtim, sizeof(src.st_mtim)));
assert_success(memcmp(&src.st_mode, &dst.st_mode, sizeof(src.st_mode)));
}
#endif
assert_true(file_exists("second/nested1/nested2/file"));
assert_success(unlink("second/nested1/nested2/file"));
assert_success(rmdir("second/nested1/nested2"));
assert_success(rmdir("second/nested1"));
assert_success(rmdir("second"));
}
/* perform_operation() interface adaptor for the undo unit. */
static int
undo_perform_func(OPS op, void *data, const char src[], const char dst[])
{
return perform_operation(op, NULL, data, src, dst);
}
int
example_syscall(struct credential *cred, int index, int op)
{
/*
* Entering the system call should instantiate automata:
*
* CHECK: [CALE] example_syscall
* CHECK: sunrise
*/
struct object *o;
/*
* get_object() calls hold(), which should be reflected in two automata
* (one which cares about entry and the other, exit):
*
* CHECK: [CALE] hold
* CHECK: new [[A0I0:[0-9]+]]: [[INIT:[0-9]+:0x0]] ('[[A0:.*]]')
* CHECK: clone [[A0I0]]:[[INIT]] -> [[A0I1:[0-9]+]]:[[HOLD:[0-9]+:0x1]]
* CHECK: [RETE] hold
* CHECK: new [[A1I0:[0-9]+]]: [[INIT:[0-9]+:0x0]] ('[[A1:.*]]')
* CHECK: clone [[A1I0]]:[[INIT]] -> [[A1I1:[0-9]+]]:[[HOLD:[0-9]+:0x1]]
*/
int error = get_object(index, &o);
if (error != 0)
return (error);
/*
* CHECK: [CALE] hold
* CHECK: clone [[A0I0]]:[[INIT]] -> [[A0I2:[0-9]+]]:[[HOLD:[0-9]+:0x1]]
* CHECK: [RETE] hold
* CHECK: clone [[A1I0]]:[[INIT]] -> [[A1I2:[0-9]+]]:[[HOLD:[0-9]+:0x1]]
*/
error = get_object(index + 1, &o);
if (error != 0)
return (error);
/*
* perform_operation() contains all NOW events:
*
* CHECK: [ASRT] automaton 0
* CHECK: update [[A0I2]]: [[HOLD]]->[[NOW:[0-9]+:0x1]]
* CHECK: [ASRT] automaton 1
* CHECK: update [[A1I2]]: [[HOLD]]->[[NOW:[0-9]+:0x1]]
*/
return perform_operation(op, o);
/*
* On leaving the assertion scope, we should be cleaning up:
*
* CHECK: [RETE] example_syscall
*
* There should only be one (shared) sunset event:
* CHECK: sunset
* CHECK-NOT: sunset
*
* CHECK: update [[A0I0]]: [[INIT]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A0]]': [[A0I0]]
* CHECK: update [[A0I1]]: [[HOLD]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A0]]': [[A0I1]]
* CHECK: update [[A0I2]]: [[NOW]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A0]]': [[A0I2]]
* CHECK: tesla_class_reset [[A0]]
*
* CHECK: update [[A1I0]]: [[INIT]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A1]]': [[A1I0]]
* CHECK: update [[A1I1]]: [[HOLD]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A1]]': [[A1I1]]
* CHECK: update [[A1I2]]: [[NOW]]->[[DONE:[0-9]+:0x0]]
* CHECK: pass '[[A1]]': [[A1I2]]
* CHECK: tesla_class_reset [[A1]]
*/
}
int main(int argc, char **argv)
{
unsigned int *input_matrices[INPUT_SIZE];
unsigned int *output_matrices[GRAPH_COLS];
unsigned int i, j;
unsigned int begin_input, end_input;
unsigned int rows, cols;
int r = 0;
int has_failed;
struct timeval start_time, end_time;
unsigned long start_us, end_us, total_time = 0;
struct device_info device_info;
if (argc != 3) {
fprintf(stderr, "Usage: %s rows cols\n", argv[0]);
return -1;
}
rows = (unsigned int)atoi(argv[1]);
cols = (unsigned int)atoi(argv[2]);
/* generate identity matrices */
for (i = 0; i < INPUT_SIZE; i++) {
if ((input_matrices[i] = (unsigned int *)malloc(rows * cols *
sizeof(unsigned int))) == NULL) {
fprintf(stderr, "Out of memory error.\n");
for (j = 0; j < i; j++)
free(input_matrices[i]);
return -1;
}
for (j = 0; j < rows * cols; j++)
input_matrices[i][j] = 1;
}
/*
if (madd_gpu_init(&device_info)) {
for (i = 0; i < INPUT_SIZE; i++)
free(input_matrices[i]);
return -1;
}
*/
begin_input = 0;
end_input = GRAPH_ROWS + 1;
/* Each column in the graph represents a parallel execution path. */
for (i = 0; i < GRAPH_COLS; i++) {
gettimeofday(&start_time, NULL);
output_matrices[i] = perform_operation(&device_info,
input_matrices, begin_input, end_input, rows, cols, &r);
gettimeofday(&end_time, NULL);
if (r) {
for (j = 0; j < INPUT_SIZE; j++)
free(input_matrices[j]);
for (j = 0; j < i; j++)
free(output_matrices[j]);
return r;
}
start_us = (unsigned long)start_time.tv_sec * 1000000 +
(unsigned long)start_time.tv_usec;
end_us = (unsigned long)end_time.tv_sec * 1000000 +
(unsigned long)end_time.tv_usec;
total_time += end_us - start_us;
begin_input = end_input;
end_input += GRAPH_ROWS + 1;
}
/*
if (madd_gpu_close(&device_info)) {
for (i = 0; i < INPUT_SIZE; i++)
free(input_matrices[i]);
for (i = 0; i < GRAPH_COLS; i++)
free(output_matrices[i]);
return -1;
}
*/
has_failed = 0;
/* Test output matrices */
for (i = 0; i < GRAPH_COLS && !has_failed; i++) {
for (j = 0; j < rows * cols && !has_failed; j++) {
if (output_matrices[i][j] != EXPECTED_SUM) {
printf("output_matrix[%u][%u] was %u, but \\"
" expected %u\n", i, j, output_matrices[i][j],
EXPECTED_SUM);
has_failed = 1;
}
}
}
printf("Test %s.\n", has_failed ? "failed" : "passed");
printf("Running time of rectangle: %lu microseconds\n", total_time);
for (i = 0; i < INPUT_SIZE; i++)
free(input_matrices[i]);
for (i = 0; i < GRAPH_COLS; i++)
free(output_matrices[i]);
return 0;
}
int exec_cmd(struct command_t *cmd) {
int arg1, arg2;
if (!number(cmd->arguments[0]) && !number(cmd->arguments[1]) && !supported_operation(cmd->operation)) {
cmd->success = 0;
return -4;
}
if (supported_operation(cmd->operation)) {
if (
(strlen(cmd->operation) < 2) &&
(strlen(cmd->arguments[0]) <= 0 || strlen(cmd->arguments[1]) <= 0) &&
(strcmp(cmd->operation, "!") != 0)
) {
cmd->success = 0;
return -2;
}
if (
(strlen(cmd->operation) >= 2) &&
(strlen(cmd->arguments[0]) > 0 && strlen(cmd->arguments[1]) > 0)
) {
cmd->success = 0;
return -2;
}
if ((!number(cmd->arguments[0]) || !number(cmd->arguments[1])) &&
strcmp(cmd->operation, "++") != 0 &&
strcmp(cmd->operation, "!") != 0
) {
cmd->success = 0;
return -3;
}
if (strcmp(cmd->operation, "++") == 0 && number(cmd->arguments[1]) && strlen(cmd->arguments[0]) <= 0) {
cmd->success = 0;
return -4;
}
sscanf(cmd->arguments[0], "%d", &arg1);
sscanf(cmd->arguments[1], "%d", &arg2);
if (strcmp(cmd->operation, "/") == 0 && arg2 == 0) {
cmd->success = 0;
return -5;
}
cmd->result = perform_operation(arg1, arg2, cmd->operation);
if (cmd->result == 42) {
cmd->success = 1;
return -42;
}
} else {
cmd->success = 0;
return -1;
}
cmd->success = 1;
return 0;
}