BOINC@Poland

Cytat: necavi w 07 Kwiecień 2016, 18:05
Tylko te 7900 i niższe nie posiadały CUDA, dopiero od 8000 je miały.

Tak, wiem. Pewnie dlatego także po części też te karty są sporo tańsze.
Muszę się obyć bez CUDA.

Cytat: Troll81 w 07 Kwiecień 2016, 20:45
Potiwerdzam. 8600 katowałem przes dłuuugi czas i nie padła a była chłodzona pasywnie firmowym radiatorkiem :D

A jak 7900 GTX?

Mam jeszcze jedno pytanie. Myślę nie będę zakładać nowego wątku.

Jak jest z "padalnością" kart z serii GeForce 7900 GTX? Z tego co czytałem to GeForce 8800 były strasznie wadliwe - często padały. Jak w przypadku tych o generację starszych? Trzymały się?

Boję się trochę, że kupię fajną kartę, a ona po jakimś czasie padnie  :deadman:

Będę wykorzystywał jedynie DX9. Raczej tylko na 7900 GTX będzie mnie stać (lub ewentualnie Readeon X1950 Pro z 6 miesięczną gwarancją).

Tak, wiem, że GeForce 9800GX2 ma wszystko praktycznie x10 w porównaniu do tego GeForce 210.

Sama kwestia wydajności jest ok. Nie jest jeszcze tak tragicznie.

Chodzi mi tylko o te nakładanie tekstur na obiekty i czy pamięć dwukanałowa tutaj może coś lekko pomóc?

Karcioszka dotarła w zeszłym tygodniu według planów.

Wydajność nie jest oszałamiająca ale zawsze to coś  :attack: :attack:

Wielkie dzięki  :attack: :attack:

Ahoj Kamraci!

Mam problem. Otrzymałem od Szoplera kartę graficzną GeForce 210 (dzięki!).
Niestety stara grafika mi praktycznie padła - był to GeForce 9800GX2.

Gram w AION'a i mam problem na tym GeForce 210.

Wcześniej na GeForce 9800GX2 miałem powalającą grafikę i płynność na Ultra detalach. Później na zintegrowanej na płycie (sprawdzałem zanim otrzymałem GeForce 210) miałem na standardowych ustawieniach 8-12 FPS.

Teraz na tym GeForce jest co prawda znacznie lepiej niż na grafice zintegrowanej na płycie. Osiągam aktualnie do nawet 36 FPS ale niestety są spadki czasem do ponad 10 FPS.

Nie to (wydajność) jest jednak głównym problemem wątku.

Problem w tym, że system nie daje rady czasem odpowiednio szybko nakładać mi tekstur na obiekty! Muszę jakiś czas odczekać zanim pojawią się na obiekcie tekstury i do tego czasu są one jednolicie szare lub co gorsze obiektów nie widać wcale. Czasem może to trwać nawet i kilka sekund...

Domyślam się, że może być to spowodowane technologią TurboCache.

W sieci wyczytałem, że TurboCache to technologia umożliwiające rozszerzenie pamięci karty graficznej o pewne zasoby pamięci RAM. Według Wikipedii, karta graficzna posiada wbudowaną jakąś minimalną ilość pamięci, a resztę wykorzystuje z RAM'u. Myślałem, że TurboCache wykorzystuje całość z RAM'u ale widać się myliłem  :attack:

Pytanie jest takie: Ile pamięci wbudowanej ma faktycznie standardowo GeForce 210? Na karcie nie ma żadnych informacji... W nazwie o ile dobrze pamiętam obok liczby 512 (tyle pamięci przez TurboCache może zaalokować) widnieje liczba 32. Więc może ona ma 32 MB wbudowanej pamięci?

Kolejne pytanie tyczy się samej istoty wydajności działania TurboCache. Aktualnie nie planuję nowej karty graficznej (brak kasy - niestety). Czy dodając do swojej konfiguracji kolejne 4 GB pamięci DDR3 dzięki czemu pamięć RAM będzie działała już dwukanałowo, karta graficzna z TurboCache (ten GeForce 210) będzie także korzystała dwukanałowo z tej pamięci RAM?

Może pamięci mógłbym jeszcze dołożyć. Pytanie tylko czy w jakimś stopniu wyeliminuje mi to problem czasem wolno ładujących się tekstur?

 :attack: :attack: :attack:

