evince | Read-only mirror of https : //gitlab.gnome.org/GNOME/evince | Document Editor library

In manpage of bash, it says:

When bash starts a job asynchronously (in the background), it prints a line that looks like:

The short answer is it's your font. The /e glyph is throwing an error on setcachedevice (your PostScript interpreter should have told you this).

The actual problem is that the font program is careless (at least) about it's use of function name. The program contains this:

After some testing I found that the issue is caused by the GLib.idle_add(...) in line 180 which causes the process exit check be constantly called. Replaced it with

GLib.timeout_add(1000,poll_viewer_process)

which calls the check once a second. This fixes the CPU load issue...

For bash, !# is the history expansion for the current command line that you've typed so far.

How would I obtain the actual key?

The MSDN docs for ConsoleKey.Packet doesn't say anything useful, so I found references to ConsoleKey in the source which lead here. That's casting ir.keyEvent.virtualKeyCode to a ConsoleKey where ir is an InputRecord.

A quick google finds the WinApi equivalent is INPUT_RECORD, and chasing the docs through KEY_EVENT_RECORD leads to this doc of Virtual-Key codes, which contains some more docs for VK_PACKET:

Used to pass Unicode characters as if they were keystrokes. The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP

The Remarks for KEYBDINPUT say:

INPUT_KEYBOARD supports nonkeyboard-input methods—such as handwriting recognition or voice recognition—as if it were text input by using the KEYEVENTF_UNICODE flag. If KEYEVENTF_UNICODE is specified, SendInput sends a WM_KEYDOWN or WM_KEYUP message to the foreground thread's message queue with wParam equal to VK_PACKET. Once GetMessage or PeekMessage obtains this message, passing the message to TranslateMessage posts a WM_CHAR message with the Unicode character originally specified by wScan. This Unicode character will automatically be converted to the appropriate ANSI value if it is posted to an ANSI window.

From my searching it doesn't look like .NET implements this mechanism for you, so you might have to do it yourself!

I'm afraid I've no idea why it's happening in your case however...

The actual problem is, that NaN values are set to transparent black pixels (#00000000).

The transparency causes these gray outline artifacts, depending on the zooming level. If you zoom close enough, then you see no artifacts.

But as soon as the image pixels are smaller than your monitor pixels, the values are interpolated for screen display. Its seems that pdf viewers like evince (I tested also okular and mupdf) interpolate both color and alpha channels, so that the alpha value of the Nan pixels is changed, and the underlying black appears as gray border around the color pixels.

I tried several ways. The easiest one, which actually worked for me was to use the tikz terminal with option externalimages which saves images created with image as separate png file. These png file also contains transparency, and the final result has the same artifacts. But you can use imagemagick's convert to change the transparent NaN pixels of the png to white with

The following table shows the differences between these two events on Haswell to the best of my (current) knowledge:

mem_load_uops_retired.l3_miss offcore_response.demand _data_rd.l3_miss.local_dram Cacheable Retired Load Uops Per uop per line Y Cacheable Non-Retired Load Uops N Y Uncacheable WC Retired Load Uops One event per line N Uncacheable UC Retired Load Uops May occur N Uncacheable WC or UC Non-Retired Load Uops N N Locked Loads of any type to any memory type May occur I don't know Legacy IO requests May occur N L1D Prefetches N Y L2 Prefetches into L2 or L3 N N Software prefetches with no intention for write N Y Page Walk Loads N Y Servicing Unit Any Local DRAM Reliability May not be reliable Reliable

It should be clear to you now that these events, in general, are not equivalent at all. Also comparing the counts of these two events to deduce something meaningful is not an easy task.

In all of the examples you presented, the offcore_response.demand_data_rd.l3_miss.local_dram event count is larger than the mem_load_uops_retired.l3_miss event count. However, it's not hard to come up with real examples where the latter is larger than the former.

In all four benchmarks, offcore_response.demand_data_rd.l3_miss.local_dram is nearly twice as frequent as mem_load_uops_retired.l3_miss. Is this reasonable?

I think the description "nearly twice" really only applies to the second example, but not the others. I can't comment on the numbers you've shown without seeing the exact code and execution environment information.

use ls -ld /usr/share to see what the permissions on the directory are (without -d, you get the contents and their permissions).

Use code like:

One solution would be to create a list of characters in the input string, and then to remove the commas and change the square brackets to parentheses before finally using the reader to convert the string to a datum. open-input-string can be used to create a string port that can be given to read: