pyocl / openclga Goto Github PK

ref:
https://wiki.openstreetmap.org/wiki/Routing#End_users:_Routing_software

• separate crossover, mutation, fitness as three files
• implement non-repeatable crossover
• implement non-repeatable mutation
• implement repeatable crossover
• implement repeatable mutation
• generate gene/chromosome struct according to gene.py and chromoosome.py
• generate kernel entry function according to properties of algorithm.py.
  • crossover function,
  • mutation function, etc

We'd like to have a 2nd optimization algorithm to strengthen the ability of this module.

We use main-thread to handle all messages from websocket. It would be nice to handle the data at batch. Because the message from web worker may be too fast that a redux cannot handle it with clone or immutable structure. We can aggregate some of them and process them in a batch.

As a user, I would like to see the performance of each generation. It would be ok to see it at console. But it would be great to see it as a GUI chart.

As a user, I would like to specify the web server of ocl_ga_server to populate the web client I want to populate.

We should evaluate py2opencl and help it to be compatible with python 3

It looks like the reducer cannot handle a lot of data... The possible solutions may be 1. move data cloning, aggregation, comparison to another thread, 2. use a time interval for batch data processing.

as a user, I would like to share top N chromosomes among all devices to boost the performance.

Hello,

This is an interesting project. Some questions:

1. How PyOpenCL compatible with NVidia Card ?

2. Is the objective function "converted/implemented" on the GPU side (evaluation is done on GPU) ?

Thanks, regards

As a user of UI, we should block the connection when websocket is connected by one UI to prevent other users uses the server.

Provide an implementation in python.

As a user, I would like to connect all of my devices to run a single GA model.

We could improve it in some parts.

1. Add heartbeat mechanism to keep server / client connection alive
2. Send/Recv data in {Server,Client} should be separate in different threads.
3. Considering epoll to improve performance.

As a user, I would like to extinct some chromosomes if they are too similar to each other.

We shouldn't accept more connections when UI dispatches a prepare command because we cannot run, pause, stop any clients if they didn't prepared.

We can accept more connection when the server is created or all clients are stopped. In the client stopped, we can recycle the client by prepare them again....

As a user, I would like to have multiple web console to see the results. Only one can be the controller and others are viewer.

Since kilik had a remote device execution lib, we can leverage it to run oclGA among all of our devices to see who fast/best we can have.

• server
• client
• UI

To support mulit-types of genes

• tsp
• taiwan_travel_319

TSP is a problem name not a good name for GA. We should replace it with another name.

I would suggest:

• clGA
• oclGA
• GAGPU
• PyGAGPU
• pyGG

These information should be independent from chromosome.

• We need detail performance chart of each device
• We need overall performance chart accumulated by time, 5 sec by default.

Should consider it as a list or dictionary, so that we could track the top N best chromosomes, or the bottom M worst chromosomes.

don't know why....

We're append data to sendq in A thread but consuming sendq in B thread.
Even further, now we check the length of sendq to decide if the socket is ok to be closed.

We should make it thread-safe.

As a user, I would like to know if this project is robust enough...

According to the proposal 1 and 2, we should generate some PIs or codes on the fly. This part is doable. But we need to evaluate if we can cast __global variable into what we want....

This issue is just for evaluation, no need to commit any code.

As a user, I would like to pause the execution of GA for closing my computer and find a good time to resume the execution of GA.

As a user, I would like to terminate the calculation if one the following cases:

• the best solution keeps the same after Nth generations
• the maximum time that I can wait
• expected fitness value found

Currently, we use TSP as an example which tries to minimize the path. This doesn't follow the convention of GA. GA tries maximize the fitness value. We should reverse our implementation to follow the convention of GA.

it's time to write docs more than codes.

• comments of codes
  • python (@kilikkuo)
  • cl (@john-hu)
• getting started (add distributed mode, install and run our example) (@kilikkuo)
• tutorial: how to write a GA application with OpenCLGA (write a new code) (@john-hu)
• home page with jekyll
• API doc (if possible, doxygen)

The README.md still use TSP. We should rename them...

We should move the UI as a standalone repo and put the production code at ui folder.

• python unit test
• opencl unit test

as a contributor, I would like to run the test cases before contributing my code to repo for preventing breaks.

Some functions at utils do the generic things, like custom_crossover does non-repeatable element cross over. We should rename all of them to reflect their intrinsic.

kilik had found a way to define preprocessor definition at python, see #9 .

size = 100
clProg = cl.Program(ctx, fstr).build(options="-D GLOBAL_SIZE={0}".format(size))

Currently, we use code generation to put all preprocessor definitions. If possible, we should use build options to do so. I cannot make sure how long it can use or any limitation at that.

as a user, I would like to use python setup.py to install all dependencies and download it through pip...