| olli | hey RAOF, not sure if you saw my mail earlier... will I be able to give xmir a spin tomorrow my time? | 01:44 |
|---|---|---|
| RAOF | olli: Yeah, just processing email. | 01:45 |
| RAOF | You should be able to, yes. | 01:45 |
| olli | RAOF, great | 01:45 |
| olli | no hurry, I will be afk for a while | 01:45 |
| RAOF | You definitely will be able to with an xorg.conf change, maybe without (on Intel) | 01:45 |
| olli | as long as it gets to me before you leave for the day | 01:45 |
| olli | sounds good | 01:46 |
| olli | as long as it's documented | 01:46 |
| olli | cya RAOF and everybody else | 01:46 |
| duflu | olli: bye ... ? | 01:47 |
| duflu | Ah, my ISP decided they would start trying to diagnose connection problems at 9am. I'm out of whack now | 01:48 |
| duflu | RAOF: SwapbuffersWait=true gets ignored in the PPA's intel driver. It still stays off :( | 01:55 |
| duflu | Although if it was doing proper flipping then I would not be seeing tearing. Looks like it's blitting for buffer swapping... ?! | 01:55 |
| duflu | Maybe that assumption is wrong... | 01:56 |
| RAOF | duflu: And, just to check, this is happening with a regular X session, not running under the system compositor? | 02:00 |
| duflu | AFK :P | 02:00 |
| duflu | Some days the whole world tries to contact you simultaneously... | 02:10 |
| duflu | RAOF: Yes regular X with no mir running | 02:11 |
| RAOF | duflu: There'll be a new build of xf86-video-intel shortly; try that. | 02:11 |
| duflu | RAOF: Kay, thanks | 02:11 |
| RAOF | Gargh. | 04:59 |
| RAOF | Faster, laptop. | 05:00 |
| RAOF | Aha. | 05:13 |
| RAOF | Mesa! | 05:13 |
| duflu | ? | 05:20 |
| === Stskeepz is now known as Stskeeps | ||
| RAOF | duflu: Mesa is why everything is broken for me. | 05:46 |
| === mmrazik is now known as mmrazik|afk | ||
| RAOF | Woot! | 06:42 |
| RAOF | And now we're back to where we started. | 06:42 |
| RAOF | With a ridiculous orange hardware cursor on top of the XMir session :) | 06:42 |
| mlankhorst | fatally orange | 06:50 |
| duflu | Umm, that's out of date. We switched to a black and white one some days ago | 06:55 |
| duflu | Which reminds me, I meant to propose a smaller one | 06:56 |
| tvoss | RAOF, ping | 06:56 |
| RAOF | tvoss: Pong | 06:57 |
| tvoss | RAOF, good morning :) you happy with being the primary technical contact for Khronos? | 06:58 |
| duflu | Is that news I see? | 06:59 |
| RAOF | tvoss: Yeah. I've sent that email off. | 06:59 |
| duflu | In this public forum? | 06:59 |
| tvoss | duflu, yup, not a secret I guess :) | 06:59 |
| tvoss | RAOF, cool | 06:59 |
| RAOF | Khronos membership is public anyway, right? | 06:59 |
| tvoss | RAOF, yup | 07:00 |
| duflu | Woo, we shall paint Khronos a "ridiculous orange" | 07:00 |
| tvoss | duflu, :) | 07:00 |
| tvoss | alf_, ping | 07:01 |
| alf_ | tvoss: pong | 07:01 |
| tvoss | alf_, good morning :) for the snapshot question: how difficult is it to do a texture to texture copy from a surface/buffer to a texture handle supplied by Unity/shell? | 07:02 |
| alf_ | tvoss: texture handle created in the EGL context of the shell (inprocess client)? | 07:04 |
| tvoss | alf_, yup | 07:05 |
| alf_ | tvoss: We don't have access to textures from different (non-shared) contexts. An option we were considering yesterday was to add eglCreateImageKHR support for the mir EGL platform, so we could create egl images for the native buffer handles (from our surface buffers) in the inprocess client context. | 07:08 |
| alf_ | tvoss: so we don't actually share EGL resources (because we can't) but share the underlying native buffer | 07:08 |
| tvoss | alf_, can you give me a ballpark estimate of the work? | 07:09 |
| tvoss | alf_, remind me why we can't share the eglcontext? | 07:09 |
| alf_ | tvoss: however, there are complications here, since we can't just give native buffers to the shell without synchronization with our internal swapping | 07:11 |
| tvoss | alf_, fair enough | 07:12 |
| alf_ | tvoss: @sharing eglcontext, because egl objects are namespaced under the egldisplay they are created with | 07:12 |
| tvoss | alf_, ack | 07:12 |
| tvoss | Saviq, ping | 07:12 |
| alf_ | tvoss: @estimation, testing etc 1.5 weeks, + couple of days for spike first to ensure what we are trying to do will actually work | 07:14 |
| alf_ | tvoss: (e.g. a feasibility check) | 07:14 |
| tvoss | alf_, okay, please keep looking at it for the time being. There are two use-cases here: (1.) The shell needs to be able to transform an app's surfaces (moving, scaling, shearing), (2.) the shell needs to be able to acquire a snapshot of a surface right before an app is stopped/killed | 07:15 |
| duflu | Hmm, isn't a "snapshot" a much simpler case? We're going to need a non-GL interface for that to eventually support screenshotting too | 07:16 |
| alf_ | tvoss: use case (1) should be done inside a compositing strategy (using the display server's EGL context), so no problem there in terms of sharing buffers. | 07:17 |
| RAOF | Yeah. Is there any particular reason why the snapshots shouldn't be exposed as a blob of bytes? | 07:17 |
| alf_ | tvoss: (2) What does it want to get back? Pixels, like now or a texture? | 07:18 |
| tvoss | alf_, right now, we are using pixels that are uploaded to a texture (saviq, please correct me if I'm wrong) | 07:18 |
| duflu | Eventually we'll need pixels. But some shell features require more efficient textures... like a switcher | 07:19 |
| tvoss | duflu, exactly, and turning a texture to pixels is always possible | 07:19 |
| duflu | Although it's interesting to point out that Compiz does the live-previews thing without any "snapshotting" | 07:19 |
| tvoss | duflu, that's use-case (1.) though, where the app is running and the surface exists | 07:19 |
| tvoss | duflu, we still need "previews"/"snapshots" of the last state for killed/stopped apps (implication of the lifecycle model) | 07:20 |
| RAOF | The other option of course is that the surface still exists with the most-recent content. | 07:20 |
| duflu | Well, not just transform, but hook drawing functions and redraw a surface in multiple locations (like a workspace switcher) | 07:20 |
| tvoss | duflu, agreed, that's what I call "transformation" *handwaving* | 07:21 |
| alf_ | tvoss: for killed apps pixels are the only way forward, because otherwise we would need to keep buffers alive... | 07:21 |
| tvoss | :) | 07:21 |
| RAOF | alf_: Why can't we keep buffers alive? | 07:21 |
| duflu | Yeah you need "pixels" for killed/suspended apps. And also screenshot utils | 07:21 |
| tvoss | duflu, alf_ okay, pixels sounds like a good idea then ... | 07:21 |
| duflu | Because it's unreasonable (I think) to say a screen shot util needs to be a GL app | 07:22 |
| RAOF | duflu: Oh, certainly. But that's orthogonal. | 07:22 |
| RAOF | Is there any particular reason to scrape the pixels out of the buffer, then keep a copy of those pixels, rather than just keeping the buffer around? | 07:22 |
| duflu | Yeah. Just wondering if we need both approaches or only one | 07:22 |
| tvoss | alf_, for the snapshotting/synchronization: I would think that the shell interacts with a surface object for the snapshotting, too ... | 07:23 |
| duflu | RAOF: We do it already ;) ... https://bugs.launchpad.net/mir/+bug/1188451 | 07:23 |
| ubot5 | Launchpad bug 1188451 in Mir "Mir server leaks surfaces from dead clients" [High,Confirmed] | 07:23 |
| RAOF | I don't think we'll be saving any appreciable amount of scarce resources by destroying the buffer but keeping the contents. | 07:23 |
| RAOF | duflu: Heh. | 07:23 |
| tvoss | duflu, mark it a feature then :) | 07:23 |
| duflu | Hmm, it's a feature when we /want/ to leak | 07:24 |
| alf_ | RAOF: I was thinking that it may be too complicated, but I guess in the case we are destroying the surface on the compositor side, it's easy to reason about. | 07:25 |
| alf_ | RAOF: However, giving out the buffer while the DS still owns it, is a world of sync hell. | 07:25 |
| RAOF | Not destroying the surface for an app that's tombstoned would fix that, though. | 07:26 |
| RAOF | Bonus marks if we can get the resurrected app to use the same surface, so it starts with valid content. | 07:26 |
| duflu | It's only in sync after it's tombstoned :) | 07:26 |
| duflu | Hence not useful for other screenshotting apps | 07:26 |
| RAOF | duflu: No, I mean that if the surface still exists then the shell can just composite it as normal; it doesn't need a separate snapshotting process. | 07:27 |
| duflu | Hmm, Nexus4 is giving me stuttering. But only when I wasn't looking. Now I'm looking for the bug it's fine | 07:27 |
| tvoss | RAOF, yeah, like removing all buffers except for the most current one from the surface | 07:28 |
| duflu | Ah there it is | 07:28 |
| RAOF | *Having* a separate snapshotting process is useful for screenshot apps (however we want to do that), but that might not be the best way to give the shell what they need. | 07:28 |
| alf_ | tvoss: RAOF: duflu: Saviq: Have time for a hangout? | 07:30 |
| RAOF | I'll be bathing Zoë soon. | 07:30 |
| tvoss | RAOF, will you be back after the bath? | 07:30 |
| duflu | alf_, in a couple of minutes, or later... | 07:31 |
| RAOF | Just delegated bathing to Sam. | 07:31 |
| RAOF | I may pop in and out once or twice, but I'm good to go. | 07:31 |
| * tvoss searches for the headset | 07:31 | |
| tvoss | good to go | 07:32 |
| RAOF | Oh, and we don't have a thomi this week, do we? | 07:32 |
| tvoss | RAOF, nope | 07:33 |
| alf_ | tvoss: RAOF: duflu: https://plus.google.com/hangouts/_/d306e4af1fc3351c7a344cb62ef288f737707419?hl=en | 07:33 |
| duflu | alf_: Having output device problems again. It refuses to use the headset and goes thru the PC speaker only :P | 07:35 |
| RAOF | duflu: In a couple of minutes. Or, in fact, now. :) | 07:36 |
| duflu | Argh and the mic doesn't work either | 07:37 |
| duflu | I need to log a bug | 07:37 |
| duflu | This happens too often | 07:38 |
| * duflu searches for another mic | 07:40 | |
| duflu | Sorry, I'm out. Need to get a plain old-style mic, and/or a bug fix :( | 07:42 |
| === mmrazik|afk is now known as mmrazik | ||
| === alan_g is now known as alan_g|afk | ||
| === alan_g|afk is now known as alan_g | ||
| Saviq | tvoss, alf_, I believe at the moment the snapshot _includes_ the strut (the top panel), that's why we need the sourceX and sourceY - to _ignore_ the part that's uninteresting | 08:23 |
| tvoss | Saviq, ack | 08:23 |
| Saviq | tvoss, alf_, so if that changes (we get only the surface), we'll need to adapt qtubuntu accordingly | 08:24 |
| alf_ | Saviq: tvoss: Yes, in mir we will just get the surface contents | 08:24 |
| alf_ | alan_g: in light of clang handling "=default" differently from g++ in terms of exceptions, does the recommendation to use =default still stand, or should we prefer "noexcept {}" for destructors? | 08:42 |
| alan_g | alf_: do we see an important difference? | 08:43 |
| alan_g | AFAIK "= default" works fine on interfaces, and we typically have an explicit destructor for implementations. (The exception being google mocks where we have to add "~T() noexcept {}") | 08:46 |
| alf_ | alan_g: I don't think in my case... just wondering for the sake of general correctness | 08:46 |
| alan_g | alf_: correct me if I'm wrong, but isn't the difference in behaviour only evident if you explicitly say "=default" in an implementation? Which is pointless. | 08:50 |
| xrc | hello | 08:52 |
| xrc | I need help with some package problems | 08:52 |
| alf_ | alan_g: yes, you are right, I had misinterpreted the problem as applying to all "=default"s, thanks! | 08:52 |
| xrc | regarding this bug: https://bugs.launchpad.net/unity-system-compositor/+bug/1177722 | 08:52 |
| ubot5 | Launchpad bug 1177722 in Unity System Compositor "mir ppa : unity-system-compositor should be built against latest mir libraries" [High,Fix released] | 08:52 |
| xrc | I have managed to somehow install the lightdm with unity-system-compositor today | 08:57 |
| xrc | but after I clicked upgrade in my ubuntu window with proposed updates - it uninstalled it to go for the latest build of libmirserver | 08:58 |
| alan_g | xrc: I hear your pain. But I'm not sure what state packaging is in just now. (I know there were changes recently - if RAOF is still about he might know.) | 09:06 |
| xrc | alan_g, should I try asking him directly? | 09:07 |
| alan_g | xrc: It's his evening - if he didn't see the mention he's not about. | 09:08 |
| xrc | alan_g, oh, I see. The problem is that I kind of got it installed for a second | 09:12 |
| xrc | alan_g, only to find it slip through my fingers a moment later... Oh well, waiting I should be then. | 09:13 |
| alan_g | xrc: we are trying to get things sorted (and they mostly work with a bit of patience) but it is still a work in progress | 09:14 |
| xrc | alan_g, keep up the good work ) sorry if I'm a little bit aggressive on this, just that I'm very excited about MIR ) | 09:23 |
| === alan_g is now known as alan_g|tea | ||
| === greyback is now known as greyback|shops | ||
| === alan_g|tea is now known as alan_g | ||
| === mmrazik is now known as mmrazik|lunch | ||
| === mmrazik|lunch is now known as mmrazik | ||
| === mzanetti is now known as mzanetti|lunch | ||
| === mzanetti|lunch is now known as mzanetti | ||
| === alan_g is now known as alan_g|lunch | ||
| === alan_g|lunch is now known as alan_g | ||
| alan_g | alf_: thanks for catching my flawed logic. | 15:04 |
| === alan_g is now known as alan_g|tea | ||
| alf_ | alan_g: yw, do you think that providing the mentioned guarantee to comm->pause() is feasible with reasonable effort/complexity? | 15:06 |
| === alan_g|tea is now known as alan_g | ||
| * kdub can't think of something other than SwapperDirector | 15:14 | |
| alan_g | alf_: we can't allow requests to block and guarantee that they've completed | 15:14 |
| racarr | Morning! halfway | 15:14 |
| racarr | greyback: Can we delay sync 20 minutes? | 15:15 |
| alf_ | alan_g: that's true :( | 15:15 |
| alan_g | Afternoon!! | 15:15 |
| alan_g | alf_: we have to allow requests that can't be serviced now to block | 15:16 |
| * alan_g thinks that's a possible TODO in display | 15:17 | |
| alf_ | alan_g: I think this is much more complicated than we had previously... I am not convinced that the complexity is worth it (meaning that we should explore other ways, too) | 15:19 |
| alan_g | alf_: Perhaps, but I do think that "paused" is actually a meaningful state. | 15:22 |
| alan_g | making frontend keep track of retries is just pushing all the complexity there. | 15:23 |
| * alan_g thinks that if we decide to put "pause" logic in another place it grows into a utility class. | 15:24 | |
| alf_ | alan_g: I guess I am arguing it's simpler not to support internal retries. That is, do what have been doing until now: when we pause: 1. we ensure that all pending requests are handled 2. we block new requests. It's simple and leaves the server in a clean state. | 15:28 |
| alan_g | alf_: If it isn't simplistic that works for me. Why did we decide that we'd allow blocking in the swapper yesterday? | 15:32 |
| greyback | racarr: meeting? | 15:32 |
| alf_ | alan_g: because we hadn't thought through all the issues of doing so... and to avoid sending an error response to the client | 15:34 |
| kdub | we'd have to wait for some free buffers before the pause takes effect then | 15:35 |
| kdub | which is probably ok, but the response to pause might take some time then | 15:35 |
| alf_ | kdub: that's what has been happening until recently | 15:35 |
| alan_g | It is simple enough to wait for all current requests to finish in communicator::pause() | 15:36 |
| kdub | yeah | 15:36 |
| alan_g | The problem was that communicator::stop() actually aborts blocked requests | 15:36 |
| kdub | right, as long as we're not breaking the order that the buffers are going out to the clients, or returning an error code to the clients its ok | 15:37 |
| kdub | i too forget how that precondition led to the conclusion of yesterday's meeting :) | 15:37 |
| alf_ | alan_g: no, the problem is that, after the swapper-swapper changes, we are throwing an exception from the swapper which leads to an error response | 15:38 |
| alan_g | alf_: No, that was just a quieter failure | 15:39 |
| alf_ | alan_g: the exception is a result of unblocking the client thread (but that didn't used to be the case, unblocking the client thread had no ill effects) | 15:39 |
| kdub | but we do that because we force_client_completion() | 15:39 |
| kdub | if we're just waiting for the request to be serviced, then we won't have the exception/error msg | 15:40 |
| alan_g | kdub: but that used to return a (random) buffer | 15:40 |
| alan_g | s/random/handy/ | 15:40 |
| alan_g | alf kdub - hangout? | 15:41 |
| alan_g | alf_: ^ | 15:41 |
| alf_ | alan_g: sure | 15:41 |
| racarr | greyback: 10 minutes? | 15:41 |
| alf_ | kdub: ? | 15:43 |
| kdub | sure! | 15:43 |
| alan_g | https://plus.google.com/hangouts/_/afc1479538f15eda73de20aca26fc67be70699b5?hl=en-GB | 15:43 |
| alan_g | https://code.launchpad.net/~alan-griffiths/mir/fix-1189443/+merge/168639 | 15:43 |
| racarr | ricmm: Can we do our sync whenever greyback comes back? | 15:50 |
| racarr | i.e. hopefully soon. sorry perfect storm of minor inconveniences on my part lol | 15:50 |
| ricmm | racarr: hey | 15:52 |
| ricmm | we are in a hangout | 15:52 |
| racarr | Oh. Sorry | 15:52 |
| racarr | link? | 15:52 |
| alf_ | kdub: SwapperVicePresidentOfInternalOperations :D | 16:02 |
| racarr_ | Ok now im really awake | 16:17 |
| racarr_ | alan_g: Want to hear about an interesting requirement on frontend/shell (well depending on how you interpret it)? | 16:20 |
| alan_g | racarr_: Want to tell? | 16:20 |
| racarr_ | Yes! aha | 16:20 |
| racarr_ | So there is the application lifecycle stuff, where the shell can suspend an application that isn't focused | 16:21 |
| racarr_ | and then it may just be paused, it may be killed and reloaded later | 16:21 |
| racarr_ | (and restore its state from an archive it created) | 16:21 |
| racarr_ | etc | 16:21 |
| alan_g | I believe you, go on. | 16:21 |
| racarr_ | but the whole time it is a "running application", appears in the running application sources, etc | 16:21 |
| racarr_ | which implies that, a Session should stay around after | 16:21 |
| alan_g | WTF?! | 16:21 |
| racarr_ | it's socket connection closes | 16:21 |
| racarr_ | (well, it could be at other levels too) | 16:22 |
| racarr_ | the metaphor isn't that the application is killed it's that | 16:22 |
| racarr_ | it is paused, and may come back with a different | 16:22 |
| racarr_ | PID | 16:22 |
| racarr_ | haha | 16:22 |
| alan_g | metaphors are well and good, but "running" is "running" | 16:23 |
| racarr_ | mm. | 16:24 |
| racarr_ | I'm unsure if we should punt it entirely to the shell (i.e. they keep track of applications they suspend and mix this in with the mir data source) | 16:25 |
| racarr_ | or we have some API where like, the shell can | 16:25 |
| racarr_ | steal the session from a session mediator | 16:25 |
| racarr_ | and give it back to a new one later | 16:25 |
| alan_g | "mir data source"? | 16:25 |
| racarr_ | well, I mean, say from a session listener, they are building a list of session objects, that they somehow map to | 16:25 |
| racarr_ | entries in the running app lens, the launcher, etc. | 16:25 |
| racarr_ | we can say for applications, in paused lifecycle, you just have to keep track of yourself, and mix them in with the list we give you where you want them, etc (and presumably at this point they are no longer mir::*::Session, but just some data the shell is keeping around) | 16:26 |
| alan_g | racarr_: you're talking implementation when I'd question the sanity of what the feature | 16:26 |
| alan_g | s/what// | 16:26 |
| racarr_ | alan_g: It's not so much crazier than | 16:26 |
| racarr_ | swap partitions | 16:27 |
| alan_g | racarr_: it is so | 16:27 |
| racarr_ | alan_g: To be clear, when I say the application serializes it's state | 16:28 |
| racarr_ | I don't mean it dumps it's memory | 16:28 |
| alan_g | racarr_: I didn't read it that way | 16:28 |
| racarr_ | ok aha | 16:28 |
| racarr_ | anyway, Id unno, I think it makes sense on a phone, if I have a list of "running applications" | 16:28 |
| racarr_ | I don't really mind and probably prefer that some are occasionally killed | 16:29 |
| racarr_ | but its hidden from me by magic | 16:29 |
| racarr_ | when I have low memory | 16:29 |
| alan_g | but to use your analogy - it is like a "swap partition" that loads at a random memory location and leaves the application code to do address fixup | 16:29 |
| alan_g | What should be happening is that the connection remains open and that the resurrected application talks on it. | 16:32 |
| alan_g | mir doesn't need to care. | 16:33 |
| alan_g | s/does/should/ | 16:33 |
| racarr_ | Is it possible? | 16:33 |
| alan_g | Well, if no-one tells mir the client has gone it won't know. | 16:34 |
| alan_g | The problem is saving and restoring the client state. | 16:34 |
| alan_g | (Including sockets, file handles, ...) | 16:34 |
| alan_g | racarr_: actually, that doesn't work - the client will have resources (like buffers) that we'd want to release. | 16:36 |
| racarr_ | alan_g: I think it's fine to consider | 16:39 |
| racarr_ | the surfaces closed. | 16:39 |
| alan_g | racarr_: I think this needs taking through - what resources are needed while the client is suspended? what resources can be reclaimed? What information is persisted in Mir? | 16:39 |
| racarr_ | well, no, the surfaces close | 16:39 |
| alan_g | if the surfaces close, then the shell can't preview etc | 16:39 |
| racarr_ | well, I think for paused applications it's a snapshot | 16:40 |
| racarr_ | made at pause time | 16:40 |
| alan_g | racarr_: so Mir doesn't need to know it is the same application because it doesn't retain any resources? | 16:41 |
| tvoss | alan_g, exactly ... | 16:41 |
| tvoss | alan_g, at least not for step one | 16:41 |
| racarr_ | alan_g: No. I mean this was part of my question | 16:41 |
| racarr_ | should mir keep track, or do we punt it entirely to the shell | 16:42 |
| racarr_ | I think, conceptually somehow, even if there are no resources left (besides, the application metadata) | 16:42 |
| tvoss | racarr_, I think we should collapse the state of non-running sessions | 16:42 |
| racarr_ | it seems like Mir (in it's role as the ApplicationManager) | 16:42 |
| racarr_ | should still know... | 16:42 |
| racarr_ | so there is one source of information "what are the application which are 'running'" (in the user sense) | 16:43 |
| racarr_ | tvoss: ? | 16:43 |
| racarr_ | one level less abstract ;) | 16:43 |
| tvoss | racarr_, collapsing the state as in open fd's / buffers etc. We can keep track of non-running, recent apps, but we should start over with collapsing active state | 16:43 |
| alan_g | racarr_: the shell takes a snapshot and tells the application to suspend. The application closes the connection and exits. Later the shell tells the application to resume and a new process makes a connection to Mir | 16:43 |
| racarr_ | alan_g: Yes, the question is in the mean time, the shell | 16:45 |
| racarr_ | wants to display the list of 'running' sessions. somehow | 16:45 |
| racarr_ | is it still just a mapping from the SessionManager (i.e. through some hypothetical for_each method or the SessionListener) | 16:45 |
| racarr_ | or does it need to track the "suspended" applications itself | 16:45 |
| racarr_ | tvoss: Yes. I think closing the buffers is clear (I hadn't really thought about the fds, but just assumed we would close them) | 16:46 |
| racarr_ | I am mostly thinking about the API we provide to the shell | 16:46 |
| racarr_ | over what actually happens to the resources | 16:46 |
| tvoss | racarr_, fair point, I have an email drafted and will call in a meeting tomorrow my late afternoon | 16:47 |
| racarr_ | ok | 16:47 |
| alan_g | Mir handles real applications with real sessions. If the shell wants to report something else... | 16:47 |
| racarr_ | the thing that got me thinking about this, is with the | 16:47 |
| racarr_ | HUD being out of process and relying on Session IDs | 16:47 |
| racarr_ | you gain an extra step there | 16:47 |
| racarr_ | unless somehow the session "stays alive" to mir | 16:47 |
| alan_g | How does that make a difference? | 16:48 |
| racarr_ | I mean, the HUD has all this precomputed data assosciated with one session ID, then when the session comes back with a new ID | 16:49 |
| racarr_ | even though from the perspective of HUD it's supposed to be the same application | 16:49 |
| racarr_ | it needs to like, reset or assosciate them somehow | 16:49 |
| racarr_ | which, seems incorrect :) | 16:49 |
| racarr_ | but I dunno | 16:49 |
| alan_g | racarr_: how does Mir being told about the association help HUD? | 16:49 |
| racarr_ | Sesion ID's can stay the asame (just as one example) | 16:50 |
| racarr_ | alan_g: Well, the architecture for the HUD is | 16:51 |
| alan_g | HUD is using Mir's internal IDs?! | 16:51 |
| racarr_ | Uh. Basically. but maybe that is a little flexible | 16:51 |
| racarr_ | the architecture is the applications push their session ID and their menus to the HUD server on startup | 16:51 |
| racarr_ | and then receives messages from Mir (well the shell really, over a private API) | 16:51 |
| tvoss | racarr_, I don't think that we have settled on a final solution there :) | 16:52 |
| racarr_ | like, "session 4 focused" | 16:52 |
| racarr_ | no, iteration 1 | 16:52 |
| racarr_ | :) | 16:52 |
| racarr_ | anyway that message could just as easily be in terms of | 16:52 |
| alan_g | racarr_: so it gets a message from shell saying "here's a new id for old id" | 16:52 |
| racarr_ | alan_g: Yes. | 16:52 |
| alan_g | easier than trying to reuse an id | 16:52 |
| racarr_ | That is the extra step that made me think | 16:52 |
| racarr_ | that the concepts were wrong | 16:52 |
| alan_g | Either Mir needs to be able to understand suspended sessions and be told by the shell that a new session is a suspended one resuming. Or the HUD needs to understand ID changes. | 16:55 |
| racarr_ | Mm. | 16:55 |
| racarr_ | I'm sure understanding ID changes is fine | 16:55 |
| racarr_ | it's just not the ideal code path | 16:56 |
| alan_g | "not the ideal code path" == "it is harder to make a small change to HUD than a large change to Mir"? | 16:58 |
| racarr_ | I wonder if it is such a hard/large change | 16:59 |
| racarr_ | I mean what happens if you just close things down, and the shell keeps a reference to the session... | 16:59 |
| racarr_ | I dunno | 17:00 |
| racarr_ | at this point I don't think there is a strong enough reason for it anymore aha | 17:00 |
| racarr_ | just trying to think through the ideas :) | 17:00 |
| alan_g | Associating a new ID with existing data ought to be simpler than managing lifetime. | 17:03 |
| === mmrazik is now known as mmrazik|afk | ||
| === alan_g is now known as alan_g|life | ||
| racarr_ | alan_g|life: Cya! | 17:06 |
| racarr_ | thanks for feedback | 17:06 |
| alan_g|life | Hope it helps. ;) | 17:06 |
| racarr_ | oi, we will keep it simple. | 17:08 |
| kdub | alan_g|life, something briefly on screen :) | 17:19 |
| kdub | wow, lots of /sb | 17:20 |
| racarr_ | kdub: Nothing much, I had an awful idea and Alan hates me now | 17:22 |
| racarr_ | you know, tuesday | 17:22 |
| racarr_ | :p | 17:22 |
| alan_g|life | racarr_: stop projecting | 17:23 |
| racarr_ | alan_g|life: I'm just teasing :) | 17:23 |
| alan_g|life | So am I | 17:24 |
| racarr_ | alan_g|life: It's hard to tell, Americans are subconciously programmed to conider all british people very serious | 17:29 |
| * alan_g|life [evil laugh] | 17:29 | |
| racarr_ | Um. So. | 17:33 |
| racarr_ | Need to check my brain quickly... | 17:33 |
| racarr_ | kdub: SurfaceStack iterates, from rbegin to rend to emit the surfaces to the compositor | 17:33 |
| racarr_ | but houldn't it be the other way around and we just don't notice because | 17:33 |
| racarr_ | of isngle visibility? | 17:33 |
| kdub | 'single visibility'? | 17:34 |
| racarr_ | kdub: i.e. when we focus surfaces we hide all the others | 17:34 |
| racarr_ | so it's unclear that rendering is going backwards ;) | 17:35 |
| kdub | i guess that depends on how we define the Z ordering | 17:35 |
| racarr_ | mm | 17:35 |
| racarr_ | I guess create_surface can insert at the bottom and that's | 17:35 |
| kdub | if we insert the top surface at the end, then its ok | 17:35 |
| kdub | right | 17:35 |
| racarr_ | mm. | 17:35 |
| racarr_ | I feel like it's kind of counterintuitive | 17:36 |
| racarr_ | with the name stack | 17:36 |
| === mmrazik|afk is now known as mmrazik | ||
| === olli_ is now known as olli | ||
| === mmrazik is now known as mmrazik|afk | ||
| kdub | we should just have a macro to generate unique include guards on all the headers | 20:03 |
| kdub | /end c++ boilerplate grumble | 20:04 |
| racarr_ | kdub: (fset 'create-mir-class (lambda (&optional arg) "Keyboard macro." (interactive "p") (kmacro-exec-ring-item (quote ([ | 20:28 |
| racarr_ | <<SNIP OF HUNDREDS OF INTEGERS>> | 20:28 |
| racarr_ | ;) | 20:28 |
| === racarr_ is now known as racarr | ||
| kdub | heh | 20:29 |
| racarr | qmake | 20:34 |
| racarr | is not the easiest make :( | 20:34 |
| kdub | racarr better than Android.mk :P | 20:51 |
| olli | RAOF, ping | 21:41 |
| racarr | Does someone have time to give a pass on depthify stack (hasn't really changed since merging trunk) | 22:12 |
| racarr | hoping to use it asap (tomorrow?) | 22:12 |
| olli | robert_ancell, can you pls make sure I get my ppa q answered? | 22:53 |
| robert_ancell | olli, yep, have pinged RAOF about it | 22:53 |
| kdub_ | racarr, i'll take another look | 23:06 |
| racarr | kdub_: Thanks :) | 23:07 |
Generated by irclog2html.py 2.7 by Marius Gedminas - find it at mg.pov.lt!