dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

whitespace and coding style cleanups

This commit is contained in:
Sven Neumann 2009-06-04 11:13:42 +02:00
parent ac680f1cbd
commit b2fc6d2876
5 changed files with 128 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
app/base/tile-cache.c
View File

@ -27,14 +27,11 @@
#include "tile-rowhints.h"
#include "tile-private.h"
#define IDLE_SWAPPER_START 1000
#define IDLE_SWAPPER_INTERVAL_MS 20
#define IDLE_SWAPPER_TILES_PER_INTERVAL 10
static gboolean tile_cache_zorch_next (void);
static void tile_cache_flush_internal (Tile *tile);
static gboolean tile_idle_preswap (gpointer data);
static void tile_verify(void);
typedef struct _TileList
{
@ -42,6 +39,7 @@ typedef struct _TileList
Tile *last;
} TileList;
static gulong cur_cache_size = 0;
static gulong max_cache_size = 0;
static gulong cur_cache_dirty = 0;
@ -75,6 +73,15 @@ static GMutex *tile_cache_mutex = NULL;
#define PENDING_WRITE(t) ((t)->dirty || (t)->swap_offset == -1)
static gboolean tile_cache_zorch_next (void);
static void tile_cache_flush_internal (Tile *tile);
static gboolean tile_idle_preswap (gpointer data);
#ifdef TILE_PROFILING
static void tile_verify (void);
#endif
void
tile_cache_init (gulong tile_cache_size)
{
@ -167,9 +174,9 @@ tile_cache_insert (Tile *tile)
{
GTimeVal now;
GTimeVal later;
g_get_current_time(&now);
#endif
while ((cur_cache_size + tile->size) > max_cache_size)
{
if (! tile_cache_zorch_next ())
@ -180,7 +187,7 @@ tile_cache_insert (Tile *tile)
}
#ifdef TILE_PROFILING
g_get_current_time(&later);
g_get_current_time (&later);
tile_total_interactive_usec += later.tv_usec - now.tv_usec;
tile_total_interactive_sec += later.tv_sec - now.tv_sec;
@ -195,7 +202,6 @@ tile_cache_insert (Tile *tile)
tile_total_interactive_usec -= 1000000;
tile_total_interactive_sec++;
}
}
#endif
@ -206,11 +212,12 @@ tile_cache_insert (Tile *tile)
tile->next = NULL;
tile->prev = tile_list.last;
if(tile_list.last){
if (tile_list.last)
tile_list.last->next = tile;
}else{
else
tile_list.first = tile;
}
tile_list.last = tile;
tile->cached = TRUE;
idle_delay = 1;
@ -219,12 +226,11 @@ tile_cache_insert (Tile *tile)
{
cur_cache_dirty += tile->size;
if(!idle_scan_last)
if (! idle_scan_last)
idle_scan_last=tile;
if (!idle_swapper)
{
if (! idle_swapper)
{
#ifdef TILE_PROFILING
g_printerr("idle swapper -> started\n");
g_printerr("idle swapper -> waiting");
@ -274,48 +280,51 @@ tile_cache_flush_internal (Tile *tile)
{
tile->cached = FALSE;
if (PENDING_WRITE(tile))
cur_cache_dirty -= tile->size;
cur_cache_size -= tile->size;
if (tile->next)
tile->next->prev = tile->prev;
else
tile_list.last = tile->prev;
if(tile->prev){
tile->prev->next = tile->next;
}else{
tile_list.first = tile->next;
}
if(tile == idle_scan_last)
idle_scan_last = tile->next;
tile->next = tile->prev = NULL;
if (tile->prev)
tile->prev->next = tile->next;
else
tile_list.first = tile->next;
if (tile == idle_scan_last)
idle_scan_last = tile->next;
tile->next = tile->prev = NULL;
}
static gboolean
tile_cache_zorch_next (void)
{
Tile *tile = tile_list.first;
if(!tile)return FALSE;
Tile *tile = tile_list.first;
if (! tile)
return FALSE;
#ifdef TILE_PROFILING
tile_total_zorched++;
tile->zorched = TRUE;
if(PENDING_WRITE(tile))
if (PENDING_WRITE (tile))
{
tile_total_zorched_swapout++;
tile->zorchout = TRUE;
}
#endif
tile_cache_flush_internal (tile);
if (PENDING_WRITE(tile))
if (PENDING_WRITE (tile))
{
idle_delay = 1;
tile_swap_out (tile);
@ -325,6 +334,7 @@ tile_cache_zorch_next (void)
{
g_free (tile->data);
tile->data = NULL;
#ifdef TILE_PROFILING
tile_exist_count--;
#endif
@ -362,46 +372,48 @@ tile_idle_preswap_run (gpointer data)
tile = idle_scan_last;
while(tile)
while (tile)
{
if(PENDING_WRITE(tile))
if (PENDING_WRITE (tile))
{
idle_scan_last = tile->next;
#ifdef TILE_PROFILING
tile_idle_swapout++;
#endif
tile_swap_out (tile);
if(!PENDING_WRITE(tile))
if (! PENDING_WRITE(tile))
cur_cache_dirty -= tile->size;
count++;
if(count>=IDLE_SWAPPER_TILES_PER_INTERVAL)
if (count >= IDLE_SWAPPER_TILES_PER_INTERVAL)
{
TILE_CACHE_UNLOCK;
return TRUE;
}
}
tile = tile->next;
}
g_printerr("\nidle swapper -> stopped\n");
g_printerr ("\nidle swapper -> stopped\n");
idle_scan_last = NULL;
idle_swapper = 0;
#ifdef TILE_PROFILING
tile_verify();
tile_verify ();
#endif
TILE_CACHE_UNLOCK;
return FALSE;
}
static gboolean
tile_idle_preswap (gpointer data)
{
if (idle_delay){
#ifdef TILE_PROFILING
g_printerr(".");
@ -409,12 +421,12 @@ tile_idle_preswap (gpointer data)
idle_delay = 0;
return TRUE;
}
#ifdef TILE_PROFILING
tile_verify();
tile_verify ();
g_printerr("\nidle swapper -> running");
#endif
idle_swapper = g_timeout_add_full (G_PRIORITY_LOW,
IDLE_SWAPPER_INTERVAL_MS,
tile_idle_preswap_run,
@ -424,41 +436,39 @@ tile_idle_preswap (gpointer data)
#ifdef TILE_PROFILING
static void
tile_verify(void)
tile_verify (void)
{
/* scan list linearly, count metrics, compare to running totals */
gulong local_size=0;
gulong local_dirty=0;
gulong acc=0;
Tile *t = tile_list.first;
const Tile *t;
gulong local_size = 0;
gulong local_dirty = 0;
gulong acc = 0;
while(t)
for (t = tile_list.first; t; t = t->next)
{
local_size+=t->size;
if(PENDING_WRITE(t))
local_dirty+=t->size;
t=t->next;
local_size += t->size;
if (PENDING_WRITE (t))
local_dirty += t->size;
}
if(local_size != cur_cache_size)
g_printerr("\nCache size mismatch: running=%lu, tested=%lu\n",
cur_cache_size,local_size);
if (local_size != cur_cache_size)
g_printerr ("\nCache size mismatch: running=%lu, tested=%lu\n",
cur_cache_size,local_size);
if(local_dirty != cur_cache_dirty)
g_printerr("\nCache dirty mismatch: running=%lu, tested=%lu\n",
cur_cache_dirty,local_dirty);
if (local_dirty != cur_cache_dirty)
g_printerr ("\nCache dirty mismatch: running=%lu, tested=%lu\n",
cur_cache_dirty,local_dirty);
/* scan forward from scan list */
t = idle_scan_last;
while(t)
for (t = idle_scan_last; t; t = t->next)
{
if(PENDING_WRITE(t))
acc+=t->size;
t=t->next;
if (PENDING_WRITE (t))
acc += t->size;
}
if(acc != local_dirty)
g_printerr("\nDirty scan follower mismatch: running=%lu, tested=%lu\n",
acc,local_dirty);
if (acc != local_dirty)
g_printerr ("\nDirty scan follower mismatch: running=%lu, tested=%lu\n",
acc,local_dirty);
}
#endif

13
app/base/tile-cache.h
View File

@ -19,14 +19,13 @@
#define __TILE_CACHE_H__
void tile_cache_init (gulong cache_size);
void tile_cache_exit (void);
void tile_cache_init (gulong cache_size);
void tile_cache_exit (void);
void tile_cache_set_size (gulong cache_size);
void tile_cache_suspend_idle_swapper(void);
void tile_cache_insert (Tile *tile);
void tile_cache_flush (Tile *tile);
void tile_cache_set_size (gulong cache_size);
void tile_cache_suspend_idle_swapper (void);
void tile_cache_insert (Tile *tile);
void tile_cache_flush (Tile *tile);
#endif /* __TILE_CACHE_H__ */

1
app/base/tile-manager.c
View File

@ -203,6 +203,7 @@ tile_manager_get (TileManager *tm,
new->size = new->ewidth * new->eheight * new->bpp;
new->data = g_new (guchar, new->size);
#ifdef TILE_PROFILING
tile_exist_count++;
if (tile_exist_count > tile_exist_peak)

61
app/base/tile-swap.c
View File

@ -122,30 +122,30 @@ static gulong tile_total_seek = 0;
/* how many tiles were swapped out under cache pressure but never
swapped back in? This does not count idle swapped tiles, as those
do not contribute to any perceived load or latency */
static gulong tile_total_wasted_swapout = 0;
static gulong tile_total_wasted_swapout = 0;
/* total tile flushes under cache pressure */
gulong tile_total_zorched = 0;
gulong tile_total_zorched_swapout = 0;
static gulong tile_total_zorched_swapin = 0;
gulong tile_total_zorched = 0;
gulong tile_total_zorched_swapout = 0;
static gulong tile_total_zorched_swapin = 0;
/* total tiles swapped out to swap file (not total calls to swap out;
this only counts actual flushes to disk) */
static gulong tile_total_swapout = 0;
static gulong tile_unique_swapout = 0;
gulong tile_idle_swapout = 0;
static gulong tile_total_swapout = 0;
static gulong tile_unique_swapout = 0;
gulong tile_idle_swapout = 0;
/* total tiles swapped in from swap file (not total calls to swap in;
this only counts actual tile reads from disk) */
static gulong tile_total_swapin = 0;
static gulong tile_unique_swapin = 0;
static gulong tile_total_swapin = 0;
static gulong tile_unique_swapin = 0;
/* total dead time spent waiting to read or write */
static glong tile_total_swapwait_sec = 0;
static glong tile_total_swapwait_usec = 0;
static glong tile_total_swapwait_sec = 0;
static glong tile_total_swapwait_usec = 0;
/* total time spent in tile cache due to cache pressure */
glong tile_total_interactive_sec = 0;
glong tile_total_interactive_sec = 0;
glong tile_total_interactive_usec = 0;
#endif
@ -231,21 +231,25 @@ tile_swap_exit (void)
g_printerr ("\n\nPeak Tile usage: %d Tile structs\n\n",
tile_exist_peak);
g_printerr ("Total tiles swapped out to disk: %lu\n",tile_total_swapout);
g_printerr ("Unique tiles swapped out to disk: %lu\n",tile_unique_swapout);
g_printerr ("Total tiles swapped in from disk: %lu\n",tile_total_swapin);
g_printerr ("Unique tiles swapped in from disk: %lu\n",tile_unique_swapin);
g_printerr ("Tiles swapped out by idle swapper: %lu\n",tile_idle_swapout);
g_printerr ("Total seeks during swapping: %lu\n",tile_total_seek);
g_printerr ("Total tiles swapped out to disk: %lu\n", tile_total_swapout);
g_printerr ("Unique tiles swapped out to disk: %lu\n", tile_unique_swapout);
g_printerr ("Total tiles swapped in from disk: %lu\n", tile_total_swapin);
g_printerr ("Unique tiles swapped in from disk: %lu\n", tile_unique_swapin);
g_printerr ("Tiles swapped out by idle swapper: %lu\n", tile_idle_swapout);
g_printerr ("Total seeks during swapping: %lu\n", tile_total_seek);
g_printerr ("Total time spent in swap: %f seconds\n\n",
tile_total_swapwait_sec+.000001*tile_total_swapwait_usec);
tile_total_swapwait_sec + 0.000001 * tile_total_swapwait_usec);
g_printerr ("Total zorched tiles: %lu\n",tile_total_zorched);
g_printerr ("Total zorched tiles swapped out: %lu\n",tile_total_zorched_swapout);
g_printerr ("Total zorched tiles swapped back in: %lu\n",tile_total_zorched_swapin);
g_printerr ("Total zorched tiles wasted after swapping out: %lu\n",tile_total_wasted_swapout);
g_printerr ("Total zorched tiles: %lu\n", tile_total_zorched);
g_printerr ("Total zorched tiles swapped out: %lu\n",
tile_total_zorched_swapout);
g_printerr ("Total zorched tiles swapped back in: %lu\n",
tile_total_zorched_swapin);
g_printerr ("Total zorched tiles wasted after swapping out: %lu\n",
tile_total_wasted_swapout);
g_printerr ("Total interactive swap/cache delay: %f seconds\n\n",
tile_total_interactive_sec+.000001*tile_total_interactive_usec);
tile_total_interactive_sec +
0.000001 * tile_total_interactive_usec);
#endif
@ -271,6 +275,7 @@ tile_swap_exit (void)
gimp_swap_file->fd = -1;
}
#endif
g_unlink (gimp_swap_file->filename);
g_free (gimp_swap_file->filename);
@ -377,8 +382,8 @@ tile_swap_default_in (SwapFile *swap_file,
tile_cache_suspend_idle_swapper();
#ifdef TILE_PROFILING
g_get_current_time(&now);
#ifdef TILE_PROFILING
g_get_current_time (&now);
tile_total_swapin++;
if (tile->zorched)
@ -436,7 +441,7 @@ tile_swap_default_in (SwapFile *swap_file,
}
#ifdef TILE_PROFILING
g_get_current_time(&later);
g_get_current_time (&later);
tile_total_swapwait_usec += later.tv_usec - now.tv_usec;
tile_total_swapwait_sec += later.tv_sec - now.tv_sec;
@ -547,7 +552,7 @@ tile_swap_default_out (SwapFile *swap_file,
}
#ifdef TILE_PROFILING
g_get_current_time(&later);
g_get_current_time (&later);
tile_total_swapwait_usec += later.tv_usec - now.tv_usec;
tile_total_swapwait_sec += later.tv_sec - now.tv_sec;

9
app/base/tile.c
View File

@ -42,14 +42,15 @@ static gint tile_count = 0;
static gint tile_share_count = 0;
static gint tile_active_count = 0;
gint tile_exist_peak = 0;
gint tile_exist_count = 0;
gint tile_exist_peak = 0;
gint tile_exist_count = 0;
#endif
static void tile_destroy (Tile *tile);
Tile *
tile_new (gint bpp)
{
@ -163,6 +164,7 @@ tile_alloc (Tile *tile)
#ifdef TILE_PROFILING
tile_exist_count++;
if (tile_exist_count > tile_exist_peak)
tile_exist_peak = tile_exist_count;
#endif
@ -181,14 +183,17 @@ tile_destroy (Tile *tile)
g_warning ("tried to destroy an attached tile");
return;
}
if (tile->data)
{
g_free (tile->data);
tile->data = NULL;
#ifdef TILE_PROFILING
tile_exist_count--;
#endif
}
if (tile->rowhint)
{
g_slice_free1 (sizeof (TileRowHint) * TILE_HEIGHT, tile->rowhint);