Czyli jeszcze w tym tygodniu powinna dojść.

:attack: :attack: :attack:

PW wysłane. :attack: :attack: :attack:

Przyjmę jakąś kartę graficzną. Niekoniecznie nawet musi mieć wsparcia dla DX10 ani CUDA/OpenCL.
Koniecznie jednak PCI-E.
Coś albo od AMD/ATI albo od nVidii (aby nie było problemów z kompatybilnością).

Gdyby u któregoś z Kamratów coś takiego kurzyło  się w szafce to byłbym wdzięczny.
Ewentualnie kontakt na PW.

Pozdrawiam

Witam serdecznie,

Przyjmę praktycznie jakikolwiek (tylko działający) telefon z Java MIDP 2.0. Dobrze byłoby gdyby telefon nie miał SIM-locka lub miał tylko na Orange.

Proszę o kontakt za pomocą PW.

PS. Do telefonu przydałaby się pewnie też ładowarka.

A dzięki. Faktycznie nie zobaczyłęm tych dodatkowych wygenerowanych kolumn. Sprawa jasna.

Pytanie kolejne do Kamratów. Mamy na pokładzie kogoś znającego się na makach w MS Excel?

Tollu coś jest nie tak.

Załączony przez Ciebie plik zajmuję 5 razy więcej miejsca, a nie widzę tam jakichkolwiek dodatkowych danych? Wiesz o co może w tym chodzić?

Przesyłam arkusz, z którego można wygenerować dane do testowania (przykładową siatkę kwadratową):

http://sendfile.pl/183014/graph_256x256.xlsm

Na pierwszej karcie można wygenerować (F9) losowy 'teren' o wymiarach 256x256. Jak nam się spodoba jakiś zestaw, możemy skopiować wartości do drugiej karty. Tam, po wciśnięciu ctrl+g wygenerują się dane grafu w określonym formacie.

Teraz sprawa wygląda następująco:
1. Wejdź na kartę pierwszą i wygeneruj jakiś zestaw danych (F9).
2. Skopiuj dane z pierwszej karty na drugą.
3. Zrób sceena (zapisz najlepiej np. do PNG - kompresja bezstratna) tak aby były widoczne wszystkie losowo wygenerowane dane w Excelu (ta kwadratowa plansza).
3. Na drugiej karcie naciśnij ctrl+g i powinno się coś wygenerować (nie mam pojęcia jak to wygląda).
4. Wygenerowany plik (o ile się wygeneruje) i screen załaduj na jakiś sewer i podaj tutaj linka do niego.

To na początek tyle - zobaczymy czy coś z tego wyjdzie na tym etapie. O reszcie napiszę ewentualnie jak się uda to później.

