static void object_err(struct kmem_cache *cache, struct page *page,
void *object, char *unused_reason)
{
struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object);
struct kasan_free_meta *free_info;
dump_stack();
pr_err("Object at %p, in cache %s\n", object, cache->name);
if (!(cache->flags & SLAB_KASAN))
return;
switch (alloc_info->state) {
case KASAN_STATE_INIT:
pr_err("Object not allocated yet\n");
break;
case KASAN_STATE_ALLOC:
pr_err("Object allocated with size %u bytes.\n",
alloc_info->alloc_size);
pr_err("Allocation:\n");
print_track(&alloc_info->track);
break;
case KASAN_STATE_FREE:
pr_err("Object freed, allocated with size %u bytes\n",
alloc_info->alloc_size);
free_info = get_free_info(cache, object);
pr_err("Allocation:\n");
print_track(&alloc_info->track);
pr_err("Deallocation:\n");
print_track(&free_info->track);
break;
}
}
static void print_tracking(struct kmem_cache *s, void *object)
{
if (!(s->flags & SLAB_STORE_USER))
return;
print_track("Allocated", get_track(s, object, TRACK_ALLOC));
print_track("Freed", get_track(s, object, TRACK_FREE));
}
static void describe_object(struct kmem_cache *cache, void *object,
const void *addr)
{
struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object);
if (cache->flags & SLAB_KASAN) {
print_track(&alloc_info->alloc_track, "Allocated");
pr_err("\n");
print_track(&alloc_info->free_track, "Freed");
pr_err("\n");
}
describe_object_addr(cache, object, addr);
}
static void playlist_browse_try(void)
{
int i, tracks;
metadata_updated_fn = playlist_browse_try;
if(!sp_playlist_is_loaded(playlist_browse))
return;
tracks = sp_playlist_num_tracks(playlist_browse);
for(i = 0; i < tracks; i++) {
sp_track *t = sp_playlist_track(playlist_browse, i);
if (!sp_track_is_loaded(t))
return;
}
printf("\tPlaylist and metadata loaded\n");
for(i = 0; i < tracks; i++) {
sp_track *t = sp_playlist_track(playlist_browse, i);
printf(" %5d: ", i + 1);
print_track(t);
}
sp_playlist_remove_callbacks(playlist_browse, &pl_callbacks, NULL);
sp_playlist_release(playlist_browse);
playlist_browse = NULL;
metadata_updated_fn = NULL;
cmd_done();
}
void
set_mapcenter( float lat,
float lon,
int zoom)
{
int pixel_x, pixel_y;
lat = deg2rad(lat);
lon = deg2rad(lon);
pixel_x = lon2pixel(zoom, lon);
pixel_y = lat2pixel(zoom, lat);
printf("fill_tiles_latlon(): lat %f %i -- lon %f %i\n",
lat,pixel_y,lon,pixel_x);
osd_speed();
global_x = pixel_x - global_drawingarea_width/2;
global_y = pixel_y - global_drawingarea_height/2;
global_zoom = zoom;
fill_tiles_pixel ( pixel_x - global_drawingarea_width/2,
pixel_y - global_drawingarea_height/2,
zoom);
print_track();
paint_friends();
paint_photos();
paint_pois();
paint_wp();
osd_speed();
}
static void kasan_object_err(struct kmem_cache *cache, void *object)
{
struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object);
dump_stack();
pr_err("Object at %p, in cache %s size: %d\n", object, cache->name,
cache->object_size);
if (!(cache->flags & SLAB_KASAN))
return;
pr_err("Allocated:\n");
print_track(&alloc_info->alloc_track);
pr_err("Freed:\n");
print_track(&alloc_info->free_track);
}
void
Pathfinder::dijkstra(int r0, int c0)
{
if ( r0 >= rows || c0 >= cols ) {
std::cerr << "[Pathfinder::dijkstra] Error: Start coordinates out of bounds\n";
return;
}
bool found[nodes.size()];
int parents[nodes.size()];
int dist[nodes.size()];
int t = -1;
for ( int i = 0; i < nodes.size() ; ++i) {
found[i] = false;
parents[i] = -1;
dist[i] = INT_MAX;
}
int start = r0 * cols + c0;
int i = start;
dist[i] = 0;
while ( !found[i] ){
found[i] = true;
if ( nodes.at(i).type == 'T' ) t = i; // found target;
node* n = nodes.at(i).next;
while ( n != nullptr ) {
if ( dist[n->index] > dist[i] + 1 ) {
dist[n->index] = dist[i] + 1;
parents[n->index] = i;
}
n = n->next;
}
int cd = INT_MAX;
for ( int j = 0; j < nodes.size() ; ++j ) {
if ( !found[j] && dist[j] < cd ) {
cd = dist[j];
i = j;
}
}
}
if ( t == -1 || dist[t] == INT_MAX ) {
std::cerr << "[Pathfinder::dijkstra] Error: Target impossible to reach from (" << r0 << "," << c0 <<")\n";
return;
}
std::vector<int> track = construct_track(start, t, parents);
std::cout << "\nDijkstra: \n";
print_track(track);
plot_track(track);
}
void
Pathfinder::bfs(int r0, int c0)
{
if ( r0 >= rows || c0 >= cols ) {
std::cerr << "[Pathfinder::bfs] Error: Start coordinates out of bounds\n";
return;
}
bool found[nodes.size()];
int parent[nodes.size()];
for ( int i = 0; i < nodes.size() ; ++i ) {
found[i] = false;
parent[i] = -1;
}
std::queue<int> q;
int start = r0 * cols + c0;
q.push(start);
found[start] = true;
int i = start;
bool stop = false;
while ( !q.empty() && !stop ) {
i = q.front();
q.pop();
node* nn = nodes.at(i).next;
while (nn != nullptr ) {
if ( !found[nn->index] ) {
found[nn->index] = true;
parent[nn->index] = i;
if ( nn->type == 'T' ) {
i = nn->index;
stop = true;
break;
}
q.push(nn->index);
}
nn = nn->next;
}
}
if ( !stop ) {
std::cerr << "[Pathfinder::bfs] Error: Unable to reach target from (" << r0 << "," << c0 << ")\n";
return;
}
std::vector<int> track = construct_track( start, i, parent );
std::cout << "\nbfs: \n";
print_track(track);
plot_track(track);
}
void test_cases_for_students(struct station *kipling, struct train *first)
{
// test cases for students
// Test 1. enter passengers
enter_passengers(kipling);
print_track(kipling, &first, 0, 1); // if enter_passengers is working you should see something including:
/*
38: || = (n = 227, avg = 0.0) StGeorge
39: ||
40: || = (n = 241, avg = 0.0) Bay
41: ||
42: || = (n = 127, avg = 0.0) Yonge
43: ||
44: || = (n = 72, avg = 0.0) Sherbourne
45: ||
46: || = (n = 36, avg = 0.0) CastleFrank
47: ||
*/
// Test 2. passengers wait
passengers_wait(kipling);
print_track(kipling, &first, 0, 1); // you should see all passengers have waited one minute
enter_passengers(kipling);
print_track(kipling, &first, 0, 1); // now you should see something like:
/*
38: || = (n = 326, avg = 0.7) StGeorge
39: ||
40: || = (n = 466, avg = 0.5) Bay
41: ||
42: || = (n = 343, avg = 0.4) Yonge
43: ||
44: || = (n = 142, avg = 0.5) Sherbourne
45: ||
46: || = (n = 49, avg = 0.7) CastleFrank
47: ||
*/
}
string
Track::print_branch_recursive (const unsigned int indentation)
{
string str;
for(unsigned int i = 0; i < indentation; i++)
str += " ";
str += print_track();
str += "\n";
BOOST_FOREACH(shared_ptr<Track> track, get_child_tracks())
{
REQUIRE(track);
str += track->print_branch_recursive(indentation + 1);
}
int main()
{
// Simulate the TTC!
// To keep things consitent, we'll use a predefined seed of 1
srand(1);
// we'll be outputting data to a file called data.csv
FILE *file;
file = fopen("data.csv","w+");
// set up our first station and first two trains
struct station *kipling = read_stations();
struct train *first = make_train(5, 0);
struct train *second = make_train(0, 5);
first->next = second;
if(DEBUGGING == 1)
{
printf("BEGINNING TEST\n");
test_cases_for_students(kipling, first);
}
else
{
// if we're not debugging, then simulate!
fprintf(file, "time, avg_wait, num_trains, avg_dist\n");
int i = 0;
for(i = 0; i < SIM_TIME; i++)
{
advance_time(kipling, &first);
// print data every half hour
if(i % 30 == 0)
{
fprintf(file, "%d, %lf, %d, %lf\n", i, average_wait_time(kipling), num_trains(first), avg_train_dist(first));
}
}
print_track(kipling, &first, i, 1);
}
// cleanup
clear_all_trains(&first);
remove_all_stations(&kipling);
fclose(file);
return 0;
}
void
Pathfinder::dfs(int r0, int c0)
{
bool found[nodes.size()];
int parent[nodes.size()];
for (int i = 0; i < nodes.size() ; ++i ) {
found[i] = false;
parent[i] = -1;
}
std::stack<int> s;
int start = r0 * cols + c0;
found[start] = true;
int i = start;
bool stop = false;
s.push(i);
while( !s.empty() && !stop ) {
i = s.top();
s.pop();
node * nn = nodes.at(i).next;
while ( nn != nullptr ) {
if ( !found[nn->index] ) {
found[nn->index] = true;
parent[nn->index] = i;
if ( nn->type == 'T' ) {
i = nn->index;
stop = true;
break;
}
s.push(nn->index);
}
nn = nn->next;
}
}
if ( !stop ) {
std::cerr << "[Pathfinder::dfs] Error: unable to reach target from (" << r0 << "," << c0 << ")\n";
return;
}
std::vector<int> track = construct_track(start, i, parent);
std::cout << "\ndfs: \n";
print_track(track);
plot_track(track);
}
/**
* Print the given artist browse result and as much information as possible
*
* @param browse The browse result
*/
static void print_artistbrowse(sp_artistbrowse *browse)
{
int i;
printf("Artist browse of \"%s\"\n", sp_artist_name(sp_artistbrowse_artist(browse)));
for (i = 0; i < sp_artistbrowse_num_similar_artists(browse); ++i)
printf(" Similar artist: %s\n", sp_artist_name(sp_artistbrowse_similar_artist(browse, i)));
printf(" Portraits: %d\n", sp_artistbrowse_num_portraits(browse));
printf(" Tracks : %d\n", sp_artistbrowse_num_tracks(browse));
printf(" Biography: %.60s...\n", sp_artistbrowse_biography(browse));
puts("");
for (i = 0; i < sp_artistbrowse_num_tracks(browse); ++i)
print_track(sp_artistbrowse_track(browse, i));
puts("");
}
static void track_browse_try(void)
{
switch (sp_track_error(track_browse)) {
case SP_ERROR_OK:
print_track(track_browse);
break;
case SP_ERROR_IS_LOADING:
return; // Still pending
default:
fprintf(stderr, "Unable to resolve track: %s\n", sp_error_message(sp_track_error(track_browse)));
break;
}
metadata_updated_fn = NULL;
cmd_done();
sp_track_release(track_browse);
}
/**
* Print the given album browse result and as much information as possible
*
* @param browse The browse result
*/
static void print_albumbrowse(sp_albumbrowse *browse)
{
int i;
printf("Album browse of \"%s\" (%d)\n",
sp_album_name(sp_albumbrowse_album(browse)),
sp_album_year(sp_albumbrowse_album(browse)));
for (i = 0; i < sp_albumbrowse_num_copyrights(browse); ++i)
printf(" Copyright: %s\n", sp_albumbrowse_copyright(browse, i));
printf(" Tracks: %d\n", sp_albumbrowse_num_tracks(browse));
printf(" Review: %.60s...\n", sp_albumbrowse_review(browse));
puts("");
for (i = 0; i < sp_albumbrowse_num_tracks(browse); ++i)
print_track(sp_albumbrowse_track(browse, i));
puts("");
}
/**
* Callback for libspotify
*
* @param result The toplist result object that is now done
* @param userdata The opaque pointer given to sp_toplistbrowse_create()
*/
static void got_toplist(sp_toplistbrowse *result, void *userdata)
{
int i;
// We print from all types. Only one of the loops will acually yield anything.
for(i = 0; i < sp_toplistbrowse_num_artists(result); i++)
print_artist(i + 1, sp_toplistbrowse_artist(result, i));
for(i = 0; i < sp_toplistbrowse_num_albums(result); i++)
print_album(i + 1, sp_toplistbrowse_album(result, i));
for(i = 0; i < sp_toplistbrowse_num_tracks(result); i++) {
printf("%3d: ", i + 1);
print_track(sp_toplistbrowse_track(result, i));
}
sp_toplistbrowse_release(result);
cmd_done();
}
/**
* Print the given search result with as much information as possible
*
* @param search The search result
*/
static void print_search(sp_search *search)
{
int i;
printf("Query : %s\n", sp_search_query(search));
printf("Did you mean : %s\n", sp_search_did_you_mean(search));
printf("Tracks in total: %d\n", sp_search_total_tracks(search));
puts("");
for (i = 0; i < sp_search_num_tracks(search); ++i)
print_track(sp_search_track(search, i));
puts("");
for (i = 0; i < sp_search_num_albums(search); ++i)
print_album(sp_search_album(search, i));
puts("");
for (i = 0; i < sp_search_num_artists(search); ++i)
print_artist(sp_search_artist(search, i));
puts("");
}
