ObjFW  Diff

Annotate Patch Side-by-side Diff

Differences From Artifact [b1989e4bd7]:

To Artifact [6db686d146]:

  • File src/OFKernelEventObserver_poll.m — part of check-in [220513a3f5] at 2015-05-09 18:13:19 on branch trunk — More OFKernelEventObserver refactoring

    This was necessary because select(), poll() and kevent() on FreeBSD and
    OS X would sometimes return 0 events, even if there are some, and
    sometimes return the correct number of events that were pending, meaning
    the number of events returned is unreliable. To make things worse,
    whether it returns 0 or the number of events that were pending is
    completely non-deterministic on both FreeBSD and OS X (running the same
    tests multiple times in a row would make it sometimes work and sometimes
    fail).

    In order to prevent code from depending on the return value of
    -[observeForTimeInterval:] (which would depend on select(), poll() and
    kevent() returning the correct number), OFKernelObserver no longer
    returns whether there were pending events. It is expected that
    -[observe] or -[observeForTimeInterval:] is just called in a loop as
    long as events should be handled.

    The tests have been changed as well to reflect this. What they do now is
    set a deadline and call -[observeForTimeInterval:] with a small timeout
    in a loop until the deadline is reached or all events have been handled.

    Note: DragonFlyBSD has not been tested, but will most likely behave like
    FreeBSD and OS X. (user: js, size: 4504) [annotate] [blame] [check-ins using]

︙
148
149
150
151
152
153
154
155

156
157
158
159
160

161
162
163
164

165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

148
149
150
151
152
153
154

155
156
157
158
159

160
161
162


163



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181



182
183
184
185
186
187
188








-
+




-
+


-
-
+
-
-
-


















-
-
-








- (void)OF_removeObjectForWriting: (id)object
{
	[self OF_removeObject: object
	       fileDescriptor: [object fileDescriptorForWriting]
		       events: POLLOUT];
}

- (bool)observeForTimeInterval: (of_time_interval_t)timeInterval
- (void)observeForTimeInterval: (of_time_interval_t)timeInterval
{
	void *pool = objc_autoreleasePoolPush();
	struct pollfd *FDs;
	int events;
	size_t i, nFDs, realEvents = 0;
	size_t i, nFDs;

	[self OF_processQueueAndStoreRemovedIn: nil];

	if ([self OF_processReadBuffers]) {
	[self OF_processReadBuffers];
		objc_autoreleasePoolPop(pool);
		return true;
	}

	objc_autoreleasePoolPop(pool);

	FDs = [_FDs items];
	nFDs = [_FDs count];

#ifdef OPEN_MAX
	if (nFDs > OPEN_MAX)
		@throw [OFOutOfRangeException exception];
#endif

	events = poll(FDs, (nfds_t)nFDs,
	    (int)(timeInterval != -1 ? timeInterval * 1000 : -1));

	if (events < 0)
		@throw [OFObserveFailedException exceptionWithObserver: self
								 errNo: errno];

	if (events == 0)
		return false;

	for (i = 0; i < nFDs; i++) {
		if (FDs[i].fd > _maxFD)
			@throw [OFOutOfRangeException exception];

		if (FDs[i].revents & POLLIN) {
			if (FDs[i].fd == _cancelFD[0]) {
				char buffer;
︙
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

231
232
233
234
235
236

197
198
199
200
201
202
203


204
205
206
207
208
209
210
211
212
213
214


215
216
217
218

219





220








-
-











-
-




-
+
-
-
-
-
-



			if ([_delegate respondsToSelector:
			    @selector(objectIsReadyForReading:)])
				[_delegate objectIsReadyForReading:
				    _FDToObject[FDs[i].fd]];

			objc_autoreleasePoolPop(pool);

			realEvents++;
		}

		if (FDs[i].revents & POLLOUT) {
			pool = objc_autoreleasePoolPush();

			if ([_delegate respondsToSelector:
			    @selector(objectIsReadyForWriting:)])
				[_delegate objectIsReadyForWriting:
				    _FDToObject[FDs[i].fd]];

			objc_autoreleasePoolPop(pool);

			realEvents++;
		}

		FDs[i].revents = 0;
	}

}
	if (realEvents == 0)
		return false;

	return true;
}
@end