Nikt nie ma Excela? Nie za ciekawie  :(

Mam pewien nietypowy problem.

Posiadam w formacie MS Excela dokument. Jest to arkusz, w którym są makra generujące plik tekstowy w formacie jakim mi łyka program w C.

Cały zonk polega na tym, że to generowanie nie działa mi na Libre Office, a tylko taki posiadam (Linux).

Może ktoś posiada MS Excel i mógłby mi wygenerować ten pliczek?

Kolejna prośba jest następująca: W arkuszu tym makra działają mi na 256 kolumnach i 256 wierszach - tyle też pól (256x256) mam uzupełnionych (pola te reprezentują wagi w grafie). Przydałoby się zwiększyć ilość wykorzystywanych pól np. do 2048x2048 lub nawet 4096x4096 i z tego wygenerować plik tekstowy. Nie wiem czy w pliku trzeba coś zmieniać (w makrach) czy wystarczy zwyczajnie "przeciągnąć" i dodać więcej pól.

Podobno już przy 256x256 potrafi przy generowaniu przyciąć więc nie wiem jak by to działało dla 4096x4096 i czy to do wykonania w Excelu.

Jest moźe ktoś posiadający w najbliższym czasie chwilę z odpowiednim oprogramowaniem?

Już poprawiłem.

Jak możesz to pobierz kod obydwu plików jeszcze raz (drng.h też się zmieniło), skompiluj i odpal.

Teraz martwię się tymi dwoma zerami:

The first three random numbers:
         1953446555 0 0

Kurczę to powinny być liczby losowe... Niby w nowej rewizji drng.h to poprawiłem ale coś nie widać efektów...

A teraz?

Najnowsza rewizja random_noise_thermal_intel_generator.cpp (r784) i drng.h (r786).

@Krzyszp

Nie mam pojęcia co jest nie tak. Zauważ, że błędy wysypał Ci kompilator do linii 1600, a kod ma tylko 110 linijek...


@RAD-Poland

Cytat: RAD-Poland w 15 Sierpień 2014, 15:43
dziwne jest, że miały być trzy losowe liczby a jest jedna, a później dwa zera w obu próbach

Plik wynikowy temp.bin ile w tym przypadku ma B?

Instrukcja odpalenia:

Należy pobrać dwa pliki:

drng.h
https://code.google.com/p/olib/source/browse/trunk/others/random/intel_thermal_noise/drng.h

random_noise_thermal_intel_generator.cpp
https://code.google.com/p/olib/source/browse/trunk/others/random/intel_thermal_noise/random_noise_thermal_intel_generator.cpp

Kompilujemy za pomocą polecenia:

g++ random_noise_thermal_intel_generator.cpp -o random_noise_thermal_intel_generator

Uruchamiamy poleceniem:

./random_noise_thermal_intel_generator 32 8192 temp.bin

Proszę o testy. Szczególnie na >= Ivy Bridge chociaż proszę o test także na starszych.

Uwaga: Podczas uruchamiania  program może wywalić błąd: "Illegal instruction" - proszę w takim przypadku o informację.

Tak jak w temacie poszukuję komputerów z procesorem Intel Ivy Bridge lub Haswell działających pod kontrolą systemu operacyjnego Linux.

Nie chodzi nawet o dostęp zdalny. Wystarczy za pomocą GCC skompilować odpalić kilka programików (myślę, że będą 2).

Programy mają:
1. Wygenerować ciągi liczb losowych za pomocą odpowiednich funkcji wbudowanych w dany typ procesora (dlatego wymagane włącznie z Ivy Bridge w górę) wykorzystujących zjawisko szumu termicznego.
2. Sprawdzić wydajność generowania liczb losowych (także wielowątkowo).

Wygenerowany plik (myślę jakieś 1 GB) trzeba będzie mi przesłać.

Potrzebuję możliwie bogatej gamy procesorów więc jeżeli ktoś chce to może się zgłosić i pomóc  :attack:

Programów jeszcze nie napisałem więc nie ma napinki czasowej. Myślę, że nawet jeżeli ktoś planuje w najbliższych miesiącach wymianę procesora/komputera to się załapie bo jest sporo czasu.

Ale zaraz, zaraz...

Mam tam coś takiego:

DWORD *j = &Length;

Skąd niby się wzięło &Length? Przecież nigdzie nie jest zadeklarowane.

Rozwiązałem problem trochę inaczej....

Przerobiłem program z C za pomocą GCC do Asemblera. Później z poziomu Asemblera ręcznie zmieniłem nazwy zmiennych na adresy im odpowiadające i skompilowałem kod Asemblera do kodu binarnego. Działa.

Wydajność jednak mnie nie powala i szukam szybszego rozwiązania. Znalazłem kod zoptymalizowany dla Pentium 4 (ten co mam wykorzystuje jedynie MMX).

Kod ten jednak zaczyna się od:


char ReverseAddandCheck()
{
DWORD *j = &Length;
char lc_Rem[128], *lcRem = lc_Rem;

INT128  c14141414141414141414141414141414 = {0x14141414,0x14141414,0x14141414,0x14141414};
INT128  c76767676767676767676767676767676 = {0x76767676,0x76767676,0x76767676,0x76767676};
INT128  c7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F = {0x7F7F7F7F,0x7F7F7F7F,0x7F7F7F7F,0x7F7F7F7F};
ULARGE_INTEGER cFFFFFFFFFFFFFFFF, cF6F6F6F6F6F6F6F6;

cF6F6F6F6F6F6F6F6.LowPart = 0xF6F6F6F6;
cF6F6F6F6F6F6F6F6.HighPart = 0xF6F6F6F6;
cFFFFFFFFFFFFFFFF.LowPart = 0xFFFFFFFF;
cFFFFFFFFFFFFFFFF.HighPart = 0xFFFFFFFF;
...

Według komentarzy jest to napisane zjadliwie dla kompilatora MSVC 6.0. Jak zapisać te linijki aby łyknęło to GCC/G++?

Cały kod znajduje się pod linkiem: http://users.tmok.com/~pla/Lychrel/e_goldst.c

Mam problem z kompilacją wstawki asemblerowej w kodzie C.

Wziąłem program ze strony: http://users.tmok.com/~pla/Lychrel/196xampl_vs.zip

Oczywiście nie chciał chodzić na Linuxie z kilku względów.

Musiałem zmienić składnię asemblera z Intelowskiej na AT&T (przepisałem tych 300 linijek).

Mam jednak coś takiego:

int faa8x64a(void *dat1, void *dat2, int leng)
{
    const unsigned long long int C0x0000000000000001 = 0x0000000000000001;
    const unsigned long long int C0x0000000100000000 = 0x0000000100000000;
    const unsigned long long int C0x0606060606060606 = 0x0606060606060606;
    const unsigned long long int C0x0F0F0F0F0F0F0F0F = 0x0F0F0F0F0F0F0F0F;
    const unsigned long long int C0x76F6F6F676F6F6F6 = 0x76F6F6F676F6F6F6;
    const unsigned long long int C0x7FFFFFFF7FFFFFFF = 0x7FFFFFFF7FFFFFFF;
    unsigned long long int flag = 0xFFFFFFFFFFFFFFFF;

    asm("mov    $leng,  %edx");
    asm("mov    ($dat1),  %edi");
    asm("mov    %edx,     %esi");
    asm("add    %edi,     %edx");
    asm("add    %edi,     %esi");
    asm("sub    $32,      %edx");
    asm("mov    ($dat2),  %ebx");
    asm("mov    $0,       %eax");
    asm("pxor   %mm7,     %mm7");
    asm("nop");
    asm("nop");
    asm("nop");

// start outer loop
asm("faa0:");
            // try to pre-cache the data for the next loop iteration
        asm("mov    -48(%edx), %eax");
        asm("mov    48(%edi),  %eax");

            // load next reversed section
        asm("mov    24(%edx), %eax");
        asm("mov    28(%edx), %ecx");
        asm("bswap  %eax");
        asm("bswap  %ecx");
        asm("movd   %eax,   %mm1");
        asm("movd   %ecx,   %mm0");
        asm("mov    16(%edx), %eax");
        asm("mov    20(%edx), %ecx");
        asm("bswap  %eax");
...


Całość wywala się na linkowaniu... System zwraca mi błędy:

Cytat/tmp/cckXS6V6.o: In function `faa8x64a(void*, void*, int)':
engine6.cpp:(.text+0x69): undefined reference to `leng'
engine6.cpp:(.text+0x6f): undefined reference to `$dat1'
engine6.cpp:(.text+0x7e): undefined reference to `$dat2'
...

Jak prawidłowo odnosić się do zmiennych z C w tym Asemblerze?

Próbowałem na różne sposoby np. tak:

asm("mov    $leng,  %edx");

asm("mov    leng,  %edx");

asm("mov    ($leng),  %edx");

asm("mov    (leng),  %edx");

i zawsze mam ten sam błąd z linkowaniem. Jak zrobić to prawidłowo?

Cytat: krzyszp w 15 Czerwiec 2014, 23:30
Albo ja czegoś nie rozumiem, albo nieźle zamotałeś.
To ma chodzić jako projekt BOINC?

Gdzie tam, jako jaki projekt BOINC znowu. Toć to nie miałoby sensu jako projekt BOINC.

Cytat: krzyszp w 15 Czerwiec 2014, 23:30
Poco w ogóle, skoro można sparsować statsy z danego serwera?

Tak tylko, że żadne statystyki zapisywane do plików nie są generowane w czasie rzeczywistym. Co jeżeli nie możemy sobie pozwolić na utratę nawet jednego kredytu?

Do tego dochodzi problem zaufania do admina (który może teraz z kredytami wszystko).

Piszę kawałek serwera odpowiedzialnego za przyznawanie kredytów pomiędzy wieloma projektami BOINC (ujednolicony system przyznawania i emisji kredytów).

Część kliencka ma być wbudowana w validatora, który to będzie wysyłał odpowiednie zapytanie do owego serwera ile ma kredytów za określone zadanie o określonym czasie wykonywania przydzielić. W owym zapytaniu zawarte są wszystkie informacje niezbędne do obliczenia przyznanych ilości kredytów.

W informacji zwrotnej validator otrzymuje ilość kredytów jaką ma przydzielić userowi.

Aktualne zabezpieczenie polega jedynie na tym, że sprawdzam czy klient (validator) łączy się z odpowiedniego przypisanego do danego projektu adresu IP (jest on zapisany w odpowiedniej kolumnie i odpowiednim rekordzie w bazie danych).

Idealnie byłoby gdyby w bazie danych obok tego adresu IP znalazło się także hasło (inne dla każdego projektu) i wykorzystywane byłoby ono do szyfrowania/deszyfrowania przesyłanych wiadomości.

Kiedyś na potrzeby studiów i artykułu naukowego zaimplementowałem 3DES'a i myślałem, że tutaj jego wykorzystam ale okazało się, że wywala mi błąd pamięci (wcześniej - kilka lat temu - działał dobrze). Nie mam energii aby dochodzić co w nim nie gra.

Stąd też moje pytanie o bezpieczeństwo. Jako tako nie przesyłam tam, żadnych danych tajnych i szyfrowanie nie jest potrzebne. Potrzebna jednak jest jakaś autoryzacja klienta, aby nie mógł podłączyć się ktoś inny i narobić bajzlu. Teoretycznie to nic by nie szkodziło aby ktoś inny się podłączył. Bo co uzyska? Nic.

Problem jednak polega na tym, że serwer emisji kredytów na podstawie zapytań pochodzących z projektów BOINC buduje własną bazę danych kredytów użytkowników. Ta baza danych powinna być (co oczywiste) odbiciem lustrzanym oryginalnej, projektowej bazy danych (zawiera jednak tylko wycinek danych z ID userów i przypisanych do nich kredytami). W przypadku padu serwera projektu (np. pad dysku) zawsze można wydobyć ilość kredytów jaką posiada dany user bez jakiejkolwiek ewentualnej straty (bo przecież ta baza danych jest budowana w czasie rzeczywistym). W przypadku zwykłych backupów zawsze możemy stracić kredyty przydzielone zaraz po zrobieniu backupu.

Już jednak admin "z palca, ręcznie" nie wpisze kredytów danemu userowi (powstanie brak spójności baz, który może być w każdej chwili wykryty). Za bardzo także nie będzie miał możliwości modyfikacji validatora, bo ten będzie udostępniany jako już skompilowany (ewentualnie kompilowany z modyfikacjami na "zamówienie" i na życzenie admina projektu). Można odzyskać dane kodu źródłowego ze skompilowanego programu ale to już nie będzie takie proste.

Sprawa jest nieco skomplikowana - niemniej pierwszą wersję serwera już zaimplementowałem. Nie działa ona efektywnie przynajmniej z kilku powodów ale jakoś działa  %)

Gdyby ktoś był chętny do pomocy to proszę pisać.

Piszę aplikację na socketach w C.

Czy jako klient mogę się jakoś podszyć i zmienić swoje IP tak ze serwer wykryje (i w zapisywanych logach) będzie miał inne IP niż to faktyczne?

Chodzi mi o to czy to wystarczające zabezpieczenie sprawdzać czy ktoś łączy się z odpowiedniego adresu IP i wtedy autoryzować takie połączenie, czy jednak istnieje możliwość aby to obejść.

Przepraszam, żę podbijam stary temat ale mam pytanie.

Dlaczego statystyk FreeHAL'a nie ma na BOINCStats?

Propozycja harmonogramu notowań jednolitych na BOINC Stock Exchange:

Cytat0:00 - 1:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie)

1:00 - otwarcie (określenie kursu jednolitego)
1:00 - 1:30 - dogrywka
1:30 - 7:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie)

