| 2011-02-18 00:57:34 |
Nicolas Slusarenko |
bug |
|
|
added bug |
| 2011-02-18 00:59:13 |
Nicolas Slusarenko |
description |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
matrixOpeMask moA= create<matrixOpeMask>("matrixOpe");
matrixOpeMask moB= create<matrixOpeMask>("matrixOpe");
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- Hence, we trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' takes a lot of time it would be a great advantage to have an internal thread on the trigger call T_product(..) scheduled with the task. Then the call will return immediately. Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one. |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
matrixOpeMask moA= create<matrixOpeMask>("matrixOpe");
matrixOpeMask moB= create<matrixOpeMask>("matrixOpe");
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- Hence, we trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' takes a lot of time it would be a great advantage to have an internal thread on the trigger call 'T_product(..)' sending the arguments. Then the call will return immediately, the thread will do the job.
- Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one. |
|
| 2011-02-18 02:21:31 |
Nicolas Slusarenko |
description |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
matrixOpeMask moA= create<matrixOpeMask>("matrixOpe");
matrixOpeMask moB= create<matrixOpeMask>("matrixOpe");
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- Hence, we trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' takes a lot of time it would be a great advantage to have an internal thread on the trigger call 'T_product(..)' sending the arguments. Then the call will return immediately, the thread will do the job.
- Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one. |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- We trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' to the component takes a lot of time it would be a great advantage to have an internal thread on the trigger call 'T_product(..)' sending the arguments. Then the call will return immediately, the thread will continue doing the job.
- Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one.
- Sending the arguments take between 0.5 and 1.0 second and it is not consuming the whole bandwidth, so it is perfect possible feasible to have two calls in parallel. |
|
| 2011-02-18 02:21:37 |
Nicolas Slusarenko |
lexiko: assignee |
|
Nicolas Slusarenko (nicolas-slusarenko) |
|
| 2011-02-18 02:31:33 |
Nicolas Slusarenko |
description |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- We trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' to the component takes a lot of time it would be a great advantage to have an internal thread on the trigger call 'T_product(..)' sending the arguments. Then the call will return immediately, the thread will continue doing the job.
- Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one.
- Sending the arguments take between 0.5 and 1.0 second and it is not consuming the whole bandwidth, so it is perfect possible feasible to have two calls in parallel. |
- When a call to component is performed it is done something like this:
matrixOpeMask mo= create<matrixOpeMask>("matrixOpe");
c= mo.product(a, b);
- If there are two 'matrixOpeMask' we could try:
moA.T_product(a, b);
moB.T_product(a, b);
c1= moA.productA();
c2= moB.productA();
- We trigger a job (the product of matrices 'a' and 'b') on 'moA' and then we trigger another job on 'moB'.
- However, if conveying the arguments 'a' and 'b' to the component takes a lot of time it would be a great advantage to have an internal thread on the trigger call 'T_product(..)' sending the arguments. Then the call will return immediately, the thread will continue doing the job.
- Then would be possible to do the same with 'moB'.
- This case happened to be relevant sending two matrices, 'a' and 'b' of 1000x1000 (one million of elements) each one.
- Sending the arguments take between 0.5 and 1.0 second and it is not consuming the whole bandwidth, so it is perfectly feasible to have two, or more, calls in parallel. |
|
| 2011-02-18 02:31:45 |
Nicolas Slusarenko |
lexiko: importance |
Undecided |
Medium |
|
