private void TryMt(EPServiceProvider epService, int numEvents)
{
var epl =
"create table varTotal (key string primary key, total sum(int));\n" +
"into table varTotal select TheString, sum(IntPrimitive) as total from SupportBean group by TheString;\n" +
"@Name('listen') select varTotal[p00].total as c0 from SupportBean_S0;\n";
epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl);
epService.EPRuntime.SendEvent(new SupportBean("A", 10));
var queueCreated = new LinkedBlockingQueue<string>();
var writeRunnable = new WriteRunnable(epService, numEvents, queueCreated);
var readRunnable = new ReadRunnable(epService, numEvents, queueCreated);
// start
var t1 = new Thread(writeRunnable.Run);
var t2 = new Thread(readRunnable.Run);
t1.Start();
t2.Start();
// join
Log.Info("Waiting for completion");
t1.Join();
t2.Join();
Assert.IsNull(writeRunnable.Exception);
Assert.IsNull(readRunnable.Exception);
}
/// <summary> Constructor.</summary>
/// <param name="tagger">- the POS tagger plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public PosTaggerThread(PosTagger tagger, LinkedBlockingQueue<SetOfSentences> in_Renamed,
LinkedBlockingQueue<Sentence> out_Renamed)
{
this.tagger = tagger;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
/// <summary> Constructor.</summary>
/// <param name="tagger">- the POS tagger plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public PosTaggerThread(PosTagger tagger, LinkedBlockingQueue <SetOfSentences> in_Renamed,
LinkedBlockingQueue <Sentence> out_Renamed)
{
this.tagger = tagger;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
/**
* Carrega dados para troca de senha.
* @param settings
* @param filaNovaSenha
*/
public SessaoFIX(
SessionSettings settings,
string novaSenha,
LinkedBlockingQueue <string> filaNovaSenha)
{
this.filaNovaSenha = filaNovaSenha;
this.novaSenha = novaSenha;
object[] objsessions = settings.getSessions().ToArray();
foreach (object objsession in objsessions)
{
SessionID session = (SessionID)objsession;
try
{
Dictionary dictionary = settings.get(session);
if (dictionary.has(FIX_RAWDATA))
{
senha = dictionary.getString(FIX_RAWDATA);
}
}
catch (ConfigError e)
{
logger.Error("Falha de configuracao: " + e.Message);
}
catch (FieldConvertError e)
{
logger.Error("Falha de conversao: " + e.Message);
}
}
}
/// <exception cref="System.Exception"/>
public override LinkedBlockingQueue <E> Load(string keyName)
{
LinkedBlockingQueue <E> keyQueue = new LinkedBlockingQueue <E>();
refiller.FillQueueForKey(keyName, keyQueue, (int)(lowWatermark * numValues));
return(keyQueue);
}
private static void TryMT(
RegressionEnvironment env,
int numEvents)
{
var epl =
"create table varTotal (key string primary key, total sum(int));\n" +
"into table varTotal select TheString, sum(IntPrimitive) as total from SupportBean group by TheString;\n" +
"@Name('s0') select varTotal[P00].total as c0 from SupportBean_S0;\n";
env.CompileDeploy(epl).AddListener("s0");
env.SendEventBean(new SupportBean("A", 10));
var queueCreated = new LinkedBlockingQueue<string>();
var writeRunnable = new WriteRunnable(env, numEvents, queueCreated);
var readRunnable = new ReadRunnable(env, numEvents, queueCreated);
// start
var t1 = new Thread(writeRunnable.Run);
t1.Name = typeof(InfraTableMTGroupedAccessReadIntoTableWriteNewRowCreation).Name + "-write";
var t2 = new Thread(readRunnable.Run);
t2.Name = typeof(InfraTableMTGroupedAccessReadIntoTableWriteNewRowCreation).Name + "-read";
t1.Start();
t2.Start();
// join
log.Info("Waiting for completion");
t1.Join();
t2.Join();
env.UndeployAll();
Assert.IsNull(writeRunnable.Exception);
Assert.IsNull(readRunnable.Exception);
}
private static BlockingQueue<long[]> queueItemIDsInBatches(DataModel dataModel, int batchSize) {
longPrimitiveIterator itemIDs = dataModel.getItemIDs();
int numItems = dataModel.getNumItems();
BlockingQueue<long[]> itemIDBatches = new LinkedBlockingQueue<long[]>((numItems / batchSize) + 1);
long[] batch = new long[batchSize];
int pos = 0;
while (itemIDs.hasNext()) {
if (pos == batchSize) {
itemIDBatches.add(batch.clone());
pos = 0;
}
batch[pos] = itemIDs.nextlong();
pos++;
}
int nonQueuedItemIDs = batchSize - pos;
if (nonQueuedItemIDs > 0) {
long[] lastBatch = new long[nonQueuedItemIDs];
Array.Copy(batch, 0, lastBatch, 0, nonQueuedItemIDs);
itemIDBatches.add(lastBatch);
}
log.info("Queued {} items in {} batches", numItems, itemIDBatches.Count);
return itemIDBatches;
}
/// <summary> Constructor.</summary>
/// <param name="plainTextProcessor">- the plain text processor plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public PlainTextProcThread(PlainTextProcessor plainTextProcessor, LinkedBlockingQueue <PlainSentence> in_Renamed,
LinkedBlockingQueue <PlainSentence> out_Renamed)
{
this.plainTextProcessor = plainTextProcessor;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
public SessaoFIXInstantaneo(
LinkedBlockingQueue <MarketDataSnapshotFullRefresh> filaMensagensFIX,
LinkedBlockingQueue <string> filaMensagensRetransmissorBMF)
{
this.filaMensagensFIX = filaMensagensFIX;
this.filaMensagensRetransmissorBMF = filaMensagensRetransmissorBMF;
}
/// <summary> It adds the specified input text to the input queue of the work flow. After this method,
/// you are allowed to get the analysis result by using one of the following methods:
///
/// - getResultOfSentence() : to get the result for one sentence at the front of result queue
/// - getResultOfDocument() : to get the entire result for all sentences
///
/// If the input document is not small, getResultOfDocument() may show lower performance, and it
/// could be better to call getResultOfSentence() repeatedly. You need to pay attention on this.
///
/// </summary>
/// <param name="document">- the path for the text file to be analyzed
/// </param>
/// <throws> IOException </throws>
public virtual void analyze(System.IO.FileInfo document)
{
System.IO.StreamReader br = new System.IO.StreamReader(document.FullName, System.Text.Encoding.UTF8);
LinkedBlockingQueue <PlainSentence> queue = queuePhase1[0];
if (queue == null)
{
return;
}
System.String line = null;
int i = 0;
while ((line = br.ReadLine()) != null)
{
if (br.Peek() != -1)
{
queue.Add(new PlainSentence(0, i++, false, line.Trim()));
}
else
{
queue.Add(new PlainSentence(0, i++, true, line.Trim()));
break;
}
}
br.Close();
if (!isThreadMode)
{
analyzeInSingleThread();
}
}
/// <summary> Constructor.</summary>
/// <param name="ma">- the morphological analyzer plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public MorphAnalyzerThread(MorphAnalyzer ma, LinkedBlockingQueue<PlainSentence> in_Renamed,
LinkedBlockingQueue<SetOfSentences> out_Renamed)
{
this.ma = ma;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
/// <summary> Constructor.</summary>
/// <param name="ma">- the morphological analyzer plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public MorphAnalyzerThread(MorphAnalyzer ma, LinkedBlockingQueue <PlainSentence> in_Renamed,
LinkedBlockingQueue <SetOfSentences> out_Renamed)
{
this.ma = ma;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
public Unit(Vector3 bronPoint)
{
this.bronPoint = bronPoint;
actions = new LinkedBlockingQueue <IAction>();
effects = new Queue <IEffect>();
states = new Dictionary <int, IState>();
}
/// <summary> Constructor.</summary>
/// <param name="plainTextProcessor">- the plain text processor plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public PlainTextProcThread(PlainTextProcessor plainTextProcessor, LinkedBlockingQueue<PlainSentence> in_Renamed,
LinkedBlockingQueue<PlainSentence> out_Renamed)
{
this.plainTextProcessor = plainTextProcessor;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
private static ExecutorService BuildExecutorService(JobScheduler scheduler)
{
BlockingQueue <ThreadStart> workQueue = new LinkedBlockingQueue <ThreadStart>(_ioParallelism * 4);
RejectedExecutionHandler rejectionPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
ThreadFactory threadFactory = scheduler.ThreadFactory(Group.FILE_IO_HELPER);
return(new ThreadPoolExecutor(0, _ioParallelism, 10, TimeUnit.SECONDS, workQueue, threadFactory, rejectionPolicy));
}
public SessaoFIXIncremental(
LinkedBlockingQueue <MarketDataIncrementalRefresh> filaMensagensFIX,
LinkedBlockingQueue <string> filaMensagensRetransmissorBMF)
{
this.filaMensagensFIX = filaMensagensFIX;
this.filaMensagensRetransmissorBMF = filaMensagensRetransmissorBMF;
return;
}
public void TestPerformance()
{
int numEvents = 1;
int numThreads = 2;
Configuration config = new Configuration();
config.EngineDefaults.Threading.IsListenerDispatchPreserveOrder = false;
EPServiceProvider engine = EPServiceProviderManager.GetDefaultProvider(config);
engine.EPAdministrator.Configuration.AddEventType(typeof(TransactionEvent));
engine.EPAdministrator.Configuration.AddPlugInSingleRowFunction("MyDynModel", GetType().FullName, "MyDynModel");
String epl = "select MyDynModel({Col_001, Col_002, Col_003}) as model_score from TransactionEvent";
EPStatement stmt = engine.EPAdministrator.CreateEPL(epl);
stmt.Subscriber = new MySubscriber();
var queue = new LinkedBlockingQueue <Runnable>();
var latch = new CountDownLatch(numEvents);
for (int i = 0; i < numEvents; i++)
{
queue.Push((new MyRunnable(engine.EPRuntime, latch, new TransactionEvent(1, 2, 3))).Run);
}
var threads = Executors.NewFixedThreadPool(numThreads);
var delta = PerformanceObserver.TimeMillis(
() =>
{
for (int ii = 0; ii < numThreads; ii++)
{
threads.Submit(
() =>
{
Runnable runnable;
while (queue.Pop(0, out runnable))
{
runnable.Invoke();
}
});
}
//ThreadPoolExecutor threads = new ThreadPoolExecutor(numThreads, numThreads, 10, TimeUnit.SECONDS, queue);
//threads.PrestartAllCoreThreads();
latch.Await(TimeSpan.FromMinutes(1));
if (latch.Count > 0)
{
throw new Exception("Failed to complete in 1 minute");
}
});
Console.WriteLine("Took " + delta + " millis");
threads.Shutdown();
threads.AwaitTermination(TimeSpan.FromSeconds(10));
}
/// <summary>
/// This removes the "num" values currently at the head of the Queue for the
/// provided key.
/// </summary>
/// <remarks>
/// This removes the "num" values currently at the head of the Queue for the
/// provided key. Will immediately fire the Queue filler function if key
/// does not exist
/// How many values are actually returned is governed by the
/// <code>SyncGenerationPolicy</code> specified by the user.
/// </remarks>
/// <param name="keyName">String key name</param>
/// <param name="num">Minimum number of values to return.</param>
/// <returns>List<E> values returned</returns>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="ExecutionException"/>
public virtual IList <E> GetAtMost(string keyName, int num)
{
LinkedBlockingQueue <E> keyQueue = keyQueues.Get(keyName);
// Using poll to avoid race condition..
List <E> ekvs = new List <E>();
try
{
for (int i = 0; i < num; i++)
{
E val = keyQueue.Poll();
// If queue is empty now, Based on the provided SyncGenerationPolicy,
// figure out how many new values need to be generated synchronously
if (val == null)
{
// Synchronous call to get remaining values
int numToFill = 0;
switch (policy)
{
case ValueQueue.SyncGenerationPolicy.AtleastOne:
{
numToFill = (ekvs.Count < 1) ? 1 : 0;
break;
}
case ValueQueue.SyncGenerationPolicy.LowWatermark:
{
numToFill = Math.Min(num, (int)(lowWatermark * numValues)) - ekvs.Count;
break;
}
case ValueQueue.SyncGenerationPolicy.All:
{
numToFill = num - ekvs.Count;
break;
}
}
// Synchronous fill if not enough values found
if (numToFill > 0)
{
refiller.FillQueueForKey(keyName, ekvs, numToFill);
}
// Asynch task to fill > lowWatermark
if (i <= (int)(lowWatermark * numValues))
{
SubmitRefillTask(keyName, keyQueue);
}
return(ekvs);
}
ekvs.AddItem(val);
}
}
catch (Exception e)
{
throw new IOException("Exeption while contacting value generator ", e);
}
return(ekvs);
}
private ExecutorService CreateThreadPool()
{
int threads = NumberOfPopulationWorkers;
BlockingQueue <ThreadStart> workQueue = new LinkedBlockingQueue <ThreadStart>(_taskQueueSize);
ThreadFactory threadFactory = daemon(FLUSH_THREAD_NAME_PREFIX);
RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.CallerRunsPolicy();
return(new ThreadPoolExecutor(threads, threads, 0L, TimeUnit.MILLISECONDS, workQueue, threadFactory, rejectedExecutionHandler));
}
public GeradorEventosBMFRetransmissor(
EPServiceProvider epService,
LinkedBlockingQueue <string> filaMensagensRetransmissorBMF)
{
this.epService = epService;
this.filaMensagensRetransmissorBMF = filaMensagensRetransmissorBMF;
return;
}
/**
* Construtor que cria a fila e instancia a camada consumer.
*
* @param dadosGlobais Atributo que é repassado para a classe consumer.
* @param maximoItens Quantidade maxima de itens no livro de ofertas.
*/
public BMFLivroOfertasListener(DadosGlobais dadosGlobais, int maximoItens)
{
this.filaMensagensLivroOfertas = new LinkedBlockingQueue <EventoBMF>();
BMFLivroOfertasConsumer consumer = new BMFLivroOfertasConsumer(dadosGlobais, filaMensagensLivroOfertas, maximoItens);
consumer.Start();
return;
}
public Unit(int cid, bool isControl, Shap shap, Vector3 bronPoint)
{
this.cid = cid;
this.isControl = isControl;
this.shap = shap;
this.bronPoint = bronPoint;
actions = new LinkedBlockingQueue <IAction>();
effects = new Queue <IEffect>();
states = new Dictionary <int, IState>();
}
public BMFLivroOfertasConsumer(
DadosGlobais dadosGlobais,
LinkedBlockingQueue <EventoBMF> filaMensagensLivroOfertas,
int maximoItens)
{
this.parametros = dadosGlobais.Parametros;
this.epService = dadosGlobais.EpService;
this.todosLivrosBMF = dadosGlobais.TodosLivrosBMF;
this.filaMensagensLivroOfertas = filaMensagensLivroOfertas;
this.maximoItens = maximoItens;
this.dadosGlobais = dadosGlobais;
}
public RetransmissorBMF(DadosGlobais dadosGlobais)
{
this.dadosGlobais = dadosGlobais;
this.epService = dadosGlobais.EpService;
this.parametros = dadosGlobais.Parametros;
this.filaFeeder = dadosGlobais.getFilaFeeder();
this._config = parametros.BMFMarketDataConfig;
filaMensagensRetransmissorBMF = new LinkedBlockingQueue <string>();
filaMensagensFIXInstantaneo = new LinkedBlockingQueue <MarketDataSnapshotFullRefresh>();
filaMensagensFIXIncremental = new LinkedBlockingQueue <MarketDataIncrementalRefresh>();
return;
}
private LinkedBlockingQueue<String> PopulatedDeque(int n)
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(n);
Assert.IsTrue(q.IsEmpty());
for(int i = 0; i < n; i++)
{
Assert.IsTrue(q.Offer(i.ToString()));
}
Assert.IsFalse(q.IsEmpty());
Assert.AreEqual(0, q.RemainingCapacity());
Assert.AreEqual(n, q.Size());
return q;
}
private void TryMT(int numInserted)
{
var epl = "create table MyTable (key int primary key, p0 int);";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl);
var runnables = new List <BaseRunnable>();
var insertOutQ = new LinkedBlockingQueue <int>();
var insert = new InsertRunnable(_epService, numInserted, insertOutQ);
runnables.Add(insert);
var selectOutQ = new LinkedBlockingQueue <int>();
var select = new SelectRunnable(_epService, insertOutQ, selectOutQ);
runnables.Add(select);
var updateOutQ = new LinkedBlockingQueue <int>();
var update = new UpdateRunnable(_epService, selectOutQ, updateOutQ);
runnables.Add(update);
var deleteOutQ = new LinkedBlockingQueue <int>();
var delete = new DeleteRunnable(_epService, updateOutQ, deleteOutQ);
runnables.Add(delete);
// start
var threads = new Thread[runnables.Count];
for (var i = 0; i < runnables.Count; i++)
{
threads[i] = new Thread(runnables[i].Run);
threads[i].Start();
}
// join
foreach (var t in threads)
{
t.Join();
}
// assert
foreach (var runnable in runnables)
{
Assert.IsNull(runnable.Exception);
Assert.AreEqual(numInserted + 1, runnable.NumberOfOperations, "failed for " + runnable); // account for -1 indicator
}
}
private static void TryMT(
RegressionEnvironment env,
int numInserted)
{
var path = new RegressionPath();
var epl = "create table MyTable (key int primary key, p0 int);";
env.CompileDeploy(epl, path);
IList<BaseRunnable> runnables = new List<BaseRunnable>();
var insertOutQ = new LinkedBlockingQueue<int>();
var insert = new InsertRunnable(env, path, numInserted, insertOutQ);
runnables.Add(insert);
var selectOutQ = new LinkedBlockingQueue<int>();
var select = new SelectRunnable(env, path, insertOutQ, selectOutQ);
runnables.Add(select);
var updateOutQ = new LinkedBlockingQueue<int>();
var update = new UpdateRunnable(env, path, selectOutQ, updateOutQ);
runnables.Add(update);
IBlockingQueue<int> deleteOutQ = new LinkedBlockingQueue<int>();
var delete = new DeleteRunnable(env, path, updateOutQ, deleteOutQ);
runnables.Add(delete);
// start
var threads = new Thread[runnables.Count];
for (var i = 0; i < runnables.Count; i++) {
threads[i] = new Thread(runnables[i].Run);
threads[i].Name = typeof(InfraTableMTGroupedFAFReadFAFWriteChain).Name + "-" + i;
threads[i].Start();
}
// join
foreach (var t in threads) {
t.Join(TimeSpan.FromSeconds(60));
}
env.UndeployAll();
// assert
foreach (var runnable in runnables) {
Assert.IsNull(runnable.Exception);
Assert.AreEqual(
numInserted + 1,
runnable.NumberOfOperations,
"failed for " + runnable); // account for -1 indicator
}
}
internal ILoopResult ForEach(IEnumerable <T> source, int maxDegreeOfParallelism)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
_maxDegreeOfParallelism = OptimizeMaxDegreeOfParallelism(source, maxDegreeOfParallelism);
var iterator = source.GetEnumerator();
if (!iterator.MoveNext())
{
return(this);
}
if (_maxDegreeOfParallelism == 1)
{
Process(iterator);
return(this);
}
// avoid running out of memory.
var capacity = Math.Min(512, _maxDegreeOfParallelism);
_itemQueue = new LinkedBlockingQueue <KeyValuePair <long, T> >(capacity);
_futures = new List <IFuture <Void> >(capacity);
try
{
Submit(StartParallel);
}
catch (RejectedExecutionException)
{
Process(iterator);
return(this);
}
bool success;
long count = 0;
do
{
success = _itemQueue.TryPut(new KeyValuePair <long, T>(count++, iterator.Current));
}while (success && iterator.MoveNext());
_itemQueue.Break();
WaitForAllTaskToComplete();
return(this);
}
/**
* Carrega dados do arquivo de configuracao quickfix.
* @param settings
* @param dadosGlobais
*/
public SessaoFIX(
SessionSettings settings,
DadosGlobais dadosGlobais,
LinkedBlockingQueue <MarketDataSnapshotFullRefresh> filaMensagensFIXInstantaneo,
LinkedBlockingQueue <MarketDataIncrementalRefresh> filaMensagensFIXIncremental,
LinkedBlockingQueue <string> filaMensagensRetransmissorBMF)
{
instrumentosAssinados =
new SortedDictionary <string, DadosInstrumentosBMF>();
this.filaMensagensFIXInstantaneo = filaMensagensFIXInstantaneo;
this.filaMensagensFIXIncremental = filaMensagensFIXIncremental;
this.filaMensagensRetransmissorBMF = filaMensagensRetransmissorBMF;
object [] objsessions = settings.getSessions().ToArray();
foreach (object objsession in objsessions)
{
SessionID session = (SessionID)objsession;
try
{
Dictionary dictionary = settings.get(session);
if (dictionary.has(FIX_RAWDATA))
{
senha = dictionary.getString(FIX_RAWDATA);
}
if (dictionary.has(FIX_NEWPASSWORD))
{
novaSenha = dictionary.getString(FIX_NEWPASSWORD);
}
if (dictionary.has(FIX_FILTRO_LISTA_INSTRUMENTOS))
{
padraoInstrumentos = new Regex(
dictionary.getString(FIX_FILTRO_LISTA_INSTRUMENTOS));
}
}
catch (ConfigError e)
{
logger.Error("Falha de configuracao: " + e.Message);
}
catch (FieldConvertError e)
{
logger.Error("Falha de conversao: " + e.Message);
}
}
}
public BovespaLivroOfertasListener(DadosGlobais dadosGlobais, int maximoItens)
{
filaMensagensLivroOfertas = new LinkedBlockingQueue <EventoBovespa>();
BovespaLivroOfertasConsumer consumer = new BovespaLivroOfertasConsumer(
dadosGlobais,
filaMensagensLivroOfertas,
maximoItens);
Thread thconsumer = new Thread(new ThreadStart(consumer.Run));
thconsumer.Start();
return;
}
/// <summary> Returns the analysis result for one sentence at the top of the result queue. You can call this method
/// repeatedly to get the result for remaining sentences in the input document. If there is no result,
/// this method will be blocked until a new result comes.
///
/// It stores the specified object with the analysis result. The return type of the object depends on the
/// analysis phase of the work flow so you must give the relevant type of parameter.
///
/// In this way, you can get the analysis result with a relevant object, so you don't need to parse the result string
/// again. If you just want to see the result, consider to use "String getResultOfSentence()" instead.
///
/// </summary>
/// <param name="<T>">- One of PlainSentence (for the first phase), Sentence (for the second phase), and SetOfSentences (for the third phase).
/// </param>
/// <param name="a">- the object to get the result
/// </param>
/// <returns> the analysis result for one sentence at front
/// </returns>
/// <throws> ResultTypeException </throws>
public T getResultOfSentence <T>(T a) where T : class
{
Type objClass = a.GetType();
try
{
if (typeof(PlainSentence).Equals(objClass))
{
if (outputPhaseNum != 1)
{
throw new ResultTypeException(outputPhaseNum);
}
LinkedBlockingQueue <PlainSentence> queue = queuePhase1[outputQueueNum];
a = queue.Take() as T;
}
else if (typeof(SetOfSentences).Equals(objClass))
{
if (outputPhaseNum != 2)
{
throw new ResultTypeException(outputPhaseNum);
}
LinkedBlockingQueue <SetOfSentences> queue = queuePhase2[outputQueueNum];
a = queue.Take() as T;
}
else if (typeof(Sentence).Equals(objClass))
{
if (outputPhaseNum != 3)
{
throw new ResultTypeException(outputPhaseNum);
}
LinkedBlockingQueue <Sentence> queue = queuePhase3[outputQueueNum];
a = queue.Take() as T;
}
else
{
throw new ResultTypeException(outputPhaseNum);
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
return(a);
}
public DadosGlobais()
{
mapaInstrumento = new SortedDictionary <string, DadosInstrumentos>();
listaComposicaoIndice = new HashSet <string>();
//listaGrupoCotacao = new SortedDictionary<string, DadosGrupoCotacao>();
//todosLivrosBMF = new SortedDictionary<string, BMFLivroOfertas>();
TodosLOF = new SortedDictionary <string, BovespaLivroOfertas>();
TodosLivrosBMF = new SortedDictionary <string, BMFLivroOfertas>();
todosLivrosPersistencia = new SortedDictionary <string, BovespaLivroOfertas>();
//maioresVolumes = new SortedDictionary<DadosRanking, string>(new ComparadorRankingDecrescente());
//maioresVolumesPorMsgID = new SortedDictionary<string, DadosRanking>();
//maisNegociadas = new SortedDictionary<DadosRanking, string>(new ComparadorRankingDecrescente());
//maisNegociadasPorMsgID = new SortedDictionary<string, DadosRanking>();
//maioresBaixas = new SortedDictionary<DadosRanking, string>();
//maioresAltas = new SortedDictionary<DadosRanking, string>(new ComparadorRankingDecrescente());
//maioresMenoresPorMsgID = new SortedDictionary<string, DadosRanking>();
filaFeeder = new LinkedBlockingQueue <string>();
}
public BovespaLivroOfertasConsumer(
DadosGlobais dadosGlobais,
LinkedBlockingQueue <EventoBovespa> filaMensagensLivroOfertas,
int maximoItens)
{
this._dadosGlobais = dadosGlobais;
this.epService = dadosGlobais.EpService;
this.todosLivros = dadosGlobais.TodosLOF;
this.filaMensagensLivroOfertas = filaMensagensLivroOfertas;
this.maximoItens = maximoItens;
normalizador = new NormalizadorNumero();
papeisReenvio = new HashSet <string>();
emReenvio = false;
return;
}
// Test dispatcher should timeout on draining events.
/// <exception cref="System.Exception"/>
public virtual void TestDispatchStopOnTimeout()
{
BlockingQueue <Org.Apache.Hadoop.Yarn.Event.Event> eventQueue = new LinkedBlockingQueue
<Org.Apache.Hadoop.Yarn.Event.Event>();
eventQueue = Org.Mockito.Mockito.Spy(eventQueue);
// simulate dispatcher is not drained.
Org.Mockito.Mockito.When(eventQueue.IsEmpty()).ThenReturn(false);
YarnConfiguration conf = new YarnConfiguration();
conf.SetInt(YarnConfiguration.DispatcherDrainEventsTimeout, 2000);
DrainDispatcher disp = new DrainDispatcher(eventQueue);
disp.Init(conf);
disp.SetDrainEventsOnStop();
disp.Start();
disp.WaitForEventThreadToWait();
disp.Close();
}
public void TestPut()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
for (int i = 0; i < SIZE; ++i)
{
q.Put(i.ToString());
Assert.IsTrue(q.Contains(i.ToString()));
}
Assert.AreEqual(0, q.RemainingCapacity());
}
catch (Exception)
{
UnexpectedException();
}
}
public void TestAddAll5()
{
ArrayList<String> empty = new ArrayList<String>();
ArrayList<String> strings = new ArrayList<String>(SIZE);
for (int i = 0; i < SIZE; ++i)
{
strings.Add(i.ToString());
}
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
Assert.IsFalse(q.AddAll(empty));
Assert.IsTrue(q.AddAll(strings));
for (int i = 0; i < SIZE; ++i)
{
Assert.AreEqual(strings.Get(i), q.Poll());
}
}
public void TestPutNull()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
q.Put(null);
ShouldThrow();
}
catch (NullReferenceException)
{
}
catch (Exception)
{
UnexpectedException();
}
}
public void TestAddAll4()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(1);
ArrayList<String> strings = new ArrayList<String>();
for (int i = 0; i < SIZE-1; ++i)
{
strings.Add(i.ToString());
}
q.AddAll(strings);
ShouldThrow();
}
catch (IllegalStateException) {}
}
/// <summary> Constructor.</summary>
/// <param name="posProcessor">- the POS processor plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public PosProcThread(PosProcessor posProcessor, LinkedBlockingQueue<Sentence> in_Renamed, LinkedBlockingQueue<Sentence> out_Renamed)
{
this.posProcessor = posProcessor;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
public void TestAddAll2()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
ArrayList<String> strings = new ArrayList<String>();
strings.Add(null);
strings.Add(null);
strings.Add(null);
q.AddAll(strings);
ShouldThrow();
}
catch (NullReferenceException) {}
}
public void TestAddAll3()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
ArrayList<String> strings = new ArrayList<String>();
for (int i = 0; i < SIZE-1; ++i)
{
strings.Add(i.ToString());
}
strings.Add(null);
q.AddAll(strings);
ShouldThrow();
}
catch (NullReferenceException) {}
}
public void TestEmptyFull()
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(2);
Assert.IsTrue(q.IsEmpty());
Assert.AreEqual(2, q.RemainingCapacity(), "should have room for 2");
q.Add(one);
Assert.IsFalse(q.IsEmpty());
q.Add(two);
Assert.IsFalse(q.IsEmpty());
Assert.AreEqual(0, q.RemainingCapacity());
Assert.IsFalse(q.Offer(three));
}
public void TestOfferNull()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>();
q.Offer(null);
ShouldThrow();
}
catch (NullReferenceException) {}
}
public void TestOffer()
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(1);
Assert.IsTrue(q.Offer(zero));
Assert.IsFalse(q.Offer(one));
}
/// <summary> Constructor.</summary>
/// <param name="morphProcessor">- the morpheme processor plug-in
/// </param>
/// <param name="in">- input queue
/// </param>
/// <param name="out">- output queue
/// </param>
public MorphemeProcThread(MorphemeProcessor morphProcessor, LinkedBlockingQueue<SetOfSentences> in_Renamed, LinkedBlockingQueue<SetOfSentences> out_Renamed)
{
this.morphProcessor = morphProcessor;
this.in_Renamed = in_Renamed;
this.out_Renamed = out_Renamed;
}
public void TestAddAll1()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(1);
q.AddAll(null);
ShouldThrow();
}
catch (NullReferenceException) {}
}
public void TestAdd()
{
try
{
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(SIZE);
for (int i = 0; i < SIZE; ++i)
{
Assert.IsTrue(q.Add(i.ToString()));
}
Assert.AreEqual(0, q.RemainingCapacity());
q.Add(SIZE.ToString());
}
catch (IllegalStateException)
{
}
}
public void TestConstructor6()
{
ArrayList<String> strings = new ArrayList<String>();
for (int i = 0; i < SIZE; ++i)
{
strings.Add(i.ToString());
}
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>(strings);
for (int i = 0; i < SIZE; ++i)
{
Assert.AreEqual(strings.Get(i), q.Poll());
}
}