7:00 - otwarcie (określenie kursu jednolitego)
7:00 - 7:30 - dogrywka
7:30 - 12:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie)

12:00 - otwarcie (określenie kursu jednolitego)
12:00 - 12:30 - dogrywka
12:30 - 16:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie)

16:00 - otwarcie (określenie kursu jednolitego)
16:00 - 16:30 - dogrywka
16:30 - 21:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie)

21:00 - otwarcie (określenie kursu jednolitego)
21:00 - 21:30 - dogrywka
21:30 - 24:00 - faza przed otwarciem (przyjmowanie zleceń na otwarcie następnej sesji)

Wszystkie godziny podane w strefie czasowej UTC.

Faza - przed otwarciem
Przyjmowanie zleceń od inwestorów i wprowadzanie bezpośrednio do systemu giełdowego (Centralny arkusz zleceń). Transakcje nie są zawierane. Wraz z wprowadzeniem każdego nowego zlecenia kalkulowany jest teoretyczny kurs otwarcia podawany do publicznej wiadomości.
Można składać zlecenia: PCRO, PKC, LIMIT.

Wyznaczenie kursu jednolitego (pierwszy fixing) - godz. 1:00
W oparciu o przyjęte wcześniej zlecenia zostaje wyznaczony kurs po jakim dojdzie do zawarcia transakcji. Kursem tym jest ostatni znany teoretyczny kurs otwarcia z fazy przed otwarciem. Dla każdego papieru wartościowego i instrumentu finansowego wyznaczany jest osobny kurs.

