You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xalan.apache.org by pa...@locus.apache.org on 2000/10/11 19:28:05 UTC
cvs commit: xml-xalan/c/Tests/Threads ThreadTestold.cpp
pauldick 00/10/11 10:28:05
Added: c/Tests/Threads ThreadTestold.cpp
Log:
Initial check in of older version thread tests
Revision Changes Path
1.1 xml-xalan/c/Tests/Threads/ThreadTestold.cpp
Index: ThreadTestold.cpp
===================================================================
#include <cassert>
#include <fstream>
#include <iostream>
#include <strstream>
#include <util/PlatformUtils.hpp>
#include <PlatformSupport/DOMStringHelper.hpp>
#include <DOMSupport/DOMSupportDefault.hpp>
#include <XPath/XObjectFactoryDefault.hpp>
#include <XPath/XPathSupportDefault.hpp>
#include <XPath/XPathFactoryDefault.hpp>
#include <XSLT/StylesheetConstructionContextDefault.hpp>
#include <XSLT/StylesheetExecutionContextDefault.hpp>
#include <XSLT/StylesheetRoot.hpp>
#include <XSLT/XSLTEngineImpl.hpp>
#include <XSLT/XSLTInputSource.hpp>
#include <XSLT/XSLTProcessorEnvSupportDefault.hpp>
#include <XSLT/XSLTResultTarget.hpp>
#include <XercesParserLiaison/XercesParserLiaison.hpp>
#include <XercesPlatformSupport/TextFileOutputStream.hpp>
#include <XercesPlatformSupport/XercesDOMPrintWriter.hpp>
//This is here for the threads.
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winbase.h>
#define THREADFUNCTIONRETURN DWORD WINAPI
#if !defined(XALAN_NO_NAMESPACES)
using std::cerr;
using std::cout;
using std::endl;
using std::ifstream;
using std::ios_base;
using std::ostrstream;
using std::string;
#endif
// Used to hold compiled stylesheet, and source document.
StylesheetRoot* glbStylesheetRoot;
//XalanNode* glbSourceDoc;
void outputMessage(DWORD id, char msg[])
{
ostrstream threadMsg;
threadMsg << "\n" << msg << " Thread: " << id << '\0';
cout << threadMsg.str();
threadMsg.freeze(false);
}
THREADFUNCTIONRETURN theThread(LPVOID param)
{
// This routine uses compiled stylesheet (glbStylesheetRoot), which is set using the
// theProcessor.setStylesheetRoot method. The transform is done using the theProcessor's
// process() method.
const int number = reinterpret_cast<int>(param);
const DWORD theThreadID = GetCurrentThreadId();
// Create the support objects that are necessary for running the processor...
DOMSupportDefault theDOMSupport;
XercesParserLiaison theParserLiaison(theDOMSupport);
XPathSupportDefault theXPathSupport(theDOMSupport);
XSLTProcessorEnvSupportDefault theXSLTProcessorEnvSupport;
XObjectFactoryDefault theXObjectFactory(theXSLTProcessorEnvSupport,
theXPathSupport);
XPathFactoryDefault theXPathFactory;
// Create a processor...and output start message.
XSLTEngineImpl theProcessor(
theParserLiaison,
theXPathSupport,
theXSLTProcessorEnvSupport,
theXObjectFactory,
theXPathFactory);
outputMessage(theThreadID,"Starting ");
// Connect the processor to the support object...
theXSLTProcessorEnvSupport.setProcessor(&theProcessor);
// The execution context uses the same factory support objects as
// the processor, since those objects have the same lifetime as
// other objects created as a result of the execution.
StylesheetExecutionContextDefault ssExecutionContext(
theProcessor,
theXSLTProcessorEnvSupport,
theXPathSupport,
theXObjectFactory);
// Our input files. The assumption is that the executable will be run
// from same directory as the input files.
// Generate the input and output file names.
ostrstream theFormatterIn, theFormatterOut;
theFormatterIn << "Birds.xml" << '\0';
theFormatterOut << "Birds" << number << ".out" << '\0';
//Generate the XML input and output objects.
XSLTInputSource theInputSource(theFormatterIn.str());
XSLTResultTarget theResultTarget(theFormatterOut.str());
// Unfreeze the ostrstreams, so the memory is returned...
theFormatterIn.freeze(false);
theFormatterOut.freeze(false);
// Set the stylesheet to be the compiled stylesheet. Then do the transform.
// Report both the start of the transform and end of the thread.
theProcessor.setStylesheetRoot(glbStylesheetRoot);
outputMessage(theThreadID,"Transforming");
theProcessor.process(theInputSource,theResultTarget,ssExecutionContext);
outputMessage(theThreadID,"Finishing");
return (0);
}
void doThreads(int x)
{
DWORD dwStackSize = 4096; // initial thread stack size
LPTHREAD_START_ROUTINE lpStartAddress = (LPTHREAD_START_ROUTINE)theThread;
DWORD dwCreationFlags = 0; // creation flags
int nThreads = x;
std::vector<HANDLE> hThreads;
hThreads.reserve(nThreads);
int i=0;
try
{
cout << endl << "Clock before starting threads: " << clock() << endl;
for (i=0; i< nThreads; i++)
{
HANDLE hThread;
DWORD threadID;
hThread = CreateThread(
0, dwStackSize,
lpStartAddress, // pointer to thread function
reinterpret_cast<LPVOID>(i), // argument for new thread
dwCreationFlags, // creation flags
&threadID);
assert(hThread != 0);
hThreads.push_back(hThread);
}
WaitForMultipleObjects(hThreads.size(), &hThreads[0], TRUE, INFINITE);
cout << endl << "Clock after threads: " << clock() << endl;
for (i=0; i< nThreads; i++)
CloseHandle(hThreads[i]);
}
catch(...)
{
cerr << "Exception caught!!!"
<< endl
<< endl;
}
}
int main(int argc, const char* /* argv */[])
{
if (argc != 1)
{
cerr << "Usage: ThreadTest"
<< endl
<< endl;
}
else
{
try
{
// Call the static initializers...
XMLPlatformUtils::Initialize();
XSLTEngineImpl::Initialize();
// Create the necessary stuff of compile the stylesheet.
DOMSupportDefault ssDOMSupport;
XercesParserLiaison ssParserLiaison(ssDOMSupport);
XPathSupportDefault ssXPathSupport(ssDOMSupport);
XSLTProcessorEnvSupportDefault ssXSLTProcessorEnvSupport;
XObjectFactoryDefault ssXObjectFactory(ssXSLTProcessorEnvSupport,
ssXPathSupport);
XPathFactoryDefault ssXPathFactory;
// Create a processor to compile the stylesheet...
XSLTEngineImpl ssProcessor(
ssParserLiaison,
ssXPathSupport,
ssXSLTProcessorEnvSupport,
ssXObjectFactory,
ssXPathFactory);
// Create separate factory support objects so the stylesheet's
// factory-created XObject and XPath instances are independent
// from processor's.
XObjectFactoryDefault ssStylesheetXObjectFactory(
ssXSLTProcessorEnvSupport,
ssXPathSupport);
XPathFactoryDefault ssStylesheetXPathFactory;
// Create a stylesheet construction context, using the
// stylesheet's factory support objects.
StylesheetConstructionContextDefault ssConstructionContext(
ssProcessor,
ssXSLTProcessorEnvSupport,
ssStylesheetXObjectFactory,
ssStylesheetXPathFactory);
const XalanDOMString theXSLFileName("Birds.xsl");
const XalanDOMString theXMLFileName("Birds.xml");
// Our stylesheet input source...
XSLTInputSource ssStylesheetSourceXSL(c_wstr(theXSLFileName));
XSLTInputSource ssStylesheetSourceXML(c_wstr(theXMLFileName));
// Ask the processor to create a StylesheetRoot for the specified
// input XSL. This is the compiled stylesheet. We don't have to
// delete it, since it is owned by the StylesheetConstructionContext
// instance.
glbStylesheetRoot = ssProcessor.processStylesheet(ssStylesheetSourceXSL,
ssConstructionContext);
assert(glbStylesheetRoot != 0);
// Create a compiled source tree as well, to use with perThreadCC
// glbSourceDoc = ssProcessor.getSourceTreeFromInput(ssStylesheetSourceXML);
// assert(glbSourceDoc != 0);
doThreads(10);
}
catch(...)
{
cerr << "Exception caught!!!"
<< endl
<< endl;
}
}
return 0;
}