int main(int argc, char *argv[])
{
uint warp_filters_per_host = 1;
std::string dest_host_scratch_filename;
bool non_local_destination = 0;
std::string client_hosts_filename;
bool non_local_clients = 0;
while (argc > 1) {
if (!strcmp(argv[1], "-w")) {
warp_filters_per_host = atoi(argv[2]);
dcmpi_args_shift(argc, argv);
}
else if (!strcmp(argv[1], "-clients")) {
non_local_clients = 1;
client_hosts_filename = argv[2];
dcmpi_args_shift(argc, argv);
}
else if (!strcmp(argv[1], "-dest")) {
non_local_destination = 1;
dest_host_scratch_filename = argv[2];
dcmpi_args_shift(argc, argv);
}
else {
break;
}
dcmpi_args_shift(argc, argv);
}
if ((argc-1) != 3) {
appname = argv[0];
usage();
}
HostScratch *dest_host_scratch = NULL;
if (non_local_destination) {
dest_host_scratch = new HostScratch(dest_host_scratch_filename);
}
if (non_local_destination && dest_host_scratch->components.empty()) {
std::cerr << "ERROR: destination host file is empty, aborting"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
HostScratch *client_host_scratch = NULL;
if (non_local_clients) {
client_host_scratch = new HostScratch(client_hosts_filename);
}
if (non_local_clients && client_host_scratch->components.empty()) {
std::cerr << "ERROR: destination host file is empty, aborting"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (!dcmpi_string_ends_with(tostr(argv[1]), ".xml")) {
std::cerr << "ERROR: invalid filename " << tostr(argv[1])
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
JibberXMLDescriptor *jxd = new JibberXMLDescriptor();
jxd->init_from_file(argv[1]);
cout << "delta = " << jxd->delta << endl;
cout << "ncp = " << jxd->num_control_points << endl;
if (!dcmpi_string_ends_with(tostr(argv[2]), ".dim")) {
std::cerr << "ERROR: invalid filename " << tostr(argv[2])
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (!dcmpi_string_ends_with(tostr(argv[3]), ".dim")) {
std::cerr << "ERROR: invalid filename " << tostr(argv[3])
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
std::string warp_filename = tostr(argv[3]);
uint u, u2;
int rc;
ImageDescriptor descriptor;
std::string image_descriptor_string = file_to_string(argv[2]);
descriptor.init_from_string(image_descriptor_string);
std::vector<std::string> input_hosts = descriptor.get_hosts();
std::vector<std::string> hosts;
std::map< std::string, std::string> src_to_dest_host, client_to_dest_host, client_to_src_host, src_to_client_host;
if (non_local_destination && !non_local_clients) {
assert(input_hosts.size() == dest_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < dest_host_scratch->components.size(); u++) {
src_to_dest_host[input_hosts[u]] = (dest_host_scratch->components[u])[0];
}
}
if (non_local_clients) {
assert(input_hosts.size() == client_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < client_host_scratch->components.size(); u++) {
client_to_src_host[(client_host_scratch->components[u])[0]] = input_hosts[u];
src_to_client_host[input_hosts[u]] = (client_host_scratch->components[u])[0];
}
if (non_local_destination) {
assert(client_host_scratch->components.size() == dest_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < client_host_scratch->components.size(); u++) {
client_to_dest_host[(client_host_scratch->components[u])[0]] = (dest_host_scratch->components[u])[0];
}
}
hosts = client_host_scratch->get_hosts();
}
else {
hosts = input_hosts;
}
DCLayout layout;
layout.use_filter_library("libocvmfilters.so");
DCFilterInstance console ("<console>", "console");
layout.add(console);
std::vector< std::string> dest_hosts;
std::vector< std::string> client_hosts;
if (non_local_destination) {
dest_hosts = dest_host_scratch->get_hosts();
}
if (non_local_clients) {
client_hosts = client_host_scratch->get_hosts();
}
MediatorInfo info = mediator_setup(layout, 2, 1, input_hosts, client_hosts, dest_hosts);
std::vector<DCFilterInstance*> computers;
std::vector<DCFilterInstance*> mappers;
std::vector<DCFilterInstance*> readalls;
std::vector<DCFilterInstance*> mapper_readalls;
std::vector<DCFilterInstance*> writers;
for (u = 0; u < hosts.size(); u++) {
for (u2 = 0; u2 < warp_filters_per_host; u2++) {
std::string uniqueName = "W1_" + tostr(u) + "_" + tostr(u2);
DCFilterInstance * warper =
new DCFilterInstance("ocvm_warper", uniqueName);
layout.add(warper);
computers.push_back(warper);
warper->bind_to_host(hosts[u]);
warper->set_param("algo", "naive");
warper->set_param("label", uniqueName);
warper->set_param("myhostname", hosts[u]);
warper->set_param("threadID", tostr(u2));
warper->set_param("warp_filters_per_host", warp_filters_per_host);
warper->set_param("delta", tostr(jxd->delta));
warper->set_param("num_control_points", tostr(jxd->num_control_points));
// warper->set_param("image_descriptor_string", tostr(descriptor));
if (non_local_clients && non_local_destination) {
warper->set_param("dest_host_string", client_to_dest_host[hosts[u]]);
warper->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(client_to_dest_host[hosts[u]]));
}
else if (non_local_destination && !non_local_clients) {
warper->set_param("dest_host_string", src_to_dest_host[hosts[u]]);
warper->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(src_to_dest_host[hosts[u]]));
}
else {
warper->set_param("dest_host_string", hosts[u]);
if (!non_local_clients) {
warper->set_param("dest_scratchdir", "");
}
else {
warper->set_param("dest_scratchdir", client_host_scratch->get_scratch_for_host(hosts[u]));
}
}
layout.add_port(&console, "to_warper", warper, "from_console");
if (u2 > 0) {
continue; // only 1 warp mapper and writer per host
}
DCFilterInstance * mediator_readall =
new DCFilterInstance("ocvm_mediator_readall_samehost",
tostr("ra_") + tostr(hosts[u]));
mediator_readall->bind_to_host(hosts[u]);
readalls.push_back(mediator_readall);
// mediator_readall->set_param("image_descriptor_string",
// tostr(descriptor));
layout.add(mediator_readall);
DCFilterInstance * mapper_readall =
new DCFilterInstance("ocvm_mediator_readall_samehost",
tostr("mra_") + tostr(hosts[u]));
mapper_readall->bind_to_host(hosts[u]);
mapper_readalls.push_back(mapper_readall);
// mapper_readall->set_param("image_descriptor_string",
// tostr(descriptor));
layout.add(mapper_readall);
uniqueName = "WM_" + tostr(u);
DCFilterInstance * warpmapper =
new DCFilterInstance("ocvm_warp_mapper", uniqueName);
layout.add(warpmapper);
mappers.push_back(warpmapper);
warpmapper->bind_to_host(hosts[u]);
warpmapper->set_param("label", uniqueName);
warpmapper->set_param("myhostname", hosts[u]);
warpmapper->set_param("warp_filters_per_host", warp_filters_per_host);
// warpmapper->set_param("image_descriptor_string", tostr(descriptor));
layout.add_port(mapper_readall, "output",
warpmapper, "from_readall");
layout.add_port(warpmapper, "ack",
mapper_readall, "ack");
uniqueName = "WW_" + tostr(u);
DCFilterInstance * warpwriter =
new DCFilterInstance("ocvm_warp_writer", uniqueName);
layout.add(warpwriter);
writers.push_back(warpwriter);
warpwriter->bind_to_host(hosts[u]);
warpwriter->set_param("label", uniqueName);
warpwriter->set_param("myhostname", hosts[u]);
warpwriter->set_param("warp_filters_per_host", warp_filters_per_host);
// warpwriter->set_param("image_descriptor_string", tostr(descriptor));
if (non_local_clients && non_local_destination) {
warpwriter->set_param("dest_host_string", client_to_dest_host[hosts[u]]);
warpwriter->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(client_to_dest_host[hosts[u]]));
}
else if (non_local_destination && !non_local_clients) {
warpwriter->set_param("dest_host_string", src_to_dest_host[hosts[u]]);
warpwriter->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(src_to_dest_host[hosts[u]]));
}
else {
warpwriter->set_param("dest_host_string", hosts[u]);
if (!non_local_clients) {
warpwriter->set_param("dest_scratchdir", "");
}
else {
warpwriter->set_param("dest_scratchdir", client_host_scratch->get_scratch_for_host(hosts[u]));
}
}
if (non_local_clients) {
warper->set_param("input_hostname", client_to_src_host[hosts[u]]);
warpmapper->set_param("input_hostname", client_to_src_host[hosts[u]]);
warpwriter->set_param("input_hostname", client_to_src_host[hosts[u]]);
}
else {
warper->set_param("input_hostname", hosts[u]);
warpmapper->set_param("input_hostname", hosts[u]);
warpwriter->set_param("input_hostname", hosts[u]);
}
layout.add_port(warpwriter, "to_console", &console, "from_warpwriter");
}
}
for (u = 0; u < readalls.size(); u++) {
for (u2 = 0; u2 < warp_filters_per_host; u2++) {
layout.add_port(readalls[u], "output",
computers[u*warp_filters_per_host + u2], "from_readall");
layout.add_port(computers[u*warp_filters_per_host + u2], "ack",
readalls[u], "ack");
}
}
for (u = 0; u < computers.size(); u++) {
for (u2 = 0; u2 < mappers.size(); u2++) { // assumes 1 mapper and 1 writer per host
if (computers[u]->get_param("myhostname") == writers[u2]->get_param("myhostname")) {
layout.add_port(computers[u], "to_" + writers[u2]->get_param("myhostname"), writers[u2], "0");
}
layout.add_port(computers[u], "to_m_" + mappers[u2]->get_param("myhostname"), mappers[u2], "0");
}
}
for (u = 0; u < mappers.size(); u++) {
for (u2 = 0; u2 < writers.size(); u2++) {
layout.add_port(mappers[u], "to_" + writers[u2]->get_param("myhostname"), writers[u2], "0");
}
}
mediator_add_client(layout, info, readalls);
mediator_add_client(layout, info, mapper_readalls);
mediator_add_client(layout, info, writers);
double before = dcmpi_doubletime();
std::string dim_timestamp = get_dim_output_timestamp();
layout.set_param_all("dim_timestamp", dim_timestamp);
DCFilter * console_filter = layout.execute_start();
DCBuffer * imgstr = new DCBuffer(image_descriptor_string.size()+1);
imgstr->pack("s", image_descriptor_string.c_str());
console_filter->write_broadcast(imgstr, "to_warper");
delete imgstr;
for (u = 0; u < jxd->num_control_points; u++) {
DCBuffer * out = new DCBuffer(4 * sizeof(float) + sizeof(uint));
/*
cout << jxd->correspondences[u]->origin_x << " " <<
jxd->correspondences[u]->origin_y << " " <<
jxd->correspondences[u]->endpoint_x << " " <<
jxd->correspondences[u]->endpoint_y << " " <<
jxd->correspondences[u]->weight << endl;
*/
out->pack("ffffi", jxd->correspondences[u]->origin_x,
jxd->correspondences[u]->origin_y,
jxd->correspondences[u]->endpoint_x,
jxd->correspondences[u]->endpoint_y,
jxd->correspondences[u]->weight);
console_filter->write_broadcast(out, "to_warper");
}
std::map<ImageCoordinate, std::pair<std::string, int8> > newfiles;
for (u = 0; u < descriptor.parts.size(); u++) {
DCBuffer * in = console_filter->read("from_warpwriter");
ImageCoordinate ic;
std::string output_filename;
int8 output_offset;
in->unpack("iiisl", &ic.x, &ic.y, &ic.z,
&output_filename, &output_offset);
newfiles[ic] = make_pair(output_filename, output_offset);
delete in;
}
rc = layout.execute_finish();
if (rc) {
std::cerr << "ERROR: layout.execute() returned " << rc
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
else {
std::string message = "type BGRplanar\n";
message += "pixels_x " + tostr(descriptor.pixels_x) + "\n";
message += "pixels_y " + tostr(descriptor.pixels_y) + "\n";
message += "pixels_z " + tostr(descriptor.pixels_z) + "\n";
message += "chunks_x " + tostr(descriptor.chunks_x) + "\n";
message += "chunks_y " + tostr(descriptor.chunks_y) + "\n";
message += "chunks_z " + tostr(descriptor.chunks_z) + "\n";
message += "chunk_dimensions_x";
for (u = 0; u < descriptor.chunks_x; u++) {
message += " ";
message += tostr(descriptor.chunk_dimensions_x[u]);
}
message += "\n";
message += "chunk_dimensions_y";
for (u = 0; u < descriptor.chunks_y; u++) {
message += " ";
message += tostr(descriptor.chunk_dimensions_y[u]);
}
message += "\n";
for (u = 0; u < descriptor.parts.size(); u++) {
ImagePart & part = descriptor.parts[u];
std::string & fn_old = part.filename;
std::string fn_new = newfiles[part.coordinate].first;
int8 offset_new = newfiles[part.coordinate].second;
std::string output_hostname = part.hostname;
if (non_local_destination && non_local_clients) {
output_hostname = client_to_dest_host[src_to_client_host[part.hostname]];
}
if (non_local_destination && !non_local_clients) {
output_hostname = src_to_dest_host[part.hostname];
}
if (!non_local_destination && non_local_clients) {
output_hostname = src_to_client_host[part.hostname];
}
message += "part " + tostr(part.coordinate) + " " +
output_hostname + " " + fn_new + " " + tostr(offset_new) + "\n";
}
message += "timestamp " + dcmpi_get_time() + "\n";
FILE *f_wdim;
if ((f_wdim = fopen(warp_filename.c_str(), "w")) == NULL) {
std::cerr << "ERROR: opening file"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fwrite(message.c_str(), message.size(), 1, f_wdim) < 1) {
std::cerr << "ERROR: calling fwrite()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fclose(f_wdim) != 0) {
std::cerr << "ERROR: calling fclose()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
}
double after = dcmpi_doubletime();
std::cout << "elapsed warp " << (after - before) << " seconds" << endl;
return rc;
}
int answer_ps_queries(
DCFilter * console_filter,
const std::vector<std::string> & hosts,
ImageDescriptor original_image_descriptor,
ImageDescriptor prefix_sum_descriptor,
std::vector<PixelReq> query_points,
int zslice,
std::vector<std::vector<int8> > & results)
{
DCBuffer keep_going;
keep_going.pack("i", 1);
console_filter->write_broadcast(&keep_going, "0");
DCBuffer out;
out.pack("ssi",
"psquery",
tostr(prefix_sum_descriptor).c_str(),
zslice);
std::cout << "zslice is " << zslice << endl;
console_filter->write_broadcast(&out, "0");
// build cache
int tess_x, tess_y;
std::string extra = prefix_sum_descriptor.extra;
std::vector<std::string> toks = dcmpi_string_tokenize(extra);
tess_x = Atoi(toks[1]);
tess_y = Atoi(toks[3]);
std::string lpscache = toks[5];
toks = dcmpi_string_tokenize(lpscache, ":");
// fill lower-right-corner cache
std::map<std::string, std::string> lower_right_corner_cache;
for (uint u = 0; u < toks.size(); u++) {
const std::string & s = toks[u];
std::vector<std::string> toks2 = dcmpi_string_tokenize(s, "/");
lower_right_corner_cache[toks2[0]] = toks2[1];
std::cout << "cache: " << toks2[0] << "->" << toks2[1] << endl;
}
std::map<PixelReq, std::vector<int> > cached_contributions;
std::map<PixelReq, std::vector<PixelReq> > querypoint_pspoints;
#define INSERT(x,y) request_set.insert(PixelReq(x,y)); querypoint_pspoints[*it].push_back(PixelReq(x,y)); std::cout << "inserted " << x << "," << y << "\n";
SerialSet<PixelReq> request_set;
std::vector<PixelReq>::iterator it;
for (it = query_points.begin();
it != query_points.end();
it++) {
int8 psx, psy;
int8 new_x, new_y;
psx = it->x / tess_x;
psy = it->y / tess_y;
int chunk_x, chunk_y;
prefix_sum_descriptor.pixel_to_chunk(psx, psy, chunk_x, chunk_y);
if (chunk_x != 0 && chunk_y != 0) {
chunk_x--;
chunk_y--;
std::string key =
tostr(chunk_x) + "," +
tostr(chunk_y) + "," +
tostr(zslice);
std::string val = lower_right_corner_cache[key];
std::vector<std::string> toks = dcmpi_string_tokenize(val, ",");
std::vector<int> bgrvals;
for (uint u = 0; u < toks.size(); u++) {
bgrvals.push_back(Atoi(toks[u]));
}
cached_contributions[*it] = bgrvals;
std::cout << "cached_contribution for query point "
<< *it << " is "
<< val << endl;
}
while (1) {
if (prefix_sum_descriptor.bottommost_pixel_next_chunk_up(
psx, psy, new_x, new_y) == false) {
break;
}
INSERT(new_x, new_y);
psx = new_x;
psy = new_y;
}
psx = it->x / tess_x;
psy = it->y / tess_y;
while (1) {
if (prefix_sum_descriptor.rightmost_pixel_next_chunk_to_the_left(
psx, psy, new_x, new_y) == false) {
break;
}
INSERT(new_x, new_y);
psx = new_x;
psy = new_y;
}
psx = it->x / tess_x;
psy = it->y / tess_y;
INSERT(psx, psy);
}
std::cout << "request_set: ";
std::copy(request_set.begin(), request_set.end(), ostream_iterator<PixelReq>(cout, " ")); cout << endl;
DCBuffer pointsbuf;
request_set.serialize(&pointsbuf);
console_filter->write_broadcast(&pointsbuf, "0");
int4 scalar;
int color = 0;
int i;
std::map<PixelReq, std::vector<int4> > fetch_results;
for (i = 0; i < hosts.size(); i++) {
DCBuffer * reply = console_filter->read("fromreader");
std::string from_host;
reply->unpack("s", &from_host);
while (reply->getExtractAvailSize()) {
PixelReq req;
req.deSerialize(reply);
std::vector<int4> tuple3;
for (color = 0; color < 3; color++) {
std::cout << "reply from host " << from_host
<< ", pixelreq " << req
<< ", color " << color << ": ";
reply->unpack("i", &scalar);
tuple3.push_back(scalar);
std::cout << scalar << "\n";
}
fetch_results[req] = tuple3;
}
delete reply;
}
std::map<PixelReq, std::vector<int8> > sum_results;
for (it = query_points.begin();
it != query_points.end();
it++) {
const PixelReq & querypoint = *it;
const std::vector<PixelReq> & needed_points =
querypoint_pspoints[querypoint];
std::vector<int8> single_sum_results;
single_sum_results.push_back(0);
single_sum_results.push_back(0);
single_sum_results.push_back(0);
uint np;
for (np = 0; np < needed_points.size(); np++) {
const PixelReq & needed_point = needed_points[np];
std::vector<int> & lookup = fetch_results[needed_point];
for (color = 0; color < 3; color++) {
single_sum_results[color] += lookup[color];
}
}
sum_results[querypoint] = single_sum_results;
if (cached_contributions.count(querypoint) > 0) {
std::cout << "cache hit for querypoint "
<< querypoint << endl;
std::vector<int> & cache = cached_contributions[querypoint];
for (color = 0; color < 3; color++) {
sum_results[querypoint][color] += cache[color];
std::cout << "hit for color " << color
<< ": " << cache[color] << endl;
}
}
else {
std::cout << "cache miss for querypoint "
<< querypoint << endl;
}
}
for (i = 0; i < query_points.size(); i++) {
results.push_back(sum_results[query_points[i]]);
}
return 0;
}
int ocvm_dim_writer::process()
{
std::string output_directory;
int x1, y1, x2, y2, z;
int i, j;
DCBuffer * in;
const char * mode;
//while (1) {
//in = read_until_upstream_exit("0");
in = read("0");
//if (!in) {
// break;
//}
in->unpack("siiiii",
&output_directory, &x1, &y1,
&x2, &y2, &z);
in->consume();
// cout << "dimwriter on " << dcmpi_get_hostname()
// << ": writing to "
// << output_filename << endl;
std::string containing_dir = dcmpi_file_dirname(output_directory);
if (!dcmpi_file_exists(containing_dir)) {
if (dcmpi_mkdir_recursive(containing_dir)) {
std::cerr << "ERROR: making directories on "
<< dcmpi_get_hostname()
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
}
}
assert(dcmpi_file_exists(containing_dir));
FILE * f;
mode = "w";
for (i = y1; i <= y2; i++) {
for (j = x1; j <= x2; j++) {
std::string output_filename = output_directory + tostr(j) + "_" + tostr(i) + "_0";
if ((f = fopen(output_filename.c_str(), mode)) == NULL) {
std::cerr << "ERROR: opening " << output_filename
<< " for mode " << mode
<< " on host " << dcmpi_get_hostname()
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
in = read("0");
if (compress) {
in->decompress();
}
if (fwrite(in->getPtr(), in->getUsedSize(), 1, f) < 1) {
std::cerr << "ERROR: calling fwrite()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
in->consume();
if (fclose(f) != 0) {
std::cerr << "ERROR: calling fclose()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
}
}
//}
return 0;
}
int ocvm_dim_writer2::process()
{
std::cout << "dim writer on "
<< get_bind_host()
<< " launching\n" << flush;
DCBuffer * in;
std::string output_filename;
std::string mode;
std::vector<std::string> dirs_made;
std::vector<std::string> dirs_rename_to;
while (1) {
in = read_until_upstream_exit("0");
if (!in) {
break;
}
in->unpack("ss", &output_filename, &mode);
std::string d = dcmpi_file_dirname(output_filename);
std::string tstamp = dcmpi_file_basename(d);
std::string scratch_dir = dcmpi_file_dirname(d);
std::string temporary_dir = scratch_dir + "/.tmp." + tstamp;
std::string new_filename =
temporary_dir + "/" + dcmpi_file_basename(output_filename);
if (!dcmpi_file_exists(temporary_dir)) {
if (dcmpi_mkdir_recursive(temporary_dir)) {
if (errno != EEXIST) {
std::cerr << "ERROR: making directory " << temporary_dir
<< " on " << dcmpi_get_hostname()
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
}
else {
dirs_made.push_back(temporary_dir);
dirs_rename_to.push_back(scratch_dir + "/" + tstamp);
}
}
assert(dcmpi_file_exists(temporary_dir));
FILE * f;
if ((f = fopen(new_filename.c_str(), mode.c_str())) == NULL) {
std::cerr << "ERROR: opening " << new_filename
<< " for mode " << mode
<< " on host " << dcmpi_get_hostname()
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fwrite(in->getPtrExtract(), in->getExtractAvailSize(), 1, f) < 1) {
std::cerr << "ERROR: calling fwrite()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fclose(f) != 0) {
std::cerr << "ERROR: calling fclose()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
delete in;
}
// barrier
int nwriters = get_param_as_int("nwriters");
if (nwriters > 1) {
DCBuffer broadcast;
write_broadcast(&broadcast, "barrier");
for (int i = 0; i < nwriters-1; i++) {
DCBuffer* input = read ("barrier");
delete input;
}
}
for (unsigned int u = 0; u < dirs_made.size(); u++) {
rename(dirs_made[u].c_str(), dirs_rename_to[u].c_str());
}
std::cout << "dim writer on "
<< get_bind_host()
<< " exiting\n";
return 0;
}
int main(int argc, char *argv[])
{
std::string dest_host_scratch_filename;
bool non_local_destination = 0;
std::string client_hosts_filename;
bool non_local_clients = 0;
while (argc > 1) {
if (!strcmp(argv[1], "-dest")) {
non_local_destination = 1;
dest_host_scratch_filename = argv[2];
dcmpi_args_shift(argc, argv);
}
else if (!strcmp(argv[1], "-clients")) {
non_local_clients = 1;
client_hosts_filename = argv[2];
dcmpi_args_shift(argc, argv);
}
else {
break;
}
dcmpi_args_shift(argc, argv);
}
appname = argv[0];
if ((argc-1) != 5) {
usage();
}
HostScratch *dest_host_scratch = NULL;
if (non_local_destination) {
dest_host_scratch = new HostScratch(dest_host_scratch_filename);
}
if (non_local_destination && dest_host_scratch->components.empty()) {
std::cerr << "ERROR: destination host file is empty, aborting"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
HostScratch *client_host_scratch = NULL;
if (non_local_clients) {
client_host_scratch = new HostScratch(client_hosts_filename);
}
if (non_local_clients && client_host_scratch->components.empty()) {
std::cerr << "ERROR: destination host file is empty, aborting"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (!dcmpi_string_ends_with(tostr(argv[1]), ".dim")) {
std::cerr << "ERROR: invalid filename " << tostr(argv[1])
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (!dcmpi_string_ends_with(tostr(argv[2]), ".dim")) {
std::cerr << "ERROR: invalid filename " << tostr(argv[2])
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
int xs = atoi(argv[3]);
int ys = atoi(argv[4]);
int zs = atoi(argv[5]);
if (xs < 1 || ys < 1 || zs < 1) {
usage();
}
uint u, u2;
int rc;
DCLayout layout;
layout.use_filter_library("libocvmfilters.so");
DCFilterInstance console ("<console>", "console");
layout.add(console);
ImageDescriptor original_image_descriptor;
original_image_descriptor.init_from_file(argv[1]);
std::vector<std::string> input_hosts = original_image_descriptor.get_hosts();
std::vector<std::string> hosts;
std::map< std::string, std::string> src_to_dest_host, client_to_dest_host, client_to_src_host, src_to_client_host;
if (non_local_destination && !non_local_clients) {
assert(input_hosts.size() == dest_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < dest_host_scratch->components.size(); u++) {
src_to_dest_host[input_hosts[u]] = (dest_host_scratch->components[u])[0];
}
}
if (non_local_clients) {
assert(input_hosts.size() == client_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < client_host_scratch->components.size(); u++) {
client_to_src_host[(client_host_scratch->components[u])[0]] = input_hosts[u];
src_to_client_host[input_hosts[u]] = (client_host_scratch->components[u])[0];
}
if (non_local_destination) {
assert(client_host_scratch->components.size() == dest_host_scratch->components.size()); // Assumption for now. Will change later
for (u = 0; u < client_host_scratch->components.size(); u++) {
client_to_dest_host[(client_host_scratch->components[u])[0]] = (dest_host_scratch->components[u])[0];
}
}
hosts = client_host_scratch->get_hosts();
}
else {
hosts = input_hosts;
}
std::vector<DCFilterInstance*> rangefetchers;
std::vector<DCFilterInstance*> scalers;
for (u = 0; u < hosts.size(); u++) {
std::string uniqueName = "SC" + tostr(u);
DCFilterInstance * rangefetcher =
new DCFilterInstance("ocvm_mediator_rangefetcher",
uniqueName + "_f");
layout.add(rangefetcher);
rangefetchers.push_back(rangefetcher);
rangefetcher->bind_to_host(hosts[u]);
DCFilterInstance * scaler =
new DCFilterInstance("ocvm_scaler", uniqueName + "_cxx");
layout.add(scaler);
scalers.push_back(scaler);
scaler->bind_to_host(hosts[u]);
scaler->set_param("desc", tostr(original_image_descriptor));
if (non_local_clients && non_local_destination) {
scaler->set_param("dest_host_string", client_to_dest_host[hosts[u]]);
scaler->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(client_to_dest_host[hosts[u]]));
}
else if (non_local_destination && !non_local_clients) {
scaler->set_param("dest_host_string", src_to_dest_host[hosts[u]]);
scaler->set_param("dest_scratchdir", dest_host_scratch->get_scratch_for_host(src_to_dest_host[hosts[u]]));
}
else {
scaler->set_param("dest_host_string", hosts[u]);
if (!non_local_clients) {
scaler->set_param("dest_scratchdir", "");
}
else {
scaler->set_param("dest_scratchdir", client_host_scratch->get_scratch_for_host(hosts[u]));
}
}
if (non_local_clients) {
scaler->set_param("input_hostname", client_to_src_host[hosts[u]]);
}
else {
scaler->set_param("input_hostname", hosts[u]);
}
layout.add_port(rangefetcher, "0",
scaler, "from_rangefetcher");
layout.add_port(scaler, "to_rangefetcher",
rangefetcher, "0");
layout.add_port(scaler, "to_console", &console, "from_scaler");
}
std::vector< std::string> dest_hosts;
std::vector< std::string> client_hosts;
if (non_local_destination) {
dest_hosts = dest_host_scratch->get_hosts();
}
if (non_local_clients) {
client_hosts = client_host_scratch->get_hosts();
}
MediatorInfo info = mediator_setup(layout, 1, 1, input_hosts, client_hosts, dest_hosts);
mediator_add_client(layout, info, scalers);
mediator_add_client(layout, info, rangefetchers);
double before = dcmpi_doubletime();
std::string dim_timestamp = get_dim_output_timestamp();
layout.set_param_all("dim_timestamp", dim_timestamp);
layout.set_param_all("xs", tostr(xs));
layout.set_param_all("ys", tostr(ys));
layout.set_param_all("zs", tostr(zs));
DCFilter * console_filter = layout.execute_start();
std::map<ImageCoordinate, std::vector<std::string> > newfiles;
int newparts = xs*ys*zs*
original_image_descriptor.chunks_x*
original_image_descriptor.chunks_y*
original_image_descriptor.chunks_z;
std::cout << "newparts " << newparts << endl;
for (u = 0; u < newparts; u++) {
DCBuffer * in = console_filter->read("from_scaler");
ImageCoordinate ic;
std::string hn;
std::string output_filename;
int8 output_offset;
in->unpack("siiisl", &hn, &ic.x, &ic.y, &ic.z,
&output_filename, &output_offset);
std::vector<std::string> v;
v.push_back(hn);
v.push_back(output_filename);
v.push_back(tostr(output_offset));
newfiles[ic] = v;
delete in;
}
rc = layout.execute_finish();
if (rc) {
std::cerr << "ERROR: layout.execute() returned " << rc
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
else {
int i;
std::string message = "type BGRplanar\n";
message += "pixels_x " + tostr(original_image_descriptor.pixels_x*xs)+"\n";
message += "pixels_y " + tostr(original_image_descriptor.pixels_y*ys)+"\n";
message += "pixels_z " + tostr(original_image_descriptor.pixels_z*zs)+"\n";
message += "chunks_x " + tostr(original_image_descriptor.chunks_x*xs)+"\n";
message += "chunks_y " + tostr(original_image_descriptor.chunks_y*ys)+"\n";
message += "chunks_z " + tostr(original_image_descriptor.chunks_z*zs)+"\n";
message += "chunk_dimensions_x";
for (i = 0; i < xs; i++) {
for (u = 0; u < original_image_descriptor.chunks_x; u++) {
message += " ";
message += tostr(original_image_descriptor.chunk_dimensions_x[u]);
}
}
message += "\n";
message += "chunk_dimensions_y";
for (i = 0; i < ys; i++) {
for (u = 0; u < original_image_descriptor.chunks_y; u++) {
message += " ";
message += tostr(original_image_descriptor.chunk_dimensions_y[u]);
}
}
message += "\n";
std::map<ImageCoordinate, std::vector<std::string> >::iterator it;
for (it = newfiles.begin();
it != newfiles.end();
it++) {
std::string hn_new = it->second[0];
std::string fn_new = it->second[1];
std::string offset_new = it->second[2];
message += "part " + tostr(it->first) + " " +
hn_new + " " + fn_new + " " + offset_new + "\n";
}
message += "timestamp " + dcmpi_get_time() + "\n";
FILE *fout;
if ((fout = fopen(argv[2], "w")) == NULL) {
std::cerr << "ERROR: opening file"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fwrite(message.c_str(), message.size(), 1, fout) < 1) {
std::cerr << "ERROR: calling fwrite()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
if (fclose(fout) != 0) {
std::cerr << "ERROR: calling fclose()"
<< " at " << __FILE__ << ":" << __LINE__
<< std::endl << std::flush;
exit(1);
}
}
double after = dcmpi_doubletime();
std::cout << "elapsed scaler " << (after - before) << " seconds" << endl;
return rc;
}