Faza - dogrywka
Wszyscy mogą składać zlecenia po wyznaczonym na fixingu kursie (LIMIT). Transakcje zawierane są na bieżąco, ale po jednakowej cenie (kursie).


-----------------------------------
W tekście przewinęły się typy zleceń PCRO, PKC:

Zlecenie PKC – zlecenie po każdej cenie, jest to zlecenie do natychmiastowego wykonania.

Zlecenie PKC jest szczególnym rodzajem zleceń na GPW, ma ono pierwszeństwo przed innymi zleceniami, zostaje zrealizowane w całości, natychmiast po wprowadzeniu do systemu. Inwestor składający tego typu zlecenie godzi się na każdy kurs po jakim może być ono zawarte, ważna jest dla niego jedynie całkowita realizacja zlecenia.

Zlecenia PKC mogą być składane podczas każdej fazy sesji giełdowej, poza dogrywką.

Zlecenie PCR – zlecenie giełdowe ,,po cenie rynkowej". Jest to jeden z rodzajów zleceń używanych na Giełdzie Papierów Wartościowych.



-----------------------------------
Teraz o tym jak jest wyznaczany kurs.

W idealnym przypadku centralny arkusz zleceń może wyglądać następująco:

CytatLiczba akcji
Cena  Kupno  Zgłoszona  Skumulowana  Sprzedaż  Zgłoszona  Skumulowana
PKC                1000          1000                                                                         
110                1500           2500                           2500           6000               
105                1000           3500                           2000           3500               
100                500             4000                           1000           1500               
PKC                                                                    500             500     

