int main(int argc, char **argv)
{
if(argc < 2){
printf("No input file given");
exit(0);
}
K = 5;
readBinary(argv[1]);
//readFile("uniform_data_16_1000.csv");
initVars();
threshold = 0.001;
//printf("Centroids at start:\n");
//printCentroids();
//printf("Starting k-Means\n");
//printDatapoints();
//time_t start = time(NULL);
double startTime = get_wall_time();
kMeans();
double endTime = get_wall_time();
printf("%.2f\n", endTime-startTime);
printDatapointClusters();
return 0;
}
DWORD WINAPI ExtractAndSendThreadEntry(LPVOID lpParam)
{
TThreadData* pTDat = (TThreadData*)lpParam;
//uint8_T* TSinglePart = pTDat->TSinglePart;
uint8_T* Tvec = pTDat->Tvec;
uint32_T* BoundBox = pTDat->BoundBox;
const uint32_T d = pTDat->d;
//uint8_T* RSinglePart = pTDat->RSinglePart;
uint8_T* Rvec = pTDat->Rvec;
uint32_T* b_DSPResponsibilityBox = pTDat->b_DSPResponsibilityBox;
uint32_T b_i = pTDat->b_i;
CHPRPCRequestStoreImg* pRequest = pTDat->pRequest;
//Extract partial image (places the extracted lines into the HPRPC command buffer. In case of a PCIe transfer directly to the buffers of the non-paged kernel memory used for DMA.)
CBufferedWriter& BufferedWriter=pRequest->GetHPRPCConnection().GetBufferedWriter();
extract(Tvec, BoundBox, d, BufferedWriter);
//Note: We could initiate the sending and start the pyramid generation here allready.
extract(Rvec, b_DSPResponsibilityBox, d, BufferedWriter);
//record duration
pTDat->ExtractFinishedWCTime = get_wall_time();
pTDat->ExtractFinishedCPUTime = get_cpu_time();
g_lastImageExtractor = pTDat; //last thread wins
//Start sending the data buffer to the target DSP (async, header and image data)
matlab_c_sendToTarget(b_i, pRequest);
//Remember completion time (for performance analysis)
pTDat->SndStartdWCTime = get_wall_time();
pTDat->SndStartdCPUTime = get_cpu_time();
g_lastPCIeSender = pTDat; //last thread wins
return 0;
}
PhysicsEngine::PhysicsEngine(int ballsPerSecond, float minimumY, float ballRadius) {
kMinimumY = minimumY;
kMsBetweenBalls = 1.f / ballsPerSecond * 1000.f;
kLastUpdate = get_wall_time();
kLastBall = get_wall_time();
kBallRadius = ballRadius;
}
void get_properties(const std::string &filename,
std::map<int, std::vector<double> > &properties)
{
std::cout << "Getting properties..." << std::endl;
double t_begin = get_wall_time();
std::ifstream in(filename.c_str());
require(in, "File " + filename + " can't be opened");
int materialID;
std::vector<double> values;
int n_values = 0; // default value
std::string line;
while (getline(in, line)) // read the file line-by-line
{
// if the line is empty or starts with '#' (a comment), we skip it
if (line.empty() || line[0] == '#') continue;
values.clear();
if (n_values == 0) // first run
values.reserve(10); // we don't expect more than 10 parameters by default
else
values.reserve(n_values);
std::istringstream instr(line);
instr >> materialID;
double val;
while (instr >> val)
values.push_back(val);
if (n_values == 0)
n_values = values.size();
else
require(n_values == (int)values.size(), "The number of parameters in the "
"first appearance was " + d2s(n_values) + ", but in some line "
"there are " + d2s(values.size()) + " of them");
// insert the vector into the map
std::pair<std::map<int, std::vector<double> >::const_iterator, bool> res =
properties.insert(std::pair<int, std::vector<double> >(materialID, values));
// check that the insertion was successfull
require(res.second, "Insertion of the values for the material with ID =" +
d2s(materialID) + " failed. Check the data (file = " + filename +
")");
}
in.close();
std::cout << "Getting properties is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
void Run(std::string iArgument1, std::string iArgument2)
{
if (iArgument2=="GeneralStats")
GeneralStats(iArgument1);
else if (iArgument2=="")
{
std::string Instance = iArgument1;
int PopSize = 16;
int MaxHamming = 3;
int RCLLength = 3;
double MutationRate = 0.1;
double TransmitionRate = 0.2;
int MaxNbGenerations = 200;
double InfMeanDiff = 0.002;
Traces ExecTraces;
ExecTraces.Initialize(PopSize, MaxNbGenerations);
GRASP myGRASP(Instance, PopSize, MaxHamming, RCLLength, MutationRate, TransmitionRate, MaxNbGenerations, InfMeanDiff, &ExecTraces);
ExecTraces._BeginPopBuilt_UserTime = get_wall_time();
ExecTraces._BeginPopBuilt_CPUTime = get_cpu_time();
myGRASP.Construction();
ExecTraces._EndPopBuilt_CPUTime = get_cpu_time();
ExecTraces._EndPopBuilt_UserTime = get_wall_time();
Localisation * TmpBestLoc = myGRASP.GetBestLocalisation();
if (TmpBestLoc)
ExecTraces._GRASPBestCost = TmpBestLoc->GetLocalisationCost();
ExecTraces._BeginGenetic_UserTime = get_wall_time();
ExecTraces._BeginGenetic_CPUTime = get_cpu_time();
myGRASP.GeneticAlgorithm();
ExecTraces._EndGenetic_CPUTime = get_cpu_time();
ExecTraces._EndGenetic_UserTime = get_wall_time();
TmpBestLoc = myGRASP.GetBestLocalisation();
if (TmpBestLoc)
ExecTraces._GeneticBestCost = TmpBestLoc->GetLocalisationCost();
std::cout << "===== Parameters\n";
std::cout << "Size of the population: " << PopSize << "\n";
std::cout << "Maximal Hamming Distance: " << MaxHamming << "\n";
std::cout << "Length of RCl (restricted candidates list): " << RCLLength << "\n";
std::cout << "Mutation rate: " << MutationRate << "\n";
std::cout << "Transmition rate: " << TransmitionRate << "\n";
std::cout << "Maximal number of generation in genetic algorithm: " << MaxNbGenerations << "\n";
std::cout << "Mean difference of the costs of the population from which stop: " << InfMeanDiff << "\n";
std::cout << "\n";
std::cout << "===== Result of the metaheuristic\n";
myGRASP.PrintBestLocalisation();
ExecTraces.PostTreatment();
TmpBestLoc = 0;
}
}
void makeSelectionTrees_small(void)
{
// TChain *tth_chain = loadFiles("ttH");
// run_it(tth_chain,"ttH_lepTopBDTResults.root");
double totStart = get_wall_time();
TString output_file = "skimSelection.root";
TChain *chain = new TChain("OSTwoLepAna/summaryTree");
//chain->Add("/tmpscratch/users/mlink2/rootFiles/charlie_tree_11503.root");
/*
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/tth_nonbb/charlie_tree_11503.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/tth_nonbb/charlie_tree_21176.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/tth_nonbb/charlie_tree_30640.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_10640.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_11504.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_12183.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_13130.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_13381.root");
*/
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_10640.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_11504.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_12183.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_13130.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_13381.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_14553.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_15205.root");
chain->Add("/hadoop/store/user/lannon/bdtreco_v0/ttjets_semilep/charlie_tree_16058.root");
/*
std::ifstream infile("files_forSelection_ttjet.txt");
TString line;
while (infile >> line ){
chain->Add(line );
cout << line << endl;
}
*/
double chainTime = get_wall_time() - totStart;
run_it(chain,output_file);
double totEnd = get_wall_time();
double totalTime = totEnd - totStart;
cout << "total time: " << totalTime << endl;
cout << "chain time: " << chainTime << endl;
// TChain *ttw_chain = loadFiles("ttW");
// TChain *ttbar_chain = loadFiles("ttbar");
}
int main(int argc, char *argv[])
{
int size, rank;
int i, j;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
double start=get_wall_time();
int N=5;
int hist_size=25;
int **global_image=allocate_2d_matrix(N,N);
int *local_histogram=calloc(hist_size,sizeof(int));
int *histogram=calloc(hist_size,sizeof(int));
int counter=0;
for(i=rank; i<N; i=i+size)
for(j=0; j<N; j++)
global_image[i][j]=i*N+j;
MPI_Barrier(MPI_COMM_WORLD);
for(i=rank; i<N; i=i+size)
for(j=0; j<N; j++)
local_histogram[global_image[i][j]]++;
MPI_Barrier(MPI_COMM_WORLD);
MPI_Reduce(local_histogram, histogram, hist_size, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
if(rank==0)
for(i=0;i<hist_size;i++)
printf("%d. %d\n",i+1,histogram[i]);
free(global_image);
free(local_histogram);
free(histogram);
double end=get_wall_time();
//printf("\nElapsed time: %f\n",(end-start));
MPI_Finalize();
return 0;
}
void RectangularMesh::
write_binary_files_in_cells(const std::string &prop_filename,
std::vector<std::string> &filenames_out) const
{
std::cout << "Writing binary files in cells..." << std::endl;
double t_begin = get_wall_time();
// Create the map between the material IDs and the media properties. The
// material IDs must exactly the same as in the given triangular mesh.
std::map<int, std::vector<double> > properties;
get_properties(prop_filename, properties);
const int n_properties = properties.begin()->second.size();
filenames_out.resize(n_properties);
std::ofstream *out = new std::ofstream[n_properties];
for (int i = 0; i < n_properties; ++i)
{
filenames_out[i] = "property" + d2s(i) + "_cells.bin";
out[i].open(filenames_out[i].c_str(), std::ios::binary);
require(out[i], "File '" + filenames_out[i] + "' can't be opened");
}
for (int i = 0; i < _n_elements_x*_n_elements_z; ++i)
{
const int matID = _cells_ID[i];
std::map<int, std::vector<double> >::const_iterator iter =
properties.find(matID);
require(iter != properties.end(), "The material ID " + d2s(matID) +
" wasn't found in the properties file");
const std::vector<double> values = iter->second;
for (int p = 0; p < n_properties; ++p)
{
OUT_FLOAT_TYPE val = values[p];
out[p].write(reinterpret_cast<char*>(&val), sizeof(OUT_FLOAT_TYPE));
}
}
for (int i = 0; i < n_properties; ++i)
out[i].close();
delete[] out;
std::cout << "Writing binary files in cells is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
void RectangularMesh::
assign_material_id_at_nodes(const TriangularMesh &tri_mesh)
{
double t0 = get_wall_time();
std::cout << "Assigning material IDs at nodes..." << std::endl;
_verts_ID = new int[(_n_elements_x+1)*(_n_elements_z+1)];
const double x0 = _min_coord.x(); // limits in x-direction
const double x1 = _max_coord.x();
const double z0 = _min_coord.z(); // limits in z-direction
const double z1 = _max_coord.z();
const double hx = (x1 - x0) / _n_elements_x; // step in x-direction
const double hz = (z1 - z0) / _n_elements_z; // step in z-direction
const bool throw_exception = false;
for (int iz = 0; iz < _n_elements_z+1; ++iz)
{
const double z = (iz == _n_elements_z ? z1 : z0 + iz*hz);
int triangle_index = 0; // reset the index from the previous search
for (int ix = 0; ix < _n_elements_x+1; ++ix)
{
const double x = (ix == _n_elements_x ? x1 : x0 + ix*hx);
Point2 vertex(x, z);
require(tri_mesh.contains_point(vertex), "The triangular mesh doesn't "
"contain the point: " + d2s(vertex));
// every search along the x-line at the same z-coordinate starts with the
// previously found triangle
triangle_index = tri_mesh.find_element(vertex,
triangle_index,
throw_exception);
if (triangle_index < 0) // if it wasn't found
{
std::cout << " full search for point " << vertex << std::endl;
triangle_index = tri_mesh.full_search(vertex);
}
const int mat_ID = tri_mesh.element(triangle_index).material_id();
_verts_ID[iz*(_n_elements_x+1)+ix] = mat_ID;
}
}
std::cout << "Assigning material IDs at nodes is done. Time = "
<< get_wall_time() - t0 << std::endl;
}
void RectangularMesh::
assign_material_id_in_cells(const TriangularMesh &tri_mesh)
{
double t0 = get_wall_time();
std::cout << "Assigning material IDs in cells..." << std::endl;
_cells_ID = new int[_n_elements_x*_n_elements_z];
const double x0 = _min_coord.x(); // limits in x-direction
const double x1 = _max_coord.x();
const double z0 = _min_coord.z(); // limits in z-direction
const double z1 = _max_coord.z();
const double hx = (x1 - x0) / _n_elements_x; // step in x-direction
const double hz = (z1 - z0) / _n_elements_z; // step in z-direction
const bool throw_exception = false;
for (int iz = 0; iz < _n_elements_z; ++iz)
{
const double zcen = z0 + (iz+0.5)*hz; // z-coord of a cell center
int triangle_index = 0; // reset the index from the previous search
for (int ix = 0; ix < _n_elements_x; ++ix)
{
const double xcen = x0 + (ix+0.5)*hx; // x-coord of a cell center
Point2 cell_center(xcen, zcen);
require(tri_mesh.contains_point(cell_center), "The triangular mesh "
"doesn't contain the point: " + d2s(cell_center));
// every search along the x-line at the same z-coordinate starts with the
// previously found triangle
triangle_index = tri_mesh.find_element(cell_center,
triangle_index,
throw_exception);
if (triangle_index < 0) // if it wasn't found
{
std::cout << " full search for point " << cell_center << std::endl;
triangle_index = tri_mesh.full_search(cell_center);
}
const int mat_ID = tri_mesh.element(triangle_index).material_id();
_cells_ID[iz*_n_elements_x + ix] = mat_ID;
}
}
std::cout << "Assigning material IDs in cells is done. Time = "
<< get_wall_time() - t0 << std::endl;
}
void start_server_discovery()
{
if(server_discovery_started)
return;
selected_server = -1;
top_server_visible = 0;
num_servers_unqueried = 0;
num_servers_queried = 0;
num_servers_found = 0;
num_servers_new_proto = 0;
struct server_t *cserver = rumoured_servers;
while(cserver)
{
num_servers_unqueried++;
LL_ADD_TAIL(struct server_t, &unqueried_servers, cserver);
LL_NEXT(cserver);
}
pipe(servers_info_pipe);
output_server_query();
servers_first_output = get_wall_time();
servers_next_output = 1.0 / SERVER_QUERY_OUTPUT_RATE + servers_first_output;
pipe(servers_kill_pipe);
pthread_create(&servers_thread_id, NULL, servers_thread, NULL);
server_discovery_started = 1;
}
double Clock::timeElapsed() {
if (_started)
return _elapsed + get_wall_time() - _last;
else
return _elapsed;
}
void process_server_info(struct sockaddr_in *sockaddr, struct buffer_t *buffer)
{
struct queried_server_t *cserver = queried_servers;
struct found_server_t new_server_info;
uint16_t servers;
struct sockaddr_in s;
time_t t;
int proto_ver;
while(cserver)
{
if(cserver->ip == sockaddr->sin_addr.s_addr &&
cserver->port == sockaddr->sin_port)
{
proto_ver = buffer_read_uint8(buffer);
if(proto_ver != EM_PROTO_VER)
{
if(proto_ver > EM_PROTO_VER)
num_servers_new_proto++;
break;
}
new_server_info.ip = sockaddr->sin_addr.s_addr;
new_server_info.port = sockaddr->sin_port;
new_server_info.ping = get_wall_time() - cserver->stamp;
new_server_info.host_name = buffer_read_string(buffer);
new_server_info.map_name = buffer_read_string(buffer);
new_server_info.num_players = buffer_read_uint8(buffer);
new_server_info.max_players = buffer_read_uint8(buffer);
new_server_info.authenticating = buffer_read_uint8(buffer);
add_new_found_server(&new_server_info);
add_new_server(&rumoured_servers, sockaddr, time(NULL));
servers = buffer_read_uint16(buffer);
while(servers--)
{
s.sin_addr.s_addr = buffer_read_uint32(buffer);
s.sin_port = buffer_read_uint16(buffer);
t = buffer_read_uint32(buffer);
if(!find_queried_server(s.sin_addr.s_addr, s.sin_port))
{
if(add_new_server(&unqueried_servers, &s, t))
num_servers_unqueried++;
}
}
break;
}
LL_NEXT(cserver);
}
}
std::vector<PhysicsBall> PhysicsEngine::update(glm::vec3 desiredDropOrigin, std::vector<PhysicsInteractor> hands) {
std::vector<PhysicsBall> balls;
float secElapsed = get_wall_time() - kLastUpdate;
kLastUpdate = get_wall_time();
//create balls if its been too long
if (((get_wall_time() - kLastBall) * 1000.f) > kMsBetweenBalls) {
kLastBall = get_wall_time();
kBalls.push(PhysicsBall(desiredDropOrigin, glm::vec3(0, -0.01, 0), kBallRadius));
}
//run physics for all balls
for (unsigned int i = 0; i < kBalls.size(); i++) {
PhysicsBall curBall = kBalls.front();
bool keepBall = true;
kBalls.pop();
//Don't calculate ball if it has dropped out of frame
if (curBall.position.y < kMinimumY)
continue;
//Calc ball movement
curBall.position += curBall.velocity * secElapsed;
curBall.velocity += glm::vec3(0, -9.8 * secElapsed, 0);
//Handle hand interaction
for (unsigned int j = 0; j < hands.size(); j++) {
if (glm::distance(curBall.position, hands[j].position) < curBall.radius + hands[j].radius) {
if (hands[j].bounce) {
//ball is bounced, recalc velocity and add
glm::vec3 newDirection = glm::normalize(curBall.position - hands[j].position);
curBall.velocity = newDirection * glm::length(curBall.velocity);
} else {
keepBall = false;
break;
}
}
}
if (keepBall) {
kBalls.push(curBall);
balls.push_back(curBall);
}
}
return balls;
}
void RectangularMesh::
write_ASCII_files_at_nodes(const std::string &prop_filename) const
{
std::cout << "Writing ASCII files at nodes..." << std::endl;
double t_begin = get_wall_time();
// Create the map between the material IDs and the media properties. The
// material IDs must exactly the same as in the given triangular mesh.
std::map<int, std::vector<double> > properties;
get_properties(prop_filename, properties);
const int n_properties = properties.begin()->second.size();
std::vector<std::string> filenames_out(n_properties);
std::ofstream *out = new std::ofstream[n_properties];
for (int i = 0; i < n_properties; ++i)
{
filenames_out[i] = "property" + d2s(i) + "_nodes.txt";
out[i].open(filenames_out[i].c_str(), std::ios::binary);
require(out[i], "File '" + filenames_out[i] + "' can't be opened");
}
for (int i = 0; i < (_n_elements_x+1)*(_n_elements_z+1); ++i)
{
const int matID = _verts_ID[i];
std::map<int, std::vector<double> >::const_iterator iter =
properties.find(matID);
require(iter != properties.end(), "The material ID " + d2s(matID) +
" wasn't found in the properties file");
const std::vector<double> values = iter->second;
for (int p = 0; p < n_properties; ++p)
out[p] << values[p] << "\n";
}
for (int i = 0; i < n_properties; ++i)
out[i].close();
delete[] out;
std::cout << "Writing ASCII files at nodes is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
void init_control()
{
double time = get_wall_time();
next_control_tick = ((int)(time / CONTROL_TICK_INTERVAL) + 1) * (double)CONTROL_TICK_INTERVAL;
create_alarm_listener(process_control_alarm);
pipe(control_kill_pipe);
pthread_create(&control_thread_id, NULL, control_thread, NULL);
}
void test_performance(bvgraph g, int test_num)
{
//randomly generate test case
int64_t i = 0;
uint64_t d;
srand(time(NULL));
double start, end;
bvgraph_random_iterator ri;
int rval = bvgraph_random_access_iterator(&g, &ri);
if (rval){
printf ("Random access iterator allocation failed. Stop.\n");
return;
}
int64_t node = 0;
int64_t *links = NULL;
int64_t edge_count = 0;
start = get_wall_time();
for (i = 0; i < test_num; i++) {
node = rand() % g.n;
bvgraph_random_outdegree(&ri, node, &d);
bvgraph_random_successors(&ri, node, &links, &d);
int64_t j = 0;
int64_t link;
for (j=0; j<d; j++){
link = links[j];
}
edge_count += d;
//printf ("node %d has degree %d\n", node, d);
}
end = get_wall_time();
double dif = ((double)end - (double)start);
double edge_per_sec = edge_count / dif;
printf("Used %.2lf secs. Edges = %"PRId64". Edges per second = %.2lf\n", dif, edge_count, edge_per_sec);
bvgraph_random_free(&ri);
}
int main(void) {
double pi = 0.0f;
long long i;
double time_begin=get_wall_time();
double t = 0;
#pragma acc parallel loop private(t)
for (i=0; i<N; i++) {
t= (double)((i+0.5)/N);
pi +=4.0/(1.0+t*t);
}
double time_end=get_wall_time();
printf("pi=%11.10f\n",pi/N);
printf("Total elapsed time is: %.4lf\n", (time_end - time_begin));
return 0;
}
void servers_alarm()
{
if(!server_discovery_started)
return;
float time = get_wall_time();
if(time >= servers_next_output)
{
pthread_mutex_lock(&servers_mutex);
output_server_query();
pthread_mutex_unlock(&servers_mutex);
servers_next_output = (floor((time - servers_first_output) *
SERVER_QUERY_OUTPUT_RATE) + 1.0) / SERVER_QUERY_OUTPUT_RATE + servers_first_output;
}
}
void process_control_alarm()
{
double time = get_wall_time();
if(time > next_control_tick)
{
pthread_mutex_lock(&control_mutex);
if(game_state == GAMESTATE_PLAYING)
{
pthread_mutex_lock(&control_mutex);
if(roll_changed)
{
net_emit_uint8(game_conn, EMMSG_ROLL);
net_emit_float(game_conn, roll);
net_emit_end_of_stream(game_conn);
roll_changed = 0;
roll = 0.0;
}
if(rolling_left)
{
net_emit_uint8(game_conn, EMMSG_ROLL);
net_emit_float(game_conn, -0.2);
net_emit_end_of_stream(game_conn);
}
if(rolling_right)
{
net_emit_uint8(game_conn, EMMSG_ROLL);
net_emit_float(game_conn, 0.2);
net_emit_end_of_stream(game_conn);
}
pthread_mutex_unlock(&control_mutex);
}
next_control_tick = ((int)(time / CONTROL_TICK_INTERVAL) + 1) *
(double)CONTROL_TICK_INTERVAL;
pthread_mutex_unlock(&control_mutex);
}
}
void output_server_query()
{
struct sockaddr_in sockaddr;
struct queried_server_t queried_server;
if(unqueried_servers)
{
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = unqueried_servers->ip;
sockaddr.sin_port = unqueried_servers->port;
net_emit_server_info(&sockaddr, NULL, 0);
queried_server.ip = unqueried_servers->ip;
queried_server.port = unqueried_servers->port;
queried_server.stamp = get_wall_time();
LL_ADD(struct queried_server_t, &queried_servers, &queried_server);
LL_REMOVE(struct server_t, &unqueried_servers, unqueried_servers);
num_servers_unqueried--;
num_servers_queried++;
}
}
void TypicalTimeOfLocalisationBuilt(std::string iInstance)
{
// Creation of the instance
Testio Instance(iInstance);
// Time needed to build the localisation
double ConstructionUserTime = 0;
double ConstructionCPUTime = 0;
// Time to explore a neighbourhood for Hamming distance equal to 1
double Exploration1UserTime = 0;
double Exploration1CPUTime = 0;
// Time to explore a neighbourhood for Hamming distance equal to 2
double Exploration2UserTime = 0;
double Exploration2CPUTime = 0;
// Time to explore a neighbourhood for Hamming distance equal to 3
double Exploration3UserTime = 0;
double Exploration3CPUTime = 0;
// Time to execute a complete local search
double LocalSearchUserTime = 0;
double LocalSearchCPUTime = 0;
int NbIter = 10;
int i;
for (i = 0; i < NbIter; i++)
{
Localisation myLoc(Instance, 0, 0);
// Construction of the localisation
double BeginUserTime = get_wall_time();
double BeginCPUTime = get_cpu_time();
myLoc.Construction(3);
double EndCPUTime = get_cpu_time();
double EndUserTime = get_wall_time();
ConstructionUserTime = ConstructionUserTime + EndUserTime - BeginUserTime;
ConstructionCPUTime = ConstructionCPUTime + EndCPUTime - BeginCPUTime;
// Exploration of a neighbourhood for Hamming distance equal to 1
BeginUserTime = get_wall_time();
BeginCPUTime = get_cpu_time();
myLoc.NeighbourhoodSearch(1);
EndCPUTime = get_cpu_time();
EndUserTime = get_wall_time();
Exploration1UserTime = Exploration1UserTime + EndUserTime - BeginUserTime;
Exploration1CPUTime = Exploration1CPUTime + EndCPUTime - BeginCPUTime;
// Exploration of a neighbourhood for Hamming distance equal to 1
BeginUserTime = get_wall_time();
BeginCPUTime = get_cpu_time();
myLoc.NeighbourhoodSearch(2);
EndCPUTime = get_cpu_time();
EndUserTime = get_wall_time();
Exploration2UserTime = Exploration2UserTime + EndUserTime - BeginUserTime;
Exploration2CPUTime = Exploration2CPUTime + EndCPUTime - BeginCPUTime;
// Exploration of a neighbourhood for Hamming distance equal to 1
BeginUserTime = get_wall_time();
BeginCPUTime = get_cpu_time();
myLoc.NeighbourhoodSearch(3);
EndCPUTime = get_cpu_time();
EndUserTime = get_wall_time();
Exploration3UserTime = Exploration3UserTime + EndUserTime - BeginUserTime;
Exploration3CPUTime = Exploration3CPUTime + EndCPUTime - BeginCPUTime;
}
int NbLocalSearch = 5;
for (i = 0; i < NbLocalSearch; i++)
{
Localisation myLoc(Instance, 0, 0);
// Construction of the localisation
myLoc.Construction(3);
// Computation of a complete local search
double BeginUserTime = get_wall_time();
double BeginCPUTime = get_cpu_time();
myLoc.LocalSearchAlgorithm(3);
double EndCPUTime = get_cpu_time();
double EndUserTime = get_wall_time();
LocalSearchUserTime = LocalSearchUserTime + EndUserTime - BeginUserTime;
LocalSearchCPUTime = LocalSearchCPUTime + EndCPUTime - BeginCPUTime;
}
std::cout.precision(4);
std::cout << "Time needed to build the localisation\n";
std::cout << " CPU time : " << ConstructionCPUTime/NbIter << "s\n";
std::cout << " User time: " << ConstructionUserTime/NbIter << "s\n";
std::cout << "Time to explore a neighbourhood for Hamming distance equal to 1\n";
std::cout << " CPU time : " << Exploration1CPUTime/NbIter << "s\n";
std::cout << " User time: " << Exploration1UserTime/NbIter << "s\n";
std::cout << "Time to explore a neighbourhood for Hamming distance equal to 2\n";
std::cout << " CPU time : " << Exploration2CPUTime/NbIter << "s\n";
std::cout << " User time: " << Exploration2UserTime/NbIter << "s\n";
std::cout << "Time to explore a neighbourhood for Hamming distance equal to 3\n";
std::cout << " CPU time : " << Exploration3CPUTime/NbIter << "s\n";
std::cout << " User time: " << Exploration3UserTime/NbIter << "s\n";
std::cout << "Time to execute a complete local search\n";
std::cout << " CPU time : " << LocalSearchCPUTime/NbLocalSearch << "s\n";
std::cout << " User time: " << LocalSearchUserTime/NbLocalSearch << "s\n";
std::cout << "\n";
}
void NonOptimalSolutions(std::string iInstance)
{
// Optimal values of the instances
static struct {
const std::string _TestName;
double _OptimalValue;
} aInstance[] = {
// Test name Optimal value
{"TestCases/Input/cap71.txt", 932615.75 },
{"TestCases/Input/cap72.txt", 977799.4 },
{"TestCases/Input/cap73.txt", 1010641.45 },
{"TestCases/Input/cap74.txt", 1034976.975 },
{"TestCases/Input/cap101.txt", 796648.4375 },
{"TestCases/Input/cap102.txt", 854704.2 },
{"TestCases/Input/cap103.txt", 893782.1125 },
{"TestCases/Input/cap104.txt", 928941.75 },
{"TestCases/Input/cap131.txt", 793439.5625 },
{"TestCases/Input/cap132.txt", 851495.325 },
{"TestCases/Input/cap133.txt", 893076.7125 },
{"TestCases/Input/cap134.txt", 928941.75 },
{"TestCases/Input/capa.txt", 17156454.4783 },
{"TestCases/Input/capb.txt", 12979071.58143},
{"TestCases/Input/capc.txt", 11505594.32878}
};
int IdxTest;
for (IdxTest = 0; IdxTest < 15; IdxTest++) {
if (aInstance[IdxTest]._TestName == iInstance)
break;
}
if (IdxTest==15) {
std::cout << "The optimal value of the problem is unknown. Fill code with it!\n";
return;
}
int NbTest = 100;
// Array of the found optimal costs
double * aOptimalCosts = new double[NbTest];
memset(aOptimalCosts, 0, NbTest*sizeof(double));
// Time to perform algorithm
double UserTime = 0;
double CPUTime = 0;
// Parameters of the algorithm
std::string Instance = iInstance;
int PopSize = 16;
int MaxHamming = 3;
int RCLLength = 3;
double MutationRate = 0.1;
double TransmitionRate = 0.2;
int MaxNbGenerations = 200;
double InfMeanDiff = 0.002;
int i;
for (i = 0; i < NbTest; i++)
{
GRASP myGRASP(Instance, PopSize, MaxHamming, RCLLength, MutationRate, TransmitionRate, MaxNbGenerations, InfMeanDiff, 0);
double BeginUserTime = get_wall_time();
double BeginCPUTime = get_cpu_time();
myGRASP.Construction();
myGRASP.GeneticAlgorithm();
double EndCPUTime = get_cpu_time();
double EndUserTime = get_wall_time();
Localisation * BestLoc = myGRASP.GetBestLocalisation();
if (BestLoc)
aOptimalCosts[i] = BestLoc->GetLocalisationCost();
UserTime = UserTime + EndUserTime - BeginUserTime;
CPUTime = CPUTime + EndCPUTime - BeginCPUTime;
}
int NbNonOptimal = 0;
double MeanDiff = 0;
for (i = 0; i < NbTest; i++) {
double diff = fabs(aOptimalCosts[i]-aInstance[IdxTest]._OptimalValue);
if ( diff > EPSILON )
{
NbNonOptimal++;
MeanDiff+=diff;
}
}
std::cout.precision(3);
std::cout << "Percentage of returned non-optimal solutions: " << NbNonOptimal*100./NbTest << "%\n";
std::cout.precision(4);
if (NbNonOptimal > 0)
MeanDiff = 100 * MeanDiff / (NbNonOptimal*aInstance[IdxTest]._OptimalValue);
std::cout << "Averge mean difference of non-optimal solutions with optimum: " << MeanDiff << "%\n";
std::cout << "\n";
std::cout.precision(4);
std::cout << "Average time to perform GRASP algorithm:\n";
std::cout << " CPU time : " << CPUTime/NbTest << "s\n";
std::cout << " User time: " << UserTime/NbTest << "s\n";
std::cout << "\n";
if (aOptimalCosts)
delete [] aOptimalCosts; aOptimalCosts = 0;
}
int main(int argc, char *argv[])
{
int i,j,ii,jj,i_tile,j_tile;
const int N=100000;
double sumC_n, sumC_t;
double *A = malloc(sizeof(double)*N*N);
double *b = malloc(sizeof(double)*N);
double *c_naive = malloc(sizeof(double)*N);
double *c_tile=malloc(sizeof(double)*N);
sumC_n = 0.0;
sumC_t = 0.0;
j_tile = 10000;
i_tile = 10000;
for (i=0; i<N; i++){
for (j=0; j<N; j++){
A[i*N+j] = (i+1)*N+j+1;
}
}
for (i=0; i<N; i++){
b[i] = (i+1)^2;
c_naive[i] = 0.0;
c_tile[i] = 0.0;
}
double start_n=get_wall_time();
for(i=0; i<N; i++){
for(j=0; j<N; j++){
c_naive[i] += A[i*N+j]*b[j];
}
}
double finish_n=get_wall_time();
double start=get_wall_time();
//#pragma omp for private(i,j,ii,jj) shared(A,b,c,i_tile,j_tile) num_threads(4)
for(jj=0; jj<N; jj+=j_tile){
for(i=0; i<N; i++){
for(j=jj; j<jj+j_tile; j++){
c_tile[i] += A[i*N+j]*b[j];
}
}
}
double finish=get_wall_time();
for(i=0;i<N;i++){
sumC_n = sumC_n + c_naive[i];
sumC_t = sumC_t + c_tile[i];
}
free(A);
free(b);
free(c_naive);
free(c_tile);
printf("Naive Time: %f seconds and SUM: %f\n",finish_n-start_n,sumC_n);
printf("Tiled Time: %f seconds and SUM: %f\n",finish-start,sumC_t);
return 0;
}
void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, image *labels, int classes, int frame_skip)
{
detection_layer l;
//skip = frame_skip;
int delay = frame_skip;
demo_names = names;
demo_labels = labels;
demo_classes = classes;
demo_thresh = thresh;
printf("Demo\n");
net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
if(filename){
cap = cvCaptureFromFile(filename);
}else{
cap = cvCaptureFromCAM(cam_index);
}
if(!cap) error("Couldn't connect to webcam.\n");
l = net.layers[net.n-1];
int j;
avg = (float *) calloc(l.outputs, sizeof(float));
for(j = 0; j < FRAMES; ++j) predictions[j] = (float *) calloc(l.outputs, sizeof(float));
for(j = 0; j < FRAMES; ++j) images[j] = make_image(1,1,3);
boxes = (box *)calloc(l.side*l.side*l.n, sizeof(box));
probs = (float **)calloc(l.side*l.side*l.n, sizeof(float *));
for(j = 0; j < l.side*l.side*l.n; ++j) probs[j] = (float *)calloc(l.classes, sizeof(float *));
pthread_t fetch_thread;
pthread_t detect_thread;
fetch_in_thread(0);
det = in;
det_s = in_s;
fetch_in_thread(0);
detect_in_thread(0);
disp = det;
det = in;
det_s = in_s;
for(j = 0; j < FRAMES/2; ++j){
fetch_in_thread(0);
detect_in_thread(0);
disp = det;
det = in;
det_s = in_s;
}
int count = 0;
cvNamedWindow("Demo", CV_WINDOW_AUTOSIZE);
cvMoveWindow("Demo", 0, 0);
cvResizeWindow("Demo", 1352, 1013);
double before = get_wall_time();
while(1){
++count;
if(1){
if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed");
if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed");
show_image(disp, "Demo");
int c = cvWaitKey(1);
if (c == 10){
if(frame_skip == 0) frame_skip = 60;
else if(frame_skip == 4) frame_skip = 0;
else if(frame_skip == 60) frame_skip = 4;
else frame_skip = 0;
}
pthread_join(fetch_thread, 0);
pthread_join(detect_thread, 0);
if(delay == 0){
free_image(disp);
disp = det;
}
det = in;
det_s = in_s;
}else {
fetch_in_thread(0);
det = in;
det_s = in_s;
detect_in_thread(0);
if(delay == 0) {
free_image(disp);
disp = det;
}
show_image(disp, "Demo");
cvWaitKey(1);
}
--delay;
if(delay < 0){
delay = frame_skip;
double after = get_wall_time();
float curr = 1./(after - before);
fps = curr;
before = after;
}
}
}
bool
prb_stopwatch_start(prb_stopwatch_t* sw, int op)
{
sw->start_times[op] = get_wall_time();
}
bool
prb_stopwatch_stop(prb_stopwatch_t* sw, int op)
{
sw->stop_times[op] = get_wall_time();
sw->durations[op] = sw->stop_times[op] - sw->start_times[op];
}
int timer_timedOut(void){
return (timerActive && get_wall_time() > timerEndTime);
}
void timer_start(double duration){
timerEndTime = get_wall_time() + duration;
timerActive = 1;
}
/* Function Definitions */
void c_transmitImageData(uint32_T DSPCount, real32_T w[3], real32_T da, real32_T
dtr, const emxArray_uint8_T *Tvec, const emxArray_uint8_T *Rvec, uint32_T d, uint32_T levels, CImgTransTimestamps& Timestamps)
{
real32_T y;
real32_T dmax;
real32_T b_y;
real32_T s;
uint32_T aHeight;
uint32_T aWidth;
real32_T rr;
real32_T angles[6];
int32_T i;
uint32_T b_i;
real32_T rl;
int32_T angle_size;
int32_T c_y;
int32_T Box_size_idx_0;
int32_T ixstart;
real32_T Box_data[48];
real32_T uBox[8];
int32_T x;
//uint8_t *TSinglePart;
//uint8_t *RSinglePart;
real32_T rt;
real32_T rb;
real32_T DSPResponsibilityBox[4];
int32_T ix;
boolean_T exitg4;
uint32_T marginL;
boolean_T exitg3;
uint32_T marginR;
boolean_T exitg2;
uint32_T marginO;
boolean_T exitg1;
uint32_T marginU;
uint32_T BoundBox[4];
uint32_T b_DSPResponsibilityBox[4];
uint32_T MarginAddon[3];
Timestamps.BeginXtrct.measureWallAndCPUTime();
/* Global definition has only effect in matlab simulation (coder.extrinsic forbids global use here in matlab coder) */
/* coder.extrinsic('global'); %this line unfortunately doesn't work */
/* global GlobTParts GlobTPartsPtrs GlobRParts GlobRPartsPtrs GlobDSPResponsibilityBox GlobBoundBox GlobImgDimension; */
y = (real32_T)d / 2.0F;
dmax = (real32_T)d / 2.0F - 0.5F;
b_y = (real32_T)d / 2.0F;
s = (real32_T)d / 2.0F + 0.5F;
/* Shifting, um negative Koordinaten in Matrixbereich zu bringen */
/* ======================================================================== */
/* = Relevante Bildteile berechnen, Bilder �bertragen */
/* ======================================================================== */
/* Calc layout of DSP grid regarding the Reference image */
calcDSPLayout(DSPCount, &aWidth, &aHeight);
/* Winkelst�tzstellen berechnen. */
/* Einerseits die erlaubten Maximalwinkel w-da, w+da */
/* Ferner alle Extrema zwischen den St�tzstelen ((x-45) mod 90 = 0) */
rr = w[0] / 6.28318548F;
rr = (rr - (real32_T)floor(rr)) * 6.28318548F;
w[0] = rr;
/* ensure angle to be in range 0 ... 360 deg */
for (i = 0; i < 6; i++) {
angles[i] = 0.0F;
}
angles[0] = w[0] - da;
angles[1] = w[0] + da;
b_i = 2U;
/* Maximum diagonal extend is at 45deg, (90+45)deg, (190+45)deg etc. */
/* wMax=single(0); */
for (i = 0; i < 12; i++) {
rl = -5.497787F + (real32_T)i * 1.57079637F;
/* because dt is allowed to be 0 ... 360 deg */
if ((angles[0] < rl) && (angles[1] > rl)) {
angles[(int32_T)b_i] = rl;
b_i++;
}
}
angle_size = (int32_T)b_i;
/* DSPResponsibilityBox=zeros(4,'single'); */
/* BoundBox=zeros(4,'uint32'); */
c_y = (int32_T)(((uint32_T)(int32_T)b_i - 1U) << 2);
Box_size_idx_0 = (int32_T)((uint32_T)c_y + 4U);
i = ((int32_T)((uint32_T)c_y + 4U) << 1) - 1;
for (ixstart = 0; ixstart <= i; ixstart++) {
Box_data[ixstart] = 0.0F;
}
for (ixstart = 0; ixstart < 8; ixstart++) {
uBox[ixstart] = 0.0F;
}
b_i = 1U;
x = 0;
while (x <= (int32_T)(real32_T)aWidth - 1) {
for (c_y = 0; c_y <= (int32_T)(real32_T)aHeight - 1; c_y++) {
/* Untransformed x,y edges per DSP ------------------- */
rl = (((1.0F + (real32_T)x) - 1.0F) / (real32_T)aWidth * (real32_T)d -
(real32_T)d / 2.0F) + 0.5F;
/* -s for matching coordinate system to registration algorithm */
rr = ((1.0F + (real32_T)x) / (real32_T)aWidth * (real32_T)d - (real32_T)d /
2.0F) - 0.5F;
rt = (((1.0F + (real32_T)c_y) - 1.0F) / (real32_T)aHeight * (real32_T)d -
(real32_T)d / 2.0F) + 0.5F;
rb = ((1.0F + (real32_T)c_y) / (real32_T)aHeight * (real32_T)d - (real32_T)
d / 2.0F) - 0.5F;
DSPResponsibilityBox[0] = rl;
DSPResponsibilityBox[1] = rr;
DSPResponsibilityBox[2] = rt;
DSPResponsibilityBox[3] = rb;
uBox[0] = rl;
/* -s for matching coordinate system to registration algorithm */
uBox[4] = rt;
uBox[1] = rr;
uBox[5] = rt;
uBox[2] = rl;
uBox[6] = rb;
uBox[3] = rr;
uBox[7] = rb;
/* Transform edge coordinates -------------------------- */
for (i = 1; (uint32_T)i <= (uint32_T)angle_size; i = (int32_T)((uint32_T)i
+ 1U)) {
for (ixstart = 0; ixstart < 4; ixstart++) {
Box_data[(int32_T)(((uint32_T)i - 1U) << 2) + ixstart] = ((real32_T)
cos(angles[i - 1]) * uBox[ixstart] - (real32_T)sin(angles[i - 1]) *
uBox[4 + ixstart]) + w[1];
Box_data[((int32_T)(((uint32_T)i - 1U) << 2) + ixstart) +
Box_size_idx_0] = ((real32_T)sin(angles[i - 1]) * uBox[ixstart] +
(real32_T)cos(angles[i - 1]) * uBox[4 + ixstart])
+ w[2];
}
}
/* X Bounding Box ------------------------------- */
i = (int32_T)((uint32_T)angle_size << 2);
ixstart = 1;
rl = Box_data[0];
if (rtIsNaNF(Box_data[0])) {
ix = 2;
exitg4 = FALSE;
while ((exitg4 == 0U) && (ix <= i)) {
ixstart = ix;
if (!rtIsNaNF(Box_data[ix - 1])) {
rl = Box_data[ix - 1];
exitg4 = TRUE;
} else {
ix++;
}
}
}
if (ixstart < i) {
while (ixstart + 1 <= i) {
if (Box_data[ixstart] < rl) {
rl = Box_data[ixstart];
}
ixstart++;
}
}
rt = (rl - 1.0F) - dtr;
/* 1 more pixel for bilinear filtering */
marginL = 0U;
if (rt < -dmax) {
/* clipping */
marginL = (uint32_T)rt_roundf_snf((-dmax - rt) + 1.0F);
/* +1 = ceil */
rt = -dmax;
}
ixstart = 1;
rl = Box_data[0];
if (rtIsNaNF(Box_data[0])) {
ix = 2;
exitg3 = FALSE;
while ((exitg3 == 0U) && (ix <= i)) {
ixstart = ix;
if (!rtIsNaNF(Box_data[ix - 1])) {
rl = Box_data[ix - 1];
exitg3 = TRUE;
} else {
ix++;
}
}
}
if (ixstart < i) {
while (ixstart + 1 <= i) {
if (Box_data[ixstart] > rl) {
rl = Box_data[ixstart];
}
ixstart++;
}
}
rr = (rl + 1.0F) + dtr;
/* 1 more pixel for bilinear filtering */
marginR = 0U;
if (rr > y - 0.5F) {
/* clipping */
marginR = (uint32_T)rt_roundf_snf((rr - (y - 0.5F)) + 1.0F);
/* +1 = ceil */
rr = y - 0.5F;
}
/* Y Bounding Box ------------------------------- */
i = (int32_T)((uint32_T)angle_size << 2);
ixstart = 1;
rl = Box_data[Box_size_idx_0];
if (rtIsNaNF(Box_data[Box_size_idx_0])) {
ix = 2;
exitg2 = FALSE;
while ((exitg2 == 0U) && (ix <= i)) {
ixstart = ix;
if (!rtIsNaNF(Box_data[(ix + Box_size_idx_0) - 1])) {
rl = Box_data[(ix + Box_size_idx_0) - 1];
exitg2 = TRUE;
} else {
ix++;
}
}
}
if (ixstart < i) {
while (ixstart + 1 <= i) {
if (Box_data[ixstart + Box_size_idx_0] < rl) {
rl = Box_data[ixstart + Box_size_idx_0];
}
ixstart++;
}
}
rb = (rl - 1.0F) - dtr;
/* 1 more pixel for bilinear filtering; */
marginO = 0U;
if (rb < -dmax) {
/* clipping */
marginO = (uint32_T)rt_roundf_snf((-dmax - rb) + 1.0F);
/* +1 = ceil */
rb = -dmax;
}
ixstart = 1;
rl = Box_data[Box_size_idx_0];
if (rtIsNaNF(Box_data[Box_size_idx_0])) {
ix = 2;
exitg1 = FALSE;
while ((exitg1 == 0U) && (ix <= i)) {
ixstart = ix;
if (!rtIsNaNF(Box_data[(ix + Box_size_idx_0) - 1])) {
rl = Box_data[(ix + Box_size_idx_0) - 1];
exitg1 = TRUE;
} else {
ix++;
}
}
}
if (ixstart < i) {
while (ixstart + 1 <= i) {
if (Box_data[ixstart + Box_size_idx_0] > rl) {
rl = Box_data[ixstart + Box_size_idx_0];
}
ixstart++;
}
}
rl = (rl + 1.0F) + dtr;
/* 1 more pixel for bilinear interpolation; */
marginU = 0U;
if (rl > y - 0.5F) {
/* clipping */
marginU = (uint32_T)rt_roundf_snf((rl - (y - 0.5F)) + 1.0F);
/* +1 = ceil */
rl = y - 0.5F;
}
/* Extract img ------------------------------- */
BoundBox[0] = (uint32_T)rt_roundf_snf((real32_T)floor(rt + (b_y + 0.5F)));
BoundBox[1] = (uint32_T)rt_roundf_snf((real32_T)ceil(rr + (b_y + 0.5F)));
BoundBox[2] = (uint32_T)rt_roundf_snf((real32_T)floor(rb + (b_y + 0.5F)));
BoundBox[3] = (uint32_T)rt_roundf_snf((real32_T)ceil(rl + (b_y + 0.5F)));
/* Keep only the biggest margin of left and right. (We share both */
/* margins on the right with one exception, we add one times the left */
/* margin to the space between the top margin and the data start.) */
if (marginL > marginR) {
marginR = marginL;
}
/* Return R */
for (ixstart = 0; ixstart < 4; ixstart++) {
b_DSPResponsibilityBox[ixstart] = (uint32_T)rt_roundf_snf
(DSPResponsibilityBox[ixstart] + s);
}
/* Keep only the biggest margin of left and right. (We share both */
/* margins on the right with one exception, we add one times the left */
/* margin to the space between the top margin and the data start.) */
if (marginL > marginR) {
marginR = marginL;
}
MarginAddon[0] = marginR;
MarginAddon[1] = marginO + 1U;
MarginAddon[2] = marginU;
/* We add 1 to the upper margin because of the reusal of the right and */
/* left margin. It would be sufficient to add marginL padding bytes to */
/* the top, however adding a whole row is more convenient as the */
/* resulting data buffer remains a square picture and the loss of a few */
/* KB ram (in a cache-uninteresting area) is neglectible. */
/* Matlab coder compilation: Start sendingall data to target needed */
/* for being able to call function 'jacobian' on the target. */
/* (Sending will be done async/nonblocking in the background). */
//Prepare HPRPC store image command header.
uint32_T TSinglePartLen = getImagePartSize(BoundBox);
uint32_T RSinglePartLen = getImagePartSize(b_DSPResponsibilityBox);
CHPRPCRequestStoreImg *pRequest = matlab_c_prepareSendToTarget(
b_i, BoundBox, MarginAddon, DSPResponsibilityBox,
/*TSinglePart,*/ TSinglePartLen, /*RSinglePart,*/
RSinglePartLen, d, levels
);
double dBeforeExtraction = get_wall_time();
//Start 1 thread per DSP for image extraction (directly into the send buffers which might allready be in non-paged kernel memory)
TThreadData* pThreadData = &g_ThreadData[b_i-1];
//pThreadData->TSinglePart = TSinglePart;
pThreadData->Tvec = &Tvec->data[0];
memcpy(pThreadData->BoundBox, BoundBox, 4*sizeof(uint32_T));
pThreadData->d = d;
//pThreadData->RSinglePart = RSinglePart;
pThreadData->Rvec = &Rvec->data[0];
memcpy(pThreadData->b_DSPResponsibilityBox, b_DSPResponsibilityBox, 4*sizeof(uint32_T));
pThreadData->b_i = b_i;
pThreadData->pRequest = pRequest;
SpawnExtractAndSendThread(pThreadData, (b_i-1));
b_i++;
}
x++;
}
double TimeForAddMarginsTotal=0;
double TimeForPyramidTotal=0;
b_i = 1U;
for (x = 0; x <= (int32_T)(real32_T)aWidth - 1; x++) {
for (c_y = 0; c_y <= (int32_T)(real32_T)aHeight - 1; c_y++) {
/* Matlab coder compilation: Wait until every DSP confirmed data */
/* transmission. */
double TimeForAddMargins, TimeForPyramid;
waitUntilTargetReady(b_i, TimeForAddMargins, TimeForPyramid);
TimeForAddMarginsTotal+=TimeForAddMargins;
TimeForPyramidTotal+=TimeForPyramid;
b_i++;
}
}
//Performance measurement:
//Time when the DSPs responded about having received (and processed) the image data and are ready for calculation
Timestamps.FinishedXtrct.measureWallAndCPUTime();
//Time when the CPU finished extracting the partial image data
Timestamps.XtrctPartFinished.setWallClockTime(g_lastImageExtractor->ExtractFinishedWCTime);
Timestamps.XtrctPartFinished.setCPUTime(g_lastImageExtractor->ExtractFinishedCPUTime);
//Time when the CPU finished regarding the data sending (below the latest value is determined)
Timestamps.SendingStartedSystemNowIdle.setWallClockTime(g_lastPCIeSender->SndStartdWCTime);
Timestamps.SendingStartedSystemNowIdle.setCPUTime(g_lastPCIeSender->SndStartdCPUTime);
//Average times from target
Timestamps.TimeForAddMargins = TimeForAddMarginsTotal / DSPCount;
Timestamps.TimeForPyramidTotal = TimeForPyramidTotal / DSPCount;
/* Datenreduktion etwa auf folgenden Wert (ist / max) */
/* dbgSizDat_Transmitted_Data = dbgSizDat / (d*d*4) */
}
