Příspěvky

1

Vývoj / Integrace LLVM do projektu

« kdy: 15. 04. 2014, 08:07:39 »

Dobry den,
Potreboval by som pomoct s tym ako pouzit vo vlastnom programe llvm kninice.
Davnejsie som ho uz pouzival a stacilo si nakopirovat llvm headre do priecinku z mojim kodom, medzi tym som odvedy som ale reinsaloval system a uz si nepametam ako sa pridavali libky kompilatoru.

Pouzivam gcc 4.8, llvm 3.4, ako ide code blocks.

Dakujem

2

Vývoj / Re:Zkušenosti s jazykem D

« kdy: 25. 02. 2014, 19:31:06 »

...

Vector by mohol vyzerat takto (bez emplace/destroy):

Kód: [Vybrat]


import std.stdio;

class example{
int num;

this(int num){
this.num = num;
writeln("example ctor ", num);
}
~this(){
writeln("example dtor ", num);
}
}

struct simpleVector(T)if(is(T == class)){
import core.stdc.stdlib, std.traits;

enum instanceSize = __traits(classInstanceSize, T);
enum padding = instanceSize % std.traits.classInstanceAlignment!T;
enum paddedInstanceSize = instanceSize + padding;

private void[] buffer;
private size_t size_ = 0;

private T data(size_t i){
return cast(T) buffer[i*paddedInstanceSize .. $].ptr;
}

@property size_t size()const{return size_;}

bool emplaceBack(Args...)(Args args){
if(size*paddedInstanceSize < buffer.length){
auto s = buffer.length*2;
auto p = cast(ubyte*) realloc(buffer.ptr, s);
if(!p)return false;
buffer = p[0 .. s];
}
data(size_++).__ctor(args);
return true;
}

void clear(){
for(size_t i=0; i < size; ++i){
data(i).__dtor();
}
size_ = 0;
}

@disable this();

static auto opCall(){
return simpleVector(2);
}

this(size_t x){
assert(x);
auto bytes = paddedInstanceSize*x;
auto p = malloc(bytes);
buffer = p ? p[0 .. bytes] : null;
}

~this(){
for(size_t i=0; i < size; ++i){
data(i).__dtor();
}
free(buffer.ptr);
}

T opIndex(size_t index){
assert(index < size);
return data(index);
}
}

void main(){
auto vc = simpleVector!example();
foreach(int i; 0..10){
vc.emplaceBack(i);
}

foreach(size_t i; 0..5){
vc[i*2].num *= 10;
}   

for (int i=0; i<vc.size; ++i){
writeln(vc[i].num);
}     
}



3

Vývoj / Re:Zkušenosti s jazykem D

« kdy: 25. 02. 2014, 16:46:12 »

Jo zapomněl sem napsat, vytvořit uživatelem předefinovatelný alokátor pro GC. Aby bylo možné třeba vytvořit ňejaký pool statické paměti a na ní napojit GC. Sice nevím k čemu by to bylo, ale šlo by vytvořit snadno low level program s GC (ačkoli by to pak bylo zkurveně pomalí -> ale zajímaví).

To tusim ide pomocou GC.malloc: http://dlang.org/phobos/core_memory.html#.GC.malloc
Skus sa pozret aj sem: https://github.com/andralex/phobos/blob/allocator/std/allocator.d

Das sem kod tvojho object poolu?

4

Vývoj / Re:Zkušenosti s jazykem D

« kdy: 24. 02. 2014, 16:21:20 »

GC GC GC, to je snad ňáká mantra? v OOP není třeba GC (čas se s ním ale zabít dá no). Jo jinak mám další dojmy z Dčka. Slyšel jsem, že D bylo vytvořeno protože C++ je strašné a má strašnou syntaxi. Když se teď hrabu hloubš v D, C++ je proti tomu ráj. Pro příklad volaní konstruktoru a destruktoru:

C++: pointer->~jménoTřídy(); /* ... */
D:     destroy(object) /* Destroy je prosím knihovní funkce ... vnitřně asi používá obj.__dtor() ale fakt nevím, nikde o tom není ani zmínka */
C++: new (memoryChunk) jménoTypu(args);
D:     emplace!jménoTypu(memoryChunk, args) /* Opět knihovní funkce která vnitřně používá ňákej obj.__ctor(args) jež je nezdokumentovanej */

