sequential.c

#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>

// Problem parameters.
int screen_width, screen_height;
int wire_width, wire_height;
int wire_shift_x, wire_shift_y;
int iteration_limit;
double wire_voltage;

// Algorithm parameters.
double v_top, v_right, v_bottom, v_left, v_x;

// Data rows.
// Each segment border shares with other adjacent segments.
double* data;

// Process data size;
int segment_size_x, segment_size_y;

// Board size.
int process_board_x, process_board_y;

// Position on board for current process_number.
int process_x, process_y;

// MPI specific definitions.
int available_processes, process_number;

/*
#ifdef DEBUG
#define d(format, args...) _debug
#else
#define d(format, args...)
#endif
*/

// former _debug
void d(const char*, ...);

void display_progress(int, int);
void initialize_globals(char**);
void print_board();

double initial_voltage(const int, const int);
int is_wire(const int, const int);
int is_outside(const int, const int);

double calculation(const int);
double* get_point_address(int, int);

int top_point(const int, const int);
int right_point(const int, const int);
int bottom_point(const int, const int);
int left_point(const int, const int);

int top_segment();
int right_segment();
int bottom_segment();
int left_segment();

int file_exists(const char*);

void finalize();
void communicate(int);

int main(int argc, char* argv[]) {
	int x, y;
	char buffer[255];
	FILE* file;
	int iteration = 0;
	int progress = -1;
	int add_headers = 0;
	double timer;
	clock_t start;

	if (argc < 7) {
		printf("Usage: %s screen_width screen_height wire_width wire_height wire_mili_voltage iteration_limit\n", argv[0]);
		return 1;
	}

	initialize_globals(argv);

	d("Simulating MPI world");
	available_processes = 1;
	process_number = 0;

	wire_shift_x = (screen_width - wire_width) / 2;
	wire_shift_y = (screen_height - wire_height) / 2;

	process_board_x = sqrt(available_processes);
	process_board_y = available_processes / process_board_x;
	process_x = process_number % process_board_x;
	process_y = process_number / process_board_x;

//	printf("My rank: %d.\nMy location: %d:%d (board size: %d:%d)\n", process_number, process_x, process_y, process_board_x, process_board_y);
	if (process_number >= process_board_x * process_board_y) {
		printf("I'm out of board. Should never happen!\n");
		finalize();
		return 0;
	}

	d("Initiate data storage%s", ".");
	segment_size_x = screen_width / process_board_x + 2;
	segment_size_y = screen_height / process_board_y + 2;
	data = (double*) malloc(sizeof(double) * segment_size_x * segment_size_y);

	if (0 == process_number) {
		print_board();
	}

	for (y = 0; y < segment_size_y; ++y) {
		for (x = 0; x < segment_size_x; ++x) {
			data[y * segment_size_x + x] = initial_voltage(x, y);
		}
	}



	d("Register custom MPI type (not applicable)%s", ".");

	start = clock();
	communicate(iteration);
	while (iteration < iteration_limit) {
		d("Iterations start%s", ".");
		calculation(iteration);
		communicate(iteration);
		++iteration;
		if (process_number == 0 && 100 * iteration / iteration_limit > progress) {
			progress = 100 * iteration / iteration_limit;

			display_progress(progress, 80);
//			printf("Progress: %d%% (%d of %d)\n", 5 * progress, iteration, iteration_limit);
		}
	}
	if (0 == process_number) {
		printf("\n");
	}
	timer = (double) (clock() - start) / CLOCKS_PER_SEC;

	// Dump data from each process.
	sprintf(buffer, "data-%dx%d.txt", process_x, process_y);
	file = fopen(buffer, "w");
	for (y = 1; y < segment_size_y - 1; ++y) {
		for (x = 1; x < segment_size_x - 1; ++x) {
			fprintf(file, "%f\t%f\t%f\n",
					1.0 * (process_x * (segment_size_x - 2) + x) / screen_width,
					1.0 * (process_y * (segment_size_y - 2) + y) / screen_height,
					data[y * segment_size_x + x]
			);
		}
		fprintf(file, "\n");
	}
	fclose(file);

	// Log program response.
	if (process_number == 0) {
		printf("Board size: %dx%d, iterations limit: %d, used processes: %d, elapsed time: %f\n", screen_width, screen_height, iteration_limit, available_processes, timer);

		if (file_exists("results.txt") == 0) {
			add_headers = 1;
		}

		file = fopen("results.txt", "a+");
		if (add_headers) {
			fprintf(file, "W\tH\tmax\tproc\tT\n");
		}
		fprintf(file, "%d\t%d\t%d\t%d\t%f\n", screen_width, screen_height, iteration_limit, available_processes, timer);
		fclose(file);
	}

	finalize();

	return 0;
}

// former _debug
void d(const char* format, ...) {
	va_list args;
	va_start(args, format);

/**/
//	char _format[500];
//	sprintf(_format, "%s:%d (%s): %s", __FILE__, __LINE__, __FUNCTION__, format);
//	sprintf(_format, "%d (%d:%d): %s\n", process_number, process_x, process_y, _format);
//	vprintf(_format, args);
/**/
	va_end(args);
}