W przedstawionym przypadku spełnienie warunków maksymalizacji obrotu i maksymalizacji zrealizowanych zleceń, a także zachowania stabilności kursu będzie możliwe, jeżeli kurs ustali się na poziomie 105 PLN. Właściciela zmieni wówczas 3500 akcji (1000 + 1500 + 1000 po stronie popytu i 500 + 1000 + 2000 po stronie podaży), a osiągnięte obroty wyniosą 7000 x 105 PLN = 735000 PLN. Wartość 7000 to 3500 zrealizowanych zleceń kupna i 3500 zrealizowanych zleceń sprzedaży, natomiast 105 to ustalony podczas sesji kurs akcji.

W powyższym przykładzie zaistniała sytuacja idealna, w której nie wystąpiła różnica pomiędzy zrealizowanymi zleceniami kupna i sprzedaży.

Weźmy jednak nieco mniej komfortowy przykład:

Giełda jest rynkiem, na którym sytuacja nierównowagi rynkowej jest czymś prawie naturalnym. Do nadwyżek popytu lup podaży dochodzi na niej zdecydowanie częściej niż na innych rynkach. Jest to szczególnie widoczne w systemie notowań ciągłych, gdzie ceny ulegają niejednokrotnie znacznym wahaniom nawet w trakcie jednej sesji.

W systemie kursu jednolitego na GPW przyjęte zostało rozwiązanie polegające na redukcji zleceń w stopniu pozwalającym na zachowanie skoku kursu akcji w granicach określonych przez wyznaczone widełki cenowe. Ustalanie kursu w tym przypadku rozpoczyna się tak samo jak na rynku zrównoważonym, jednak zlecenia sprzed sesji oraz napływające w trakcie sesji mogą spowodować brak równowagi na rynku.
Poniżej znajduje się przykład rynku niezrównoważonego akcji z kursem odniesienia 100 PLN.

