ogb912/opensim
1
0
Fork 0
mirror of https://github.com/opensim/opensim.git synced 2026-08-09 10:46:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

now break several things at same time... sog/sop updates, threads options,...

Browse Source
This commit is contained in:
UbitUmarov
2018-12-28 13:52:59 +00:00
parent 0cf5876c45
commit 4a73cc81dc
25 changed files with 548 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
OpenSim/Framework/IClientAPI.cs
View File

@@ -683,9 +683,16 @@ namespace OpenSim.Framework
ExtraData = 1 << 20,
Sound = 1 << 21,
Joint = 1 << 22,
FullUpdate = 0x0fffffff,
SendInTransit = 0x20000000,
CancelKill = 0x4fffffff, // 1 << 30
TerseUpdate = Position | Rotation | Velocity | Acceleration | AngularVelocity,
FullUpdate = 0x00ffffff,
Animations = 1 << 24,
FullUpdatewithAnim = FullUpdate | Animations,
SendInTransit = 0x20000000, // 1 << 29
CancelKill = 0x41ffffff, // 1 << 30
Kill = 0x80000000 // 1 << 31
}
@@ -736,9 +743,6 @@ namespace OpenSim.Framework
List<uint> SelectedObjects { get; }
// [Obsolete("LLClientView Specific - Replace with ???")]
int NextAnimationSequenceNumber { get; }
/// <summary>
/// Returns the full name of the agent/avatar represented by this client
/// </summary>
@@ -765,6 +769,8 @@ namespace OpenSim.Framework
bool SendLogoutPacketWhenClosing { set; }
int NextAnimationSequenceNumber {get; set;}
// [Obsolete("LLClientView Specific - Circuits are unique to LLClientView")]
uint CircuitCode { get; }

68
OpenSim/Framework/Monitoring/WorkManager.cs
View File

@@ -88,6 +88,11 @@ namespace OpenSim.Framework.Monitoring
Watchdog.Stop();
}
public static Thread StartThread(ThreadStart start, string name, bool alarmIfTimeout = false, bool log = true)
{
return StartThread(start, name, ThreadPriority.Normal, true, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
}
/// <summary>
/// Start a new long-lived thread.
/// </summary>
@@ -99,9 +104,9 @@ namespace OpenSim.Framework.Monitoring
/// <param name="log">If true then creation of thread is logged.</param>
/// <returns>The newly created Thread object</returns>
public static Thread StartThread(
ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout, bool log = true)
ThreadStart start, string name, ThreadPriority priority, bool alarmIfTimeout, bool log = true)
{
return StartThread(start, name, priority, isBackground, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
return StartThread(start, name, priority, true, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
}
/// <summary>
@@ -162,15 +167,22 @@ namespace OpenSim.Framework.Monitoring
{
Culture.SetCurrentCulture();
callback(obj);
Watchdog.RemoveThread(log:false);
}
catch (Exception e)
{
m_log.Error(string.Format("[WATCHDOG]: Exception in thread {0}.", name), e);
}
finally
{
try
{
Watchdog.RemoveThread(log: false);
}
catch { }
}
});
StartThread(ts, name, ThreadPriority.Normal, true, false, log:log);
StartThread(ts, name, false, log:log);
}
/// <summary>
@@ -187,54 +199,6 @@ namespace OpenSim.Framework.Monitoring
Util.FireAndForget(callback, obj, name, timeout);
}
/// <summary>
/// Run a job.
/// </summary>
/// <remarks>
/// This differs from direct scheduling (e.g. Util.FireAndForget) in that a job can be run in the job
/// engine if it is running, where all jobs are currently performed in sequence on a single thread. This is
/// to prevent observed overload and server freeze problems when there are hundreds of connections which all attempt to
/// perform work at once (e.g. in conference situations). With lower numbers of connections, the small
/// delay in performing jobs in sequence rather than concurrently has not been notiecable in testing, though a future more
/// sophisticated implementation could perform jobs concurrently when the server is under low load.
///
/// However, be advised that some callers of this function rely on all jobs being performed in sequence if any
/// jobs are performed in sequence (i.e. if jobengine is active or not). Therefore, expanding the jobengine
/// beyond a single thread will require considerable thought.
///
/// Also, any jobs submitted must be guaranteed to complete within a reasonable timeframe (e.g. they cannot
/// incorporate a network delay with a long timeout). At the moment, work that could suffer such issues
/// should still be run directly with RunInThread(), Util.FireAndForget(), etc. This is another area where
/// the job engine could be improved and so CPU utilization improved by better management of concurrency within
/// OpenSimulator.
/// </remarks>
/// <param name="jobType">General classification for the job (e.g. "RezAttachments").</param>
/// <param name="callback">Callback for job.</param>
/// <param name="obj">Object to pass to callback when run</param>
/// <param name="name">Specific name of job (e.g. "RezAttachments for Joe Bloggs"</param>
/// <param name="canRunInThisThread">If set to true then the job may be run in ths calling thread.</param>
/// <param name="mustNotTimeout">If the true then the job must never timeout.</param>
/// <param name="log">If set to true then extra logging is performed.</param>
public static void RunJob(
string jobType, WaitCallback callback, object obj, string name,
bool canRunInThisThread = false, bool mustNotTimeout = false,
bool log = false)
{
if (Util.FireAndForgetMethod == FireAndForgetMethod.RegressionTest)
{
Culture.SetCurrentCulture();
callback(obj);
return;
}
if (JobEngine.IsRunning)
JobEngine.QueueJob(name, () => callback(obj));
else if (canRunInThisThread)
callback(obj);
else
Util.FireAndForget(callback, obj, name, !mustNotTimeout);
}
private static void HandleControlCommand(string module, string[] args)
{
// if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)