eventmachine-maglev- 0.12.10 → 1.0.0.beta.4

data/docs/SPAWNED_PROCESSES

@@ -1,89 +0,0 @@
-EventMachine (EM) adds two different formalisms for lightweight concurrency to the Ruby programmer's toolbox: spawned processes and deferrables. This note will show you how to use spawned processes. For more information, see the separate document LIGHTWEIGHT_CONCURRENCY.
-
-
-=== What are Spawned Processes?
-
-Spawned Processes in EventMachine are inspired directly by the "processes" found in the Erlang programming language. EM deliberately borrows much (but not all) of Erlang's terminology. However, EM's spawned processes differ from Erlang's in ways that reflect not only Ruby style, but also the fact that Ruby is not a functional language like Erlang.
-
-Let's proceed with a complete, working code sample that we will analyze line by line. Here's an EM implementation of the "ping-pong" program that also appears in the Erlang tutorial:
-
-
- require 'eventmachine'
- 
- EM.run {
-   pong = EM.spawn {|x, ping|
-     puts "Pong received #{x}"
-     ping.notify( x-1 )
-   }
- 
-   ping = EM.spawn {|x|
-     if x > 0
-       puts "Pinging #{x}"
-       pong.notify x, self
-     else
-       EM.stop
-     end
-   }
- 
-   ping.notify 3
- }
-
-If you run this program, you'll see the following output:
-
- Pinging 3
- Pong received 3
- Pinging 2
- Pong received 2
- Pinging 1
- Pong received 1
-
-Let's take it step by step.
-
-EventMachine#spawn works very much like the built-in function spawn in Erlang. It returns a reference to a Ruby object of class EventMachine::SpawnedProcess, which is actually a schedulable entity. In Erlang, the value returned from spawn is called a "process identifier" or "pid." But we'll refer to the Ruby object returned from EM#spawn simply as a "spawned process."
-
-You pass a Ruby block with zero or more parameters to EventMachine#spawn. Like all Ruby blocks, this one is a closure, so it can refer to variables defined in the local context when you call EM#spawn.
-
-However, the code block passed to EM#spawn does NOT execute immediately by default. Rather, it will execute only when the Spawned Object is "notified." In Erlang, this process is called "message passing," and is done with the operator !, but in Ruby it's done simply by calling the #notify method of a spawned-process object. The parameters you pass to #notify must match those defined in the block that was originally passed to EM#spawn.
-
-When you call the #notify method of a spawned-process object, EM's reactor core will execute the code block originally passed to EM#spawn, at some point in the future. (#notify itself merely adds a notification to the object's message queue and ALWAYS returns immediately.)
-
-When a SpawnedProcess object executes a notification, it does so in the context of the SpawnedProcess object itself. The notified code block can see local context from the point at which EM#spawn was called. However, the value of "self" inside the notified code block is a reference to the SpawnedProcesss object itself.
-
-An EM spawned process is nothing more than a Ruby object with a message queue attached to it. You can have any number of spawned processes in your program without compromising scalability. You can notify a spawned process any number of times, and each notification will cause a "message" to be placed in the queue of the spawned process. Spawned processes with non-empty message queues are scheduled for execution automatically by the EM reactor. Spawned processes with no visible references are garbage-collected like any other Ruby object.
-
-Back to our code sample:
-
-   pong = EM.spawn {|x, ping|
-     puts "Pong received #{x}"
-     ping.notify( x-1 )
-   }
-
-This simply creates a spawned process and assigns it to the local variable pong. You can see that the spawned code block takes a numeric parameter and a reference to another spawned process. When pong is notified, it expects to receive arguments corresponding to these two parameters. It simply prints out the number it receives as the first argument. Then it notifies the spawned process referenced by the second argument, passing it the first argument minus 1.
-
-And then the block ends, which is crucial because otherwise nothing else can run. (Remember that in LC, scheduled entities run to completion and are never preempted.)
-
-On to the next bit of the code sample:
-
-   ping = EM.spawn {|x|
-     if x > 0
-       puts "Pinging #{x}"
-       pong.notify x, self
-     else
-       EM.stop
-     end
-   }
-
-Here, we're spawning a process that takes a single (numeric) parameter. If the parameter is greater than zero, the block writes it to the console. It then notifies the spawned process referenced by the pong local variable, passing as arguments its number argument, and a reference to itself. The latter reference, as you saw above, is used by pong to send a return notification.
-
-If the ping process receives a zero value, it will stop the reactor loop and end the program.
-
-Now we've created a pair of spawned processes, but nothing else has happened. If we stop now, the program will spin in the EM reactor loop, doing nothing at all. Our spawned processes will never be scheduled for execution.
-
-But look at the next line in the code sample:
-
-   ping.notify 3
-
-This line gets the ping-pong ball rolling. We call ping's #notify method, passing the argument 3. This causes a message to be sent to the ping spawned process. The message contains the single argument, and it causes the EM reactor to schedule the ping process. And this in turn results in the execution of the Ruby code block passed to EM#spawn when ping was created. Everything else proceeds as a result of the messages that are subsequently passed to each other by the spawned processes.
-
-[TODO, present the outbound network i/o use case, and clarify that spawned processes are interleaved with normal i/o operations and don't interfere with them at all. Also, blame Erlang for the confusing term "process"]
-

data/ext/cplusplus.cpp

@@ -1,202 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     cplusplus.cpp
-Date:     27Jul07
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-
-#include "project.h"
-
-
-namespace EM {
-	static map<unsigned long, Eventable*> Eventables;
-	static map<unsigned long, void(*)()> Timers;
-}
-
-
-/*******
-EM::Run
-*******/
-
-void EM::Run (void (*start_func)())
-{
-	evma_set_epoll (1);
-	evma_initialize_library (EM::Callback);
-	if (start_func)
-		AddTimer (0, start_func);
-	evma_run_machine();
-	evma_release_library();
-}
-
-/************
-EM::AddTimer
-************/
-
-void EM::AddTimer (int milliseconds, void (*func)())
-{
-	if (func) {
-		const unsigned long sig = evma_install_oneshot_timer (milliseconds);
-		#ifndef HAVE_MAKE_PAIR
-		Timers.insert (map<unsigned long, void(*)()>::value_type (sig, func));
-		#else
-		Timers.insert (make_pair (sig, func));
-		#endif
-	}
-}
-
-
-/***************
-EM::StopReactor
-***************/
-
-void EM::StopReactor()
-{
-	evma_stop_machine();
-}
-
-
-/********************
-EM::Acceptor::Accept
-********************/
-
-void EM::Acceptor::Accept (const unsigned long signature)
-{
-	Connection *c = MakeConnection();
-	c->Signature = signature;
-	#ifndef HAVE_MAKE_PAIR
-	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (c->Signature, c));
-	#else
-	Eventables.insert (make_pair (c->Signature, c));
-	#endif
-	c->PostInit();
-}
-
-/************************
-EM::Connection::SendData
-************************/
-
-void EM::Connection::SendData (const char *data)
-{
-	if (data)
-		SendData (data, strlen (data));
-}
-
-
-/************************
-EM::Connection::SendData
-************************/
-
-void EM::Connection::SendData (const char *data, int length)
-{
-	evma_send_data_to_connection (Signature, data, length);
-}
-
-
-/*********************
-EM::Connection::Close
-*********************/
-
-void EM::Connection::Close (bool afterWriting)
-{
-	evma_close_connection (Signature, afterWriting);
-}
-
-
-/***************************
-EM::Connection::BindConnect
-***************************/
-
-void EM::Connection::BindConnect (const char *bind_addr, int bind_port, const char *host, int port)
-{
-	Signature = evma_connect_to_server (bind_addr, bind_port, host, port);
-	#ifndef HAVE_MAKE_PAIR
-	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (Signature, this));
-	#else
-	Eventables.insert (make_pair (Signature, this));
-	#endif
-}
-
-/***********************
-EM::Connection::Connect
-***********************/
-
-void EM::Connection::Connect (const char *host, int port)
-{
-	this->BindConnect(NULL, 0, host, port);
-}
-
-/*******************
-EM::Acceptor::Start
-*******************/
-
-void EM::Acceptor::Start (const char *host, int port)
-{
-	Signature = evma_create_tcp_server (host, port);
-	#ifndef HAVE_MAKE_PAIR
-	Eventables.insert (std::map<unsigned long,EM::Eventable*>::value_type (Signature, this));
-	#else
-	Eventables.insert (make_pair (Signature, this));
-	#endif
-}
-
-
-
-/************
-EM::Callback
-************/
-
-void EM::Callback (const unsigned long sig, int ev, const char *data, const unsigned long length)
-{
-	EM::Eventable *e;
-	void (*f)();
-
-	switch (ev) {
-		case EM_TIMER_FIRED:
-			f = Timers [length]; // actually a binding
-			if (f)
-				(*f)();
-			Timers.erase (length);
-			break;
-
-		case EM_CONNECTION_READ:
-			e = EM::Eventables [sig];
-			e->ReceiveData (data, length);
-			break;
-
-		case EM_CONNECTION_COMPLETED:
-			e = EM::Eventables [sig];
-			e->ConnectionCompleted();
-			break;
-
-		case EM_CONNECTION_ACCEPTED:
-			e = EM::Eventables [sig];
-			e->Accept (length); // actually a binding
-			break;
-
-		case EM_CONNECTION_UNBOUND:
-			e = EM::Eventables [sig];
-			e->Unbind();
-			EM::Eventables.erase (sig);
-			delete e;
-			break;
-
-		case EM_SSL_HANDSHAKE_COMPLETED:
-			e = EM::Eventables [sig];
-			e->SslHandshakeCompleted();
-			break;
-	}
-}
-

