* Fri Feb  1 2013 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.10.4-1

63580be procview: Allow configuring a single thread
 Fixes https://bugzilla.redhat.com/show_bug.cgi?id=601234
5d4ee70 tuna: Tighten "No such process" schedutils exception handling
cca561d tuna: Catch OSError exceptions from python-schedutils
 Fixes https://bugzilla.redhat.com/show_bug.cgi?id=871598
07907b3 tuna: Add man page for command line

* Fri Aug 24 2012 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.10.3-1

. Fix exception on ARM
. Remove raw cycles column when perf events are used
. Don't touch the migration threads
. Update testuna to work with 3.6.0-rc1

* Thu Jul 28 2011 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.10.2-1

[acme@felicio tuna]$ git log v0.10.1.. --format=oneline --abbrev-commit
ddd2754 oscilloscope: Switch from "Bistream Vera Sans" to "Liberation Sans"
c5c558c oscilloscope: Switch from Numeric to numpy
28d87b6 MANIFEST: Add tuna/oscilloscope.py
4de7144 cmdline: Fix IRQ affinity setting
40bc92d procview gui: Load perf globally

* Wed Feb 23 2011 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.10.1-1

24f19ce procview gui: Don't assume the perf binding is always available

* Wed Feb 23 2011 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.10-1

[acme@emilia tuna]$ git log v0.9.4.. --format=oneline --abbrev-commit
3b54abd perf: Create the threads pidstat member when we notice the first thread
04f26d1 gui: Fixup perf.evlist constructor call
00a2aa4 gui: Use perf if available
f130d84 cmdline: Alert the user when GUI packages are not installed

* Mon May 10 2010 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.9.3-1

[acme@mica tuna]$ git log v0.9.2.. --format=oneline --abbrev-commit
7d4f258 cmdline: Emit error when affinity operation can't be performed
a9e68d1 cmdline: Use tuna.cpustring_to_list in --cpus
21de19e tuna: Make is_hardirq_handler handle non thread group leaders
ab01211 cmdline: Handle unknown schedulers in -p/--priority:
bbdaf5a cmdline: Improve message about thread list being needed by -p/--priority
427f94c cmdline: Fix --priority error message when no threads are informed
85bb5d7 cmdline: Fix help line entry for --priority
6d0288b tuna: Make cpustring_to_list understand 0x prefixed hexadecimal numbers
7210b53 gui: fix use of cpu ranges
f2bc415 irqview: Fix some race conditions
a3e85fe cmdline: On threaded irq kernels, map irqs to threads
7d33dd1 cmdline: Fix threaded interrupt name bug
3a71dae cmdline: --priority/-p requires a thread list
[acme@mica tuna]$

* Thu Nov 12 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
- cmdline: -Q --show_irqs shows IRQs, so that we can see its affinity
  masks even on non-threaded IRQ kernels
- tuna: Ignore non-existing threads in threads_set_priority
- tuna: i18n, Chinese

* Thu Sep  3 2009 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.9.1-1
- cmdline: --socket needs an argument
- tuna: Present more graceful failure mode when machine can't start gui
- tuna: Handle 2.6.31 style threaded irq names

* Wed May 13 2009 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.9-1
- tuna: i18n, pt_BR & Japanese
- oscilloscope: Fix scaling bugs and add --sample_multiplier
- oscilloscope: properly refresh all widgets
- oscilloscope: Remove needless shebang and reword the package summary
- cmdline: add --show_sockets/-n

* Mon Oct 27 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.8.4-1
- cmdline: Allow globbing --irqs/-q
- cmdline: Allow globbing --threads/-t
- cmdline: Support regex on --thread
- cmdline: Check if thread names resolved to TIDs
- irqview: We have to pass an int to schedutils.setscheduler
- irqview: Initialize the rt_prio entry box
- gui: move procview to a separate file
- gui: Move irqview to a separate file
- gui: remove the Set/set trick in tuna/tuna_gui.py, not used anymore
- gui: Use schedutils.SCHED_{OTHER,FIFO,RR}
- gui: move cpuview classes to a separate file
- gui: Stop handling exceptions at procview.set_thread_columns
- oscilloscope: Ignore invalid samples, emitting just a warning

* Mon Oct 27 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.8-1
- [Non]VolCtxtSwitch columns should be represented in the GUI as unsigned
- Several spelling fixes
- Handle some more schedutils exceptions
- Fix getopt long option for --priority, it requires an arg
- Set the irq affinity mask when setting a IRQ thread affinity
- Add a --spread command line option, it will spread the threads
  passed thru --threads into the cpus specified in --cpu or --socket.

* Mon Sep 15 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.7-1
- CPU topology support: operations now can be performed on CPU sockets in
  addition to individual CPUs
- --show_threads: command line now can see the same information available
  in the GUI

* Tue Aug 12 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.6-1
- tuna: posix_cpu_timer is percpu but its too long to have '/' in the cmdline
- tuna: Fixup the message about what filename was really used (rtgroups)
- tuna: Save the affinity mask for non-percpu kthreads
- tuna: Ignore rtprio when changing sched policy to SCHED_OTHER

* Thu Aug  7 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.5-1
- tuna_gui: Provide instructions on how to use the generated rtctl file
- tuna_gui: Add "Save kthreads tunings" menu entry in the process list box
- tuna: Implement saving current kthread sched policy and rtprio as an rtctl file
- help: Add more kernel thread help texts, written by the MRG crew

* Tue Jun 17 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.4-1
- oscilloscope subpackage
- oscilloscope: Allow passing the number of samples to appear on screen
- oscilloscope: use io_add_watch instead of timeout_add
- oscilloscope: check if the latency tracer is available
- oscilloscope: Allow disabling auto-scaling
- oscilloscope: group the system info and help frames in a vbox
- oscilloscope: parse X geometry parameter
- tuna: Convert widget coords to bin_window coords
- tuna: Implement --affect_children and --priority

* Fri May 16 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.3-1
- Add oscilloscope command, initially useful with signaltest and cyclictest,
  but will also be used with the latencytest utility in the qpid project and
  with any other source of signals. Requires python-matplotlib, that will
  be added to the MRG repo soon. 
- Allow toggling auto-refresh from the irq and threads views
- Changes to make tuna work on older RHEL versions, helpful when evaluating
  RHEL-RT components.
- Allow using tuna without GUI libraries installed, please see:
  tuna --help
  For available commands.
- Several fixes

* Thu Mar 27 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.2-1
- Command line interface
- Remove the requirement of a GUI packages
- Allow moving one child thread to a CPU
- Status icon
- "What is this?", for now just for some kernel threads
- Add "Restore CPU" to undo "Isolate CPU"
- Faster CPU isolation process
- Allow moving IRQs & Threads to all cpus
- CPU filtering

* Mon Feb 26 2008 Arnaldo Carvalho de Melo <acme@redhat.com> - 0.1-1
- package created