CytatLiczba akcji
Cena     Kupno     Zgłoszona    Skumulowana             Sprzedaż    Zgłoszona    Skumulowana
PKC                       3000             3000                                                                             
115                       2500             5500                                       500                  4500
110                       1500             7000                                       1000                 4000
105                       1000             8000                                       1500                 3000
100                                                                                        1000                 1500
PKC                                                                                        500                   500 

Kurs w tym przypadku ustalony zostanie na poziomie 110 PLN, czyli górnej granicy widełek, chociaż maksymalny obrót i realizacja zleceń byłyby osiągnięte po kursie 115 PLN (kurs wymagałby jednak oprócz redukcji zleceń z limitem, także redukcji zleceń PKC).

Na poziomie 110 PLN zgłoszone zapotrzebowanie na akcje wynosi 7000, natomiast podaż akcji to 4000. Występuje więc nadwyżka popytu w ilości 3000 akcji. Stopa satysfakcji wyniesie więc

(4000 / 7000) x 100% = 57%,

ponieważ taką część zleceń kupna można zrealizować.

W przypadku bardzo dużej nierównowagi, przekraczającej relację 5:1 (czyli przy stopie satysfakcji poniżej 20%) obrót walorami zostaje zawieszony do następnej sesji, a do czasu jej rozpoczęcia ustalony zostaje na podstawie dotychczasowych zleceń kurs nietransakcyjny na granicy widełek, który będzie kursem odniesienia dla następnej sesji. Poniższy przykład oparty na walorze z kursem odniesienia 100 PLN ma na celu ukazanie sytuacji, w której dochodzi do zawieszenia transakcji.

CytatLiczba akcji
Cena        Kupno       Zgłoszona        Skumulowana       Sprzedaż       Zgłoszona        Skumulowana
PKC                           30000               30000                                                                             
110                            25000               55000                                    500                   4500
105                            15000               70000                                    1000                 4000
100                            10000               80000                                    1500                 3000
95                                                                                                 1000                 1500
PKC                                                                                               500                   500 

W powyższym przykładzie maksymalny wolumen obrotu osiągnięty zostanie na poziomie 110 PLN, czyli górnej granicy widełek (możliwa jest wtedy realizacja zleceń na kupno i sprzedaż 4500 akcji). Stopa satysfakcji wyniesie jednak

(4500 / 55000) x 100% = 8%.

Z uwagi na stopę satysfakcji niższą niż 20% nie dojdzie do transakcji, a kurs 110 PLN będzie kursem odniesienia dla następnej sesji.

Opracowanie na podstawie stron:
http://bossa.pl/edukacja/rynek/kurs/fazy/
http://eekonomia.blox.pl/2008/06/Sciaga-Algorytm-ustalania-kursu-jednolitego-na-1.html
http://pl.wikipedia.org/wiki/Gie%C5%82da_Papier%C3%B3w_Warto%C5%9Bciowych_w_Warszawie


Teraz moje pytanie: Co ma na celu wprowadzenie obliczania i uwzględniania przy opcji zawieszania sesji stopy satysfakcji? Przecież z tego co rozumiem może to zawiesić wszystkie transakcje w sesji... i do tego może dziać się tak wielokrotnie sesja po sesji...

Dodatkowo jeden użytkownik może zachwiać notowaniami danego projektu jeżeli nie wprowadzi się jakichś odgórnych limitów na maksymalną wielkość zleceń i ich ilość dla jednej sesji.

Heh. Racja. Przecież FOREX jest otwarty 24/7 i nikt nie robi problemów.

Ale 24/7 to nie damy rady na starcie. Potrzebne są wolne weekendy aby przecież zrobić jakąś konserwację/update systemu. BSE to niestety nie FOREX w pełnej krasie...

Kolejnym problemem na jaki wpadłem odnośnie BOINC Stock Exchange jest czas (godziny) w jakim ta giełda powinna być otwarta.

Sesje mogą być ustalone na czas Europejski ale wtedy nie będzie pasować Amerykanom, albo w na czas Amerykański ale wtedy nie będzie pasować Europejczykom. Co z tym zrobić?