Smutné na tom je, že co by měla pokrývat syntaxe jazyka, pokrývá knihovna. A co by měla pokrývat knihovna pokrývá syntaxe (třeba sort u polí).  Teda když bych chtěl udělat bootloader s C++, nebude to problém, s D si asi budu muset portovat celou knihovnu (která často dělá to co by měly dělat konstrukty jazyka) a odhalit všechny možné nezdokumentované nechutnosti.

Ved emplace/destroy je tu kvoly tomu aby si nemusel manualne volat konstruktory/destruktory cez __ctor, __dtor...
To ze miesto placement new sa pouzie emplace a miest ~Trieda() sa pouzie destroy je len detail.

Co sa tyka sort-u, ten bude tiez deprecated  .

Co sa tyka phobosu a alokacii, tak je to znamy problem. Momentalne sa caka na alokatory. Ked budu v phobose tak je v plane pouzit interne mallocator alebo nieco podobne. Dokonca su navrhy na atribut @nogc / @noheap ktore zakazu pre funkcie gc alokacie.

GC je v D hlavne kvoly tomu aby sa dalo v @safe kode garantovat memory safty a implementacia Slice-ov by bola bez GC problematicka.

5

Vývoj / Re:jazyk D

« kdy: 24. 02. 2014, 14:50:02 »

Teď sem narazil na něco divného. Když sem se koukal na přetěžování operátorů v jazyce D, zjistil jsem že přetěžování operátorů new a delete je deprecated. Proboha proč, to si jako nepude napsat vlastní alokátor? Vysvětlení proč u toho nebylo. Taktéž sem někde viděl že scope proměnné budou též zrušeny. Hej, ty se s tím neserou, pro systémové programování je tendle jazyk tím pádem na nic (jo, OS s GC...). Sem trošku zklamaný, začal se mi líbit (x[] += y[] -> jak elegantní). Asi chtěj zabít RAII...

Samozrejme mozes pouzit vlastne allocatory, dokonca budu allocatory priamo v phobose: https://github.com/andralex/phobos/blob/allocator/std/allocator.d

Miesto pretaznia new pouzi emplace: http://dlang.org/phobos/std_conv.html#.emplace

scoped je depracted lebo totozna funkcionalita je v phobose: http://dlang.org/phobos/std_typecons.html#.scoped

6

Vývoj / Re:D template overloading

« kdy: 23. 01. 2014, 17:17:20 »

Myslel som nieco taketo:

Kód: [Vybrat]

template Test(T : U*, U){    //staci specifikovat T, parameter U sa doplni zo specializacie T
    struct Test{}
}

int main(){
    Test!(int*) t;     //T == int*,  U == int
    return 0;
}



7

Vývoj / Re:Implementace operátoru []

« kdy: 03. 08. 2013, 08:21:43 »

Ja som nepopisal podrbne funkcnost mojho jazyka lebo som len navrhoval syntax (skor som ukopiroval existujuci uz z inych jazykov ). Samozrejme ty si nemohol vedie ake ma mat vlastnost ten jazyk (napr: neumoznit pristup do poskodenej/neplatnej pamete ). Zrejme som mal jazyk vjac popisat alebo sa lepsie vyjadrit ze chcem len pomoct z navrhom syntaxe. Nakonie som pouzil moznost B.

8

Vývoj / Re:operator []

« kdy: 21. 07. 2013, 17:52:51 »

Vracať referenciu nie je možné kvôly nasledovnému dôvodu:
(pod referenciou myslým referenciu na typ ktory nie spravovany s GC (primitivne typy a struktury, v podstate tak ako v D))

Kód: [Vybrat]

//príklad v D:

import std.stdio;

ref int mask(ref int i){
return i;
}

ref int fnc(){
int i = 2;
return mask(i);
}

void print(int x, ref int i){
writeln(i);
}

void main(){
print(3, fnc());
}


Ja nemám problem to implementovať, len sa neviem rozhodnúť aký  syntaktický cukor použiť . Poznám relatívne málo jazykov a väčšinou také ktoré majú syntax odvodenu od C/C++. Nakoniec asi použiem možnosť (B), s možnosť (C) to asi moc komplikuje.

9

Vývoj / Implementace operátoru []

« kdy: 20. 07. 2013, 18:56:33 »

Dobrý deň,
Snažím sa implementovať do môjho OOP jazyka overloading operátora []. Jedna z možností je c++ štýl:

Kód: [Vybrat]

