I use XMonad with a single physical screen with 10 workspaces. I would like to have two or more separate instances of worksapces, kinda like multiple "virtual screens" on a single physical screen. E.g., virtual screen 1 and 2 should each independently have their own workspaces and I would then use some key-bindings to switch between the virtual screens.
How can I achieve the desired configuration? I stumbled upon XMonad.Layout.IndependentScreens but it does not really cover what I need.
Related
I'm using RISC-V I would like to customize the number of cores in a tile.
Which chisel file should I modify?
Are you using RocketChip generator?
If you want to create several cores, you can change the number of cores in "rocket-chip/src/main/scala/uncore/Builder.scala" NTiles param.
If you want to add it inside a Tile, maybe you should modify rocket.scala and tile.scala, but take into account that they will share the L1 cachés and that could create conflicts.
I made a code with a switch to enable multi core feature .
I ran two different run
1st - with single core
2nd - with two cores
both were running with same exec and in the same machine in different terminals. I had to debug something. I was debugging parallel with both run, while debugging I found that "one same pointer in both run were pointing to same address" .
I know shared memory concept when we use fork , but here I was running two different process.
how Is this possible and what is the concept behind it .
You are not specifying an operating system, but typically processes have independent address spaces. What you are probably seeing are two pointers which happen to have the same value, but actually referring to each process' own memory space.
Protected mode OSs often remap physical memory into new address spaces for the user level programs.
I want to make Linux Os which run only one application as a full screen without showing any Login window at start up or title-bar and minimize/maximize/close button.
Is there any way to do this? It's Embedded platform and I already build Linux os for it and I also have application.
In the nutshell - X System is extremely flexible.
When you system starts up, it does the following steps:
Loads and runs the Kernel (and related initrd, if any, but it's irrelevant)
Starts init (process 1)
Starts system services, networking, etc.
Starts X server
Starts Window Manager (the application responsible for resizing windows etc)
Starts your application.
What you need to do, is to first disable GUI login and session (easiest to disable X) - you'll be able to log in through the console terminal (You can always access it with Ctrl-Alt-F1)
Then, launch something along the lines of
X &
DISPLAY=:0 ./yourapp.exe
If your app can handle making itself fullscreen, that would be it.
Add this to your startup scripts and you're there.
More explanation
The purpose of the Window Manager.. is to manage windows. It's that simple :)
Basically, there are 3 components of your typical X session.
X Server - the piece of software that provides an abstraction layer around the hardware (GPU drivers, Keyboard, Mouse, Touchscreen, etc). It has a concept of windows - areas where X Clients can draw into.
X Clients - Everything else. Your software, if it draws something, is likely one. So is the web browser, etc. The connect to the X Server, and draw.
Window Manager - A special type of an X Client, this piece of software provides the ability to control the windows on your screen. It often draws window decorations (minimize, maximize buttons), sometimes draws a taskbar, etc.
You are free to mix and match them entirely as you please. Simpler, minimalisting window managers, such as my ratpoison which I prefer for many prototype embedded systems only have the notion of fullscreen windows, and can switch between fullscreen apps (think Windows 8 Metro). Others draw window decorations, and allow overlapping and cascading windows.
Since developing a Window Manager is a simple and modular task, there are literally hundreds to chose from. You also can choose not to use one at all, at which point your windows have to self-manage (you'll not be able to move them around by default). Many applications respect the -geometry 1920x1080+0+0 parameter, telling them to open a window in 1920x1080 resolution at the 0,0 corner - effectively fullscreen.
Is there a good, graphical way to represent disk usage changes in a linux/unix filesystem over time?
Let me elaborate: there are several good ways to represent disk usage in a filesystem. I'm not interested in summary statistics such total space used (as given by du(1)), but more advanced interactive/visualization tools such as ncdu, gdmap, filelight or baobab, that can give me an idea of where the space is being used.
From a technical perspective, I think the best approach is squarified tree-maps (as available in gdmap), since it makes a better use of the visual space available. The circular approach used by filelight for instance cannot represent huge hierarchies efficiently, and it's dubious how to account for the increasing area of the outer rings in the representation from a human perspective. Looks nice, but that's about it.
Treemaps are perfect to have the current snapshot of disk usage in the filesystem, but I'd like to have something similar to see how disk usage has been evolving over time.
My current solution is very simple: I'm dumping the filesystem usage state using "ncdu -o" over time, and then I compare them side-by-side using two ncdu instances. It's very inefficient, but does the job. I'd like something more visual though.
All the relevant information can be dumped using:
find [dir] -printf "%P\t%s\n"
I did a crappy hack to load this state information in gdmap, so I can use two gdmap instances instead. Still not optimal though, as a treemap will fit the total allocated space into the same rectangle. As such, you cannot really tell if the same area is equivalent to more or less space. If two big directories grow proportionately, they will not change the visualization.
I need something better than that. Obviously, I cannot plot the cumulative directory sizes in a simple line plot, as I would have too many directories.
I'd like something similar to a treemap, where maybe the color of the square represents size increase/decrease using some colormap. However, since a treemap will show individual files as opposed to directories, it's not obvious on how to color-map a directory in which the allocated space has been growing/shrinking due to new/removed files.
What kind of visualization techniques could be used to see the evolution of allocated space over time, which take the whole underlying tree into account?
To elaborate even more, in a squarified treemap the whole allocated space is proportionally divided by file size, and each directory logically clusters the allocated space within it. As such, we don't "see" directories, we see the proportional space taken by it's content.
How we could extend and/or improve the visualization in order to see how the allocated space has been moved to a different area of the treemap?
You can usee Cacti for this.
You need to install snmp deamon on you machine and install cacti (freeware) localy or on any other PC and monitor you linux machine.
http://blog.securactive.net/wp-content/uploads/2012/12/cacti_performance_vision1.png
You can monitor network interfaces, spaces of any partitions and lot of other parameters of your LINUX OS.
apt-get install cacti
vim /etc/snmp/snmpd.conf
add this at about 42 line:
view systemonly included .1.3.6.1
close and restart snmpd deamon
go to cacti config and try to discover your linux machine.
On a computer with multiple monitors where the desktop is not shown on one of them, is there any way to draw on that monitor from a program?
Reasoning: I need to display a variable image full-screen on a separate monitor, without the user being able to disturb the screen with the mouse or without being able to shift windows on top of my image. Example: a computer has one monitor and one projector connected; the monitor shows a "normal" desktop and the projector shows the generated image (say, a color gradient).
The first use would be on Win7, but if a portable solution exists, an X11 solution under Linux would also be nice.
On Linux this is easy using xvfb, a virtual framebuffer. The command is:
Xvfb :1 -screen 0 1600x1200x32
You can run programs on the virtual screen by setting the environment variable DISPLAY=:1
The best part is the user doesn't even have to worry about interfering with the mouse or keyboard. Very useful for testing.
Under Linux, you can also run a second X session on the extra monitor
Xorg :1 -config /path/to/xorg_1.conf
But you'd need to write a xorg_1.conf configuration file to feed in.