Cały czas skłaniam się ku notowaniom jednolitym, które są stosowane dla instrumentów o niskiej i średniej płynności. W tych notowaniach mamy ustalone o określonej godzinie sesje podczas których po jakimś kursie są zawierane transakcje. Tylko właśnie problem w ustaleniu tych godzin... Skoro system ma być międzynarodowy to może co np. 6 godzin - 4 sesje w dzień (0, 6, 12, 18, 24) ? Ale czy takie podejście (24/24) nie obniży atrakcyjności giełdy - mogą pojawić się ludzie, którzy będą chcieli obserwować giełdę podczas całego czasu jej działania, a to im takie obserwowanie uniemożliwi.

Cytat: krzyszp w 17 Maj 2014, 19:48
Trochę nie rozumiem dlaczego notowania ciągłe miałyby być trudniejsze w implementacji?

Tak mi się przynajmniej wydaje. A znasz algorytm ustalania kursu?

Cytat: krzyszp w 17 Maj 2014, 19:48
Natomiast pytanie jeszcze, jak przewidujesz liczyć "zyski" dla giełdy? Spread? Procent od wkładu/wypłaty?

Myślałem o procencie od wpłaty/wypłaty.

Cytat: krzyszp w 17 Maj 2014, 19:48
Co z obsługą kryptowalut?

Nie myślałem o tym wcale. Pomyślałem dopiero kiedy przeczytałem Twojego posta. Może w przyszłości...

Na starcie przewiduję umożliwienie wykonywania operacji giełdowych w trzech projektach.

Miały być notowania ciągłe ale może okazać się, że ciężko będzie to zrealizować. Do tego dochodzi kwestia bezpieczeństwa notowań ciągłych. Znacznie prościej ustalić sesje w trakcie, których będą realizowane złożone zlecenia. Zaczynam się skłaniać ku takiemu rozwiązaniu... Z czasem przecież będzie można przejść na notowania ciągłe.

Do końca roku ma to działać już w praktyce. Do końca tego miesiąca powinna już działać pierwsza odsłona strony. Później etapami forum i helpdesk. Na samym końcu cała implementacja wirtualnego portfela i integracja z BOINC.

Z działalnością gospodarczą to może załatwi to się tak, że ja założę działalność przy AIP (Akademickie Inkubatory Przedsiębiorczości) co wyniesie mnie znacznie mniej niż normalnie bo 250 zł miesięcznie.

Może Fundacja BOINC Polska byłaby zainteresowana współpracą?

Będzie nowa wersja ale wszystko spokojnie.

To nie jest temat o bealathome!

Będę rozwijał ale aktualnie zbliża się sesja itp. itd. Zadania jednak powinny działać i być przydzielane cały czas.

Proszę o wypowiedzi na temat domeny  :deadman:

Ponieważ pomimo wszędobylskiej krytyki postanowiłem przejść do realizacji giełdy BOINC chciałbym Was spytać jaką domenę polecilibyście dla BOINC Stock Exchange?

Czy może:

http://boinc-stock.com

Czy może ma ktoś jakieś inne pomysły?

Niestety bse.com zajęte. Wymagane jest raczej aby to była domena com.

Cytat: sknd w 31 Marzec 2014, 21:40
a czekpointy już są?

Nie ma  %) Nadal wisi stara wersja aplikacji 1.0. %)

Beal@Home jest na BOINCStats:

http://boincstats.com/en/stats/148/project/detail

Tak to wygląda ponieważ  nie było aktualizacji statystyk. Odpaliłem raz ręcznie z palca wygenerowanie statystyk i tyle.

Teraz już powinno być ok.

Gdzie to znalazłeś? W kodzie nie widzę takiego komentarza.

Jak tak jest to śmiech na sali...

No niestety dla teoretycznie:

minbase=1 maxbase=1000 minpower=0 maxpower=1000

Program zwraca mi przykładowo takie możliwe równania:

Cytat25^8 + 9^561 = 13^47837345743319 count = 0
23^10 + 12^610 = 7^47837345743345 count = 0
4^7 + 3^973 = 7^47837345743601 count = 0

Ktoś może orientować się co jest nie tak jak trzeba?

Asz Wy... Już widzę.

Przecież na początku pliku jest jasno napisane:

/***** Define start and end values for exponents *****/

#define XSTART 0

// The values start from 0 so as to have kernels with block sizes
// that are always powers of 2. This helps performance according to
// the programming guide. The block size is determined using these values.

#define XEND 10
#define YSTART 0
#define YEND 10
#define ZSTART 0
#define ZEND 10

Ślepy jakiś jestem czy jak? Trzeba zaraz sprawdzić wydajność tego rozwiązania xD