On Monday, 4 July 2016 at 01:36:00 UTC, Mike Parker wrote:
On Sunday, 3 July 2016 at 23:20:35 UTC, Hiemlick Hiemlicker
wrote:
The only difference is that the thread is a windows
CreateThread. I guess D doesn't know about such threads and
hence shared doesn't extend across to them?
The runtime doesn't know about external threads, no. You have
to tell it about them with a call to thread_attachThis() [1].
Still, AFAIK, shared variables should not be dependent upon
runtime threads. Do you have a minimum working example to share?
[1] https://dlang.org/phobos/core_thread.html#.thread_attachThis
Basically the sExtThread struct, changed __gshared to shared or
remove.
You can check the and see that the values are correct in the
thread by writeln(&paused) type of thing(or store address in
global variable).
import std.stdio, std.datetime, std.algorithm, std.string;
import core.thread, core.sync.mutex, core.atomic;
version (Windows)
{
import core.sys.windows.windows;
void makeExecutable(void[] code)
{
DWORD old;
VirtualProtect(code.ptr, code.length,
PAGE_EXECUTE_READWRITE, &old);
}
}
else
version (linux)
{
import core.sys.posix.sys.mman;
import core.sys.posix.unistd;
static if (!is(typeof(&mprotect)))
extern(C) int mprotect(void*, size_t, int);
void makeExecutable(ubyte[] code)
{
auto pageSize = sysconf(_SC_PAGE_SIZE);
auto address = ((cast(size_t)code.ptr) & ~(pageSize-1));
int pageCount = (address/pageSize ==
(address+code.length)/pageSize) ? 1 : 2;
mprotect(cast(void*)address, pageSize * pageCount,
PROT_READ | PROT_WRITE | PROT_EXEC);
}
}
else
static assert(0, "TODO");
// Creates a thunk by creating a function(functionTemplate),
which the compiler generates code for
// then manipulates the function's code indirectly so the actual
architecture asm is not required.
// Creates a thunk by creating a function(functionTemplate),
which the compiler generates code for
// then manipulates the function's code indirectly so the actual
architecture asm is not required.
R function(A) Delegate2Function(R, A...)(R delegate(A) d)
{
// Memory placeholders for d.ptr and d.funcptr. Stored per
template `instance`.
shared enum size_t TEMPLATE1 =
cast(size_t)0x01234567_01234567;
shared enum size_t TEMPLATE2 =
cast(size_t)0x89ABCDEF_89ABCDEF;
// Thunk callback. This is the function called by Win32, which
creates the delegate and points it
// to the desired callback. It stores the callback this and
function ptr in TEMPLATE1 & TEMPLATE2 resp.
extern(Windows) // No good?
static R functionTemplate(A args)
{
R delegate(A) d;
d.ptr = cast(typeof(d.ptr))TEMPLATE1;
d.funcptr = cast(typeof(d.funcptr))TEMPLATE2;
return d(args);
}
// A placeholder to help get the size of functionTemplate
static void functionTemplateEnd() {asm {naked; nop;} }
// searches a and replaces matches from and rewrites to to
static void replaceWord(void[] a, size_t from, size_t to)
{
foreach (i; 0..a.length - size_t.sizeof + 1)
{
auto p = cast(size_t*)(a.ptr + i);
if (*p == from)
{
*p = to;
return;
}
}
assert(0);
}
// Gets the length, in bytes, of the thunk and a slice to it's
instructions
auto functionTemplatePtr = cast(size_t*)&functionTemplate;
auto length = cast(size_t)((cast(size_t*)&functionTemplateEnd -
functionTemplatePtr));
auto functionTemplateInstructions =
functionTemplatePtr[0..length];
// must allocate type with pointers, otherwise GC won't scan
it
auto newFunctionInstructions = new size_t[length + 3 + 10];
// store context in ptr-aligned boundary, so the GC can find
it. This is just so delegate won't be released.
newFunctionInstructions[0] = cast(size_t)d.ptr;
newFunctionInstructions[1] = cast(size_t)d.funcptr;
newFunctionInstructions = newFunctionInstructions[2..$];
// Copy old instructions to new instructions
newFunctionInstructions[0..length] =
functionTemplateInstructions[0..length];
// Stores this in "thunk data"(local space in function)
replaceWord(newFunctionInstructions, TEMPLATE1,
cast(size_t)d.ptr);
replaceWord(newFunctionInstructions, TEMPLATE2,
cast(size_t)d.funcptr);
// Make code executable
makeExecutable(newFunctionInstructions);
// return thunk(which wraps original delegate to be called)
return cast(typeof(return)) newFunctionInstructions.ptr;
}
static struct sExtThread
{
private __gshared
{
bool paused = false;
bool terminated = false;
uint _ID = 0;
HANDLE _Handle;
Duration Call_Delay = dur!("msecs")(100);
Duration Paused_Wait = dur!("msecs")(1000);
void function() callback;
void delegate() originalCallback;
}
alias callbackType = extern (Windows) uint function(void*);
public void Create(void delegate() c, bool suspended = false,
uint stackSize = 16000)
{
originalCallback = c;
callback = Delegate2Function(c);
auto del = cast(callbackType)Delegate2Function((void*)
{
import core.thread;
do
{
if (!paused)
do
{
Thread.sleep(Call_Delay);
if (!terminated)
callback();
else
paused = true;
} while(!paused && !terminated);
else
{
Thread.sleep(Paused_Wait);
}
} while(!terminated);
return 0;
}
);
_Handle = CreateThread(cast(SECURITY_ATTRIBUTES*)null,
stackSize, del, null, (suspended) ? CREATE_SUSPENDED : 0, &_ID);
}
public @property HANDLE Handle() { return _Handle; }
public @property int ID() { return _ID; }
public void Pause()
{
paused = true;
}
public void Resume()
{
paused = false;
}
// Terminates the thread when it is finished executing at least
one cycle.
public void Terminate()
{
terminated = true;
}
public void Now()
{
originalCallback();
}
~this()
{
if (!terminated)
TerminateThread(Handle, 0);
terminated = true;
}
}
private sExtThread bThread;
static class Data
{
static __gshared
{
}
static void Init()
{
}
static double getCpu()
{
return 0;
}
static ulong getMem()
{
return 0;
}
static ulong getVMem()
{
return 0;
}
}
private void RTStatsCollector()
{
Data.Init();
bThread.Create(
(){
UpdateStats();
});
}
public static void UpdateStats()
{
with(Data)
{
}
}
void main()
{
RTStatsCollector();
import std.random;
while(getchar() != EOF)
{
auto x = new int[std.random.uniform(1000000, 10000000)];
writeln("--------");
bThread.Now();
}
getchar();
}