void display_progress(int percent, int width) {
	int i;
	int middle;

	printf("%3d%% [", percent);

	middle = width * percent / 100.0;

	for (i = 0; i < middle; ++i) {
		printf("=");
	}

	for (i = middle; i < width; ++i) {
		printf(" ");
	}

//	printf("]\n\033[F\033[J");
	printf("]\r");
}

void initialize_globals(char* argv[]) {
	// Screen size.
	screen_width = atoi(argv[1]);
	screen_height = atoi(argv[2]);

	// Wire inside screen size.
	wire_width = atoi(argv[3]);
	wire_height = atoi(argv[4]);

	if (screen_width <= wire_width) {
		screen_width = wire_width;
		wire_width = atoi(argv[1]);
	}

	if (screen_height <= wire_height) {
		screen_height = wire_height;
		wire_height = atoi(argv[2]);
	}

	// Wire constant voltage; input as mV thus "/ 1000" part.
	wire_voltage = atoi(argv[5]) / 1000;

	// Maximum number of iterations.
	iteration_limit = atoi(argv[6]);
}

void print_board() {
    if (screen_width > 120 || screen_height > 120) {
		return;
	}

	printf("Board layout (%dx%d):\n", screen_width, screen_height);

	for (int y = 0; y < segment_size_y; ++y) {
		for (int x = 0; x < segment_size_x; ++x) {
			printf("%s ", is_wire(x, y) ? "x" : (is_outside(x, y) ? "o" : "."));
		}
		printf("\n");
	}
}

double initial_voltage(const int x, const int y) {
	if (is_wire(x, y)) {
		return wire_voltage;
	}

	return 0.0;
}

int is_wire(const int x, const int y) {
	int board_x, board_y;

	board_x = process_x * (segment_size_x - 2) + x - 1;
	board_y = process_y * (segment_size_y - 2) + y - 1;

	if (board_x < wire_shift_x
		|| board_y < wire_shift_y
		|| board_x >= wire_shift_x + wire_width
		|| board_y >= wire_shift_y + wire_height
	) {
		return 0;
	}

	return 1;
}

int is_outside(const int x, const int y) {
	int board_x, board_y;

	board_x = process_x * (segment_size_x - 2) + x - 1;
	board_y = process_y * (segment_size_y - 2) + y - 1;

	if (board_x < 0
		|| board_y < 0
		|| board_x >= screen_width
		|| board_y >= screen_height
	) {
		return 1;
	}

	return 0;
}

// Calculate one step and max corrections
double calculation(const int iterate) {
	// Vt + Vr + Vb + Vl - 4Vx = 0
	int y, x;
	double maxStepSize, pde, stepSize;
	d("Calculation step (iterate: %d)", iterate);
	maxStepSize = 0;

	for (y = 1; y < segment_size_y - 1; ++y) {
		for (x = 1; x < segment_size_x - 1; ++x) {
			// We're using checkerboard to calculate values.
			if ((y + x + iterate) % 2 == 0
				|| is_outside(x, y)
				|| is_wire(x, y)
			) {
				continue;
			}

			pde = data[bottom_point(x, y)]
				+ data[top_point(x, y)]
				+ data[left_point(x, y)]
				+ data[right_point(x, y)];
			pde *= .25;

			stepSize = abs(pde - data[y * segment_size_x + x]);
			if (stepSize > maxStepSize) {
				maxStepSize = stepSize;
			}

			data[y * segment_size_x + x] = pde;
		}
	}

	return maxStepSize;
}

// Get point data; wrap coordinates to fit segment box.
double* get_point_address(int x, int y) {
	if (x < 0) {
		while (x < 0) {
			x += segment_size_x;
		}
	} else {
		while (x >= segment_size_x) {
			x -= segment_size_x;
		}
	}
	if (y < 0) {
		while (y < 0) {
			y += segment_size_y;
		}
	} else {
		while (y >= segment_size_y) {
			y -= segment_size_y;
		}
	}

	return data + y * segment_size_x + x;
}

int left_point(const int x, const int y) {
	if (x > 0) {
		return y * segment_size_x + x - 1;
	}

	return -1;
}

int right_point(const int x, const int y) {
	if (1 + x < segment_size_x) {
		return y * segment_size_x + x + 1;
	}

	return -1;
}

int top_point(const int x, const int y) {
	if (y > 0) {
		return (y - 1) * segment_size_x + x;
	}

	return -1;
}

int bottom_point(const int x, const int y) {
	if (1 + y < segment_size_y) {
		return (y + 1) * segment_size_x + x;
	}

	return -1;
}

int left_segment() {
	if (0 >= process_x) {
		return -1;
	}

	return process_y * process_board_x + process_x - 1;
}

int right_segment() {
	if (process_x + 1 >= process_board_x) {
		return -1;
	}

	return process_y * process_board_x + process_x + 1;
}

int top_segment() {
	if (0 >= process_y) {
		return -1;
	}

	return (process_y - 1) * process_board_x + process_x;
}

int bottom_segment() {
	if (process_y + 1 >= process_board_y) {
		return -1;
	}

	return (process_y + 1) * process_board_x + process_x;
}

int file_exists(const char* filename) {
	FILE* file = fopen(filename, "r");
	if (file) {
		fclose(file);
		return 1;
	}
	return 0;
}

// Communicate with adjacent segments.
void communicate(int iteration) {
	// We don't use communication in sequential program.
}

void finalize() {
	// This is just a stub function.
}