data/ext/emwin.cpp

@@ -1,300 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     emwin.cpp
-Date:     05May06
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-
-// THIS ENTIRE FILE IS FOR WINDOWS BUILDS ONLY
-// INCOMPLETE AND DISABLED FOR NOW.
-#ifdef xOS_WIN32
-
-#include "project.h"
-
-
-// Keep a global variable floating around
-// with the current loop time as set by the Event Machine.
-// This avoids the need for frequent expensive calls to time(NULL);
-time_t gCurrentLoopTime;
-
-
-/******************************
-EventMachine_t::EventMachine_t
-******************************/
-
-EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const char*, int)):
-	EventCallback (event_callback),
-	NextHeartbeatTime (0)
-{
-	gTerminateSignalReceived = false;
-	Iocp = NULL;
-}
-
-
-/*******************************
-EventMachine_t::~EventMachine_t
-*******************************/
-
-EventMachine_t::~EventMachine_t()
-{
-	cerr << "EM __dt\n";
-	if (Iocp)
-		CloseHandle (Iocp);
-}
-
-
-/****************************
-EventMachine_t::ScheduleHalt
-****************************/
-
-void EventMachine_t::ScheduleHalt()
-{
-  /* This is how we stop the machine.
-   * This can be called by clients. Signal handlers will probably
-   * set the global flag.
-   * For now this means there can only be one EventMachine ever running at a time.
-   */
-	gTerminateSignalReceived = true;
-}
-
-
-
-/*******************
-EventMachine_t::Run
-*******************/
-
-void EventMachine_t::Run()
-{
-	HookControlC (true);
-
-	Iocp = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL, 0, 0);
-	if (Iocp == NULL)
-		throw std::runtime_error ("no completion port");
-
-
-	DWORD nBytes, nCompletionKey;
-	LPOVERLAPPED Overlapped;
-
-	do {
-		gCurrentLoopTime = time(NULL);
-		// Have some kind of strategy that will dequeue maybe up to 10 completions 
-		// without running the timers as long as they are available immediately.
-		// Otherwise in a busy server we're calling them every time through the loop.
-		if (!_RunTimers())
-			break;
-		if (GetQueuedCompletionStatus (Iocp, &nBytes, &nCompletionKey, &Overlapped, 1000)) {
-		}
-		cerr << "+";
-	} while (!gTerminateSignalReceived);
-
-
-	/*
-	while (true) {
-		gCurrentLoopTime = time(NULL);
-		if (!_RunTimers())
-			break;
-		_AddNewDescriptors();
-		if (!_RunOnce())
-			break;
-		if (gTerminateSignalReceived)
-			break;
-	}
-	*/
-
-	HookControlC (false);
-}
-
-
-/**************************
-EventMachine_t::_RunTimers
-**************************/
-
-bool EventMachine_t::_RunTimers()
-{
-	// These are caller-defined timer handlers.
-	// Return T/F to indicate whether we should continue the main loop.
-	// We rely on the fact that multimaps sort by their keys to avoid
-	// inspecting the whole list every time we come here.
-	// Just keep inspecting and processing the list head until we hit
-	// one that hasn't expired yet.
-
-	while (true) {
-		multimap<time_t,Timer_t>::iterator i = Timers.begin();
-		if (i == Timers.end())
-			break;
-		if (i->first > gCurrentLoopTime)
-			break;
-		if (EventCallback)
-			(*EventCallback) (NULL, EM_TIMER_FIRED, NULL, i->second.GetBinding());
-		Timers.erase (i);
-	}
-	return true;
-}
-
-
-/***********************************
-EventMachine_t::InstallOneshotTimer
-***********************************/
-
-const char *EventMachine_t::InstallOneshotTimer (int seconds)
-{
-	if (Timers.size() > MaxOutstandingTimers)
-		return false;
-	// Don't use the global loop-time variable here, because we might
-	// get called before the main event machine is running.
-
-	Timer_t t;
-	Timers.insert (make_pair (time(NULL) + seconds, t));
-	return t.GetBinding();
-}
-
-
-/**********************************
-EventMachine_t::OpenDatagramSocket
-**********************************/
-
-const char *EventMachine_t::OpenDatagramSocket (const char *address, int port)
-{
-	cerr << "OPEN DATAGRAM SOCKET\n";
-	return "Unimplemented";
-}
-
-
-/*******************************
-EventMachine_t::CreateTcpServer
-*******************************/
-
-const char *EventMachine_t::CreateTcpServer (const char *server, int port)
-{
-	/* Create a TCP-acceptor (server) socket and add it to the event machine.
-	 * Return the binding of the new acceptor to the caller.
-	 * This binding will be referenced when the new acceptor sends events
-	 * to indicate accepted connections.
-	 */
-
-	const char *output_binding = NULL;
-
-	struct sockaddr_in sin;
-
-	SOCKET sd_accept = socket (AF_INET, SOCK_STREAM, 0);
-	if (sd_accept == INVALID_SOCKET) {
-		goto fail;
-	}
-
-	memset (&sin, 0, sizeof(sin));
-	sin.sin_family = AF_INET;
-	sin.sin_addr.s_addr = INADDR_ANY;
-	sin.sin_port = htons (port);
-
-	if (server && *server) {
-		sin.sin_addr.s_addr = inet_addr (server);
-		if (sin.sin_addr.s_addr == INADDR_NONE) {
-			hostent *hp = gethostbyname (server);
-			if (hp == NULL) {
-				//__warning ("hostname not resolved: ", server);
-				goto fail;
-			}
-			sin.sin_addr.s_addr = ((in_addr*)(hp->h_addr))->s_addr;
-		}
-	}
-
-
-	// No need to set reuseaddr on Windows.
-
-
-	if (bind (sd_accept, (struct sockaddr*)&sin, sizeof(sin))) {
-		//__warning ("binding failed");
-		goto fail;
-	}
-
-	if (listen (sd_accept, 100)) {
-		//__warning ("listen failed");
-		goto fail;
-	}
-
-	{ // Looking good.
-		AcceptorDescriptor *ad = new AcceptorDescriptor (this, sd_accept);
-		if (!ad)
-			throw std::runtime_error ("unable to allocate acceptor");
-		Add (ad);
-		output_binding = ad->GetBinding();
-
-		CreateIoCompletionPort ((HANDLE)sd_accept, Iocp, NULL, 0);
-		SOCKET sd = socket (AF_INET, SOCK_STREAM, 0);
-		CreateIoCompletionPort ((HANDLE)sd, Iocp, NULL, 0);
-		AcceptEx (sd_accept, sd, 
-	}
-
-	return output_binding;
-
-	fail:
-	if (sd_accept != INVALID_SOCKET)
-		closesocket (sd_accept);
-	return NULL;
-}
-
-
-/*******************************
-EventMachine_t::ConnectToServer
-*******************************/
-
-const char *EventMachine_t::ConnectToServer (const char *server, int port)
-{
-	if (!server || !*server || !port)
-		return NULL;
-
-	sockaddr_in pin;
-	unsigned long HostAddr;
-
-	HostAddr = inet_addr (server);
-	if (HostAddr == INADDR_NONE) {
-		hostent *hp = gethostbyname (server);
-		if (!hp)
-			return NULL;
-		HostAddr = ((in_addr*)(hp->h_addr))->s_addr;
-	}
-
-	memset (&pin, 0, sizeof(pin));
-	pin.sin_family = AF_INET;
-	pin.sin_addr.s_addr = HostAddr;
-	pin.sin_port = htons (port);
-
-	int sd = socket (AF_INET, SOCK_STREAM, 0);
-	if (sd == INVALID_SOCKET)
-		return NULL;
-
-
-	LPOVERLAPPED olap = (LPOVERLAPPED) calloc (1, sizeof (OVERLAPPED));
-	cerr << "I'm dying now\n";
-	throw runtime_error ("UNIMPLEMENTED!!!\n");
-
-}
-
-
-
-/*******************
-EventMachine_t::Add
-*******************/
-
-void EventMachine_t::Add (EventableDescriptor *ed)
-{
-	cerr << "ADD\n";
-}
-
-
-
-#endif // OS_WIN32
-

data/ext/emwin.h

@@ -1,94 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     emwin.h
-Date:     05May06
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-
-// THIS ENTIRE FILE IS FOR WINDOWS BUILDS ONLY.
-// INCOMPLETE AND DISABLED FOR NOW.
-#ifdef xOS_WIN32
-
-#ifndef __EventMachine__H_
-#define __EventMachine__H_
-
-
-extern time_t gCurrentLoopTime;
-
-class EventableDescriptor;
-
-
-/********************
-class EventMachine_t
-********************/
-
-class EventMachine_t
-{
-	public:
-		EventMachine_t (void(*event_callback)(const char*, int, const char*, int));
-		virtual ~EventMachine_t();
-
-		void Run();
-		void ScheduleHalt();
-		const char *InstallOneshotTimer (int);
-		const char *ConnectToServer (const char *, int);
-		const char *CreateTcpServer (const char *, int);
-		const char *OpenDatagramSocket (const char *, int);
-
-		void Add (EventableDescriptor*);
-
-	public:
-		enum { // Event names
-			TIMER_FIRED = 100,
-			CONNECTION_READ = 101,
-			CONNECTION_UNBOUND = 102,
-			CONNECTION_ACCEPTED = 103,
-			CONNECTION_COMPLETED = 104,
-			LOOPBREAK_SIGNAL = 105
-		};
-
-	private:
-		HANDLE Iocp;
-
-	private:
-		bool _RunOnce();
-		bool _RunTimers();
-		void _AddNewDescriptors();
-
-	private:
-		enum {
-			MaxOutstandingTimers = 40,
-			HeartbeatInterval = 2
-		};
-		void (*EventCallback)(const char*, int, const char*, int);
-
-		class Timer_t: public Bindable_t {
-		};
-
-		multimap<time_t, Timer_t> Timers;
-		vector<EventableDescriptor*> Descriptors;
-		vector<EventableDescriptor*> NewDescriptors;
-
-		time_t NextHeartbeatTime;
-};
-
-
-
-
-#endif // __EventMachine__H_
-
-#endif // OS_WIN32
-

data/ext/epoll.cpp

@@ -1,26 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     epoll.cpp
-Date:     06Jun07
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-
-#ifdef HAVE_EPOLL
-
-#include "project.h"
-
-#endif // HAVE_EPOLL
-