synchronization

I have a internet application that supports offline mode where users might create data that will be synchronized with the server when the user comes back online. So because of this I'm using UUID's for identity in my database so the disconnected clients can generate new objects without fear of using an ID used by another client, etc. However, while this works great for objects that are owned by this user there are objects that are shared by multiple users. For example, tags used by a user might be global, and there's no possible way the remote database could hold all possible tags in the

In my driver's file_operations structure, I have: struct file_operations Fops = { read: device_read, write: device_write, unlocked_ioctl: device_ioctl, ... }; I.e. there is no ioctl field used. Is this sufficient to avoid Big Kernel Lock and enter into device_ioctl() without any synchronization? Or do I have to change ioctl() calls in userspace part of the code too? Read this LWN article: http://lwn.net/Articles/119652/ Also sometime between 2.6.33 and a 2.6.35 rc (use git-diff to find out which commit) the kernel now WARNs when only .ioctl is defined. This is a move towards more explicit and

Is there anything wrong with using lock with a try block? I remember reading somewhere that we should always try to put minimum amount of code within try block and lock itself internally uses a try-finally block, do you guys see something wrong here.I need to deal with the fact that the code within that lock block can throw exception try { lock(syncblk) { // do some processing } } catch(Exception e) { // do something with exception } Eric Lippert I need to deal with the fact that the code within that lock block can throw exception And there's your problem. That's a terrible situation to be in.

I am making a client server MMO style game. So far I have the framework set up so that the server and clients interact with each other in order to provide state updates. The server maintains the game state and periodically calculates the next state and then it every once in a while (every n milliseconds) it sends out the new state to all the clients. This new state is able to be viewed and reacted to on the client side by the user. These actions are then sent back to the server to be processed and sent out for the next update. The obvious problem is that it takes time for these updates to

Almost anywhere I read about programming with CUDA there is a mention of the importance that all of the threads in a warp do the same thing. In my code I have a situation where I can't avoid a certain condition. It looks like this: // some math code, calculating d1, d2 if (d1 < 0.5) { buffer[x1] += 1; // buffer is in the global memory } if (d2 < 0.5) { buffer[x2] += 1; } // some more math code. Some of the threads might enter into one for the conditions, some might enter into both and other might not enter into either. Now in order to make all the thread get back to "doing the same thing"

is there a way to automatically sync my Core Data Model with a server (preferably REST)? Thanks Apple has shared their Sync Services Framework it is documented here: http://developer.apple.com/documentation/Cocoa/Conceptual/SyncServices/SyncServices.html This section is specifically related to syncing managed objects: http://developer.apple.com/documentation/Cocoa/Conceptual/SyncServices/Articles/UsingCoreData.html#//apple_ref/doc/uid/TP40005232 As for which style of data transfer is used, I'm not sure if it using REST, I don't see it immediately obvious. Typically the data transferred to and

The Situation: I would like to ask what's the best logic for synchronizing objects in a multiplayer 1:1 game using BT or a web server. The game has two players, each of them has multiple guns & bullets, the bullets are created dynamically and disappear after a while, the players my move objects around simultaneously. The Problem: I have a real issue with synchronization, since the bullets on one device may be faster than other, also they may have already gone or hit an object on one device while on the other its still in the air. Possibilities? What is the best way of handling synchonization