//A)
<type> 'operator' '[' ']' '(' [params]...  ')' [qualifier]
Problém je ten, že môj jazyk má správu pamäte podobnu c#, takže funkcia nemôže večšinou vracať referenciu, takže takýto operator sa dá požiť len ako getter. Syntax môjho jazyka je odvodena od D (konštruktor sa volá this(), property sa riešia tiež ako v D pomocou atributu @property ) takže vytvoriť property this[] ako v C# sa moc nehodí.
Ďalšie riešenie čo ma napadlo je nasledovné:

Kód: [Vybrat]

//B)
<type> 'operator' '[' [params]... ']' '(' ')' [qualifier]      //getter     
<type> 'operator' '[' [params]... ']' '(' <param> ')' [qualifier]      //setter     
//alebo s '=':
<type> 'operator' '[' [params]... ']' '=' '(' <param> ')' [qualifier]      //setter

//priklad:
class C{
    int[] x;
    int operator [ size_t index ] () {return x[index];}
    void operator [ size_t index ]( int value) {x[index] = value;}    // '=' by tam v podstate ani nemuselo byť
    //alebo s '=':
    void operator [ size_t index ] = ( int value) {x[index] = value;}    // '=' by tam v podstate ani nemuselo byť
}
Toto riešenie sa my zatial najviac pozdava. (je to v podstate C# property this[] s inou syntaxou)

Ďalej ma napadol taký mix C++ a D:

Kód: [Vybrat]

//C)
<type> 'operator' '[' [params]... ']' '(' ')' [qualifier]      //getter     
<type> 'operator' '[' [params]... ']' <unar_op> '('  ')' [qualifier]      //setter, napr   obj[index]++,
<type> 'operator' '[' [params]... ']' <bin_op> '(' <param> ')' [qualifier]      //setter, napr obj[index]+= tmp; obj[index]= tmp;

//priklad:
class C{
    int[] x;
    int operator [ size_t index ] () {return x[index];}
    void operator [ size_t index ]=( int value) {x[index] = value;}
    void operator [ size_t index ]+=( int value) {x[index] += value;}
    void operator [ size_t index ]++() {x[index]++;}     //toto sa my zda už prehnané

    //sem by sa potom hodil daky generator (určituú formu compile time templatov ako v D čo je ďalšia práca navyše lebo planujem mať zaťial len templaty ako v C#, čiže priamo v bytecode)

}
Toto riešenie rozširuje možnosť B) a spája aj iné operátory ako '=' s indexovacím  '[]'. Tu mám na vás jednu otázku. Požívate často nasledovný kód:

Kód: [Vybrat]

  obj[index] += expr;
  obj[index] -= expr;
  obj[index] op= expr;    //op je iny operator ktory sa da spája s '='.
Či sa vobec oplati zaoberať takymto až "extrémnym" overloadingom.
Prípadne stretli ste sa s inou syntaxou overloadingu operatorov ktorá by sa viac hodila?

10

Vývoj / Re:Implementace garbage collectoru

« kdy: 16. 03. 2013, 11:01:42 »

Tak uz som si daco vyhladal. Stack map je zrejme zoznam vsetky rootov v danom frame (funkcii). Pouziva sa na vecsinu gc algoritmov. Co sa tyka shadow stacku tak ten nefunguje pri JIT kompilacii.
Nasiel som toto: http://llvm.org/releases/2.5/docs/GarbageCollection.html#plugin
Je tam asi vsetko co potrebujem, dnes to skusim pridat do kompilatoru. Zatial dik.

11

Vývoj / Implementace garbage collectoru

« kdy: 15. 03. 2013, 19:55:20 »

Dobry den,
Potreboval by som pomoct s implementaciou garbage colektoru.
Moj jazyk je podobny s C# (triedy su referencne typy odvodene od bazovej triedy 'object' a su alkovne na heape).
Frontend mam naprogramovany v c++ a ako backend pouzivam llvm 3.1, program spustam cez JIT (lli).
GC by mal byt inkrementalny, nemusi byt thread safe.
Postupujem podla tohto: http://llvm.org/docs/GarbageCollection.html#getting-started

Write a runtime library or find an existing one which implements a GC heap:

1. Implement a memory allocator.
2. Design a binary interface for the stack map, used to identify references within a stack frame on the machine stack.*
3. Implement a stack crawler to discover functions on the call stack.*
4. Implement a registry for global roots.
5. Design a binary interface for type maps, used to identify references within heap objects.
6. Implement a collection routine bringing together all of the above.

bod 1: pouzivam malloc a zatial funguje ok.

Dalej nechampem ak implementovat stack map a co to vlastne je?