/hg/release/icedtea6-1.7: 2 new changesets
andrew at icedtea.classpath.org
andrew at icedtea.classpath.org
Wed Jun 2 06:27:52 PDT 2010
changeset 0ebb8329d845 in /hg/release/icedtea6-1.7
details: http://icedtea.classpath.org/hg/release/icedtea6-1.7?cmd=changeset;node=0ebb8329d845
author: Deepak Bhole <dbhole at redhat.com>
date: Mon Mar 15 13:35:18 2010 -0400
Liveconnect message processing design changes.
- Redesigned message consumption/processing model to allow arbitrary
number of applets to load without increasing MAX_WORKERS count.
- Implemented priority queuing to allow blocking threads to get
responses first.
- Made message consumption non-blocking and fixed thread-safety
issues therein
2010-03-13 Deepak Bhole <dbhole at redhat.com>
* plugin/icedteanp/java/sun/applet/PluginAppletViewer.java
(requestPluginCookieInfo): Register cookie info as a priority
message. (requestPluginProxyInfo): Register proxy info as a
priority message.
* plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java: Re-
designed message consumption to implement priority queuing
and parallel initialization limits so that an arbitrary
number of applets can load without blocking one another, all
in a thread-safe manner. (registerPriorityWait): New method.
Registers a string that is considered a "priority" string,
which gets delegated to dedicated worker threads.
(unRegisterPriorityWait): Unregisters a string so that it is no
longer a priority. (PluginMessageConsumer): Do not
create any workers when starting. (consume): Remove method.
Consumption is now done in a separate dedicated thread to
prevent blocking. (getPriorityStrIfPriority): New
method. If the given message is priority, return why (i.e
the 'priority string'it matched). (isInInit): New method.
Returns if the plugin is currently initializing an applet.
(addToInitWorkers): New method. Adds given worker to list of workers
currently initializting applets. (okayToProcess): New
method. Returns whether or not it is okay to process the
given applet. (notifyWorkerIsFree): New method. Notifies
this class that a worker has just become free.
(queue): Queues the given message for consumption.
(ConsumerThread): New protected inner (thread) class. Responsible
for consuming messages in the queue, and regueuing them if
consumption if not possible. (getFreeWorker):
Changed to be non-blocking, and return either a priority
worker or a normal worker depending on what is requested.
* plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java
(PluginMessageHandlerWorker): Set new priority and consumer
variables. (busy): Make thread-safe by waiting on same
property that free() waits on. (free): Make thread-safe by
waiting on same property that busy() waits on. (isPriority):
New method. Returns of worker is a priority worker.
(isFree): Made thread-safe, and accounts for priority.
* plugin/icedteanp/java/sun/applet/PluginStreamHandler.java
(startProcessing): Call consumer.queue() instead of
consumer.consume(). (postMessage): Remove unused method.
changeset 0424d3023049 in /hg/release/icedtea6-1.7
details: http://icedtea.classpath.org/hg/release/icedtea6-1.7?cmd=changeset;node=0424d3023049
author: Deepak Bhole <dbhole at redhat.com>
date: Tue Mar 16 10:29:49 2010 -0400
Added support for JSObject.finalize()
2010-03-16 Deepak Bhole <dbhole at redhat.com>
* plugin/icedteanp/IcedTeaPluginRequestProcessor.cc
(newMessageOnBus): Added support for finalize. (finalize):
New function. Decrements object reference count by one.
(queue_processor): Added support for finalize.
* plugin/icedteanp/IcedTeaPluginRequestProcessor.h: Removed unused
function declerations. Added decleration for finalize.
diffstat:
7 files changed, 363 insertions(+), 89 deletions(-)
ChangeLog | 52 +
plugin/icedteanp/IcedTeaPluginRequestProcessor.cc | 56 ++
plugin/icedteanp/IcedTeaPluginRequestProcessor.h | 10
plugin/icedteanp/java/sun/applet/PluginAppletViewer.java | 2
plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java | 267 ++++++++--
plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java | 38 +
plugin/icedteanp/java/sun/applet/PluginStreamHandler.java | 27 -
diffs (truncated from 601 to 500 lines):
diff -r 92e2665861fb -r 0424d3023049 ChangeLog
--- a/ChangeLog Tue Mar 09 15:54:50 2010 -0500
+++ b/ChangeLog Tue Mar 16 10:29:49 2010 -0400
@@ -1,3 +1,55 @@ 2010-03-09 Deepak Bhole <dbhole at redhat.
+2010-03-16 Deepak Bhole <dbhole at redhat.com>
+
+ * plugin/icedteanp/IcedTeaPluginRequestProcessor.cc
+ (newMessageOnBus): Added support for finalize.
+ (finalize): New function. Decrements object reference count by one.
+ (queue_processor): Added support for finalize.
+ * plugin/icedteanp/IcedTeaPluginRequestProcessor.h: Removed unused
+ function declerations. Added decleration for finalize.
+
+2010-03-13 Deepak Bhole <dbhole at redhat.com>
+
+ * plugin/icedteanp/java/sun/applet/PluginAppletViewer.java
+ (requestPluginCookieInfo): Register cookie info as a priority message.
+ (requestPluginProxyInfo): Register proxy info as a priority message.
+ * plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java: Re-designed
+ message consumption to implement priority queuing and parallel
+ initialization limits so that an arbitrary number of applets can load
+ without blocking one another, all in a thread-safe manner.
+ (registerPriorityWait): New method. Registers a string that is
+ considered a "priority" string, which gets delegated to dedicated worker
+ threads.
+ (unRegisterPriorityWait): Unregisters a string so that it is no longer
+ a priority.
+ (PluginMessageConsumer): Do not create any workers when starting.
+ (consume): Remove method. Consumption is now done in a separate dedicated
+ thread to prevent blocking.
+ (getPriorityStrIfPriority): New method. If the given message is priority,
+ return why (i.e the 'priority string'it matched).
+ (isInInit): New method. Returns if the plugin is currently initializing an
+ applet.
+ (addToInitWorkers): New method. Adds given worker to list of workers
+ currently initializting applets.
+ (okayToProcess): New method. Returns whether or not it is okay to process
+ the given applet.
+ (notifyWorkerIsFree): New method. Notifies this class that a worker has
+ just become free.
+ (queue): Queues the given message for consumption.
+ (ConsumerThread): New protected inner (thread) class. Responsible for
+ consuming messages in the queue, and regueuing them if consumption if not
+ possible.
+ (getFreeWorker): Changed to be non-blocking, and return either a priority
+ worker or a normal worker depending on what is requested.
+ * plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java
+ (PluginMessageHandlerWorker): Set new priority and consumer variables.
+ (busy): Make thread-safe by waiting on same property that free() waits on.
+ (free): Make thread-safe by waiting on same property that busy() waits on.
+ (isPriority): New method. Returns of worker is a priority worker.
+ (isFree): Made thread-safe, and accounts for priority.
+ * plugin/icedteanp/java/sun/applet/PluginStreamHandler.java
+ (startProcessing): Call consumer.queue() instead of consumer.consume().
+ (postMessage): Remove unused method.
+
2010-03-09 Deepak Bhole <dbhole at redhat.com>
* plugin/icedteanp/IcedTeaNPPlugin.cc
diff -r 92e2665861fb -r 0424d3023049 plugin/icedteanp/IcedTeaPluginRequestProcessor.cc
--- a/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc Tue Mar 09 15:54:50 2010 -0500
+++ b/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc Tue Mar 16 10:29:49 2010 -0400
@@ -119,7 +119,8 @@ PluginRequestProcessor::newMessageOnBus(
command == "Call" ||
command == "GetSlot" ||
command == "SetSlot" ||
- command == "Eval")
+ command == "Eval" ||
+ command == "Finalize")
{
// Update queue synchronously
@@ -665,6 +666,53 @@ PluginRequestProcessor::sendMember(std::
pthread_mutex_unlock(&tc_mutex);
}
+/**
+ * Decrements reference count to given object
+ *
+ * @param message_parts The request message.
+ */
+
+void
+PluginRequestProcessor::finalize(std::vector<std::string>* message_parts)
+{
+ std::string type;
+ std::string command;
+ int reference;
+ std::string response = std::string();
+ std::string variant_ptr_str = std::string();
+ NPVariant* variant_ptr;
+ NPObject* window_ptr;
+ int id;
+
+ type = message_parts->at(0);
+ id = atoi(message_parts->at(1).c_str());
+ reference = atoi(message_parts->at(3).c_str());
+ variant_ptr_str = message_parts->at(5);
+
+ NPP instance;
+ get_instance_from_id(id, instance);
+
+ variant_ptr = (NPVariant*) IcedTeaPluginUtilities::stringToJSID(variant_ptr_str);
+ window_ptr = NPVARIANT_TO_OBJECT(*variant_ptr);
+ browser_functions.releaseobject(window_ptr);
+
+ // remove reference
+ IcedTeaPluginUtilities::removeInstanceID(variant_ptr);
+
+ // clear memory
+ free(variant_ptr);
+
+ // We need the context 0 for backwards compatibility with the Java side
+ IcedTeaPluginUtilities::constructMessagePrefix(0, reference, &response);
+ response += " JavaScriptFinalize";
+
+ plugin_to_java_bus->post(response.c_str());
+
+ delete message_parts;
+
+}
+
+
void*
queue_processor(void* data)
{
@@ -725,6 +773,12 @@ queue_processor(void* data)
// write methods are synchronized
pthread_mutex_lock(&syn_write_mutex);
processor->setMember(message_parts);
+ pthread_mutex_unlock(&syn_write_mutex);
+ } else if (command == "Finalize")
+ {
+ // write methods are synchronized
+ pthread_mutex_lock(&syn_write_mutex);
+ processor->finalize(message_parts);
pthread_mutex_unlock(&syn_write_mutex);
} else
{
diff -r 92e2665861fb -r 0424d3023049 plugin/icedteanp/IcedTeaPluginRequestProcessor.h
--- a/plugin/icedteanp/IcedTeaPluginRequestProcessor.h Tue Mar 09 15:54:50 2010 -0500
+++ b/plugin/icedteanp/IcedTeaPluginRequestProcessor.h Tue Mar 16 10:29:49 2010 -0400
@@ -72,14 +72,6 @@ typedef struct async_call_thread_data
/* Internal request reference counter */
static long internal_req_ref_counter;
-// JS request processor methods
-static void* requestFromMainThread();
-static void* getSlot(void* tdata);
-static void* setSlot(void* tdata);
-static void* removeMember(void* tdata);
-static void* call(void* tdata);
-static void* finalize(void* tdata);
-
/* Given a value and type, performs the appropriate Java->JS type
* mapping and puts it in the given variant */
@@ -147,6 +139,8 @@ class PluginRequestProcessor : public Bu
/* Evaluate the given script */
void call(std::vector<std::string>* message_parts);
+ /* Decrements reference count for given object */
+ void finalize(std::vector<std::string>* message_parts);
};
#endif // __ICEDTEAPLUGINREQUESTPROCESSOR_H__
diff -r 92e2665861fb -r 0424d3023049 plugin/icedteanp/java/sun/applet/PluginAppletViewer.java
--- a/plugin/icedteanp/java/sun/applet/PluginAppletViewer.java Tue Mar 09 15:54:50 2010 -0500
+++ b/plugin/icedteanp/java/sun/applet/PluginAppletViewer.java Tue Mar 16 10:29:49 2010 -0400
@@ -1281,6 +1281,7 @@ import com.sun.jndi.toolkit.url.UrlUtil;
return null;
}
+ PluginMessageConsumer.registerPriorityWait(reference);
streamhandler.postCallRequest(request);
streamhandler.write(request.getMessage());
try {
@@ -1326,6 +1327,7 @@ import com.sun.jndi.toolkit.url.UrlUtil;
"plugin PluginProxyInfo reference " + reference + " " +
requestURI, reference);
+ PluginMessageConsumer.registerPriorityWait(reference);
streamhandler.postCallRequest(request);
streamhandler.write(request.getMessage());
try {
diff -r 92e2665861fb -r 0424d3023049 plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java
--- a/plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java Tue Mar 09 15:54:50 2010 -0500
+++ b/plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java Tue Mar 16 10:29:49 2010 -0400
@@ -38,82 +38,257 @@ package sun.applet;
package sun.applet;
import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Iterator;
import java.util.LinkedList;
-
-import sun.applet.AppletSecurity;
+import java.util.Set;
class PluginMessageConsumer {
- int MAX_WORKERS = 20;
+ private static int MAX_PARALLEL_INITS = 1;
+
+ // Each initialization requires 5 responses (tag, handle, width, proxy, cookie)
+ // before the message stack unlocks/collapses. This works out well because we
+ // want to allow upto 5 parallel tasks anyway
+ private static int MAX_WORKERS = MAX_PARALLEL_INITS*5;
+ private static int PRIORITY_WORKERS = MAX_PARALLEL_INITS*2;
+
+ private static Hashtable<Integer, PluginMessageHandlerWorker> initWorkers = new Hashtable<Integer, PluginMessageHandlerWorker>(2);
+
LinkedList<String> readQueue = new LinkedList<String>();
+ private static LinkedList<String> priorityWaitQueue = new LinkedList<String>();
ArrayList<PluginMessageHandlerWorker> workers = new ArrayList<PluginMessageHandlerWorker>();
PluginStreamHandler streamHandler = null;
AppletSecurity as;
+ ConsumerThread consumerThread = new ConsumerThread();
+ /**
+ * Registers a reference to wait for. Responses to registered priority
+ * references get handled by priority worker if normal workers are busy.
+ *
+ * @param reference The reference to give priority to
+ */
+ public static void registerPriorityWait(Long reference) {
+ PluginDebug.debug("Registering priority for reference " + reference);
+ registerPriorityWait("reference " + reference.toString());
+ }
+
+ /**
+ * Registers a string to wait for.
+ *
+ * @param searchString the string to look for in a response
+ */
+ public static void registerPriorityWait(String searchString) {
+ PluginDebug.debug("Registering priority for string " + searchString);
+ synchronized (priorityWaitQueue) {
+ if (!priorityWaitQueue.contains(searchString))
+ priorityWaitQueue.add(searchString);
+ }
+ }
+
+ /**
+ * Unregisters a priority reference to wait for.
+ *
+ * @param reference The reference to remove
+ */
+ public static void unRegisterPriorityWait(Long reference) {
+ unRegisterPriorityWait(reference.toString());
+ }
+
+ /**
+ * Unregisters a priority string to wait for.
+ *
+ * @param searchString The string to unregister from the priority list
+ */
+ public static void unRegisterPriorityWait(String searchString) {
+ synchronized (priorityWaitQueue) {
+ priorityWaitQueue.remove(searchString);
+ }
+ }
+
+ /**
+ * Returns the reference for this message. This method assumes that
+ * the message has a reference number.
+ *
+ * @param The message
+ * @return the reference number
+ */
+ private Long getReference(String[] msgParts) {
+ return Long.parseLong(msgParts[3]);
+ }
+
public PluginMessageConsumer(PluginStreamHandler streamHandler) {
as = new AppletSecurity();
this.streamHandler = streamHandler;
-
- // create some workers at the start...
- for (int i=0; i < 3; i++) {
- PluginDebug.debug("Creating worker " + i);
- PluginMessageHandlerWorker worker = new PluginMessageHandlerWorker(streamHandler, i, as);
- worker.start();
- workers.add(worker);
- }
+ this.consumerThread.start();
}
- public void consume(String message) {
-
- PluginDebug.debug("Consumer received message " + message);
-
- synchronized(readQueue) {
- readQueue.add(message);
- }
+ private String getPriorityStrIfPriority(String message) {
- PluginDebug.debug("Message " + message + " added to queue. Looking for free worker...");
- final PluginMessageHandlerWorker worker = getFreeWorker();
+ synchronized (priorityWaitQueue) {
+ Iterator<String> it = priorityWaitQueue.iterator();
- synchronized(readQueue) {
- if (readQueue.size() > 0) {
- worker.setmessage(readQueue.poll());
- }
- }
+ while (it.hasNext()) {
+ String priorityStr = it.next();
+ if (message.indexOf(priorityStr) > 0)
+ return priorityStr;
+ }
+ }
- worker.interrupt();
+ return null;
}
- private PluginMessageHandlerWorker getFreeWorker() {
+ private boolean isInInit(Integer instanceNum) {
+ return initWorkers.containsKey(instanceNum);
+ }
+
+ private void addToInitWorkers(Integer instanceNum, PluginMessageHandlerWorker worker) {
+ synchronized(initWorkers) {
+ initWorkers.put(instanceNum, worker);
+ }
+ }
+
+ private boolean okayToProcess(String[] msgParts) {
+
+ if (msgParts[2].equals("tag")) {
+
+ Integer instanceNum = new Integer(msgParts[1]);
+
+ synchronized(initWorkers) {
+ if (initWorkers.size() >= MAX_PARALLEL_INITS) {
+ return false;
+ }
+ }
+
+ registerPriorityWait("instance " + instanceNum + " handle");
+ registerPriorityWait("instance " + instanceNum + " width");
+
+ } else if (msgParts[2].equals("handle") || msgParts[2].equals("width")) {
+ Integer instanceNum = new Integer(msgParts[1]);
+
+ // If this instance is not in init, return false immediately.
+ // Handle/Width messages should NEVER go before tag messages
+ if (!isInInit(instanceNum))
+ return false;
+ }
+
+ return true;
+ }
+
+ public void notifyWorkerIsFree(PluginMessageHandlerWorker worker) {
+ synchronized (initWorkers) {
+ Iterator<Integer> i = initWorkers.keySet().iterator();
+ while (i.hasNext()) {
+ Integer key = i.next();
+ if (initWorkers.get(key).equals(worker))
+ initWorkers.remove(key);
+ }
+ }
+
+ consumerThread.interrupt();
+ }
+
+ public void queue(String message) {
+ synchronized(readQueue) {
+ readQueue.addLast(message);
+ }
+
+ // Wake that lazy consumer thread
+ consumerThread.interrupt();
+ }
+
+ protected class ConsumerThread extends Thread {
+ public void run() {
+
+ while (true) {
+
+ String message = null;
+
+ synchronized(readQueue) {
+ message = readQueue.poll();
+ }
+
+ if (message != null) {
+
+ String[] msgParts = message.split(" ");
+
+ // if it is no okay to process just yet, push it back and
+ if (!okayToProcess(msgParts)) {
+ synchronized(readQueue) {
+ readQueue.addLast(message);
+ }
+
+ continue; // re-loop to try next msg
+ }
+
+ String priorityStr = getPriorityStrIfPriority(message);
+ boolean isPriorityResponse = (priorityStr != null);
- // FIXME: Can be made more efficient by having an idle worker pool
-
- while (true) {
+ //PluginDebug.debug("Message " + message + " (priority=" + isPriorityResponse + ") ready to be processed. Looking for free worker...");
+ final PluginMessageHandlerWorker worker = getFreeWorker(isPriorityResponse);
+
+ if (worker == null) {
+ synchronized(readQueue) {
+ readQueue.addLast(message);
+ }
+
+ continue; // re-loop to try next msg
+ }
+
+ if (msgParts[2].equals("tag"))
+ addToInitWorkers((new Integer(msgParts[1])), worker);
+
+ if (isPriorityResponse) {
+ unRegisterPriorityWait(priorityStr);
+ }
+
+ worker.setmessage(message);
+ worker.interrupt();
+
+ } else {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException ie) {}
+ }
+ }
+ }
+ }
+
+ private PluginMessageHandlerWorker getFreeWorker(boolean prioritized) {
+
for (PluginMessageHandlerWorker worker: workers) {
- if (worker.isFree()) {
- PluginDebug.debug("Found free worker with id " + worker.getWorkerId());
+ if (worker.isFree(prioritized)) {
+ PluginDebug.debug("Found free worker (" + worker.isPriority() + ") with id " + worker.getWorkerId());
// mark it busy before returning
worker.busy();
return worker;
}
}
-
+
// If we have less than MAX_WORKERS, create a new worker
if (workers.size() <= MAX_WORKERS) {
- PluginDebug.debug("Cannot find free worker, creating worker " + workers.size());
- PluginMessageHandlerWorker worker = new PluginMessageHandlerWorker(streamHandler, workers.size(), as);
- worker.start();
- workers.add(worker);
- worker.busy();
- return worker;
- } else {
- // else wait
+ PluginMessageHandlerWorker worker = null;
+
+ if (workers.size() <= (MAX_WORKERS - PRIORITY_WORKERS)) {
+ PluginDebug.debug("Cannot find free worker, creating worker " + workers.size());
+ worker = new PluginMessageHandlerWorker(this, streamHandler, workers.size(), as, false);
+ } else if (prioritized) {
+ PluginDebug.debug("Cannot find free worker, creating priority worker " + workers.size());
+ worker = new PluginMessageHandlerWorker(this, streamHandler, workers.size(), as, true);
+ } else {
+ return null;
+ }
+
+ worker.start();
+ worker.busy();
+ workers.add(worker);
+ return worker;
+
}
-
- Thread.yield();
- }
-
- //throw new RuntimeException("Out of message handler workers");
+
+ // No workers available. Better luck next time!
+ return null;
}
}
diff -r 92e2665861fb -r 0424d3023049 plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java
--- a/plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java Tue Mar 09 15:54:50 2010 -0500
+++ b/plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java Tue Mar 16 10:29:49 2010 -0400
@@ -42,15 +42,25 @@ class PluginMessageHandlerWorker extends
class PluginMessageHandlerWorker extends Thread {
private boolean free = true;
+ private boolean isPriorityWorker = false;
More information about the distro-pkg-dev
mailing list