int main (void) { #ifdef INIT init_weights(); #endif tbb::tick_count t0 = tbb::tick_count::now(); for (int c=0; c<TIMES; c++) { solution_weight = MAX_INT; solve_tsp(weights); } tbb::tick_count t1 = tbb::tick_count::now(); printf("Ticks = %f\n", (t1-t0).seconds()); printf("Solution Weight = %d\n", solution_weight); // Dump result hexdump_var("result.hex", &solution_weight, 1); #ifdef PRINT_RESULT printf("Solution weight = %d\n", solution_weight); int i; for(i=0;i<SIZE;i++) { printf("solution[%d] = %d\n", i, solution[i]); } #endif return 0; }
int main(int argc, char *argv[]) { graph g = read_kattis(); if(g.n <= 3) // all solutions identical { for(size_t i = 0 ; i < g.n; ++i) printf("%d\n", i); graph_free(g); return 0; } // k neighbours can't be more than neighbours available if(g.n-1 < k) k = g.n-1; /* fputs("[distance matrix]\n", stderr); for(size_t i = 0; i < g.n; ++i) { for(size_t j = 0; j < g.n; ++j) fprintf(stderr, "%3d ", graph_get_dist(g, i, j)); fputc('\n', stderr); } fputs("\n[neighbour matrix]\n", stderr); for(size_t i = 0; i < g.n; ++i) { for(size_t j = 0; j < g.n; ++j) fprintf(stderr, "%3d ", graph_get_neighbour(g, i, j)); fputc('\n', stderr); }*/ size_t greedy[g.n]; greedy_tsp(g, greedy); greedy_tour = greedy; fprintf(stderr, "\n[greedy tour]\n"); print_tour(g, greedy); size_t tour[g.n]; size_t tour2[g.n]; for(size_t i = 0; i < g.n; ++i) tour2[i] = greedy[i]; size_t *tour_ptr = tour; size_t *best = tour2; fprintf(stderr, "\n[tours]\n"); for(size_t i = 0; i < 14; ++i) { solve_tsp(g, tour_ptr); print_tour(g, tour_ptr); if(tour_length(g, tour_ptr) < tour_length(g, best)) { size_t *tmp = best; best = tour_ptr; tour_ptr = tmp; } } fprintf(stderr, "\n[kattis (best)]\n"); print_kattis(g, best); fprintf(stderr, "[kattis length: %d]\n", tour_length(g,best)); graph_free(g); return 0; }
Datum tsp_matrix(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; int call_cntr; int max_calls; TupleDesc tuple_desc; AttInMetadata *attinmeta; DTYPE *matrix; int *tsp_res; int num; /* stuff done only on the first call of the function */ if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; //int path_count; int ret=-1; /* create a function context for cross-call persistence */ funcctx = SRF_FIRSTCALL_INIT(); /* switch to memory context appropriate for multiple function calls */ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); matrix = get_pgarray(&num, PG_GETARG_ARRAYTYPE_P(0)); ret = solve_tsp(matrix, num, PG_GETARG_INT32(1), // start index PG_GETARG_INT32(2), // end index &tsp_res); pfree(matrix); if (ret < 0) { elog(ERROR, "Error, failed to solve TSP."); } funcctx->max_calls = num; funcctx->user_fctx = tsp_res; /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tuple_desc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); funcctx->tuple_desc = BlessTupleDesc(tuple_desc); /* * generate attribute metadata needed later to produce tuples from raw * C strings */ //attinmeta = TupleDescGetAttInMetadata(tuple_desc); //funcctx->attinmeta = attinmeta; MemoryContextSwitchTo(oldcontext); } /* stuff done on every call of the function */ funcctx = SRF_PERCALL_SETUP(); call_cntr = funcctx->call_cntr; max_calls = funcctx->max_calls; tuple_desc = funcctx->tuple_desc; tsp_res = funcctx->user_fctx; DBG("Trying to allocate some memory"); DBG("call_cntr = %i, max_calls = %i", call_cntr, max_calls); if (call_cntr < max_calls) { /* do when there is more left to send */ HeapTuple tuple; Datum result; Datum *values; char* nulls; values = palloc(2 * sizeof(Datum)); nulls = palloc(2 * sizeof(char)); values[0] = Int32GetDatum(call_cntr); nulls[0] = ' '; values[1] = Int32GetDatum(tsp_res[call_cntr]); nulls[1] = ' '; DBG("RESULT: %d, %d", call_cntr, tsp_res[call_cntr]); DBG("Heap making"); tuple = heap_formtuple(tuple_desc, values, nulls); DBG("Datum making"); /* make the tuple into a datum */ result = HeapTupleGetDatum(tuple); DBG("RESULT: seq:%d, id:%d", call_cntr, tsp_res[call_cntr]); DBG("Trying to free some memory"); /* clean up (this is not really necessary) */ pfree(values); pfree(nulls); SRF_RETURN_NEXT(funcctx, result); } else { /* do when there is no more left */ DBG("Freeing tsp_res"); free(tsp_res); DBG("Ending function"); SRF_RETURN_DONE(funcctx); } }
int main(int argc, char* argv[]) { int nth=-1; // number of (hardware) threads (-1 means undefined) if (argc > 1) { //command line with parameters if (argc > 2) { printf("ERROR: wrong use of command line arguments. Usage %s <#threads>\n", argv[0]); return 1; } else { nth = atoi( argv[1] ); } } int defth = tbb::task_scheduler_init::default_num_threads(); if (nth<0) nth=defth; printf("Default #Threads=%d. Using %d threads\n", defth, nth); tbb::task_scheduler_init init(nth); // init lock #ifdef DEBUG_VERBOSE printf("test1\n"); #endif #ifdef INIT init_weights(); #endif #ifdef DEBUG_VERBOSE printf("release_failed = %d\n", release_failed); printf("out_of_memory = %d\n", out_of_memory); printf("test2\n"); #endif tbb::tick_count t0 = tbb::tick_count::now(); solution_weight = MAX_INT; solve_tsp(weights); #ifdef NO_LOCKS //FunctorMin<int> my_min; solution_weight = my_weight.combine (min); #endif tbb::tick_count t1 = tbb::tick_count::now(); printf("Ticks = %f\n", (t1-t0).seconds()); printf("Solution Weight = %d\n", solution_weight); // Dump result int solution = solution_weight; hexdump_var("result.hex", &solution, 1); #ifdef DEBUG_VERBOSE printf("release_failed = %d\n", release_failed); printf("out_of_memory = %d\n", out_of_memory); #endif #ifdef DEBUG // if there is an error invalidate solution_weight if (release_failed || out_of_memory) solution_weight = -1; #endif #ifdef PRINT_RESULT printf("Solution weight = %d\n", solution_weight); list_node* tmp_p = solution; int i=SIZE; while(tmp_p != NULL && i!=0) { i--; printf("solution[%d] = %d\n", i, tmp_p->val); tmp_p = tmp_p->next; } #endif return 0; }